From 1f37337753bf08f3ea07de2b30442d2300e27c94 Mon Sep 17 00:00:00 2001 From: Yernat Yestekov <2068106+doublewhy@users.noreply.github.com> Date: Sat, 10 Oct 2026 09:08:03 -0700 Subject: [PATCH 01/11] fix(sdl): fetch oci modules from public registries through the anonymous token flow ghcr.io, Docker Hub and ECR Public answer an anonymous registry request with 401 and a WWW-Authenticate Bearer challenge, and the module registry reported every such import as a fetch failure. A 401 from the requested URL that carries exactly one Bearer challenge is now answered with one anonymous token request to the challenge's HTTPS realm (no redirects followed) and one retry. The challenge is parsed strictly, tokens are cached per realm, service and scope for one import resolution, and the token is attached as an unredirected header, so urllib never sends it on the 307 to a registry's blob storage. Timeouts, size limits, digests and the urlopen seam are unchanged. --- .../packages/raes/module_registry/__init__.py | 38 +- .../raes/module_registry/_registry_auth.py | 225 ++++++ .../raes/module_registry/resolution.py | 23 +- .../test_issue_1479_oci_anonymous_token.py | 668 ++++++++++++++++++ 4 files changed, 931 insertions(+), 23 deletions(-) create mode 100644 implementations/python/packages/raes/module_registry/_registry_auth.py create mode 100644 implementations/python/tests/test_issue_1479_oci_anonymous_token.py diff --git a/implementations/python/packages/raes/module_registry/__init__.py b/implementations/python/packages/raes/module_registry/__init__.py index 0bfd92f247..299bd7d2e7 100644 --- a/implementations/python/packages/raes/module_registry/__init__.py +++ b/implementations/python/packages/raes/module_registry/__init__.py @@ -19,8 +19,9 @@ from dataclasses import dataclass from pathlib import Path, PurePosixPath from typing import Any, Protocol -from urllib.error import URLError -from urllib.request import Request, urlopen + +# Registry requests resolve ``urlopen`` through this facade, the transport patch seam. +from urllib.request import urlopen # The submodule imports below retain the package's documented domain re-exports # plus the private ``_sha256_digest`` / ``_signable_payload`` / @@ -85,6 +86,7 @@ _same_file_identity, _write_version_pointer, ) +from ._registry_auth import _registry_get, _RegistryTokens from ._verified_sources import _cache_source_result, _VerifiedSourceBundle from .models import ( Lockfile, @@ -153,14 +155,16 @@ def _read_capped(response: _CappableResponse, *, url: str, max_bytes: int) -> by return data -def _json_request(url: str, *, headers: dict[str, str] | None = None, max_bytes: int | None = None) -> dict[str, Any]: - request = Request(url, headers=headers or {}) +def _json_request( + url: str, + *, + headers: dict[str, str] | None = None, + max_bytes: int | None = None, + tokens: _RegistryTokens | None = None, +) -> dict[str, Any]: limit = _OCI_LIMITS.max_metadata_bytes if max_bytes is None else max_bytes - try: - with urlopen(request, timeout=_OCI_LIMITS.timeout_seconds) as response: - payload = _read_capped(response, url=url, max_bytes=limit) - except URLError as exc: - raise SDLParseError(f"Failed to fetch OCI metadata from {url}") from exc + failure = f"Failed to fetch OCI metadata from {url}" + payload = _registry_get(url, headers=headers, max_bytes=limit, tokens=tokens, failure=failure) return _decode_json_object(payload, context=f"OCI metadata from {url}") @@ -176,14 +180,16 @@ def _decode_json_object(payload: bytes, *, context: str) -> dict[str, Any]: return decoded -def _bytes_request(url: str, *, headers: dict[str, str] | None = None, max_bytes: int | None = None) -> bytes: - request = Request(url, headers=headers or {}) +def _bytes_request( + url: str, + *, + headers: dict[str, str] | None = None, + max_bytes: int | None = None, + tokens: _RegistryTokens | None = None, +) -> bytes: limit = _OCI_LIMITS.max_metadata_bytes if max_bytes is None else max_bytes - try: - with urlopen(request, timeout=_OCI_LIMITS.timeout_seconds) as response: - return _read_capped(response, url=url, max_bytes=limit) - except URLError as exc: - raise SDLParseError(f"Failed to fetch OCI blob from {url}") from exc + failure = f"Failed to fetch OCI blob from {url}" + return _registry_get(url, headers=headers, max_bytes=limit, tokens=tokens, failure=failure) def _oci_cache_dir(base_dir: Path) -> Path: diff --git a/implementations/python/packages/raes/module_registry/_registry_auth.py b/implementations/python/packages/raes/module_registry/_registry_auth.py new file mode 100644 index 0000000000..3b79195716 --- /dev/null +++ b/implementations/python/packages/raes/module_registry/_registry_auth.py @@ -0,0 +1,225 @@ +"""OCI distribution anonymous bearer-token flow for module-registry fetches. + +Public registries such as ghcr.io, Docker Hub and ECR Public answer an anonymous +``/v2/`` request with ``401`` and a ``WWW-Authenticate: Bearer`` challenge. The +distribution token specification has the client request a token from the +challenge ``realm`` with its ``service`` and ``scope``, then repeat the request +with ``Authorization: Bearer `` (issue #1479). + +The flow is anonymous: no credential is read, stored or sent, and the token +request follows no redirect. The token rides only on the single retry of the +challenged request, as an unredirected header, so urllib never copies it into +a redirected request. Registries answer blob requests with a ``307`` to a +storage origin, which must not receive it. +""" + +from __future__ import annotations + +import re +from contextlib import closing +from dataclasses import dataclass, field +from urllib.error import HTTPError, URLError +from urllib.parse import urlencode, urlsplit, urlunsplit +from urllib.request import ( + HTTPDefaultErrorHandler, + HTTPErrorProcessor, + HTTPSHandler, + OpenerDirector, + ProxyHandler, + Request, + UnknownHandler, +) + +from .._errors import SDLParseError + +# RFC 9110 token and quoted-string (section 5.6), restricted to ASCII. +_TCHARS = r"[!#$%&'*+.^_`|~0-9A-Za-z-]+" +_QUOTED_STRING = r'"(?:[\t \x21\x23-\x5b\x5d-\x7e]|\\[\t \x21-\x7e])*"' +_SCHEME = re.compile(rf"({_TCHARS})(?: +|$)") +_AUTH_PARAM = re.compile(rf"({_TCHARS})[ \t]*=[ \t]*({_TCHARS}|{_QUOTED_STRING})") +_LIST_SEPARATOR = re.compile(r"[ \t]*,[ \t]*") +_QUOTED_PAIR = re.compile(r"\\(.)") +# RFC 6749 scope-token. RFC 6750 b64token is the bearer credential syntax, so a token +# that matches it cannot carry header text. +_SCOPE_TOKEN = re.compile(r"[\x21\x23-\x5b\x5d-\x7e]+") +_B64TOKEN = re.compile(r"[A-Za-z0-9._~+/-]+=*") +_URL_TEXT = re.compile(r"[\x21-\x7e]+") +_MALFORMED = "malformed Bearer challenge" + + +@dataclass(frozen=True) +class _BearerChallenge: + """The parameters a token request needs; also the token cache key.""" + + realm: str + service: str | None + scope: str | None + + def token_url(self) -> str: + """Return the realm with ``service`` and each space-delimited scope entry as query parameters.""" + + query = [] if self.service is None else [("service", self.service)] + query.extend(("scope", entry) for entry in ([] if self.scope is None else self.scope.split(" "))) + parts = urlsplit(self.realm) + joined = "&".join(part for part in (parts.query, urlencode(query)) if part) + return urlunsplit((parts.scheme, parts.netloc, parts.path, joined, "")) + + +def _unquoted(value: str) -> str: + return _QUOTED_PAIR.sub(r"\1", value[1:-1]) if value.startswith('"') else value + + +def _auth_params(text: str, position: int) -> dict[str, str]: + """Return the comma-separated auth-params from ``position`` to the end of ``text``.""" + + params: dict[str, str] = {} + while True: + param = _AUTH_PARAM.match(text, position) + if param is None or param.group(1).lower() in params: + raise ValueError(_MALFORMED) + params[param.group(1).lower()] = _unquoted(param.group(2)) + position = param.end() + if position == len(text): + return params + separator = _LIST_SEPARATOR.match(text, position) + if separator is None: + raise ValueError(_MALFORMED) + position = separator.end() + + +def _is_bearer(value: str) -> bool: + scheme = _SCHEME.match(value.strip(" \t")) + return scheme is not None and scheme.group(1).lower() == "bearer" + + +def _parse_bearer_challenge(value: str) -> _BearerChallenge: + """Parse one ``Bearer`` challenge strictly (RFC 9110 sections 11.2-11.3, RFC 6750 section 3). + + ``realm`` is required and other parameters are ignored, as RFC 6750 allows. + Anything else, including a duplicate parameter, fails with ``ValueError``. + """ + + text = value.strip(" \t") + scheme = _SCHEME.match(text) + if scheme is None or scheme.group(1).lower() != "bearer": + raise ValueError(_MALFORMED) + params = _auth_params(text, scheme.end()) + realm, scope = params.get("realm"), params.get("scope") + if realm is None or (scope is not None and not all(_SCOPE_TOKEN.fullmatch(entry) for entry in scope.split(" "))): + raise ValueError(_MALFORMED) + return _BearerChallenge(realm=realm, service=params.get("service"), scope=scope) + + +def _is_https_url(url: str) -> bool: + """Accept only an absolute ``https`` URL with a host and no userinfo, fragment or whitespace.""" + + try: + parts = urlsplit(url) + # ``port`` raises ValueError when the port is out of range. + port_valid = parts.port is None or parts.port > 0 + except ValueError: + return False + return all( + ( + port_valid, + _URL_TEXT.fullmatch(url) is not None, + parts.scheme == "https", + bool(parts.hostname), + "@" not in parts.netloc, + not parts.fragment, + ) + ) + + +def _challenge_for(error: HTTPError, request: Request) -> _BearerChallenge | None: + """Return the Bearer challenge of a ``401`` from the requested URL itself, or ``None``.""" + + url = request.full_url + with closing(error): + if error.code != 401 or error.url != url: + return None + bearer = [value for value in error.headers.get_all("WWW-Authenticate") or () if _is_bearer(value)] + if not bearer: + return None + malformed = f"OCI registry {url} answered 401 with a {_MALFORMED}" + if len(bearer) > 1: + raise SDLParseError(malformed) + try: + challenge = _parse_bearer_challenge(bearer[0]) + except ValueError as exc: + raise SDLParseError(malformed) from exc + if not _is_https_url(challenge.realm): + raise SDLParseError(f"OCI registry {url} names a token realm that is not an absolute https URL") + return challenge + + +def _anonymous_token(challenge: _BearerChallenge, *, url: str) -> str: + """Request an anonymous token from the challenge realm over HTTPS, following no redirect.""" + + from . import _OCI_LIMITS, _decode_json_object, _read_capped + + token_url = challenge.token_url() + # No HTTP, redirect, FTP, file or data handler: the validated HTTPS realm is the only hop. + opener = OpenerDirector() + for handler in (ProxyHandler(), UnknownHandler(), HTTPSHandler(), HTTPDefaultErrorHandler(), HTTPErrorProcessor()): + opener.add_handler(handler) + request = Request(token_url, headers={"Accept": "application/json"}) # noqa: S310 - validated https realm + try: + with opener.open(request, timeout=_OCI_LIMITS.timeout_seconds) as response: + payload = _read_capped(response, url=token_url, max_bytes=_OCI_LIMITS.max_metadata_bytes) + except URLError as exc: + raise SDLParseError(f"Failed to obtain an anonymous OCI registry token for {url}") from exc + document = _decode_json_object(payload, context=f"OCI registry token response for {url}") + token = document.get("token") or document.get("access_token") + if not isinstance(token, str) or _B64TOKEN.fullmatch(token) is None: + raise SDLParseError(f"OCI registry token response for {url} carries no usable bearer token") + return token + + +@dataclass +class _RegistryTokens: + """Anonymous tokens for one import resolution, keyed by realm, service and scope.""" + + _tokens: dict[_BearerChallenge, str] = field(default_factory=dict) + + def token_for(self, challenge: _BearerChallenge, *, url: str) -> str: + if challenge not in self._tokens: + self._tokens[challenge] = _anonymous_token(challenge, url=url) + return self._tokens[challenge] + + +def _open_capped(request: Request, *, url: str, max_bytes: int) -> bytes: + # ``urlopen`` and the limits resolve through the package facade, so its seams apply (issue #48). + from . import _OCI_LIMITS, _read_capped, urlopen + + with urlopen(request, timeout=_OCI_LIMITS.timeout_seconds) as response: + return _read_capped(response, url=url, max_bytes=max_bytes) + + +def _registry_get( + url: str, + *, + headers: dict[str, str] | None, + max_bytes: int, + tokens: _RegistryTokens | None, + failure: str, +) -> bytes: + """GET ``url`` anonymously; answer one Bearer challenge with one token-bearing retry.""" + + request = Request(url, headers=dict(headers or {})) # noqa: S310 - trust-policy registry URL + try: + return _open_capped(request, url=url, max_bytes=max_bytes) + except HTTPError as exc: + challenge = _challenge_for(exc, request) + if challenge is None: + raise SDLParseError(failure) from exc + except URLError as exc: + raise SDLParseError(failure) from exc + token = (_RegistryTokens() if tokens is None else tokens).token_for(challenge, url=url) + retry = Request(url, headers=dict(headers or {})) # noqa: S310 - trust-policy registry URL + # Unredirected: urllib copies only ``Request.headers`` into a redirected request. + retry.add_unredirected_header("Authorization", f"Bearer {token}") + try: + return _open_capped(retry, url=url, max_bytes=max_bytes) + except URLError as exc: + raise SDLParseError(failure) from exc diff --git a/implementations/python/packages/raes/module_registry/resolution.py b/implementations/python/packages/raes/module_registry/resolution.py index dda7507a3c..80e2497b11 100644 --- a/implementations/python/packages/raes/module_registry/resolution.py +++ b/implementations/python/packages/raes/module_registry/resolution.py @@ -16,6 +16,7 @@ from ..scenario import ImportDecl, ModuleDescriptor, Scenario from ._constants import LOCKFILE_NAME, OCI_BUNDLE_MEDIA_TYPE, OCI_LAYOUT_MEDIA_TYPE from ._digests import _SHA256_PREFIX, _descriptor_digest, _normalize_exact_or_range, _satisfies_version +from ._registry_auth import _RegistryTokens from ._verified_sources import _local_resolved_source, _VerifiedSourceBundle from .models import ( Lockfile, @@ -282,12 +283,13 @@ def _resolve_oci_manifest( import_decl: ImportDecl, locked: LockRecord | None, source: str, + tokens: _RegistryTokens | None = None, ) -> tuple[str, dict[str, Any]]: from . import _bytes_request, _decode_json_object, _json_request, _sha256_digest manifest_ref = locked.manifest_digest if locked is not None else None if manifest_ref is None: - tags_payload = _json_request(f"{base_url}/v2/{quote(repository, safe='/')}/tags/list") + tags_payload = _json_request(f"{base_url}/v2/{quote(repository, safe='/')}/tags/list", tokens=tokens) raw_tags = tags_payload.get("tags") or [] if not isinstance(raw_tags, list) or any(not isinstance(tag, str) for tag in raw_tags): raise SDLParseError(f"OCI tag metadata for '{source}' has an invalid tags list") @@ -296,6 +298,7 @@ def _resolve_oci_manifest( manifest_bytes = _bytes_request( f"{base_url}/v2/{quote(repository, safe='/')}/manifests/{quote(str(manifest_ref), safe=':@/')}", headers={"Accept": OCI_LAYOUT_MEDIA_TYPE}, + tokens=tokens, ) manifest_digest = f"{_SHA256_PREFIX}{_sha256_digest(manifest_bytes)}" manifest = _decode_json_object(manifest_bytes, context=f"OCI manifest for '{source}'") @@ -307,7 +310,7 @@ def _resolve_oci_manifest( def _resolve_oci_config( - *, base_url: str, repository: str, manifest: dict[str, Any], source: str + *, base_url: str, repository: str, manifest: dict[str, Any], source: str, tokens: _RegistryTokens | None = None ) -> tuple[dict[str, Any], str]: from . import _bytes_request, _decode_json_object, _sha256_digest @@ -334,7 +337,7 @@ def _resolve_oci_config( # entrypoint. Hash the exact bytes received - never a reserialized object - # and reuse the bundle's digest spelling. config_bytes = _bytes_request( - f"{base_url}/v2/{quote(repository, safe='/')}/blobs/{quote(config_digest, safe=':@/')}" + f"{base_url}/v2/{quote(repository, safe='/')}/blobs/{quote(config_digest, safe=':@/')}", tokens=tokens ) if f"{_SHA256_PREFIX}{_sha256_digest(config_bytes)}" != config_digest: raise SDLParseError(f"OCI module '{source}' config digest verification failed") @@ -342,12 +345,15 @@ def _resolve_oci_config( return config_payload, layer_digest -def _fetch_oci_bundle(*, base_url: str, repository: str, layer_digest: str, source: str) -> bytes: +def _fetch_oci_bundle( + *, base_url: str, repository: str, layer_digest: str, source: str, tokens: _RegistryTokens | None = None +) -> bytes: from . import _OCI_LIMITS, _bytes_request, _sha256_digest bundle_bytes = _bytes_request( f"{base_url}/v2/{quote(repository, safe='/')}/blobs/{quote(layer_digest, safe=':@/')}", max_bytes=_OCI_LIMITS.max_bundle_bytes, + tokens=tokens, ) if f"{_SHA256_PREFIX}{_sha256_digest(bundle_bytes)}" != layer_digest: raise SDLParseError(f"OCI module '{source}' bundle digest verification failed") @@ -404,13 +410,16 @@ def _resolve_oci_import( raise SDLParseError(f"Registry '{registry}' is not allowed by trust policy") base_url = _registry_base_url(registry, allow_insecure_http=registry_policy.allow_insecure_http) locked = _lock_record_for(lockfile, import_decl) + tokens = _RegistryTokens() manifest_digest, manifest = _resolve_oci_manifest( - base_url=base_url, repository=repository, import_decl=import_decl, locked=locked, source=source + base_url=base_url, repository=repository, import_decl=import_decl, locked=locked, source=source, tokens=tokens ) config_payload, layer_digest = _resolve_oci_config( - base_url=base_url, repository=repository, manifest=manifest, source=source + base_url=base_url, repository=repository, manifest=manifest, source=source, tokens=tokens + ) + bundle_bytes = _fetch_oci_bundle( + base_url=base_url, repository=repository, layer_digest=layer_digest, source=source, tokens=tokens ) - bundle_bytes = _fetch_oci_bundle(base_url=base_url, repository=repository, layer_digest=layer_digest, source=source) descriptor, content_digest, root_file = _build_oci_descriptor( config_payload=config_payload, layer_digest=layer_digest, import_decl=import_decl, locked=locked, source=source ) diff --git a/implementations/python/tests/test_issue_1479_oci_anonymous_token.py b/implementations/python/tests/test_issue_1479_oci_anonymous_token.py new file mode 100644 index 0000000000..9fc84b6fad --- /dev/null +++ b/implementations/python/tests/test_issue_1479_oci_anonymous_token.py @@ -0,0 +1,668 @@ +"""Issue #1479: OCI imports through the distribution anonymous token flow. + +ghcr.io, Docker Hub and ECR Public answer an anonymous registry request with +``401`` and ``WWW-Authenticate: Bearer realm=...,service=...,scope=...``. They +serve the token from an HTTPS realm and answer blob requests with ``307`` to a +storage host on another origin. These loopback servers reproduce that shape: a +registry that challenges until it receives the expected token, an HTTPS token +endpoint signed by a throwaway CA, and a storage origin that refuses, and +records, any request carrying ``Authorization``. +""" + +from __future__ import annotations + +import base64 +import datetime as dt +import ipaddress +import json +import os +import ssl +import textwrap +import threading +from collections.abc import Callable, Iterator +from dataclasses import dataclass, replace +from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer +from pathlib import Path +from urllib.parse import urlsplit + +import pytest +import raes.module_registry as module_registry +from cryptography import x509 +from cryptography.hazmat.primitives import hashes, serialization +from cryptography.hazmat.primitives.asymmetric import ec +from cryptography.x509.oid import ExtendedKeyUsageOID, NameOID +from raes._errors import SDLParseError +from raes.module_registry import publish_module_to_oci_layout +from raes.parser import parse_sdl_file + +REPOSITORY = "acme/shared" +SERVICE = "registry.test" +SCOPE = f"repository:{REPOSITORY}:pull" +TOKEN_QUERY = f"service={SERVICE}&scope=repository%3Aacme%2Fshared%3Apull" +SIGNED_QUERY = "X-Signature=storage-only" +MODULE = """ +name: shared +version: 1.2.3 +module: + id: acme/shared + version: 1.2.3 + exports: + nodes: [vm] + infrastructure: [vm] +nodes: + vm: + type: compute + os: linux + resources: {ram: 1 gib, cpu: 1} +infrastructure: + vm: 1 +""" + +Response = tuple[int, list[tuple[str, str]], bytes] +Route = Callable[[str, str | None], Response] + + +@dataclass(frozen=True) +class _Seen: + path: str + authorization: str | None + + +class _Handler(BaseHTTPRequestHandler): + route: Route + seen: list[_Seen] + + def do_GET(self) -> None: # noqa: N802 + authorization = self.headers.get("Authorization") + self.seen.append(_Seen(self.path, authorization)) + status, headers, body = self.route(self.path, authorization) + self.send_response(status) + for name, value in headers: + self.send_header(name, value) + self.send_header("Content-Length", str(len(body))) + self.end_headers() + self.wfile.write(body) + + def log_message(self, format: str, *args: object) -> None: # noqa: A002 + del format, args + + +class _Server: + """One loopback origin whose responses come from ``route``.""" + + def __init__(self, route: Route, *, tls: ssl.SSLContext | None) -> None: + self.seen: list[_Seen] = [] + handler = type("Handler", (_Handler,), {"route": staticmethod(route), "seen": self.seen}) + self._server = ThreadingHTTPServer(("127.0.0.1", 0), handler) + self._server.daemon_threads = True + if tls is not None: + self._server.socket = tls.wrap_socket(self._server.socket, server_side=True) + scheme = "http" if tls is None else "https" + self.origin = f"{scheme}://127.0.0.1:{self._server.server_address[1]}" + # A short poll interval keeps shutdown fast; each test starts several servers. + self._thread = threading.Thread(target=self._server.serve_forever, args=(0.05,), daemon=True) + self._thread.start() + + def close(self) -> None: + self._server.shutdown() + self._server.server_close() + self._thread.join(timeout=5) + + +@dataclass(frozen=True) +class _Layout: + tag: str + manifest_digest: str + config_digest: str + bundle_digest: str + blobs: dict[str, bytes] + + +def _json(payload: object) -> Response: + return 200, [("Content-Type", "application/json")], json.dumps(payload).encode("utf-8") + + +def _registry_route( + layout: _Layout, + *, + token: str | None, + challenges: list[str], + blob_location: str = "", + anonymous: bool = False, +) -> Route: + """A registry that challenges until it sees ``token`` and redirects every blob. + + ``blob_location`` prefixes the ``307`` target: another origin, or "" for a + same-origin path. ``/storage/`` paths on this origin behave like the storage + host. ``token=None`` never accepts a token. + """ + + prefix = f"/v2/{REPOSITORY}/" + storage = _storage_route(layout) + + def route(path: str, authorization: str | None) -> Response: + if path.startswith("/storage/"): + return storage(path, authorization) + if not anonymous and (token is None or authorization != f"Bearer {token}"): + headers = [("WWW-Authenticate", value) for value in challenges] + return 401, [*headers, ("Content-Type", "application/json")], b'{"errors":[{"code":"UNAUTHORIZED"}]}' + if path == f"{prefix}tags/list": + return _json({"name": REPOSITORY, "tags": [layout.tag]}) + if path == f"{prefix}manifests/{layout.tag}": + return 200, [("Content-Type", module_registry.OCI_LAYOUT_MEDIA_TYPE)], layout.blobs[layout.manifest_digest] + if path.startswith(f"{prefix}blobs/"): + digest = path.removeprefix(f"{prefix}blobs/") + return 307, [("Location", f"{blob_location}/storage/{digest}?{SIGNED_QUERY}")], b"" + return 404, [], b"" + + return route + + +def _storage_route(layout: _Layout) -> Route: + """A blob storage host that refuses any request carrying ``Authorization``.""" + + def route(path: str, authorization: str | None) -> Response: + if authorization is not None: + return 403, [], b"Authorization reached the storage origin" + blob = layout.blobs.get(urlsplit(path).path.removeprefix("/storage/")) + return (404, [], b"") if blob is None else (200, [], blob) + + return route + + +def _fixed_route(response: Response) -> Route: + return lambda _path, _authorization: response + + +def _challenge(token_server: _Server, *, scope: str = SCOPE) -> str: + return f'Bearer realm="{token_server.origin}/token",service="{SERVICE}",scope="{scope}"' + + +def _new_token() -> str: + return base64.b64encode(os.urandom(24)).decode("ascii") + + +def _url(server: _Server, resource: str) -> str: + return f"{server.origin}/v2/{REPOSITORY}/{resource}" + + +@pytest.fixture +def serve() -> Iterator[Callable[..., _Server]]: + started: list[_Server] = [] + + def start(route: Route, *, tls: ssl.SSLContext | None = None) -> _Server: + server = _Server(route, tls=tls) + started.append(server) + return server + + yield start + for server in started: + server.close() + + +def _certificate( + subject: x509.Name, issuer: x509.Name, key: ec.EllipticCurvePrivateKey, signer: ec.EllipticCurvePrivateKey +) -> x509.CertificateBuilder: + now = dt.datetime.now(dt.UTC) + return ( + x509.CertificateBuilder() + .subject_name(subject) + .issuer_name(issuer) + .public_key(key.public_key()) + .serial_number(x509.random_serial_number()) + .not_valid_before(now - dt.timedelta(minutes=5)) + .not_valid_after(now + dt.timedelta(hours=1)) + .add_extension(x509.SubjectKeyIdentifier.from_public_key(key.public_key()), critical=False) + .add_extension( + x509.AuthorityKeyIdentifier.from_issuer_public_key(signer.public_key()), + critical=False, + ) + ) + + +@pytest.fixture(scope="module") +def tls_files(tmp_path_factory: pytest.TempPathFactory) -> tuple[Path, Path, Path]: + """A throwaway CA and a 127.0.0.1 leaf that pass Python's strict X.509 checks.""" + + ca_key = ec.generate_private_key(ec.SECP256R1()) + leaf_key = ec.generate_private_key(ec.SECP256R1()) + ca_name = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, "issue 1479 test CA")]) + leaf_name = x509.Name([x509.NameAttribute(NameOID.COMMON_NAME, "127.0.0.1")]) + ca = ( + _certificate(ca_name, ca_name, ca_key, ca_key) + .add_extension(x509.BasicConstraints(ca=True, path_length=0), critical=True) + .add_extension( + x509.KeyUsage( + digital_signature=False, + content_commitment=False, + key_encipherment=False, + data_encipherment=False, + key_agreement=False, + key_cert_sign=True, + crl_sign=True, + encipher_only=False, + decipher_only=False, + ), + critical=True, + ) + .sign(ca_key, hashes.SHA256()) + ) + leaf = ( + _certificate(leaf_name, ca_name, leaf_key, ca_key) + .add_extension(x509.BasicConstraints(ca=False, path_length=None), critical=True) + .add_extension(x509.SubjectAlternativeName([x509.IPAddress(ipaddress.ip_address("127.0.0.1"))]), critical=False) + .add_extension(x509.ExtendedKeyUsage([ExtendedKeyUsageOID.SERVER_AUTH]), critical=False) + .sign(ca_key, hashes.SHA256()) + ) + directory = tmp_path_factory.mktemp("issue-1479-tls") + paths = (directory / "ca.pem", directory / "leaf.pem", directory / "leaf-key.pem") + paths[0].write_bytes(ca.public_bytes(serialization.Encoding.PEM)) + paths[1].write_bytes(leaf.public_bytes(serialization.Encoding.PEM)) + paths[2].write_bytes( + leaf_key.private_bytes( + serialization.Encoding.PEM, serialization.PrivateFormat.PKCS8, serialization.NoEncryption() + ) + ) + return paths + + +@pytest.fixture +def https(tls_files: tuple[Path, Path, Path], monkeypatch: pytest.MonkeyPatch) -> ssl.SSLContext: + """Server context for the token endpoint; the client trusts the CA through ``SSL_CERT_FILE``.""" + + ca_path, cert_path, key_path = tls_files + monkeypatch.setenv("SSL_CERT_FILE", str(ca_path)) + context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER) + context.minimum_version = ssl.TLSVersion.TLSv1_2 + context.load_cert_chain(cert_path, key_path) + return context + + +@pytest.fixture +def layout(tmp_path: Path) -> _Layout: + module = tmp_path / "module" / "shared.yaml" + module.parent.mkdir() + module.write_text(MODULE.lstrip(), encoding="utf-8") + layout_dir = Path(publish_module_to_oci_layout(module, output_dir=tmp_path / "dist")["layout_dir"]) + entry = json.loads((layout_dir / "index.json").read_text(encoding="utf-8"))["manifests"][0] + blobs = {f"sha256:{blob.name}": blob.read_bytes() for blob in (layout_dir / "blobs" / "sha256").iterdir()} + manifest = json.loads(blobs[entry["digest"]]) + return _Layout( + tag=entry["annotations"]["org.opencontainers.image.ref.name"], + manifest_digest=entry["digest"], + config_digest=manifest["config"]["digest"], + bundle_digest=manifest["layers"][0]["digest"], + blobs=blobs, + ) + + +def _import_root(directory: Path, registry: _Server) -> Path: + host = urlsplit(registry.origin).netloc + (directory / "raes-trust.yaml").write_text( + textwrap.dedent( + f""" + schema_version: raes-trust/v1 + registries: + "{host}": + require_signatures: false + allow_insecure_http: true + """ + ).lstrip(), + encoding="utf-8", + ) + root = directory / "root.yaml" + root.write_text( + textwrap.dedent( + f""" + name: root + imports: + - source: oci:{host}/{REPOSITORY} + namespace: shared + version: 1.2.3 + """ + ).lstrip(), + encoding="utf-8", + ) + return root + + +def test_import_uses_one_anonymous_token_and_retries_each_request_once( + tmp_path: Path, layout: _Layout, serve: Callable[..., _Server], https: ssl.SSLContext +) -> None: + token = _new_token() + token_server = serve(_fixed_route(_json({"token": token})), tls=https) + storage = serve(_storage_route(layout)) + registry = serve( + _registry_route(layout, token=token, challenges=[_challenge(token_server)], blob_location=storage.origin) + ) + + scenario = parse_sdl_file(_import_root(tmp_path, registry)) + + assert set(scenario.nodes) == {"shared.vm"} + assert token_server.seen == [_Seen(f"/token?{TOKEN_QUERY}", None)] + resources = [ + f"/v2/{REPOSITORY}/tags/list", + f"/v2/{REPOSITORY}/manifests/{layout.tag}", + f"/v2/{REPOSITORY}/blobs/{layout.config_digest}", + f"/v2/{REPOSITORY}/blobs/{layout.bundle_digest}", + ] + assert registry.seen == [ + attempt for path in resources for attempt in (_Seen(path, None), _Seen(path, f"Bearer {token}")) + ] + assert storage.seen == [ + _Seen(f"/storage/{digest}?{SIGNED_QUERY}", None) for digest in (layout.config_digest, layout.bundle_digest) + ] + + +@pytest.mark.parametrize("cross_origin", [True, False], ids=["storage-origin", "same-origin"]) +def test_bearer_token_never_follows_a_blob_redirect( + layout: _Layout, serve: Callable[..., _Server], https: ssl.SSLContext, cross_origin: bool +) -> None: + token = _new_token() + token_server = serve(_fixed_route(_json({"token": token})), tls=https) + storage = serve(_storage_route(layout)) + registry = serve( + _registry_route( + layout, + token=token, + challenges=[_challenge(token_server)], + blob_location=storage.origin if cross_origin else "", + ) + ) + + payload = module_registry._bytes_request(_url(registry, f"blobs/{layout.bundle_digest}")) + + assert payload == layout.blobs[layout.bundle_digest] + target = storage if cross_origin else registry + redirected = [seen for seen in target.seen if seen.path.startswith("/storage/")] + assert redirected == [_Seen(f"/storage/{layout.bundle_digest}?{SIGNED_QUERY}", None)] + + +def test_rejected_token_gets_exactly_one_retry( + layout: _Layout, serve: Callable[..., _Server], https: ssl.SSLContext +) -> None: + token_server = serve(_fixed_route(_json({"token": _new_token()})), tls=https) + registry = serve(_registry_route(layout, token=None, challenges=[_challenge(token_server)])) + url = _url(registry, "tags/list") + + with pytest.raises(SDLParseError) as exc_info: + module_registry._json_request(url) + + assert str(exc_info.value) == f"Failed to fetch OCI metadata from {url}" + assert [seen.authorization is None for seen in registry.seen] == [True, False] + assert len(token_server.seen) == 1 + + +@pytest.mark.parametrize("challenges", [[], ['Basic realm="registry.test"']], ids=["no-challenge", "basic-only"]) +def test_401_without_a_bearer_challenge_keeps_the_existing_failure( + layout: _Layout, serve: Callable[..., _Server], challenges: list[str] +) -> None: + registry = serve(_registry_route(layout, token=None, challenges=challenges)) + url = _url(registry, "tags/list") + + with pytest.raises(SDLParseError) as exc_info: + module_registry._json_request(url) + + assert str(exc_info.value) == f"Failed to fetch OCI metadata from {url}" + assert len(registry.seen) == 1 + + +@pytest.mark.parametrize( + ("templates", "message"), + [ + pytest.param( + ['Bearer realm="{https}/token",service="a"', 'Bearer realm="{https}/token",service="b"'], + "answered 401 with a malformed Bearer challenge", + id="two-bearer-challenges", + ), + pytest.param( + ['Bearer realm="{https}/token",scope="repository:acme/shared:pull extra"'], + "answered 401 with a malformed Bearer challenge", + id="empty-scope-entry", + ), + pytest.param( + ['Bearer realm="{http}/token",service="registry.test"'], + "names a token realm that is not an absolute https URL", + id="cleartext-realm", + ), + ], +) +def test_unusable_challenges_fail_before_any_token_request( + layout: _Layout, serve: Callable[..., _Server], https: ssl.SSLContext, templates: list[str], message: str +) -> None: + token_server = serve(_fixed_route(_json({"token": _new_token()})), tls=https) + cleartext = serve(_fixed_route(_json({"token": _new_token()}))) + challenges = [template.format(https=token_server.origin, http=cleartext.origin) for template in templates] + registry = serve(_registry_route(layout, token=None, challenges=challenges)) + url = _url(registry, "tags/list") + + with pytest.raises(SDLParseError) as exc_info: + module_registry._json_request(url) + + assert str(exc_info.value) == f"OCI registry {url} {message}" + assert token_server.seen == [] + assert cleartext.seen == [] + + +def test_token_endpoint_redirect_is_not_followed( + layout: _Layout, serve: Callable[..., _Server], https: ssl.SSLContext +) -> None: + token = _new_token() + + def token_route(path: str, _authorization: str | None) -> Response: + if path.startswith("/token"): + return 302, [("Location", "/elsewhere")], b"" + return _json({"token": token}) + + token_server = serve(token_route, tls=https) + registry = serve(_registry_route(layout, token=token, challenges=[_challenge(token_server)])) + url = _url(registry, "tags/list") + + with pytest.raises(SDLParseError) as exc_info: + module_registry._json_request(url) + + assert str(exc_info.value) == f"Failed to obtain an anonymous OCI registry token for {url}" + assert [urlsplit(seen.path).path for seen in token_server.seen] == ["/token"] + assert len(registry.seen) == 1 + + +@pytest.mark.parametrize( + ("response", "message"), + [ + pytest.param((500, [], b"{}"), "Failed to obtain an anonymous OCI registry token for {url}", id="status-500"), + pytest.param( + (200, [], b""), "OCI registry token response for {url} is not valid UTF-8 JSON", id="not-json" + ), + pytest.param((200, [], b"[]"), "OCI registry token response for {url} must be a JSON object", id="not-object"), + pytest.param(_json({}), "OCI registry token response for {url} carries no usable bearer token", id="no-token"), + pytest.param( + _json({"token": 7}), "OCI registry token response for {url} carries no usable bearer token", id="number" + ), + pytest.param( + _json({"token": "two words"}), + "OCI registry token response for {url} carries no usable bearer token", + id="space", + ), + pytest.param( + _json({"token": "abc\r\nX-Injected: 1"}), + "OCI registry token response for {url} carries no usable bearer token", + id="header-injection", + ), + ], +) +def test_unusable_token_responses_fail_without_a_retry( + layout: _Layout, serve: Callable[..., _Server], https: ssl.SSLContext, response: Response, message: str +) -> None: + token_server = serve(_fixed_route(response), tls=https) + registry = serve(_registry_route(layout, token=_new_token(), challenges=[_challenge(token_server)])) + url = _url(registry, "tags/list") + + with pytest.raises(SDLParseError) as exc_info: + module_registry._json_request(url) + + assert str(exc_info.value) == message.format(url=url) + assert len(registry.seen) == 1 + assert len(token_server.seen) == 1 + + +def test_token_response_is_read_under_the_metadata_limit( + layout: _Layout, serve: Callable[..., _Server], https: ssl.SSLContext, monkeypatch: pytest.MonkeyPatch +) -> None: + token = _new_token() + token_server = serve(_fixed_route(_json({"token": token, "padding": "x" * 64})), tls=https) + registry = serve(_registry_route(layout, token=token, challenges=[_challenge(token_server)])) + limits = replace(module_registry._OCI_LIMITS, max_metadata_bytes=64) + monkeypatch.setattr(module_registry, "_OCI_LIMITS", limits) + + url = _url(registry, "tags/list") + + with pytest.raises(SDLParseError, match="exceeding the 64-byte limit"): + module_registry._json_request(url) + + assert len(registry.seen) == 1 + + +@pytest.mark.parametrize( + "body", + [{"access_token": "{token}", "expires_in": 300}, {"token": "{token}", "access_token": "other"}], + ids=["access-token-only", "token-preferred"], +) +def test_token_or_access_token_authorizes_the_retry( + layout: _Layout, serve: Callable[..., _Server], https: ssl.SSLContext, body: dict[str, object] +) -> None: + token = _new_token() + filled = {key: value.format(token=token) if isinstance(value, str) else value for key, value in body.items()} + token_server = serve(_fixed_route(_json(filled)), tls=https) + registry = serve(_registry_route(layout, token=token, challenges=[_challenge(token_server)])) + + assert module_registry._json_request(_url(registry, "tags/list")) == {"name": REPOSITORY, "tags": [layout.tag]} + assert registry.seen[-1].authorization == f"Bearer {token}" + + +def test_challenge_from_a_redirect_target_is_not_answered( + layout: _Layout, serve: Callable[..., _Server], https: ssl.SSLContext +) -> None: + token_server = serve(_fixed_route(_json({"token": _new_token()})), tls=https) + storage = serve(_fixed_route((401, [("WWW-Authenticate", _challenge(token_server))], b""))) + registry = serve(_registry_route(layout, token=None, challenges=[], blob_location=storage.origin, anonymous=True)) + url = _url(registry, f"blobs/{layout.bundle_digest}") + + with pytest.raises(SDLParseError) as exc_info: + module_registry._bytes_request(url) + + assert str(exc_info.value) == f"Failed to fetch OCI blob from {url}" + assert token_server.seen == [] + + +def test_tokens_are_cached_per_challenge_for_one_resolution( + layout: _Layout, serve: Callable[..., _Server], https: ssl.SSLContext +) -> None: + token = _new_token() + token_server = serve(_fixed_route(_json({"token": token})), tls=https) + registry = serve(_registry_route(layout, token=token, challenges=[_challenge(token_server)])) + url = _url(registry, "tags/list") + tokens = module_registry._registry_auth._RegistryTokens() + + module_registry._json_request(url, tokens=tokens) + module_registry._bytes_request(url, tokens=tokens) + assert len(token_server.seen) == 1 + + other_scope = module_registry._registry_auth._parse_bearer_challenge( + _challenge(token_server, scope="repository:acme/other:pull") + ) + assert tokens.token_for(other_scope, url=url) == token + assert len(token_server.seen) == 2 + + module_registry._json_request(url) + assert len(token_server.seen) == 3 + + +@pytest.mark.parametrize( + ("header", "expected"), + [ + pytest.param( + 'Bearer realm="https://ghcr.io/token",service="ghcr.io",scope="repository:oras-project/oras:pull"', + ("https://ghcr.io/token", "ghcr.io", "repository:oras-project/oras:pull"), + id="ghcr", + ), + pytest.param( + 'Bearer realm="https://public.ecr.aws/token/",service="public.ecr.aws",scope="aws"', + ("https://public.ecr.aws/token/", "public.ecr.aws", "aws"), + id="ecr-public", + ), + pytest.param( + ' bearer REALM="https://auth.test/token" , Service=registry.test ', + ("https://auth.test/token", "registry.test", None), + id="case-and-whitespace", + ), + pytest.param( + 'Bearer realm="https://auth.test/token",service="say \\"hi\\"",error="insufficient_scope",x=1', + ("https://auth.test/token", 'say "hi"', None), + id="escapes-and-other-parameters", + ), + ], +) +def test_bearer_challenge_grammar_accepts_rfc_7235_parameters(header: str, expected: tuple[str, ...]) -> None: + challenge = module_registry._registry_auth._parse_bearer_challenge(header) + + assert (challenge.realm, challenge.service, challenge.scope) == expected + + +@pytest.mark.parametrize( + "header", + [ + "Bearer", + "Bearer realm", + "Bearer realm=", + "Bearer abc==", + 'Bearer realm="https://auth.test/token",', + 'Bearer realm="https://auth.test/token",,service="registry.test"', + 'Bearer realm="https://auth.test/token" service="registry.test"', + 'Bearer realm="https://auth.test/token",REALM="https://auth.test/other"', + 'Bearer service="registry.test"', + 'Bearer realm="https://auth.test/token', + 'Bearer realm="https://auth.test/töken"', + 'Bearer realm="https://auth.test/token",scope="a b"', + 'Bearer realm="https://auth.test/token",scope=""', + 'Basic realm="registry.test"', + ], +) +def test_bearer_challenge_grammar_rejects_malformed_challenges(header: str) -> None: + with pytest.raises(ValueError, match="malformed Bearer challenge"): + module_registry._registry_auth._parse_bearer_challenge(header) + + +@pytest.mark.parametrize( + ("realm", "accepted"), + [ + ("https://auth.test/token", True), + ("https://auth.test:8443/token?account=reader", True), + ("HTTPS://auth.test/token", True), + ("ftp://auth.test/token", False), + ("https:///token", False), + ("/token", False), + ("https://reader@auth.test/token", False), + ("https://auth.test/token#part", False), + ("https://auth.test:99999/token", False), + ("https://auth.test/a b", False), + ("https://[::1/token", False), + ], +) +def test_token_realm_must_be_an_absolute_https_url(realm: str, accepted: bool) -> None: + assert module_registry._registry_auth._is_https_url(realm) is accepted + + +def test_token_url_carries_the_service_and_each_scope_entry() -> None: + challenge = module_registry._registry_auth._BearerChallenge( + realm="https://auth.test/token?account=reader", + service="registry.test", + scope="repository:acme/shared:pull repository:acme/other:pull", + ) + + assert challenge.token_url() == ( + "https://auth.test/token?account=reader&service=registry.test" + "&scope=repository%3Aacme%2Fshared%3Apull&scope=repository%3Aacme%2Fother%3Apull" + ) + assert module_registry._registry_auth._BearerChallenge("https://auth.test/token", None, None).token_url() == ( + "https://auth.test/token" + ) From 846e0cc98e492ab753077767afac1d6cfbfbd2da Mon Sep 17 00:00:00 2001 From: Yernat Yestekov <2068106+doublewhy@users.noreply.github.com> Date: Sat, 10 Oct 2026 09:42:31 -0700 Subject: [PATCH 02/11] test(sdl): compare parsed bearer challenges as whole objects --- .../python/tests/test_issue_1479_oci_anonymous_token.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/implementations/python/tests/test_issue_1479_oci_anonymous_token.py b/implementations/python/tests/test_issue_1479_oci_anonymous_token.py index 9fc84b6fad..f2694507b4 100644 --- a/implementations/python/tests/test_issue_1479_oci_anonymous_token.py +++ b/implementations/python/tests/test_issue_1479_oci_anonymous_token.py @@ -602,10 +602,12 @@ def test_tokens_are_cached_per_challenge_for_one_resolution( ), ], ) -def test_bearer_challenge_grammar_accepts_rfc_7235_parameters(header: str, expected: tuple[str, ...]) -> None: +def test_bearer_challenge_grammar_accepts_rfc_9110_parameters( + header: str, expected: tuple[str, str | None, str | None] +) -> None: challenge = module_registry._registry_auth._parse_bearer_challenge(header) - assert (challenge.realm, challenge.service, challenge.scope) == expected + assert challenge == module_registry._registry_auth._BearerChallenge(*expected) @pytest.mark.parametrize( From 4cb297e43ed06c3fecc2a527247ab7d750f4ebba Mon Sep 17 00:00:00 2001 From: Yernat Yestekov <2068106+doublewhy@users.noreply.github.com> Date: Sat, 10 Oct 2026 10:43:00 -0700 Subject: [PATCH 03/11] fix(sdl): reject token realms urllib cannot send and name only the requested url A realm whose host is percent-encoded or not IDNA-encodable passed the realm check and then escaped parse_sdl_file as http.client.InvalidURL or UnicodeEncodeError. The realm check now refuses a "%" in the authority and any host the IDNA codec rejects, so such a challenge fails with an SDLParseError before any token request. The token response's oversize message named the token URL built from the challenge's realm, service and scope. It now names the requested URL, like every other message in the flow. A second parse_sdl_file import against the same registry now pins the one-cache-per-import token lifetime. --- .../raes/module_registry/_registry_auth.py | 17 ++++++++--- .../test_issue_1479_oci_anonymous_token.py | 29 ++++++++++++++----- 2 files changed, 34 insertions(+), 12 deletions(-) diff --git a/implementations/python/packages/raes/module_registry/_registry_auth.py b/implementations/python/packages/raes/module_registry/_registry_auth.py index 3b79195716..fb40e80fc3 100644 --- a/implementations/python/packages/raes/module_registry/_registry_auth.py +++ b/implementations/python/packages/raes/module_registry/_registry_auth.py @@ -111,12 +111,19 @@ def _parse_bearer_challenge(value: str) -> _BearerChallenge: def _is_https_url(url: str) -> bool: - """Accept only an absolute ``https`` URL with a host and no userinfo, fragment or whitespace.""" + """Accept only an absolute ``https`` URL with a host and no userinfo, fragment or whitespace. + + urllib percent-decodes the host it connects to and the socket layer IDNA-encodes + it, so a ``%`` in the authority or a host the IDNA codec refuses is rejected here, + rather than failing later outside ``SDLParseError``. + """ try: parts = urlsplit(url) - # ``port`` raises ValueError when the port is out of range. + # ``port`` raises ValueError when the port is out of range, and the IDNA codec + # raises UnicodeError, also a ValueError, for an empty or over-long label. port_valid = parts.port is None or parts.port > 0 + host = (parts.hostname or "").encode("idna") except ValueError: return False return all( @@ -124,8 +131,9 @@ def _is_https_url(url: str) -> bool: port_valid, _URL_TEXT.fullmatch(url) is not None, parts.scheme == "https", - bool(parts.hostname), + bool(host), "@" not in parts.netloc, + "%" not in parts.netloc, not parts.fragment, ) ) @@ -166,7 +174,8 @@ def _anonymous_token(challenge: _BearerChallenge, *, url: str) -> str: request = Request(token_url, headers={"Accept": "application/json"}) # noqa: S310 - validated https realm try: with opener.open(request, timeout=_OCI_LIMITS.timeout_seconds) as response: - payload = _read_capped(response, url=token_url, max_bytes=_OCI_LIMITS.max_metadata_bytes) + # Messages name the requested URL only, never the challenge-derived token URL. + payload = _read_capped(response, url=url, max_bytes=_OCI_LIMITS.max_metadata_bytes) except URLError as exc: raise SDLParseError(f"Failed to obtain an anonymous OCI registry token for {url}") from exc document = _decode_json_object(payload, context=f"OCI registry token response for {url}") diff --git a/implementations/python/tests/test_issue_1479_oci_anonymous_token.py b/implementations/python/tests/test_issue_1479_oci_anonymous_token.py index f2694507b4..2827e0763d 100644 --- a/implementations/python/tests/test_issue_1479_oci_anonymous_token.py +++ b/implementations/python/tests/test_issue_1479_oci_anonymous_token.py @@ -326,8 +326,9 @@ def _import_root(directory: Path, registry: _Server) -> Path: return root +@pytest.mark.parametrize("imports", [1, 2], ids=["one-import", "two-imports"]) def test_import_uses_one_anonymous_token_and_retries_each_request_once( - tmp_path: Path, layout: _Layout, serve: Callable[..., _Server], https: ssl.SSLContext + tmp_path: Path, layout: _Layout, serve: Callable[..., _Server], https: ssl.SSLContext, imports: int ) -> None: token = _new_token() token_server = serve(_fixed_route(_json({"token": token})), tls=https) @@ -335,21 +336,23 @@ def test_import_uses_one_anonymous_token_and_retries_each_request_once( registry = serve( _registry_route(layout, token=token, challenges=[_challenge(token_server)], blob_location=storage.origin) ) + root = _import_root(tmp_path, registry) - scenario = parse_sdl_file(_import_root(tmp_path, registry)) + scenarios = [parse_sdl_file(root) for _ in range(imports)] - assert set(scenario.nodes) == {"shared.vm"} - assert token_server.seen == [_Seen(f"/token?{TOKEN_QUERY}", None)] + assert [set(scenario.nodes) for scenario in scenarios] == imports * [{"shared.vm"}] + # The token cache lives for one import resolution, so each import requests its own token. + assert token_server.seen == imports * [_Seen(f"/token?{TOKEN_QUERY}", None)] resources = [ f"/v2/{REPOSITORY}/tags/list", f"/v2/{REPOSITORY}/manifests/{layout.tag}", f"/v2/{REPOSITORY}/blobs/{layout.config_digest}", f"/v2/{REPOSITORY}/blobs/{layout.bundle_digest}", ] - assert registry.seen == [ + assert registry.seen == imports * [ attempt for path in resources for attempt in (_Seen(path, None), _Seen(path, f"Bearer {token}")) ] - assert storage.seen == [ + assert storage.seen == imports * [ _Seen(f"/storage/{digest}?{SIGNED_QUERY}", None) for digest in (layout.config_digest, layout.bundle_digest) ] @@ -509,16 +512,21 @@ def test_token_response_is_read_under_the_metadata_limit( layout: _Layout, serve: Callable[..., _Server], https: ssl.SSLContext, monkeypatch: pytest.MonkeyPatch ) -> None: token = _new_token() - token_server = serve(_fixed_route(_json({"token": token, "padding": "x" * 64})), tls=https) + response = _json({"token": token, "padding": "x" * 64}) + token_server = serve(_fixed_route(response), tls=https) registry = serve(_registry_route(layout, token=token, challenges=[_challenge(token_server)])) limits = replace(module_registry._OCI_LIMITS, max_metadata_bytes=64) monkeypatch.setattr(module_registry, "_OCI_LIMITS", limits) url = _url(registry, "tags/list") - with pytest.raises(SDLParseError, match="exceeding the 64-byte limit"): + with pytest.raises(SDLParseError) as exc_info: module_registry._json_request(url) + # The message names the requested URL, not the token URL built from the challenge. + assert str(exc_info.value) == ( + f"OCI response from {url} declares Content-Length {len(response[2])} bytes, exceeding the 64-byte limit" + ) assert len(registry.seen) == 1 @@ -648,6 +656,11 @@ def test_bearer_challenge_grammar_rejects_malformed_challenges(header: str) -> N ("https://auth.test:99999/token", False), ("https://auth.test/a b", False), ("https://[::1/token", False), + # urllib percent-decodes the host it connects to, and the socket layer IDNA-encodes it. + ("https://a%20b.test/token", False), + ("https://a%0a.test/token", False), + ("https://a..test/token", False), + (f"https://{'a' * 64}.test/token", False), ], ) def test_token_realm_must_be_an_absolute_https_url(realm: str, accepted: bool) -> None: From 3d7b88e2b465ffa0c0a4a6b3b8894de8e95ca2b6 Mon Sep 17 00:00:00 2001 From: Yernat Yestekov <2068106+doublewhy@users.noreply.github.com> Date: Tue, 13 Oct 2026 09:54:47 +0000 Subject: [PATCH 04/11] refactor(sdl): collapse one resolution signature to keep the module under the line cap Dev's #1426 grew resolution.py to 492 lines, so the token threading put it at 501, over the ADR-015 500-line cap. Formatting only. --- .../python/packages/raes/module_registry/resolution.py | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/implementations/python/packages/raes/module_registry/resolution.py b/implementations/python/packages/raes/module_registry/resolution.py index 80e2497b11..c8d69352f1 100644 --- a/implementations/python/packages/raes/module_registry/resolution.py +++ b/implementations/python/packages/raes/module_registry/resolution.py @@ -119,10 +119,7 @@ def _lock_record_for(lockfile: Lockfile | None, import_decl: ImportDecl) -> Lock return None -def _verify_allowed_parameters( - import_decl: ImportDecl, - descriptor: ModuleDescriptor, -) -> None: +def _verify_allowed_parameters(import_decl: ImportDecl, descriptor: ModuleDescriptor) -> None: allowed = set(descriptor.parameters) disallowed = sorted(name for name in import_decl.parameters if name not in allowed) if disallowed: From deaed7d2b9fc3146f2593c02784f0150a51b4eac Mon Sep 17 00:00:00 2001 From: Yernat Yestekov <2068106+doublewhy@users.noreply.github.com> Date: Tue, 13 Oct 2026 21:32:36 +0000 Subject: [PATCH 05/11] test: record research captures for issue #1479 Collected with blitz-tools/collect_research_evidence.py on this branch's source (6 pinned artifacts through the production pipeline, 10 retained cases via replay_case, 4 production processor cases, 14 participant functions), then recorded with python -m tools.research_capture record. --- ...96f6012e0e4fe47d70da66f670b3be307f65f.json | 4 + .../analysis.json | 171 +++++ .../manifest.json | 122 +++ .../snapshot.json | 653 ++++++++++++++++ ...8b3474dad595adcd83484f0738935cb9883e5.json | 4 + .../analysis.json | 118 +++ .../manifest.json | 10 + .../snapshot.json | 708 ++++++++++++++++++ 8 files changed, 1790 insertions(+) create mode 100644 docs/research/formal-semantic-validation/capture-records/capture-72bb493cff3e02dc25dbaf3c7aa96f6012e0e4fe47d70da66f670b3be307f65f.json create mode 100644 docs/research/formal-semantic-validation/captures/capture-72bb493cff3e02dc25dbaf3c7aa96f6012e0e4fe47d70da66f670b3be307f65f/analysis.json create mode 100644 docs/research/formal-semantic-validation/captures/capture-72bb493cff3e02dc25dbaf3c7aa96f6012e0e4fe47d70da66f670b3be307f65f/manifest.json create mode 100644 docs/research/formal-semantic-validation/captures/capture-72bb493cff3e02dc25dbaf3c7aa96f6012e0e4fe47d70da66f670b3be307f65f/snapshot.json create mode 100644 docs/research/specification-coverage/capture-records/capture-aae28f85e4516ed1fe7aa76945a8b3474dad595adcd83484f0738935cb9883e5.json create mode 100644 docs/research/specification-coverage/captures/capture-aae28f85e4516ed1fe7aa76945a8b3474dad595adcd83484f0738935cb9883e5/analysis.json create mode 100644 docs/research/specification-coverage/captures/capture-aae28f85e4516ed1fe7aa76945a8b3474dad595adcd83484f0738935cb9883e5/manifest.json create mode 100644 docs/research/specification-coverage/captures/capture-aae28f85e4516ed1fe7aa76945a8b3474dad595adcd83484f0738935cb9883e5/snapshot.json diff --git a/docs/research/formal-semantic-validation/capture-records/capture-72bb493cff3e02dc25dbaf3c7aa96f6012e0e4fe47d70da66f670b3be307f65f.json b/docs/research/formal-semantic-validation/capture-records/capture-72bb493cff3e02dc25dbaf3c7aa96f6012e0e4fe47d70da66f670b3be307f65f.json new file mode 100644 index 0000000000..772641ae75 --- /dev/null +++ b/docs/research/formal-semantic-validation/capture-records/capture-72bb493cff3e02dc25dbaf3c7aa96f6012e0e4fe47d70da66f670b3be307f65f.json @@ -0,0 +1,4 @@ +{ + "capture_path": "docs/research/formal-semantic-validation/captures/capture-72bb493cff3e02dc25dbaf3c7aa96f6012e0e4fe47d70da66f670b3be307f65f/manifest.json", + "capture_sha256": "c56eec57a1bf503ae00a8fe5c96962d9f8ff37a5eb8b1e3d352375974c0905c1" +} diff --git a/docs/research/formal-semantic-validation/captures/capture-72bb493cff3e02dc25dbaf3c7aa96f6012e0e4fe47d70da66f670b3be307f65f/analysis.json b/docs/research/formal-semantic-validation/captures/capture-72bb493cff3e02dc25dbaf3c7aa96f6012e0e4fe47d70da66f670b3be307f65f/analysis.json new file mode 100644 index 0000000000..148a3bde6c --- /dev/null +++ b/docs/research/formal-semantic-validation/captures/capture-72bb493cff3e02dc25dbaf3c7aa96f6012e0e4fe47d70da66f670b3be307f65f/analysis.json @@ -0,0 +1,171 @@ +{ + "analysis_id": "issue-1479-oci-anonymous-token-formal-analysis-bee18848d137", + "claim": { + "allowed_evidence": [ + "production parser and semantic-validator results", + "canonical compiled digests", + "participant contract regression tests", + "pinned protocol, corpus, and execution snapshot" + ], + "claim_id": "asr-530-formal-semantic-validation-retest", + "disallowed_evidence": [ + "schema success as semantic proof", + "workflow reachability as network or exploit reachability", + "FM labels as gate outcomes", + "attribution as counterfactual proof", + "formal prose or maintainer confidence alone" + ], + "evidence_artifacts": [ + "docs/research/formal-semantic-validation/protocol-v2.json", + "docs/research/formal-semantic-validation/corpus/manifest-v4.json", + "@snapshot", + "docs/research/formal-semantic-validation/evidence/finite-domain-satisfiable-v4.json", + "docs/research/formal-semantic-validation/evidence/finite-domain-unsatisfiable-v4.json", + "docs/research/formal-semantic-validation/evidence/typed-exploit-path-valid-v4.json", + "docs/research/formal-semantic-validation/evidence/typed-exploit-path-invalid-v4.json" + ], + "falsification_protocol": "Replay every retained and new case through its production entrypoint, require complete digest and evidence joins, execute participant fixtures, and derive status from the recorded outcomes.", + "objective_fail_criteria": "A supported negative passes, a positive fails, an observation drifts, a required participant case is missing, or weaker evidence is promoted to solver, exploit-path, runtime-stability, or counterfactual assurance.", + "objective_pass_criteria": "Every claim class has positive and negative cases, all supported cases reproduce the frozen outcome, every participant obligation has passing positive and negative fixtures, and unsupported classes remain untested.", + "statement": "At the recorded source-state digest, the retained RAES controls have the bounded statuses recorded here; historical releases are integrity evidence, not current replay evidence.", + "threats_to_validity": [ + "The issue-specific corpus is intentionally small and does not enumerate every validator invariant.", + "The participant fixtures exercise reference production contracts and tests, not every independent backend realization.", + "The replay gate runs on one Python reference configuration and one pinned RAES revision.", + "Unsupported solver-level classes have protocol cases but no executable observations." + ] + }, + "claim_results": [ + { + "case_count": 2, + "claim_class_id": "schema-validity", + "evidence_status": "demonstrated", + "limitations": [ + "Bounded to the named source/model structural controls." + ], + "matching_case_count": 2, + "participant_obligation_count": 0, + "replayable_case_count": 2, + "unsupported_case_count": 0 + }, + { + "case_count": 4, + "claim_class_id": "semantic-consistency", + "evidence_status": "partial", + "limitations": [ + "Partial coverage of named static semantics and participant obligations, not universal consistency." + ], + "matching_case_count": 4, + "participant_obligation_count": 7, + "replayable_case_count": 4, + "unsupported_case_count": 0 + }, + { + "case_count": 2, + "claim_class_id": "graph-reachability", + "evidence_status": "partial", + "limitations": [ + "Partial workflow control-flow reachability only; not network, service, or exploit reachability." + ], + "matching_case_count": 2, + "participant_obligation_count": 0, + "replayable_case_count": 2, + "unsupported_case_count": 0 + }, + { + "case_count": 4, + "claim_class_id": "constraint-satisfiability", + "evidence_status": "demonstrated", + "limitations": [ + "Demonstrated only for raes-finite-domain-satisfiability-v1 and its pinned solver configuration." + ], + "matching_case_count": 4, + "participant_obligation_count": 0, + "replayable_case_count": 2, + "unsupported_case_count": 2 + }, + { + "case_count": 4, + "claim_class_id": "exploit-path-validity", + "evidence_status": "demonstrated", + "limitations": [ + "Demonstrated only for the admitted snapshot, typed graph, query, semantics, and bounded search profile." + ], + "matching_case_count": 4, + "participant_obligation_count": 0, + "replayable_case_count": 2, + "unsupported_case_count": 2 + }, + { + "case_count": 2, + "claim_class_id": "determinism-stability", + "evidence_status": "partial", + "limitations": [ + "Partial parse-to-compile repeatability only; runtime and backend determinism are untested." + ], + "matching_case_count": 2, + "participant_obligation_count": 0, + "replayable_case_count": 2, + "unsupported_case_count": 0 + }, + { + "case_count": 2, + "claim_class_id": "counterfactual-necessity", + "evidence_status": "untested", + "limitations": [ + "Untested because no governed intervention or ablation entrypoint ran." + ], + "matching_case_count": 2, + "participant_obligation_count": 0, + "replayable_case_count": 0, + "unsupported_case_count": 2 + } + ], + "corpus_revision": "4.0.0", + "evidence_status": "partial", + "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", + "generated_at": "2026-10-13T21:31:14.361582+00:00", + "limitations": [ + "Satisfiability is limited to raes-finite-domain-satisfiability-v1 and its exact translation, theory, and Z3 configuration.", + "The subset-minimal unsatisfiable core is not a universal proof certificate.", + "Exploit-path results are limited to the admitted snapshot, normalized graph, query, transition semantics, and bounded search profile.", + "A valid path is not backend execution and an invalid path is not real-world non-exploitability.", + "The production exploit-path JSON loader permits duplicate keys; the research loader rejects them without claiming stronger production behavior.", + "Participant replay inherits the host environment and is not described as hermetic.", + "Counterfactual necessity remains untested.", + "Scoped observation demand is not a claim class in this preregistration and is not promoted to demonstrated by this retest.", + "EXP-732 provenance joins are verified by their dedicated regression suite; this retained corpus makes no universal run, apparatus, source, or augmentation assurance claim.", + "This retained corpus does not establish native backend attestation fidelity; materialization contract checks remain separate operational provenance, not experimental observations.", + "Capture admission and evidence-proof authority are verified by issue-1237 regression tests, not promoted to a new claim class by this retained corpus.", + "Evidence-requirement refinement lineage is outside this retained formal claim set; this retest refreshes integrated source provenance without promoting that feature to a formal claim.", + "Authoring-adapter transport behavior is outside this retained formal claim set.", + "Operational recovery observation and startup reconciliation are verified by their API-404 regression suite, not promoted to a new formal claim class by this retained corpus.", + "Single-owner store admission, immutable target/run scope, and provider shutdown ordering are verified by their API-404 CP-5 regression suite, not promoted to a formal claim by this retained corpus.", + "Mixed and staged trial admission is verified by its SEM-234/SCE-002/API-407 regression suite, not promoted to a new formal claim class by this retained corpus.", + "Offline control-plane maintenance, readiness, and bounded audit behavior are verified by issue #1186 runtime tests, not promoted to a formal claim by this retained corpus.", + "Issue #1187 control-plane crash/profile conformance and HTTP security changes are covered by their dedicated regression suite, not promoted to new claims by this retained corpus.", + "Issue #1189 profile declarations and capability admission are covered by dedicated runtime tests; the retained formal corpus does not execute control-plane profile composition.", + "Issue #1016 mixed-runtime coordination is covered by dedicated runtime tests; the retained formal corpus does not establish backend-native mixed realization, multi-controller coordination, IFC, or equivalence.", + "Issue #610's reconciliation demonstration harness is covered by its dedicated processor and CLI suite, not promoted to new claims by the retained language corpus.", + "Participant identity, organization ownership, and participant assignment are separated by issue #1338. This retained offline corpus does not establish participant autonomy, execution authority, live backend fidelity, or causal attribution.", + "Issue #1389 temporal-subject admission is verified by dedicated compiler tests and adds no new formal-semantic claim to this retained corpus.", + "Issue #971 model construction is verified by its own tests; this retained corpus establishes no participant-crossing equivalence or runtime-realization claim.", + "Issue #1359 control-plane route authority, participant-view scoping, and no-store HTTP boundary are verified by their dedicated HTTP-boundary suite and add no new formal-semantic claim to this retained corpus.", + "Issue #1401 required-evidence media-type coherence is verified by its dedicated suite and adds no new formal-semantic claim to this retained corpus.", + "Issue #1361 execution and recovery requirements are verified by dedicated policy, composition, and admission tests; this retained corpus establishes no live recovery, continuation, or trial-allocation guarantee.", + "The issue #1361 maintainability repair preserves policy semantics and retained corpus outcomes; it establishes no live recovery, continuation, or trial-allocation guarantee.", + "The issue #1361 resource type-hint repair preserves policy semantics and retained corpus outcomes; it establishes no live recovery, continuation, or trial-allocation guarantee.", + "The combined issue #1361 execution-policy and hatchling update preserves retained outcomes and bounded claims; it establishes no live recovery, continuation, or trial-allocation guarantee.", + "The issue #1418 runtime-fact export manifest split changes no contract, schema or behavior and adds no new formal-semantic claim.", + "The issue #1423 inject trigger request and occurrence contracts are new draft carriers that no SDL construct, compiler or runtime path reads, and they add no new formal-semantic claim.", + "The issue #1366 inject readback, correlation and backend declaration contracts are new draft carriers; the shared backend allowlist also lets SDL participant behavior specifications cite inject-occurrence-v1 and inject-occurrence-outcome-v1 as evidence_contract_refs, which the compiler copies through uninterpreted, and no runtime path or shipped backend reads or declares them; they add no new formal-semantic claim.", + "This synchronization preserves the original inject baseline chain in the pre-sync archive, retains frozen production and participant evidence, and binds the combined contract source. CI independently verifies current evidence replay; no new runtime adoption is claimed.", + "This second synchronization binds behavior-authoring source from issue #297, retains frozen production and participant evidence, and pins the preserved first-sync release 75 as its baseline. CI independently verifies replay; no new runtime adoption is claimed.", + "Issue #1091 request-boundary admission is verified by its dedicated tests; this retained corpus does not execute the served HTTP adapter or broaden its bounded claims.", + "This combined-source capture replays the supported retained corpus and the 18 declared participant test cases. The inject contract repair has 126 passing request, occurrence and readback tests; no runtime inject execution or broader formal claim is established. CI independently verifies replay.", + "Issue #1395 adds a separate bounded two-operation crossing model profile. This retained corpus does not establish participant-crossing equivalence or runtime realization; those assurances remain separate.", + "Issue #1479 fetches OCI modules from public registries through the distribution anonymous bearer-token flow; this retained corpus makes no new claim." + ], + "plain_language_outcome": "The retained formal cases reproduce their outcomes after issue #1479 added the anonymous bearer-token flow to OCI module fetches. Bounded claims and unsupported classes are unchanged.", + "protocol_revision": "2.0.0" +} diff --git a/docs/research/formal-semantic-validation/captures/capture-72bb493cff3e02dc25dbaf3c7aa96f6012e0e4fe47d70da66f670b3be307f65f/manifest.json b/docs/research/formal-semantic-validation/captures/capture-72bb493cff3e02dc25dbaf3c7aa96f6012e0e4fe47d70da66f670b3be307f65f/manifest.json new file mode 100644 index 0000000000..fe1efc0f0e --- /dev/null +++ b/docs/research/formal-semantic-validation/captures/capture-72bb493cff3e02dc25dbaf3c7aa96f6012e0e4fe47d70da66f670b3be307f65f/manifest.json @@ -0,0 +1,122 @@ +{ + "analysis_path": "docs/research/formal-semantic-validation/captures/capture-72bb493cff3e02dc25dbaf3c7aa96f6012e0e4fe47d70da66f670b3be307f65f/analysis.json", + "analysis_sha256": "918c025d34773ef1e8c648c171d4e8f6d87f26d0d6e915f2d814e7a20043b499", + "artifacts": [ + { + "artifact_id": "finite-domain-satisfiable-v2-input", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/satisfiable-control.sdl.yaml", + "sha256": "0ca9eaba9dc47171f7a042dc6753faa6c820c65ee966538f9d65fac5342202e8" + }, + { + "artifact_id": "finite-domain-satisfiable-v2-evidence", + "kind": "production-evidence", + "path": "docs/research/formal-semantic-validation/evidence/finite-domain-satisfiable-v4.json", + "sha256": "554202313d678046958b5c028e2de26ff03c74895cfac552677eed74e8153add" + }, + { + "artifact_id": "finite-domain-unsatisfiable-v2-input", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/unsatisfiable-control.sdl.yaml", + "sha256": "cfef56a1f56d5f0db9da195377fd75694bdd0f0b92932fdb8fafcbd3f7baf6c5" + }, + { + "artifact_id": "finite-domain-unsatisfiable-v2-evidence", + "kind": "production-evidence", + "path": "docs/research/formal-semantic-validation/evidence/finite-domain-unsatisfiable-v4.json", + "sha256": "c972725ef64822a75a60380afc11f08eac25b7fe9b091d39b058b3c9f7c8031d" + }, + { + "artifact_id": "typed-exploit-path-valid-v2-input", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/exploit-path-valid-v3.json", + "sha256": "0afe635a63db5b6e6380ac70982fd61d09790745d51a10d670321304121e7c39" + }, + { + "artifact_id": "typed-exploit-path-valid-v2-evidence", + "kind": "production-evidence", + "path": "docs/research/formal-semantic-validation/evidence/typed-exploit-path-valid-v4.json", + "sha256": "1b7f55d04db172da32658187c64a88c13b5f4d565267ce2be7cb86a9d04cb70c" + }, + { + "artifact_id": "typed-exploit-path-invalid-v2-input", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/exploit-path-invalid-v3.json", + "sha256": "0b2293d4a8983515ff05c516be6e6b418a4f3f09e055250a00bf15fda861aab3" + }, + { + "artifact_id": "typed-exploit-path-invalid-v2-evidence", + "kind": "production-evidence", + "path": "docs/research/formal-semantic-validation/evidence/typed-exploit-path-invalid-v4.json", + "sha256": "244f895a64f14c10916ab0533ab462ce80a328021cd6a50c30a4aa59266d5533" + }, + { + "artifact_id": "schema-valid-control-fixture", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/schema-valid.sdl.yaml", + "sha256": "41a9adffdf9f5f2ccc2f887dcf7b15fba3b47c83a1af15f33db872c4a2449d67" + }, + { + "artifact_id": "schema-unknown-field-fixture", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/schema-invalid-unknown-field.sdl.yaml", + "sha256": "51cf62319a86c95a2517995939d1f370573051835e4b55bb6d5beaf049640481" + }, + { + "artifact_id": "semantic-resolved-objective-fixture", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/semantic-valid-participant-identity-v2.sdl.yaml", + "sha256": "75834bdc883e2003e1c473870bdf75700978955bb83095c6bd718ba6bd3908a6" + }, + { + "artifact_id": "semantic-dangling-assertion-fixture", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/semantic-invalid-dangling-ref-participant-identity-v2.sdl.yaml", + "sha256": "1d25bee5f556054e5f0a518df025e4c62e080e1964035e3c1a12e074d88d3a5d" + }, + { + "artifact_id": "semantic-ambiguous-reference-fixture", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/semantic-invalid-ambiguous-ref.sdl.yaml", + "sha256": "653cbd2fd62e220d49fb86f80133884207df5ae6752846345ae3085b93f6e4ed" + }, + { + "artifact_id": "semantic-feature-cycle-fixture", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/semantic-invalid-feature-cycle.sdl.yaml", + "sha256": "e1f66d95a9ad039687aec8cccbc8843b514072ff08e006c1b4ca6aa5cd8d4ed1" + }, + { + "artifact_id": "workflow-reachable-control-fixture", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/workflow-reachable.sdl.yaml", + "sha256": "54c40ceb98ad47247447d737973b2c55e8fb2045e209c7545c4fb20cf42dc3dc" + }, + { + "artifact_id": "workflow-unreachable-step-fixture", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/workflow-unreachable.sdl.yaml", + "sha256": "ef22ef2e260f1a7fd92d286f9b571716436b192ddfd54aea7bdfcfdda4ca52a2" + }, + { + "artifact_id": "compile-repeatability-control-fixture", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/determinism-a.sdl.yaml", + "sha256": "0bc40900d598c1af7a405d798ca19710405e53ced262d8733081abf12edf89fe" + }, + { + "artifact_id": "compile-non-vacuity-control-comparison-fixture", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/determinism-b.sdl.yaml", + "sha256": "d85338f89f20a45515b12da8640173c1a52e47eb17ca0f4f6b4f8f3306e863a1" + } + ], + "bundle_id": "raes-formal-semantic-validation", + "corpus_path": "docs/research/formal-semantic-validation/corpus/manifest-v4.json", + "corpus_sha256": "c57207af72406aa4f70882b9bbeb7cedcc79cf3854c878a95e3eb1fa59ea7a72", + "protocol_path": "docs/research/formal-semantic-validation/protocol-v2.json", + "protocol_sha256": "abf94093e344bf495dfb04e8b0c5985c0beaab8ebb17a75e15c8674fa81b1a7c", + "revision": "capture-72bb493cff3e02dc25dbaf3c7aa96f6012e0e4fe47d70da66f670b3be307f65f", + "snapshot_path": "docs/research/formal-semantic-validation/captures/capture-72bb493cff3e02dc25dbaf3c7aa96f6012e0e4fe47d70da66f670b3be307f65f/snapshot.json", + "snapshot_sha256": "57846ec96752167f833cf99061a7aa98321892667dabb50c2fc40d11f91b0e6d" +} diff --git a/docs/research/formal-semantic-validation/captures/capture-72bb493cff3e02dc25dbaf3c7aa96f6012e0e4fe47d70da66f670b3be307f65f/snapshot.json b/docs/research/formal-semantic-validation/captures/capture-72bb493cff3e02dc25dbaf3c7aa96f6012e0e4fe47d70da66f670b3be307f65f/snapshot.json new file mode 100644 index 0000000000..0ebadbc936 --- /dev/null +++ b/docs/research/formal-semantic-validation/captures/capture-72bb493cff3e02dc25dbaf3c7aa96f6012e0e4fe47d70da66f670b3be307f65f/snapshot.json @@ -0,0 +1,653 @@ +{ + "baseline": { + "execution_id": "issue-1395-crossing-formal-3c684ef5d50a", + "release_path": "docs/research/formal-semantic-validation/captures/capture-3bad394534ce94f3cfc052a52e3305495c2733ddda860ab3b1e5c24758a3f62c/manifest.json", + "release_revision": "capture-3bad394534ce94f3cfc052a52e3305495c2733ddda860ab3b1e5c24758a3f62c", + "release_sha256": "f9544867cb1bedeb1cc1d0903e0dde2fdf22d1bda17819d90dad28de395ecc61" + }, + "captured_at": "2026-10-13T21:31:14.361582+00:00", + "commands": [ + { + "argv": [ + "implementations/python/.venv/bin/python", + "-c", + "import json, sys\nfrom pathlib import Path\nroot = Path.cwd().resolve()\nfor entry in (str(root), str(root / \"implementations\" / \"python\" / \"packages\")):\n if entry not in sys.path:\n sys.path.insert(0, entry)\nfrom tools.formal_semantic_validation._replay import replay_case\ncorpus = json.loads((root / \"docs/research/formal-semantic-validation/corpus/manifest-v4.json\").read_text(encoding=\"utf-8\"))\nskipped = set([\"exploit-path\", \"satisfiability\", \"unsupported\"])\nresults = {}\nfor case in corpus[\"cases\"]:\n if case.get(\"replay_mode\") in skipped:\n continue\n try:\n results[case[\"case_id\"]] = {\"ok\": True, **replay_case(root, case)}\n except Exception as exc:\n results[case[\"case_id\"]] = {\"ok\": False, \"error\": type(exc).__name__ + \": \" + str(exc)[:300]}\nprint(json.dumps(results, sort_keys=True))\n" + ], + "command_id": "retained-case-replay", + "network": "disabled" + }, + { + "argv": [ + "implementations/python/.venv/bin/pytest", + "-q", + "implementations/python/tests/test_sem_208_participant_behavior.py::test_hidden_truth_disclosure_is_separate_from_observable_projection", + "implementations/python/tests/test_sem_208_participant_behavior.py::test_hidden_truth_cannot_be_observed_without_explicit_disclosure_rule", + "implementations/python/tests/test_sem_211_participant_action_semantics.py::test_action_contract_declares_sem_211_classes_and_compiles_them", + "implementations/python/tests/test_sem_211_participant_action_semantics.py::test_action_result_rejects_success_when_preconditions_are_unresolved", + "implementations/python/tests/test_run_308_concurrent_participant_execution.py::test_runtime_snapshot_publishes_joint_action_and_time_context_records", + "implementations/python/tests/test_run_308_concurrent_participant_execution.py::test_joint_action_record_contract_rejects_unordered_conflicting_writes", + "implementations/python/tests/test_participant_runtime_invariants.py::test_order_discipline_accepts_supported_order_claim_strengths", + "implementations/python/tests/test_participant_runtime_invariants.py::test_order_discipline_rejects_wall_clock_causality", + "implementations/python/tests/test_sem_212_participant_attribution_semantics.py::test_attribution_edge_round_trips_on_terminal_observation", + "implementations/python/tests/test_sem_212_participant_attribution_semantics.py::test_timestamp_adjacency_cannot_be_reported_as_strong_causality", + "implementations/python/tests/test_sem_215_participant_outcome_interpretation.py::test_outcome_interpretation_rule_parses_and_compiles_explicit_layers", + "implementations/python/tests/test_sem_215_participant_outcome_interpretation.py::test_local_action_success_does_not_imply_objective_success_without_rule_record", + "implementations/python/tests/test_realization_honesty_conformance.py::test_constructive_envelope_runs_positive_and_negative_honesty_probes", + "implementations/python/tests/test_realization_honesty_conformance.py::test_only_native_live_can_support_native_conformance" + ], + "command_id": "participant-fixtures", + "network": "disabled" + }, + { + "argv": [ + "implementations/python/.venv/bin/raes", + "processor", + "satisfiability", + "docs/research/formal-semantic-validation/corpus/satisfiable-control.sdl.yaml", + "--profile", + "raes-finite-domain-satisfiability-v1" + ], + "command_id": "finite-domain-satisfiable-v2", + "network": "disabled" + }, + { + "argv": [ + "implementations/python/.venv/bin/raes", + "processor", + "satisfiability", + "docs/research/formal-semantic-validation/corpus/unsatisfiable-control.sdl.yaml", + "--profile", + "raes-finite-domain-satisfiability-v1" + ], + "command_id": "finite-domain-unsatisfiable-v2", + "network": "disabled" + }, + { + "argv": [ + "implementations/python/.venv/bin/raes", + "processor", + "exploit-path", + "docs/research/formal-semantic-validation/corpus/exploit-path-valid-v3.json", + "--profile", + "raes-exploit-path-analysis-v1" + ], + "command_id": "typed-exploit-path-valid-v2", + "network": "disabled" + }, + { + "argv": [ + "implementations/python/.venv/bin/raes", + "processor", + "exploit-path", + "docs/research/formal-semantic-validation/corpus/exploit-path-invalid-v3.json", + "--profile", + "raes-exploit-path-analysis-v1" + ], + "command_id": "typed-exploit-path-invalid-v2", + "network": "disabled" + } + ], + "configuration_id": "raes-python-reference-offline-v41", + "corpus_revision": "4.0.0", + "deviations": [], + "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", + "execution_status": "complete", + "observations": [ + { + "actual_outcome": "accepted", + "analysis_profile": null, + "case_id": "schema-valid-control", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": null, + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/schema-valid.sdl.yaml" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", + "limitations": [ + "A passing minimal source does not establish semantic correctness." + ], + "replayable": true, + "result_digest": "f7d364ef384df8a1526b489501835b635021c860793b5764f91d956710d2250c", + "source_digest": null + }, + { + "actual_outcome": "rejected", + "analysis_profile": null, + "case_id": "schema-unknown-field", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": "SDLParseError", + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/schema-invalid-unknown-field.sdl.yaml" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", + "limitations": [ + "The observation covers one unknown-field defect only." + ], + "replayable": true, + "result_digest": "f55d834b458f8e069e1c69061b4cc0a6d61e0e052bf90c670f2e6a5ad8b5bd98", + "source_digest": null + }, + { + "actual_outcome": "accepted", + "analysis_profile": null, + "case_id": "semantic-resolved-objective", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": null, + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/semantic-valid-participant-identity-v2.sdl.yaml" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", + "limitations": [ + "This is a positive control for one objective-reference slice." + ], + "replayable": true, + "result_digest": "652288785dc09095955ed3649f6407d616fb7c4d4f4188df4ed513ccb7537e0b", + "source_digest": null + }, + { + "actual_outcome": "rejected", + "analysis_profile": null, + "case_id": "semantic-dangling-assertion", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": "SDLValidationError", + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/semantic-invalid-dangling-ref-participant-identity-v2.sdl.yaml" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", + "limitations": [ + "A single dangling reference does not prove complete semantic coverage." + ], + "replayable": true, + "result_digest": "0207cf616b56708ca9b8c4499d3301abe22dbe52162cf8d58d3bec429d9db024", + "source_digest": null + }, + { + "actual_outcome": "rejected", + "analysis_profile": null, + "case_id": "semantic-ambiguous-reference", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": "SDLValidationError", + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/semantic-invalid-ambiguous-ref.sdl.yaml" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", + "limitations": [ + "One namespace collision does not enumerate every ambiguity surface." + ], + "replayable": true, + "result_digest": "9da4a87797d228e0012ab6b30459f4892e41aa6f224a9840be035fee4a2eea73", + "source_digest": null + }, + { + "actual_outcome": "rejected", + "analysis_profile": null, + "case_id": "semantic-feature-cycle", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": "SDLValidationError", + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/semantic-invalid-feature-cycle.sdl.yaml" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", + "limitations": [ + "One static dependency cycle does not establish general constraint satisfiability." + ], + "replayable": true, + "result_digest": "d15dbcd99fb4f20b965d7031b07dd6534576302270399c3fa656d29e7de02b83", + "source_digest": null + }, + { + "actual_outcome": "accepted", + "analysis_profile": null, + "case_id": "workflow-reachable-control", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": null, + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/workflow-reachable.sdl.yaml" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", + "limitations": [ + "The graph is workflow control flow only." + ], + "replayable": true, + "result_digest": "b1b49649b54bd59d4ef357b39cf9158da90f4eae560f8dd756acf97bd0827a06", + "source_digest": null + }, + { + "actual_outcome": "rejected", + "analysis_profile": null, + "case_id": "workflow-unreachable-step", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": "SDLValidationError", + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/workflow-unreachable.sdl.yaml" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", + "limitations": [ + "The result does not establish network, service, participant, or exploit reachability." + ], + "replayable": true, + "result_digest": "bb931d19346ef9193408ae6c85deb4079704378fc5f00dc5f47a2817cff21943", + "source_digest": null + }, + { + "actual_outcome": "unsupported", + "analysis_profile": null, + "case_id": "whole-scenario-satisfiable-request", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": null, + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/decisions/issue-168-formal-semantic-validation-reachability-preflight.md" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", + "limitations": [ + "No governed whole-scenario constraint theory or solver exists." + ], + "replayable": false, + "result_digest": null, + "source_digest": null + }, + { + "actual_outcome": "unsupported", + "analysis_profile": null, + "case_id": "whole-scenario-unsatisfiable-request", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": null, + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/decisions/issue-168-formal-semantic-validation-reachability-preflight.md" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", + "limitations": [ + "Local checks cannot produce a whole-scenario unsat certificate." + ], + "replayable": false, + "result_digest": null, + "source_digest": null + }, + { + "actual_outcome": "unsupported", + "analysis_profile": null, + "case_id": "valid-exploit-path-request", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": null, + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/decisions/issue-168-formal-semantic-validation-reachability-preflight.md" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", + "limitations": [ + "The issue-168 baseline had no canonical typed attack graph or path-query entrypoint." + ], + "replayable": false, + "result_digest": null, + "source_digest": null + }, + { + "actual_outcome": "unsupported", + "analysis_profile": null, + "case_id": "invalid-exploit-path-request", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": null, + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/decisions/issue-168-formal-semantic-validation-reachability-preflight.md" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", + "limitations": [ + "Vulnerability and topology declarations are not an invalid-path proof." + ], + "replayable": false, + "result_digest": null, + "source_digest": null + }, + { + "actual_outcome": "stable", + "analysis_profile": null, + "case_id": "compile-repeatability-control", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": null, + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/determinism-a.sdl.yaml" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", + "limitations": [ + "The witness ends at compiled output." + ], + "replayable": true, + "result_digest": "d7c098c5d063b8d1b0747e8df5daa90061456065cdda0bbedfa10918442f5daa", + "source_digest": null + }, + { + "actual_outcome": "distinguishable", + "analysis_profile": null, + "case_id": "compile-non-vacuity-control", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": null, + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/determinism-a.sdl.yaml", + "docs/research/formal-semantic-validation/corpus/determinism-b.sdl.yaml" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", + "limitations": [ + "Distinct digests are a non-vacuity control, not semantic non-equivalence proof." + ], + "replayable": true, + "result_digest": "a2fcebba3341592b133af813e8bb8e5f47270418bc58bfd471a89bfbc8ba46da", + "source_digest": null + }, + { + "actual_outcome": "unsupported", + "analysis_profile": null, + "case_id": "necessity-witness-request", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": null, + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/decisions/issue-168-formal-semantic-validation-reachability-preflight.md" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", + "limitations": [ + "No governed intervention or ablation protocol exists." + ], + "replayable": false, + "result_digest": null, + "source_digest": null + }, + { + "actual_outcome": "unsupported", + "analysis_profile": null, + "case_id": "non-necessity-control-request", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": null, + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/decisions/issue-168-formal-semantic-validation-reachability-preflight.md" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", + "limitations": [ + "Attribution and negative fixtures do not demonstrate non-necessity." + ], + "replayable": false, + "result_digest": null, + "source_digest": null + }, + { + "actual_outcome": "satisfiable", + "analysis_profile": "raes-finite-domain-satisfiability-v1", + "case_id": "finite-domain-satisfiable-v2", + "configuration_digest": "sha256:1204635e17e759e9ad3bd6be2ecb28c6de05c07ead6dfdd15936ed5d3d5b81b2", + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": "scenario-satisfiability-evidence/v1", + "evidence_artifact_path": "docs/research/formal-semantic-validation/evidence/finite-domain-satisfiable-v4.json", + "evidence_artifact_sha256": "554202313d678046958b5c028e2de26ff03c74895cfac552677eed74e8153add", + "evidence_digest": "sha256:23c2cae7d95d4cc83d77ca576e3911477b169ecc311c977cb45490345f633b5a", + "evidence_profile": "scenario-satisfiability-evidence/v1", + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/satisfiable-control.sdl.yaml", + "docs/research/formal-semantic-validation/evidence/finite-domain-satisfiable-v4.json", + "specs/formal/scenario-satisfiability/README.md" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", + "limitations": [ + "Demonstrates only the pinned finite-domain theory, translation, solver profile, and source." + ], + "replayable": true, + "result_digest": "sha256:23c2cae7d95d4cc83d77ca576e3911477b169ecc311c977cb45490345f633b5a", + "source_digest": "sha256:0ca9eaba9dc47171f7a042dc6753faa6c820c65ee966538f9d65fac5342202e8" + }, + { + "actual_outcome": "unsatisfiable", + "analysis_profile": "raes-finite-domain-satisfiability-v1", + "case_id": "finite-domain-unsatisfiable-v2", + "configuration_digest": "sha256:1204635e17e759e9ad3bd6be2ecb28c6de05c07ead6dfdd15936ed5d3d5b81b2", + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": "scenario-satisfiability-evidence/v1", + "evidence_artifact_path": "docs/research/formal-semantic-validation/evidence/finite-domain-unsatisfiable-v4.json", + "evidence_artifact_sha256": "c972725ef64822a75a60380afc11f08eac25b7fe9b091d39b058b3c9f7c8031d", + "evidence_digest": "sha256:317b5cad00aa7f4f7868dca66127611ba19d40ffd86f35815502622814df54c1", + "evidence_profile": "scenario-satisfiability-evidence/v1", + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/unsatisfiable-control.sdl.yaml", + "docs/research/formal-semantic-validation/evidence/finite-domain-unsatisfiable-v4.json", + "specs/formal/scenario-satisfiability/README.md" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", + "limitations": [ + "The subset-minimal core is evidence for the pinned translation and solver, not a proof certificate for arbitrary SDL." + ], + "replayable": true, + "result_digest": "sha256:317b5cad00aa7f4f7868dca66127611ba19d40ffd86f35815502622814df54c1", + "source_digest": "sha256:cfef56a1f56d5f0db9da195377fd75694bdd0f0b92932fdb8fafcbd3f7baf6c5" + }, + { + "actual_outcome": "valid-path", + "analysis_profile": "raes-exploit-path-analysis-v1", + "case_id": "typed-exploit-path-valid-v2", + "configuration_digest": "sha256:7f8876d81feb77d3a3239be2fb8337de8885e2744f8786728ba23e4e6027bc0a", + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": "exploit-path-analysis-evidence/v1", + "evidence_artifact_path": "docs/research/formal-semantic-validation/evidence/typed-exploit-path-valid-v4.json", + "evidence_artifact_sha256": "1b7f55d04db172da32658187c64a88c13b5f4d565267ce2be7cb86a9d04cb70c", + "evidence_digest": "sha256:2d4d1a362751abd9544beb8af7f8c6331d04dac8f4abc315fb261f81fbaf4387", + "evidence_profile": "exploit-path-analysis-evidence/v1", + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/exploit-path-valid-v3.json", + "docs/research/formal-semantic-validation/evidence/typed-exploit-path-valid-v4.json", + "specs/formal/exploit-path-analysis/README.md" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", + "limitations": [ + "The witness is bounded to the admitted snapshot, normalized graph, query, semantics, and search profile; it does not establish backend execution." + ], + "replayable": true, + "result_digest": "sha256:2d4d1a362751abd9544beb8af7f8c6331d04dac8f4abc315fb261f81fbaf4387", + "source_digest": "sha256:0afe635a63db5b6e6380ac70982fd61d09790745d51a10d670321304121e7c39" + }, + { + "actual_outcome": "invalid-path", + "analysis_profile": "raes-exploit-path-analysis-v1", + "case_id": "typed-exploit-path-invalid-v2", + "configuration_digest": "sha256:7f8876d81feb77d3a3239be2fb8337de8885e2744f8786728ba23e4e6027bc0a", + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": "exploit-path-analysis-evidence/v1", + "evidence_artifact_path": "docs/research/formal-semantic-validation/evidence/typed-exploit-path-invalid-v4.json", + "evidence_artifact_sha256": "244f895a64f14c10916ab0533ab462ce80a328021cd6a50c30a4aa59266d5533", + "evidence_digest": "sha256:1b416bb5a4d29d57c961b769cc9d3af5d9328624e3eebf104d57f39a94c5bb97", + "evidence_profile": "exploit-path-analysis-evidence/v1", + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/exploit-path-invalid-v3.json", + "docs/research/formal-semantic-validation/evidence/typed-exploit-path-invalid-v4.json", + "specs/formal/exploit-path-analysis/README.md" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", + "limitations": [ + "Structured rejection proves only that this bounded graph/query cannot reach its goal; it does not establish real-world non-exploitability." + ], + "replayable": true, + "result_digest": "sha256:1b416bb5a4d29d57c961b769cc9d3af5d9328624e3eebf104d57f39a94c5bb97", + "source_digest": "sha256:0b2293d4a8983515ff05c516be6e6b418a4f3f09e055250a00bf15fda861aab3" + } + ], + "participant_observations": [ + { + "evidence_refs": [ + "implementations/python/tests/test_sem_208_participant_behavior.py::test_hidden_truth_disclosure_is_separate_from_observable_projection", + "implementations/python/tests/test_sem_208_participant_behavior.py::test_hidden_truth_cannot_be_observed_without_explicit_disclosure_rule" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", + "limitations": [ + "Covers the reference SDL/contract path, not every backend projection." + ], + "negative_outcome": "passed", + "obligation_id": "hidden-vs-visible-projection", + "positive_outcome": "passed" + }, + { + "evidence_refs": [ + "implementations/python/tests/test_sem_211_participant_action_semantics.py::test_action_contract_declares_sem_211_classes_and_compiles_them", + "implementations/python/tests/test_sem_211_participant_action_semantics.py::test_action_result_rejects_success_when_preconditions_are_unresolved" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", + "limitations": [ + "Covers declared applicability and one unresolved-precondition failure." + ], + "negative_outcome": "passed", + "obligation_id": "fail-closed-action-applicability", + "positive_outcome": "passed" + }, + { + "evidence_refs": [ + "implementations/python/tests/test_run_308_concurrent_participant_execution.py::test_runtime_snapshot_publishes_joint_action_and_time_context_records", + "implementations/python/tests/test_run_308_concurrent_participant_execution.py::test_joint_action_record_contract_rejects_unordered_conflicting_writes" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", + "limitations": [ + "Contract evidence does not prove every backend's live concurrency fidelity." + ], + "negative_outcome": "passed", + "obligation_id": "shared-state-effects", + "positive_outcome": "passed" + }, + { + "evidence_refs": [ + "implementations/python/tests/test_participant_runtime_invariants.py::test_order_discipline_accepts_supported_order_claim_strengths", + "implementations/python/tests/test_participant_runtime_invariants.py::test_order_discipline_rejects_wall_clock_causality" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", + "limitations": [ + "Rejecting timestamp-only causality does not supply counterfactual proof." + ], + "negative_outcome": "passed", + "obligation_id": "ordering-before-causality", + "positive_outcome": "passed" + }, + { + "evidence_refs": [ + "implementations/python/tests/test_sem_212_participant_attribution_semantics.py::test_attribution_edge_round_trips_on_terminal_observation", + "implementations/python/tests/test_sem_212_participant_attribution_semantics.py::test_timestamp_adjacency_cannot_be_reported_as_strong_causality" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", + "limitations": [ + "Attribution labels disclose basis; they do not demonstrate necessity." + ], + "negative_outcome": "passed", + "obligation_id": "evidence-labeled-attribution", + "positive_outcome": "passed" + }, + { + "evidence_refs": [ + "implementations/python/tests/test_sem_215_participant_outcome_interpretation.py::test_outcome_interpretation_rule_parses_and_compiles_explicit_layers", + "implementations/python/tests/test_sem_215_participant_outcome_interpretation.py::test_local_action_success_does_not_imply_objective_success_without_rule_record" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", + "limitations": [ + "The fixtures establish layer separation, not outcome validity in every realization." + ], + "negative_outcome": "passed", + "obligation_id": "participant-local-outcome-separation", + "positive_outcome": "passed" + }, + { + "evidence_refs": [ + "implementations/python/tests/test_realization_honesty_conformance.py::test_constructive_envelope_runs_positive_and_negative_honesty_probes", + "implementations/python/tests/test_realization_honesty_conformance.py::test_only_native_live_can_support_native_conformance" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", + "limitations": [ + "Reference conformance evidence remains bounded to declared realization profiles." + ], + "negative_outcome": "passed", + "obligation_id": "realization-profile-honesty", + "positive_outcome": "passed" + } + ], + "protocol_revision": "2.0.0", + "raes_revision": "3d7b88e2b465ffa0c0a4a6b3b8894de8e95ca2b6", + "source_state": { + "base_revision": "3d7b88e2b465ffa0c0a4a6b3b8894de8e95ca2b6", + "checkout_state": "clean", + "implementation_digest": "bee18848d1372ba29188de8a8443c494d377824261645f88cf4c2d9353677cf8", + "profile": "python-reference-source/v2" + }, + "versions": { + "python": "3.12.3", + "raes": "5.0.0", + "z3_engine": "4.16.0", + "z3_solver": "4.16.0.0" + } +} diff --git a/docs/research/specification-coverage/capture-records/capture-aae28f85e4516ed1fe7aa76945a8b3474dad595adcd83484f0738935cb9883e5.json b/docs/research/specification-coverage/capture-records/capture-aae28f85e4516ed1fe7aa76945a8b3474dad595adcd83484f0738935cb9883e5.json new file mode 100644 index 0000000000..dd8b443ded --- /dev/null +++ b/docs/research/specification-coverage/capture-records/capture-aae28f85e4516ed1fe7aa76945a8b3474dad595adcd83484f0738935cb9883e5.json @@ -0,0 +1,4 @@ +{ + "capture_path": "docs/research/specification-coverage/captures/capture-aae28f85e4516ed1fe7aa76945a8b3474dad595adcd83484f0738935cb9883e5/manifest.json", + "capture_sha256": "5c2cd5c8dd87cb3872287f28457807dfe69f0bc316e1abd241e7d948df92de85" +} diff --git a/docs/research/specification-coverage/captures/capture-aae28f85e4516ed1fe7aa76945a8b3474dad595adcd83484f0738935cb9883e5/analysis.json b/docs/research/specification-coverage/captures/capture-aae28f85e4516ed1fe7aa76945a8b3474dad595adcd83484f0738935cb9883e5/analysis.json new file mode 100644 index 0000000000..31c46c1b9a --- /dev/null +++ b/docs/research/specification-coverage/captures/capture-aae28f85e4516ed1fe7aa76945a8b3474dad595adcd83484f0738935cb9883e5/analysis.json @@ -0,0 +1,118 @@ +{ + "analysis_id": "issue-1479-oci-anonymous-token-specification-analysis-bee18848d137", + "backend_leakage": [], + "claim": { + "allowed_evidence": [ + "pinned source metadata and bounded paraphrases", + "production parser, semantic, instantiation, admission, compiler, contract, and profile results", + "exact artifact digests and typed pointers", + "documented missing-concept and backend-specific dispositions" + ], + "claim_id": "raes-standardized-configurable-specification-coverage", + "disallowed_evidence": [ + "field-count or schema breadth alone", + "the existing scenario stress corpus as the representative request corpus", + "free-form metadata as typed coverage", + "backend-private interpretation", + "post-hoc removal or repair of falsifying concepts" + ], + "evidence_artifacts": [ + "docs/research/specification-coverage/protocol-v1.json", + "@snapshot" + ], + "falsification_protocol": "docs/research/specification-coverage/protocol-v1.json", + "objective_fail_criteria": "A load-bearing concept is missing or lossy, an applicable stage fails, or backend vocabulary is required in core SDL while the result claims success.", + "objective_pass_criteria": "Every load-bearing concept passes at every owning stage, backend-specific mechanics stay outside core SDL, and no requested concept is silently lost.", + "statement": "RAES provides a standardized configurable portable specification surface for the preregistered representative cyber-agent evaluation environment requirements without backend vocabulary in core SDL.", + "threats_to_validity": [ + "The representative corpus contains four source strata and sixteen atomic concepts rather than every cyber-range requirement.", + "The reference processor and repository fixtures are not independent backend implementations.", + "No live range, simulator federation, or participant execution was part of this offline specification-coverage test." + ] + }, + "classification_counts": { + "deliberately-backend-specific": 1, + "directly-expressible": 10, + "missing": 3, + "profile-or-manifest-constraint": 2 + }, + "evidence_status": "partial", + "execution_status": "complete", + "generated_at": "2026-10-13T21:31:14.361582+00:00", + "limitations": [ + "This result demonstrates bounded specification coverage, not universal cyber-range coverage, usability, adoption, backend substitution, or behavioral equivalence.", + "The three missing concepts are evidence, not implementation tasks within this snapshot.", + "The retained protocol does not test recursive realization or plan-level profile semantics; this release only re-establishes its original bounded coverage result against the current implementation.", + "The retained protocol does not test evidence-requirement refinement lineage; the dedicated EXP-731 regression suite covers that production boundary.", + "Authoring-adapter transport behavior is outside this retained protocol.", + "Reviewed OCI mirror and pre-seed admission is covered by its own regression suites and the development artifact policy gate, not a new claim in this preregistered matrix.", + "Operational recovery observation and startup reconciliation are covered by their API-404 regression suite, not a new claim in this preregistered matrix.", + "Store ownership, immutable runtime scope, and provider shutdown ordering are covered by the API-404 CP-5 regression suite, not by this retained specification-coverage protocol.", + "Mixed/staged trial compilation and admission are covered by issue #1015 regression tests, not by this retained specification-coverage corpus; no live mixed-runtime result is claimed.", + "Issue #1186 control-plane recovery operations are covered by their runtime regression suite, not by this retained specification-coverage corpus.", + "Issue #1187 control-plane crash/profile conformance and HTTP security changes are covered by their dedicated regression suite, not promoted to new claims by this retained corpus.", + "Issue #1189 control-plane profile declarations are covered by their dedicated runtime suite, not promoted to new claims by the retained language corpus.", + "Issue #610's reconciliation demonstration harness is covered by its dedicated processor and CLI suite, not promoted to new claims by the retained language corpus.", + "Participant identity, organization ownership, and participant assignment are separated by issue #1338. This retained offline corpus does not establish participant autonomy, execution authority, live backend fidelity, or causal attribution.", + "Participant-local outcome state is verified by the ACT-618 tests; this retained corpus makes no additional outcome-state claim.", + "Backend operation supervision contracts are covered by issue #1360 contract tests; this retained offline corpus establishes no live backend supervision or recovery guarantee.", + "This capture replays the merged issue #1360 and #1357 source; the protocol makes no live backend execution or supervision claim.", + "This capture replays the merged issue #1360 and #1358 source; the protocol makes no live backend execution or supervision claim.", + "Issue #1389 participant inject delivery temporal-subject admission is covered by dedicated compiler tests; this retained matrix makes no new timing or execution claim.", + "Issue #971 adds offline crossing model construction; this retained protocol establishes no crossing equivalence or runtime-realization claim.", + "Issue #1359 control-plane route authority, participant-view scoping, and no-store HTTP boundary are covered by their dedicated HTTP-boundary suite; this retained matrix makes no new exposure or execution claim.", + "Issue #1401 required-evidence media-type coherence is verified by its dedicated suite; this retained matrix makes no new admission or capture claim.", + "Issue #1361 execution and recovery requirements are verified by dedicated policy, composition, and admission tests; this retained corpus establishes no live recovery, continuation, or trial-allocation guarantee.", + "The issue #1361 maintainability repair preserves policy semantics and retained corpus outcomes; it establishes no live recovery, continuation, or trial-allocation guarantee.", + "The issue #1361 resource type-hint repair preserves policy semantics and retained corpus outcomes; it establishes no live recovery, continuation, or trial-allocation guarantee.", + "The combined issue #1361 execution-policy and hatchling update preserves retained outcomes and bounded claims; it establishes no live recovery, continuation, or trial-allocation guarantee.", + "The issue #1418 runtime-fact export manifest split changes no contract, schema or behavior; this retained matrix makes no new admission or coverage claim.", + "The issue #1423 inject trigger request and occurrence contracts are new draft carriers that no SDL construct, compiler or runtime path reads; this retained matrix makes no new admission or coverage claim.", + "The issue #1366 inject readback, correlation and backend declaration contracts are new draft carriers; the shared backend allowlist also lets SDL participant behavior specifications cite inject-occurrence-v1 and inject-occurrence-outcome-v1 as evidence_contract_refs, which the compiler copies through uninterpreted, and no runtime path or shipped backend reads or declares them; this retained matrix makes no new admission or coverage claim.", + "This synchronization preserves the original inject and mixed-backend captures, binds their combined source, and adds no runtime or backend-adoption claim.", + "This second synchronization adds behavior-authoring source from issue #297; prior inject and behavior-authoring captures remain preserved. No additional runtime adoption is claimed.", + "Issue #1091 request-boundary admission is verified by its dedicated tests; this retained corpus does not execute the served HTTP adapter or broaden its bounded claims.", + "Issue #1395 adds a separate bounded two-operation crossing model profile. This retained corpus does not establish participant-crossing equivalence or runtime realization; those assurances remain separate.", + "Issue #1479 fetches OCI modules from public registries through the distribution anonymous bearer-token flow; this retained corpus makes no new claim." + ], + "load_bearing_results": { + "failed": 0, + "missing": 0, + "passed": 10, + "total": 10 + }, + "plain_language_outcome": "The retained specification matrix reproduces its classifications after issue #1479 added the anonymous bearer-token flow to OCI module fetches. Bounded claims and untested concepts are unchanged.", + "protocol_revision": "1.0.0", + "request_results": [ + { + "concept_count": 6, + "failed_stage_count": 0, + "missing_count": 0, + "request_id": "survey-representative-range", + "status": "demonstrated" + }, + { + "concept_count": 5, + "failed_stage_count": 1, + "missing_count": 1, + "request_id": "cyborg-participant-evaluation", + "status": "partial" + }, + { + "concept_count": 3, + "failed_stage_count": 1, + "missing_count": 1, + "request_id": "vsdl-configurable-infrastructure", + "status": "partial" + }, + { + "concept_count": 2, + "failed_stage_count": 1, + "missing_count": 1, + "request_id": "cyber-dem-federation", + "status": "partial" + } + ], + "snapshot_id": "issue-1479-oci-anonymous-token-specification-bee18848d137", + "snapshot_sha256": "373339f30461ebe2e2839eb2aa6d024d9eebbc26c14244a92864f4356d2fbbc0" +} diff --git a/docs/research/specification-coverage/captures/capture-aae28f85e4516ed1fe7aa76945a8b3474dad595adcd83484f0738935cb9883e5/manifest.json b/docs/research/specification-coverage/captures/capture-aae28f85e4516ed1fe7aa76945a8b3474dad595adcd83484f0738935cb9883e5/manifest.json new file mode 100644 index 0000000000..a9d21de142 --- /dev/null +++ b/docs/research/specification-coverage/captures/capture-aae28f85e4516ed1fe7aa76945a8b3474dad595adcd83484f0738935cb9883e5/manifest.json @@ -0,0 +1,10 @@ +{ + "analysis_path": "docs/research/specification-coverage/captures/capture-aae28f85e4516ed1fe7aa76945a8b3474dad595adcd83484f0738935cb9883e5/analysis.json", + "analysis_sha256": "dd5d4467a1c6fa0ef080bc7a9b17d3927ff89d1680b63d7f359e152fb07d4ce5", + "bundle_id": "raes-standardized-specification-coverage", + "protocol_path": "docs/research/specification-coverage/protocol-v1.json", + "protocol_sha256": "e97a19e643e94c9e589dca823a63c6ce49d3329fe2a3cb888ab630838ed93125", + "revision": "capture-aae28f85e4516ed1fe7aa76945a8b3474dad595adcd83484f0738935cb9883e5", + "snapshot_path": "docs/research/specification-coverage/captures/capture-aae28f85e4516ed1fe7aa76945a8b3474dad595adcd83484f0738935cb9883e5/snapshot.json", + "snapshot_sha256": "e97582c266c17ec04b051381565b81ad0e4773ffe1bf6c9ce02810b19c33e6d3" +} diff --git a/docs/research/specification-coverage/captures/capture-aae28f85e4516ed1fe7aa76945a8b3474dad595adcd83484f0738935cb9883e5/snapshot.json b/docs/research/specification-coverage/captures/capture-aae28f85e4516ed1fe7aa76945a8b3474dad595adcd83484f0738935cb9883e5/snapshot.json new file mode 100644 index 0000000000..eaf01e3f37 --- /dev/null +++ b/docs/research/specification-coverage/captures/capture-aae28f85e4516ed1fe7aa76945a8b3474dad595adcd83484f0738935cb9883e5/snapshot.json @@ -0,0 +1,708 @@ +{ + "artifacts": [ + { + "artifact_id": "enterprise-participant-sdl", + "kind": "sdl", + "path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "sha256": "f7a8897beec243e188ee081975006fad32725f469f267db6e75a1e1cf5727032", + "validator": "raes parse, semantic, instantiation/admission, and compiler pipeline" + }, + { + "artifact_id": "port-range-sdl", + "kind": "sdl", + "path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "sha256": "0d5497ec946b863e6985284ec487dde7d7f6bf710a985be51401ac0e5e79dc4f", + "validator": "raes parse, semantic, instantiation/admission, and compiler pipeline" + }, + { + "artifact_id": "experiment-task-contract", + "kind": "experiment-task", + "path": "contracts/fixtures/experiment-core/experiment-task-v1/valid/reference.json", + "sha256": "f3edf713ac6af26bad609136851c6dd434bfb87ce919a2d8c4414c1035deeafc", + "validator": "raes_contracts.contracts.ExperimentTaskModel" + }, + { + "artifact_id": "apparatus-context-contract", + "kind": "experiment-apparatus-context", + "path": "contracts/fixtures/experiment-core/experiment-apparatus-context-v1/valid/reference.json", + "sha256": "e6fa559c5e961f0aab448d0f70dead24aa74fa8ba5f20e1b72f88e11473c9299", + "validator": "raes_contracts.contracts.ExperimentApparatusContextModel" + }, + { + "artifact_id": "backend-profile", + "kind": "backend-profile", + "path": "contracts/profiles/backend/orchestration-capable.json", + "sha256": "f70b8505a5c0055416db86c533e2e5bf08b11e5a514f076223b6d6c36215a092", + "validator": "raes_contracts.backend_profiles.BackendProfileModel" + }, + { + "artifact_id": "known-limitations", + "kind": "documentation", + "path": "docs/explain/sdl/limitations.md", + "sha256": "489eeab3ce682627682311581eb98af9abb9ff42a437145af266eefb71dc7fc4", + "validator": "documentation evidence only" + } + ], + "baseline": { + "release_revision": "1.1.0", + "release_sha256": "4020a1d56c7fe2831cec59ea64a12bbda9d38ccd94f93b916dd90f1a28f17fcb" + }, + "captured_at": "2026-10-13T21:31:14.361582+00:00", + "concept_results": [ + { + "backend_support": "not-evaluated", + "backend_vocabulary_occurrences": [], + "classification": "directly-expressible", + "completeness_disposition": "implemented", + "concept_id": "range-topology", + "rationale": "SDL nodes and infrastructure own host, network, link, and dependency meaning; the compiler emits canonical node deployment addresses.", + "stage_results": [ + { + "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "diagnostic_codes": [], + "note": "Typed VM declaration.", + "outcome": "passed", + "pointer": "/nodes/shipping-portal", + "stage_id": "authored", + "validation_strength": "structural" + }, + { + "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "diagnostic_codes": [], + "note": "Links and dependencies resolved.", + "outcome": "passed", + "pointer": "/infrastructure/shipping-portal", + "stage_id": "semantic", + "validation_strength": "semantic" + }, + { + "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "diagnostic_codes": [], + "note": "Published instantiated shape admitted.", + "outcome": "passed", + "pointer": "/nodes/shipping-portal", + "stage_id": "instantiated", + "validation_strength": "phase-admitted" + }, + { + "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "diagnostic_codes": [], + "note": "Canonical deployment address retained.", + "outcome": "passed", + "pointer": "/node_deployments/provision.node.shipping-portal", + "stage_id": "compiled", + "validation_strength": "compiled" + } + ], + "typed_pointer": "/nodes/shipping-portal" + }, + { + "backend_support": "not-evaluated", + "backend_vocabulary_occurrences": [], + "classification": "directly-expressible", + "completeness_disposition": "implemented", + "concept_id": "exercise-roles", + "rationale": "SDL entity roles own exercise responsibility without becoming control-plane identity or authorization.", + "stage_results": [ + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Typed red role.", + "outcome": "passed", + "pointer": "/entities/enterprise-participant/role", + "stage_id": "authored", + "validation_strength": "structural" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Entity references validated.", + "outcome": "passed", + "pointer": "/entities/enterprise-participant", + "stage_id": "semantic", + "validation_strength": "semantic" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Role retained after instantiation.", + "outcome": "passed", + "pointer": "/entities/enterprise-participant/role", + "stage_id": "instantiated", + "validation_strength": "phase-admitted" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Role retained in entity specification.", + "outcome": "passed", + "pointer": "/entity_specs/enterprise-participant/role", + "stage_id": "compiled", + "validation_strength": "compiled" + } + ], + "typed_pointer": "/entities/enterprise-participant/role" + }, + { + "backend_support": "not-evaluated", + "backend_vocabulary_occurrences": [], + "classification": "directly-expressible", + "completeness_disposition": "implemented", + "concept_id": "evaluation-objectives", + "rationale": "SDL objectives own organization ownership, participant assignment, targets, windows, and assertion-based success; measures remain experiment contracts.", + "stage_results": [ + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Typed objective declaration.", + "outcome": "passed", + "pointer": "/objectives/demonstrate-handoff", + "stage_id": "authored", + "validation_strength": "structural" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Owner, participant assignment, targets, assertions, and workflow refs resolved.", + "outcome": "passed", + "pointer": "/objectives/demonstrate-handoff/success", + "stage_id": "semantic", + "validation_strength": "semantic" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Objective retained in admitted artifact.", + "outcome": "passed", + "pointer": "/objectives/demonstrate-handoff", + "stage_id": "instantiated", + "validation_strength": "phase-admitted" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Canonical objective address retained.", + "outcome": "passed", + "pointer": "/objectives/evaluation.objective.demonstrate-handoff", + "stage_id": "compiled", + "validation_strength": "compiled" + } + ], + "typed_pointer": "/objectives/demonstrate-handoff" + }, + { + "backend_support": "not-evaluated", + "backend_vocabulary_occurrences": [], + "classification": "directly-expressible", + "completeness_disposition": "implemented", + "concept_id": "control-workflows", + "rationale": "SDL workflows own the portable control graph and compile to canonical orchestration state contracts.", + "stage_results": [ + { + "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "diagnostic_codes": [], + "note": "Typed control graph.", + "outcome": "passed", + "pointer": "/workflows/yard-recovery", + "stage_id": "authored", + "validation_strength": "structural" + }, + { + "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "diagnostic_codes": [], + "note": "Step graph and objective refs validated.", + "outcome": "passed", + "pointer": "/workflows/yard-recovery/steps", + "stage_id": "semantic", + "validation_strength": "semantic" + }, + { + "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "diagnostic_codes": [], + "note": "Workflow retained after instantiation.", + "outcome": "passed", + "pointer": "/workflows/yard-recovery", + "stage_id": "instantiated", + "validation_strength": "phase-admitted" + }, + { + "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "diagnostic_codes": [], + "note": "Canonical control graph retained.", + "outcome": "passed", + "pointer": "/workflows/orchestration.workflow.yard-recovery", + "stage_id": "compiled", + "validation_strength": "compiled" + } + ], + "typed_pointer": "/workflows/yard-recovery" + }, + { + "backend_support": "not-evaluated", + "backend_vocabulary_occurrences": [], + "classification": "directly-expressible", + "completeness_disposition": "implemented", + "concept_id": "authored-evidence-expectations", + "rationale": "SDL evidence requirements own portable capture intent and remain distinct from evidence records and measures.", + "stage_results": [ + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Typed capture obligation.", + "outcome": "passed", + "pointer": "/evidence_requirements/objective-truth-evidence", + "stage_id": "authored", + "validation_strength": "structural" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Source refs and bindings validated.", + "outcome": "passed", + "pointer": "/evidence_requirements/objective-truth-evidence", + "stage_id": "semantic", + "validation_strength": "semantic" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Evidence intent retained in admitted artifact.", + "outcome": "passed", + "pointer": "/evidence_requirements/objective-truth-evidence", + "stage_id": "instantiated", + "validation_strength": "phase-admitted" + } + ], + "typed_pointer": "/evidence_requirements/objective-truth-evidence" + }, + { + "backend_support": "profile-bound", + "backend_vocabulary_occurrences": [], + "classification": "profile-or-manifest-constraint", + "completeness_disposition": "implemented", + "concept_id": "apparatus-selection-constraints", + "rationale": "The experiment task contract binds processor/backend identities, manifest refs, and capabilities outside SDL.", + "stage_results": [ + { + "artifact_path": "contracts/fixtures/experiment-core/experiment-task-v1/valid/reference.json", + "diagnostic_codes": [], + "note": "Closed ExperimentTaskModel validated.", + "outcome": "passed", + "pointer": "/apparatus_constraints/allowed_backend_refs/0", + "stage_id": "contract", + "validation_strength": "contract" + } + ], + "typed_pointer": "/apparatus_constraints/allowed_backend_refs/0" + }, + { + "backend_support": "not-evaluated", + "backend_vocabulary_occurrences": [], + "classification": "directly-expressible", + "completeness_disposition": "implemented", + "concept_id": "participant-agent", + "rationale": "SDL agents own participant entity, knowledge, actions, observation boundaries, and operating scope.", + "stage_results": [ + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Typed participant declaration.", + "outcome": "passed", + "pointer": "/agents/participant-agent", + "stage_id": "authored", + "validation_strength": "structural" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Participant refs and scope validated.", + "outcome": "passed", + "pointer": "/agents/participant-agent/observation_boundaries", + "stage_id": "semantic", + "validation_strength": "semantic" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Participant retained in admitted artifact.", + "outcome": "passed", + "pointer": "/agents/participant-agent", + "stage_id": "instantiated", + "validation_strength": "phase-admitted" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Compiled participant scope retained.", + "outcome": "passed", + "pointer": "/agent_specs/participant-agent", + "stage_id": "compiled", + "validation_strength": "compiled" + } + ], + "typed_pointer": "/agents/participant-agent" + }, + { + "backend_support": "not-evaluated", + "backend_vocabulary_occurrences": [], + "classification": "directly-expressible", + "completeness_disposition": "implemented", + "concept_id": "participant-action-contract", + "rationale": "The action contract declares portable preconditions, effects, observations, evidence, and failure classes without a runner command.", + "stage_results": [ + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Typed action contract.", + "outcome": "passed", + "pointer": "/action_contracts/probe-customer-portal-login", + "stage_id": "authored", + "validation_strength": "structural" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Action refs and evidence bindings validated.", + "outcome": "passed", + "pointer": "/action_contracts/probe-customer-portal-login/effects", + "stage_id": "semantic", + "validation_strength": "semantic" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Action retained in admitted artifact.", + "outcome": "passed", + "pointer": "/action_contracts/probe-customer-portal-login", + "stage_id": "instantiated", + "validation_strength": "phase-admitted" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Canonical action address retained.", + "outcome": "passed", + "pointer": "/action_contracts/participant.action-contract.probe-customer-portal-login", + "stage_id": "compiled", + "validation_strength": "compiled" + } + ], + "typed_pointer": "/action_contracts/probe-customer-portal-login" + }, + { + "backend_support": "not-evaluated", + "backend_vocabulary_occurrences": [], + "classification": "directly-expressible", + "completeness_disposition": "implemented", + "concept_id": "participant-observation-boundary", + "rationale": "The observation boundary separately declares visible, hidden, and evidence-only information with transition rules.", + "stage_results": [ + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Typed observation boundary.", + "outcome": "passed", + "pointer": "/observation_boundaries/participant-view", + "stage_id": "authored", + "validation_strength": "structural" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Information refs and transitions validated.", + "outcome": "passed", + "pointer": "/observation_boundaries/participant-view/view_rules", + "stage_id": "semantic", + "validation_strength": "semantic" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Boundary retained in admitted artifact.", + "outcome": "passed", + "pointer": "/observation_boundaries/participant-view", + "stage_id": "instantiated", + "validation_strength": "phase-admitted" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Canonical boundary address retained.", + "outcome": "passed", + "pointer": "/observation_boundaries/participant.observation-boundary.participant-view", + "stage_id": "compiled", + "validation_strength": "compiled" + } + ], + "typed_pointer": "/observation_boundaries/participant-view" + }, + { + "backend_support": "not-evaluated", + "backend_vocabulary_occurrences": [], + "classification": "directly-expressible", + "completeness_disposition": "implemented", + "concept_id": "evaluation-measure", + "rationale": "ExperimentTaskModel owns metric construct, unit, direction, aggregation, and evidence requirements outside SDL objectives.", + "stage_results": [ + { + "artifact_path": "contracts/fixtures/experiment-core/experiment-task-v1/valid/reference.json", + "diagnostic_codes": [], + "note": "Closed task contract validated.", + "outcome": "passed", + "pointer": "/evaluation_protocol/metric_definitions/foothold-achieved", + "stage_id": "contract", + "validation_strength": "contract" + } + ], + "typed_pointer": "/evaluation_protocol/metric_definitions/foothold-achieved" + }, + { + "backend_support": "not-evaluated", + "backend_vocabulary_occurrences": [], + "classification": "missing", + "completeness_disposition": "documented-gap", + "concept_id": "participant-tool-affordance", + "rationale": "This preregistered matrix has no tested carrier for participant tool affordances. The retained missing classification records missing coverage evidence, not the absence of current participant-behavior capabilities.", + "stage_results": [ + { + "artifact_path": "docs/explain/sdl/limitations.md", + "diagnostic_codes": [], + "note": "The preregistered carrier slot was not run; metadata does not substitute for a typed coverage test.", + "outcome": "not_run", + "pointer": null, + "stage_id": "authored", + "validation_strength": "not-applicable" + } + ], + "typed_pointer": null + }, + { + "backend_support": "not-evaluated", + "backend_vocabulary_occurrences": [], + "classification": "directly-expressible", + "completeness_disposition": "implemented", + "concept_id": "resource-constrained-topology", + "rationale": "SDL node resources and infrastructure dependencies express portable resource intent without provider resource identifiers.", + "stage_results": [ + { + "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "diagnostic_codes": [], + "note": "Typed CPU and memory declaration.", + "outcome": "passed", + "pointer": "/nodes/shipping-portal/resources", + "stage_id": "authored", + "validation_strength": "structural" + }, + { + "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "diagnostic_codes": [], + "note": "Resource-bearing topology validated.", + "outcome": "passed", + "pointer": "/infrastructure/shipping-portal", + "stage_id": "semantic", + "validation_strength": "semantic" + }, + { + "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "diagnostic_codes": [], + "note": "Constraints retained in admitted artifact.", + "outcome": "passed", + "pointer": "/nodes/shipping-portal/resources", + "stage_id": "instantiated", + "validation_strength": "phase-admitted" + }, + { + "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "diagnostic_codes": [], + "note": "Deployment specification retains resource intent.", + "outcome": "passed", + "pointer": "/node_deployments/provision.node.shipping-portal", + "stage_id": "compiled", + "validation_strength": "compiled" + } + ], + "typed_pointer": "/nodes/shipping-portal/resources" + }, + { + "backend_support": "not-evaluated", + "backend_vocabulary_occurrences": [], + "classification": "missing", + "completeness_disposition": "documented-gap", + "concept_id": "formal-constraint-satisfiability", + "rationale": "This coverage matrix did not exercise a solver-backed carrier. The separate formal-semantic-validation release demonstrates its bounded finite-domain profile; that result is not silently imported into this protocol's missing carrier slot.", + "stage_results": [ + { + "artifact_path": "docs/explain/sdl/limitations.md", + "diagnostic_codes": [], + "note": "No coverage-carrier execution was performed here; independent solver evidence does not change this preregistered denominator.", + "outcome": "not_run", + "pointer": null, + "stage_id": "semantic", + "validation_strength": "not-applicable" + } + ], + "typed_pointer": null + }, + { + "backend_support": "profile-bound", + "backend_vocabulary_occurrences": [ + { + "allowed": true, + "artifact_path": "source:vsdl-paper", + "pointer": "source sections 4-5", + "reason": "Legitimate VSDL realization vocabulary, not RAES core SDL structure.", + "term": "OpenStack/Terraform/Packer" + } + ], + "classification": "deliberately-backend-specific", + "completeness_disposition": "external", + "concept_id": "provider-specific-provisioning", + "rationale": "Provider image selection and provisioning engines are realization mechanics and therefore remain outside core SDL.", + "stage_results": [ + { + "artifact_path": "contracts/profiles/backend/orchestration-capable.json", + "diagnostic_codes": [], + "note": "The portable boundary requires backend contracts; it does not standardize a provider engine.", + "outcome": "not_applicable", + "pointer": "/required_contracts", + "stage_id": "realization-disclosure", + "validation_strength": "profile" + } + ], + "typed_pointer": null + }, + { + "backend_support": "profile-bound", + "backend_vocabulary_occurrences": [], + "classification": "profile-or-manifest-constraint", + "completeness_disposition": "implemented", + "concept_id": "apparatus-clock-context", + "rationale": "ExperimentApparatusContextModel records clock authority, time domain, and synchronization as apparatus facts outside scenario meaning.", + "stage_results": [ + { + "artifact_path": "contracts/fixtures/experiment-core/experiment-apparatus-context-v1/valid/reference.json", + "diagnostic_codes": [], + "note": "Closed apparatus context contract validated.", + "outcome": "passed", + "pointer": "/clocks/0", + "stage_id": "contract", + "validation_strength": "contract" + } + ], + "typed_pointer": "/clocks/0" + }, + { + "backend_support": "not-evaluated", + "backend_vocabulary_occurrences": [], + "classification": "missing", + "completeness_disposition": "documented-gap", + "concept_id": "federated-object-event-exchange", + "rationale": "The federated cyber object/event exchange carrier was not exercised by this preregistered matrix. Runtime event internals are not treated as equivalent evidence.", + "stage_results": [ + { + "artifact_path": "docs/explain/sdl/limitations.md", + "diagnostic_codes": [], + "note": "The missing coverage-carrier test is recorded explicitly, without inferring an ecosystem-wide capability absence.", + "outcome": "not_run", + "pointer": null, + "stage_id": "contract", + "validation_strength": "not-applicable" + } + ], + "typed_pointer": null + } + ], + "deviations": [ + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "baseline_sha256": "54ba1a60220e27a55da9cd2a407d7d3ab836fa54460d0b0c6cad87c2e744ddbb", + "rationale": "Migrate participant affiliations and explicit objective assignment, retaining organizational intent and portable action-contract declarations without granting execution authority.", + "retest_sha256": "f7a8897beec243e188ee081975006fad32725f469f267db6e75a1e1cf5727032" + }, + { + "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "baseline_sha256": "a27c7a64e0c5c618fadaccafdf1a4e71600170a8b77b983190822b5141f00dec", + "rationale": "Migrate participant affiliations and explicit objective assignment, retaining organizational intent and portable action-contract declarations without granting execution authority.", + "retest_sha256": "0d5497ec946b863e6985284ec487dde7d7f6bf710a985be51401ac0e5e79dc4f" + }, + { + "artifact_path": "contracts/fixtures/experiment-core/experiment-task-v1/valid/reference.json", + "baseline_sha256": "21952a752f4e8581a9fc3b872e4bc308150548170d38bcfc83dbbe35ff5e0b9f", + "rationale": "Replay the retained preregistered artifact against the current evidence-provenance validation implementation.", + "retest_sha256": "f3edf713ac6af26bad609136851c6dd434bfb87ce919a2d8c4414c1035deeafc" + }, + { + "artifact_path": "contracts/fixtures/experiment-core/experiment-apparatus-context-v1/valid/reference.json", + "baseline_sha256": "9536d897a09cbc6920e667e4f8f9371e51307aa0b3b5ff3c7de682dd783420ab", + "rationale": "Replay the retained preregistered artifact against the current evidence-provenance validation implementation.", + "retest_sha256": "e6fa559c5e961f0aab448d0f70dead24aa74fa8ba5f20e1b72f88e11473c9299" + }, + { + "artifact_path": "docs/explain/sdl/limitations.md", + "baseline_sha256": "129cf17810aad4c51988bc872e28fe43ae95019a80053c42d800ff7e2b9cc93e", + "rationale": "Correct historical mandatory-profile guidance after issue #1207; retain the preregistered missing-concept classifications and coverage limits.", + "retest_sha256": "489eeab3ce682627682311581eb98af9abb9ff42a437145af266eefb71dc7fc4" + } + ], + "execution_status": "complete", + "implementation_surfaces": [ + { + "content_sha256": "19a6bd28e31df06b77d0a8b56f7177e8e97a1d571ce2df92c114bb4a56f2d6b0", + "path": "implementations/python/packages/raes_contracts", + "surface_id": "contract-models" + }, + { + "content_sha256": "e947f59695e907f5af899a6bc4bde60e629620aa7c4a69a41e074ba335758c7a", + "path": "implementations/python/packages/raes_processor", + "surface_id": "processor-pipeline" + }, + { + "content_sha256": "26449ed7c5f20fb3a8bd098b47ed672d45f7149d06affbd0b81238b4551bd887", + "path": "implementations/python/packages/raes", + "surface_id": "sdl-pipeline" + } + ], + "limitations": [ + "The execution validates the pinned reference implementation and published contracts, not an independent backend.", + "Repository-owned examples are exact execution artifacts but are not themselves the literature-derived request corpus; the protocol's requests and concepts are.", + "No live range, participant, simulator federation, or provider provisioning engine was executed.", + "Missing concepts remain frozen in this snapshot and require separately scoped product work before a later rerun.", + "This capture replays the retained protocol after EXP-732 run, apparatus, measurement-channel, and augmentation-producer provenance validation; it adds no independent backend or universal provenance assurance claim.", + "Materialization attestation is covered by its dedicated regression suite, not a new claim in this preregistered matrix.", + "This capture refreshes the corrected runtime limitations prose for issue #959; the protocol, coverage classifications and implementation source are unchanged.", + "This capture replays open-by-default augmentation scope integrated with the EXP-731 evidence refinements after composition type refinement; it does not evaluate native backend scope enforcement or broaden the preregistered coverage claims.", + "This capture replays the retained protocol after merging ACT-612 participant relationships with open-by-default augmentation scope; it adds no claim of realized participant relationships or native backend scope enforcement.", + "This capture replays issue #1299 partial listener descriptions on the integrated source state; endpoint completeness and backend admission remain outside this protocol's claims.", + "This capture also binds authoring-adapter semantic conformance to the integrated source; adapter transport behavior remains outside this protocol's claims.", + "Reviewed OCI mirror and pre-seed admission is covered by its own regression suites and the development artifact policy gate, not a new claim in this preregistered matrix.", + "This capture binds issue #1297 service-manager identity, native-name, and explicitly selected systemd-state contract changes to the integrated source. It exercises no live service manager and adds no backend-execution claim.", + "This capture replays the retained specification-coverage protocol after API-404 startup reconciliation added an operational recovery-observation contract. It does not evaluate crash recovery, classify provider effects, or broaden EXP-715 experiment-observation claims.", + "This capture binds API-404 single-owner store admission and immutable target/run scope to the integrated source. The retained offline protocol does not exercise process leases, SQLite lifecycle ordering, or crash recovery.", + "This capture binds issue #1015 deterministic mixed and staged trial admission to the integrated source. The retained offline language corpus does not execute mixed runtimes, phase transitions, backend handoff, or scheduler-driven realization.", + "This replay binds issue #1186 offline control-plane maintenance, readiness, and bounded audit code to the integrated source. The retained language corpus does not execute store recovery, HTTP health behavior, or audit redaction.", + "Issue #1187 control-plane crash/profile conformance and HTTP security changes are covered by their dedicated regression suite, not promoted to new claims by this retained corpus.", + "Issue #1189 control-plane profile declarations are covered by their dedicated runtime suite, not promoted to new claims by the retained language corpus.", + "Issue #1016 mixed-runtime coordination is covered by its dedicated runtime suite. The retained language corpus does not execute mixed providers or establish backend-native realization, multi-controller coordination, IFC, or equivalence.", + "Issue #610's reconciliation demonstration harness is covered by its dedicated processor and CLI suite, not promoted to new claims by the retained language corpus.", + "Participant identity, organization ownership, and participant assignment are separated by issue #1338. This retained offline corpus does not establish participant autonomy, execution authority, live backend fidelity, or causal attribution.", + "Issue #1361 execution and recovery requirements are verified by dedicated policy, composition, and admission tests; this retained corpus establishes no live recovery, continuation, or trial-allocation guarantee.", + "The issue #1361 maintainability repair preserves policy semantics and retained corpus outcomes; it establishes no live recovery, continuation, or trial-allocation guarantee.", + "The issue #1361 resource type-hint repair preserves policy semantics and retained corpus outcomes; it establishes no live recovery, continuation, or trial-allocation guarantee.", + "The combined issue #1361 execution-policy and hatchling update preserves retained outcomes and bounded claims; it establishes no live recovery, continuation, or trial-allocation guarantee.", + "Issue #1091 request-boundary admission is verified by its dedicated tests; this retained corpus does not execute the served HTTP adapter or broaden its bounded claims.", + "This combined-source capture re-executes the named SDL, contract and profile artifacts and their passing typed pointers. The inject placement discriminator repair adds no specification coverage claim; runtime dispatch and live backend effects remain outside this corpus. CI independently verifies replay.", + "Issue #1395 adds a separate bounded two-operation crossing model profile. This retained corpus does not establish participant-crossing equivalence or runtime realization; those assurances remain separate.", + "Issue #1479 fetches OCI modules from public registries through the distribution anonymous bearer-token flow; this retained corpus makes no new claim." + ], + "protocol_revision": "1.0.0", + "protocol_sha256": "e97a19e643e94c9e589dca823a63c6ce49d3329fe2a3cb888ab630838ed93125", + "raes_revision": "3d7b88e2b465ffa0c0a4a6b3b8894de8e95ca2b6", + "snapshot_id": "issue-1479-oci-anonymous-token-specification-bee18848d137", + "snapshot_revision": "branch-capture", + "source_state": { + "base_revision": "3d7b88e2b465ffa0c0a4a6b3b8894de8e95ca2b6", + "checkout_state": "clean", + "implementation_digest": "bee18848d1372ba29188de8a8443c494d377824261645f88cf4c2d9353677cf8", + "profile": "python-reference-source/v2" + } +} From eb32f9f1aee62d1879b581aec5cb7980847ac534 Mon Sep 17 00:00:00 2001 From: Yernat Yestekov <2068106+doublewhy@users.noreply.github.com> Date: Sun, 25 Oct 2026 08:50:54 +0000 Subject: [PATCH 06/11] test(sdl): resolve a locked oci import through the anonymous token flow Dev's locked: chain resolver (#1339) reaches _resolve_oci_import with the manifest pinned by digest, so no tags/list request precedes the challenge. Cover one and two locked hops: one token request, one retry per registry URL, and no Authorization at the storage origin. --- .../test_issue_1479_oci_anonymous_token.py | 42 ++++++++++++++++++- 1 file changed, 41 insertions(+), 1 deletion(-) diff --git a/implementations/python/tests/test_issue_1479_oci_anonymous_token.py b/implementations/python/tests/test_issue_1479_oci_anonymous_token.py index 2827e0763d..0db88ebb0f 100644 --- a/implementations/python/tests/test_issue_1479_oci_anonymous_token.py +++ b/implementations/python/tests/test_issue_1479_oci_anonymous_token.py @@ -148,7 +148,7 @@ def route(path: str, authorization: str | None) -> Response: return 401, [*headers, ("Content-Type", "application/json")], b'{"errors":[{"code":"UNAUTHORIZED"}]}' if path == f"{prefix}tags/list": return _json({"name": REPOSITORY, "tags": [layout.tag]}) - if path == f"{prefix}manifests/{layout.tag}": + if path in (f"{prefix}manifests/{layout.tag}", f"{prefix}manifests/{layout.manifest_digest}"): return 200, [("Content-Type", module_registry.OCI_LAYOUT_MEDIA_TYPE)], layout.blobs[layout.manifest_digest] if path.startswith(f"{prefix}blobs/"): digest = path.removeprefix(f"{prefix}blobs/") @@ -357,6 +357,46 @@ def test_import_uses_one_anonymous_token_and_retries_each_request_once( ] +@pytest.mark.parametrize("hops", [1, 2], ids=["one-locked-hop", "two-locked-hops"]) +def test_locked_import_fetches_the_pinned_manifest_through_the_token_flow( + tmp_path: Path, layout: _Layout, serve: Callable[..., _Server], https: ssl.SSLContext, hops: int +) -> None: + token = _new_token() + token_server = serve(_fixed_route(_json({"token": token})), tls=https) + storage = serve(_storage_route(layout)) + routes = [_registry_route(layout, token=None, challenges=[], blob_location=storage.origin, anonymous=True)] + registry = serve(lambda path, authorization: routes[-1](path, authorization)) + root = _import_root(tmp_path, registry) + # Lock while the registry is anonymous, so only the locked resolution meets the challenge. + record = module_registry.resolve_lock_records(root).imports[0] + routes.append( + _registry_route(layout, token=token, challenges=[_challenge(token_server)], blob_location=storage.origin) + ) + # A locked: chain resolves record by record until it reaches the oci: record that pins the manifest digest. + chain = [record.model_copy(update={"source": f"locked:{record.resolved_source}", "resolved_source": "first"})] + module_registry.write_lockfile(tmp_path, module_registry.Lockfile(imports=[*chain[: hops - 1], record])) + locked_ref = "first" if hops == 2 else record.resolved_source + root.write_text(root.read_text(encoding="utf-8").replace(record.source, f"locked:{locked_ref}"), encoding="utf-8") + for server in (token_server, registry, storage): + server.seen.clear() + + scenario = parse_sdl_file(root) + + assert set(scenario.nodes) == {"shared.vm"} + assert token_server.seen == [_Seen(f"/token?{TOKEN_QUERY}", None)] + resources = [ + f"/v2/{REPOSITORY}/manifests/{layout.manifest_digest}", + f"/v2/{REPOSITORY}/blobs/{layout.config_digest}", + f"/v2/{REPOSITORY}/blobs/{layout.bundle_digest}", + ] + assert registry.seen == [ + attempt for path in resources for attempt in (_Seen(path, None), _Seen(path, f"Bearer {token}")) + ] + assert storage.seen == [ + _Seen(f"/storage/{digest}?{SIGNED_QUERY}", None) for digest in (layout.config_digest, layout.bundle_digest) + ] + + @pytest.mark.parametrize("cross_origin", [True, False], ids=["storage-origin", "same-origin"]) def test_bearer_token_never_follows_a_blob_redirect( layout: _Layout, serve: Callable[..., _Server], https: ssl.SSLContext, cross_origin: bool From ebe04761c32f9648517e7a7cec6118a80622fc32 Mon Sep 17 00:00:00 2001 From: Yernat Yestekov <2068106+doublewhy@users.noreply.github.com> Date: Sun, 25 Oct 2026 08:55:14 +0000 Subject: [PATCH 07/11] test: record combined-source research captures for issue #1479 Collected on the merge of current dev with blitz-tools' collect_research_evidence.py and recorded with research_capture record: specification capture-917dcfe8, formal capture-75bb6056. --- ...247b09e748313f70098d7b3510988af5c5a67.json | 4 + .../analysis.json | 168 +++++ .../manifest.json | 122 +++ .../snapshot.json | 653 ++++++++++++++++ ...936c8ae254f68ac9da4624dbbdc8ff71da106.json | 4 + .../analysis.json | 117 +++ .../manifest.json | 10 + .../snapshot.json | 705 ++++++++++++++++++ 8 files changed, 1783 insertions(+) create mode 100644 docs/research/formal-semantic-validation/capture-records/capture-75bb60563fe13054358a57d241c247b09e748313f70098d7b3510988af5c5a67.json create mode 100644 docs/research/formal-semantic-validation/captures/capture-75bb60563fe13054358a57d241c247b09e748313f70098d7b3510988af5c5a67/analysis.json create mode 100644 docs/research/formal-semantic-validation/captures/capture-75bb60563fe13054358a57d241c247b09e748313f70098d7b3510988af5c5a67/manifest.json create mode 100644 docs/research/formal-semantic-validation/captures/capture-75bb60563fe13054358a57d241c247b09e748313f70098d7b3510988af5c5a67/snapshot.json create mode 100644 docs/research/specification-coverage/capture-records/capture-917dcfe82f8ee8c7fda5cc4dc8f936c8ae254f68ac9da4624dbbdc8ff71da106.json create mode 100644 docs/research/specification-coverage/captures/capture-917dcfe82f8ee8c7fda5cc4dc8f936c8ae254f68ac9da4624dbbdc8ff71da106/analysis.json create mode 100644 docs/research/specification-coverage/captures/capture-917dcfe82f8ee8c7fda5cc4dc8f936c8ae254f68ac9da4624dbbdc8ff71da106/manifest.json create mode 100644 docs/research/specification-coverage/captures/capture-917dcfe82f8ee8c7fda5cc4dc8f936c8ae254f68ac9da4624dbbdc8ff71da106/snapshot.json diff --git a/docs/research/formal-semantic-validation/capture-records/capture-75bb60563fe13054358a57d241c247b09e748313f70098d7b3510988af5c5a67.json b/docs/research/formal-semantic-validation/capture-records/capture-75bb60563fe13054358a57d241c247b09e748313f70098d7b3510988af5c5a67.json new file mode 100644 index 0000000000..6b8d95dd59 --- /dev/null +++ b/docs/research/formal-semantic-validation/capture-records/capture-75bb60563fe13054358a57d241c247b09e748313f70098d7b3510988af5c5a67.json @@ -0,0 +1,4 @@ +{ + "capture_path": "docs/research/formal-semantic-validation/captures/capture-75bb60563fe13054358a57d241c247b09e748313f70098d7b3510988af5c5a67/manifest.json", + "capture_sha256": "932c0ea406a68188283e5cbac4543994f7589f17e68b75f08b7317036ea35d73" +} diff --git a/docs/research/formal-semantic-validation/captures/capture-75bb60563fe13054358a57d241c247b09e748313f70098d7b3510988af5c5a67/analysis.json b/docs/research/formal-semantic-validation/captures/capture-75bb60563fe13054358a57d241c247b09e748313f70098d7b3510988af5c5a67/analysis.json new file mode 100644 index 0000000000..cb8d2925c3 --- /dev/null +++ b/docs/research/formal-semantic-validation/captures/capture-75bb60563fe13054358a57d241c247b09e748313f70098d7b3510988af5c5a67/analysis.json @@ -0,0 +1,168 @@ +{ + "analysis_id": "issue-1479-oci-anonymous-token-formal-analysis-d57e6b1838fd", + "claim": { + "allowed_evidence": [ + "production parser and semantic-validator results", + "canonical compiled digests", + "participant contract regression tests", + "pinned protocol, corpus, and execution snapshot" + ], + "claim_id": "asr-530-formal-semantic-validation-retest", + "disallowed_evidence": [ + "schema success as semantic proof", + "workflow reachability as network or exploit reachability", + "FM labels as gate outcomes", + "attribution as counterfactual proof", + "formal prose or maintainer confidence alone" + ], + "evidence_artifacts": [ + "docs/research/formal-semantic-validation/protocol-v2.json", + "docs/research/formal-semantic-validation/corpus/manifest-v4.json", + "@snapshot", + "docs/research/formal-semantic-validation/evidence/finite-domain-satisfiable-v4.json", + "docs/research/formal-semantic-validation/evidence/finite-domain-unsatisfiable-v4.json", + "docs/research/formal-semantic-validation/evidence/typed-exploit-path-valid-v4.json", + "docs/research/formal-semantic-validation/evidence/typed-exploit-path-invalid-v4.json" + ], + "falsification_protocol": "Replay every retained and new case through its production entrypoint, require complete digest and evidence joins, execute participant fixtures, and derive status from the recorded outcomes.", + "objective_fail_criteria": "A supported negative passes, a positive fails, an observation drifts, a required participant case is missing, or weaker evidence is promoted to solver, exploit-path, runtime-stability, or counterfactual assurance.", + "objective_pass_criteria": "Every claim class has positive and negative cases, all supported cases reproduce the frozen outcome, every participant obligation has passing positive and negative fixtures, and unsupported classes remain untested.", + "statement": "At the recorded source-state digest, the retained RAES controls have the bounded statuses recorded here; historical releases are integrity evidence, not current replay evidence.", + "threats_to_validity": [ + "The issue-specific corpus is intentionally small and does not enumerate every validator invariant.", + "The participant fixtures exercise reference production contracts and tests, not every independent backend realization.", + "The replay gate runs on one Python reference configuration and one pinned RAES revision.", + "Unsupported solver-level classes have protocol cases but no executable observations." + ] + }, + "claim_results": [ + { + "case_count": 2, + "claim_class_id": "schema-validity", + "evidence_status": "demonstrated", + "limitations": [ + "Bounded to the named source/model structural controls." + ], + "matching_case_count": 2, + "participant_obligation_count": 0, + "replayable_case_count": 2, + "unsupported_case_count": 0 + }, + { + "case_count": 4, + "claim_class_id": "semantic-consistency", + "evidence_status": "partial", + "limitations": [ + "Partial coverage of named static semantics and participant obligations, not universal consistency." + ], + "matching_case_count": 4, + "participant_obligation_count": 7, + "replayable_case_count": 4, + "unsupported_case_count": 0 + }, + { + "case_count": 2, + "claim_class_id": "graph-reachability", + "evidence_status": "partial", + "limitations": [ + "Partial workflow control-flow reachability only; not network, service, or exploit reachability." + ], + "matching_case_count": 2, + "participant_obligation_count": 0, + "replayable_case_count": 2, + "unsupported_case_count": 0 + }, + { + "case_count": 4, + "claim_class_id": "constraint-satisfiability", + "evidence_status": "demonstrated", + "limitations": [ + "Demonstrated only for raes-finite-domain-satisfiability-v1 and its pinned solver configuration." + ], + "matching_case_count": 4, + "participant_obligation_count": 0, + "replayable_case_count": 2, + "unsupported_case_count": 2 + }, + { + "case_count": 4, + "claim_class_id": "exploit-path-validity", + "evidence_status": "demonstrated", + "limitations": [ + "Demonstrated only for the admitted snapshot, typed graph, query, semantics, and bounded search profile." + ], + "matching_case_count": 4, + "participant_obligation_count": 0, + "replayable_case_count": 2, + "unsupported_case_count": 2 + }, + { + "case_count": 2, + "claim_class_id": "determinism-stability", + "evidence_status": "partial", + "limitations": [ + "Partial parse-to-compile repeatability only; runtime and backend determinism are untested." + ], + "matching_case_count": 2, + "participant_obligation_count": 0, + "replayable_case_count": 2, + "unsupported_case_count": 0 + }, + { + "case_count": 2, + "claim_class_id": "counterfactual-necessity", + "evidence_status": "untested", + "limitations": [ + "Untested because no governed intervention or ablation entrypoint ran." + ], + "matching_case_count": 2, + "participant_obligation_count": 0, + "replayable_case_count": 0, + "unsupported_case_count": 2 + } + ], + "corpus_revision": "4.0.0", + "evidence_status": "partial", + "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", + "generated_at": "2026-10-25T08:54:08.535564+00:00", + "limitations": [ + "Satisfiability is limited to raes-finite-domain-satisfiability-v1 and its exact translation, theory, and Z3 configuration.", + "The subset-minimal unsatisfiable core is not a universal proof certificate.", + "Exploit-path results are limited to the admitted snapshot, normalized graph, query, transition semantics, and bounded search profile.", + "A valid path is not backend execution and an invalid path is not real-world non-exploitability.", + "The production exploit-path JSON loader permits duplicate keys; the research loader rejects them without claiming stronger production behavior.", + "Participant replay inherits the host environment and is not described as hermetic.", + "Counterfactual necessity remains untested.", + "Scoped observation demand is not a claim class in this preregistration and is not promoted to demonstrated by this retest.", + "EXP-732 provenance joins are verified by their dedicated regression suite; this retained corpus makes no universal run, apparatus, source, or augmentation assurance claim.", + "This retained corpus does not establish native backend attestation fidelity; materialization contract checks remain separate operational provenance, not experimental observations.", + "Capture admission and evidence-proof authority are verified by issue-1237 regression tests, not promoted to a new claim class by this retained corpus.", + "Evidence-requirement refinement lineage is outside this retained formal claim set; this retest refreshes integrated source provenance without promoting that feature to a formal claim.", + "Authoring-adapter transport behavior is outside this retained formal claim set.", + "Operational recovery observation and startup reconciliation are verified by their API-404 regression suite, not promoted to a new formal claim class by this retained corpus.", + "Single-owner store admission, immutable target/run scope, and provider shutdown ordering are verified by their API-404 CP-5 regression suite, not promoted to a formal claim by this retained corpus.", + "Mixed and staged trial admission is verified by its SEM-234/SCE-002/API-407 regression suite, not promoted to a new formal claim class by this retained corpus.", + "Offline control-plane maintenance, readiness, and bounded audit behavior are verified by issue #1186 runtime tests, not promoted to a formal claim by this retained corpus.", + "Issue #1187 control-plane crash/profile conformance and HTTP security changes are covered by their dedicated regression suite, not promoted to new claims by this retained corpus.", + "Issue #1189 profile declarations and capability admission are covered by dedicated runtime tests; the retained formal corpus does not execute control-plane profile composition.", + "Issue #1016 mixed-runtime coordination is covered by dedicated runtime tests; the retained formal corpus does not establish backend-native mixed realization, multi-controller coordination, IFC, or equivalence.", + "Issue #610's reconciliation demonstration harness is covered by its dedicated processor and CLI suite, not promoted to new claims by the retained language corpus.", + "Participant identity, organization ownership, and participant assignment are separated by issue #1338. This retained offline corpus does not establish participant autonomy, execution authority, live backend fidelity, or causal attribution.", + "Issue #1389 temporal-subject admission is verified by dedicated compiler tests and adds no new formal-semantic claim to this retained corpus.", + "Issue #971 model construction is verified by its own tests; this retained corpus establishes no participant-crossing equivalence or runtime-realization claim.", + "Issue #1359 control-plane route authority, participant-view scoping, and no-store HTTP boundary are verified by their dedicated HTTP-boundary suite and add no new formal-semantic claim to this retained corpus.", + "Issue #1401 required-evidence media-type coherence is verified by its dedicated suite and adds no new formal-semantic claim to this retained corpus.", + "Issue #1361 execution and recovery requirements are verified by dedicated policy, composition, and admission tests; this retained corpus establishes no live recovery, continuation, or trial-allocation guarantee.", + "The issue #1361 maintainability repair preserves policy semantics and retained corpus outcomes; it establishes no live recovery, continuation, or trial-allocation guarantee.", + "The issue #1361 resource type-hint repair preserves policy semantics and retained corpus outcomes; it establishes no live recovery, continuation, or trial-allocation guarantee.", + "The combined issue #1361 execution-policy and hatchling update preserves retained outcomes and bounded claims; it establishes no live recovery, continuation, or trial-allocation guarantee.", + "The issue #1418 runtime-fact export manifest split changes no contract, schema or behavior and adds no new formal-semantic claim.", + "The issue #1423 inject trigger request and occurrence contracts are new draft carriers that no SDL construct, compiler or runtime path reads, and they add no new formal-semantic claim.", + "The issue #1366 inject readback, correlation and backend declaration contracts are new draft carriers; the shared backend allowlist also lets SDL participant behavior specifications cite inject-occurrence-v1 and inject-occurrence-outcome-v1 as evidence_contract_refs, which the compiler copies through uninterpreted, and no runtime path or shipped backend reads or declares them; they add no new formal-semantic claim.", + "This synchronization preserves the original inject baseline chain in the pre-sync archive, retains frozen production and participant evidence, and binds the combined contract source. CI independently verifies current evidence replay; no new runtime adoption is claimed.", + "This second synchronization binds behavior-authoring source from issue #297, retains frozen production and participant evidence, and pins the preserved first-sync release 75 as its baseline. CI independently verifies replay; no new runtime adoption is claimed.", + "Task-contract CLI admission and optional supplied-task reference checks are covered by test_issue_1519_experiment_tasks.py; the retained research corpus makes no additional task, artifact-content, or execution claim." + ], + "plain_language_outcome": "The retained formal cases reproduce their outcomes on the combined source of current dev and issue #1479's anonymous bearer-token flow for OCI module fetches. Bounded claims and unsupported classes are unchanged.", + "protocol_revision": "2.0.0" +} diff --git a/docs/research/formal-semantic-validation/captures/capture-75bb60563fe13054358a57d241c247b09e748313f70098d7b3510988af5c5a67/manifest.json b/docs/research/formal-semantic-validation/captures/capture-75bb60563fe13054358a57d241c247b09e748313f70098d7b3510988af5c5a67/manifest.json new file mode 100644 index 0000000000..cb809d54ef --- /dev/null +++ b/docs/research/formal-semantic-validation/captures/capture-75bb60563fe13054358a57d241c247b09e748313f70098d7b3510988af5c5a67/manifest.json @@ -0,0 +1,122 @@ +{ + "analysis_path": "docs/research/formal-semantic-validation/captures/capture-75bb60563fe13054358a57d241c247b09e748313f70098d7b3510988af5c5a67/analysis.json", + "analysis_sha256": "821651b8ae4a93e4deb2e11f54c1bd3ca406e885a95e3c7ee45903083752531a", + "artifacts": [ + { + "artifact_id": "finite-domain-satisfiable-v2-input", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/satisfiable-control.sdl.yaml", + "sha256": "0ca9eaba9dc47171f7a042dc6753faa6c820c65ee966538f9d65fac5342202e8" + }, + { + "artifact_id": "finite-domain-satisfiable-v2-evidence", + "kind": "production-evidence", + "path": "docs/research/formal-semantic-validation/evidence/finite-domain-satisfiable-v4.json", + "sha256": "554202313d678046958b5c028e2de26ff03c74895cfac552677eed74e8153add" + }, + { + "artifact_id": "finite-domain-unsatisfiable-v2-input", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/unsatisfiable-control.sdl.yaml", + "sha256": "cfef56a1f56d5f0db9da195377fd75694bdd0f0b92932fdb8fafcbd3f7baf6c5" + }, + { + "artifact_id": "finite-domain-unsatisfiable-v2-evidence", + "kind": "production-evidence", + "path": "docs/research/formal-semantic-validation/evidence/finite-domain-unsatisfiable-v4.json", + "sha256": "c972725ef64822a75a60380afc11f08eac25b7fe9b091d39b058b3c9f7c8031d" + }, + { + "artifact_id": "typed-exploit-path-valid-v2-input", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/exploit-path-valid-v3.json", + "sha256": "0afe635a63db5b6e6380ac70982fd61d09790745d51a10d670321304121e7c39" + }, + { + "artifact_id": "typed-exploit-path-valid-v2-evidence", + "kind": "production-evidence", + "path": "docs/research/formal-semantic-validation/evidence/typed-exploit-path-valid-v4.json", + "sha256": "1b7f55d04db172da32658187c64a88c13b5f4d565267ce2be7cb86a9d04cb70c" + }, + { + "artifact_id": "typed-exploit-path-invalid-v2-input", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/exploit-path-invalid-v3.json", + "sha256": "0b2293d4a8983515ff05c516be6e6b418a4f3f09e055250a00bf15fda861aab3" + }, + { + "artifact_id": "typed-exploit-path-invalid-v2-evidence", + "kind": "production-evidence", + "path": "docs/research/formal-semantic-validation/evidence/typed-exploit-path-invalid-v4.json", + "sha256": "244f895a64f14c10916ab0533ab462ce80a328021cd6a50c30a4aa59266d5533" + }, + { + "artifact_id": "schema-valid-control-fixture", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/schema-valid.sdl.yaml", + "sha256": "41a9adffdf9f5f2ccc2f887dcf7b15fba3b47c83a1af15f33db872c4a2449d67" + }, + { + "artifact_id": "schema-unknown-field-fixture", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/schema-invalid-unknown-field.sdl.yaml", + "sha256": "51cf62319a86c95a2517995939d1f370573051835e4b55bb6d5beaf049640481" + }, + { + "artifact_id": "semantic-resolved-objective-fixture", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/semantic-valid-participant-identity-v2.sdl.yaml", + "sha256": "75834bdc883e2003e1c473870bdf75700978955bb83095c6bd718ba6bd3908a6" + }, + { + "artifact_id": "semantic-dangling-assertion-fixture", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/semantic-invalid-dangling-ref-participant-identity-v2.sdl.yaml", + "sha256": "1d25bee5f556054e5f0a518df025e4c62e080e1964035e3c1a12e074d88d3a5d" + }, + { + "artifact_id": "semantic-ambiguous-reference-fixture", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/semantic-invalid-ambiguous-ref.sdl.yaml", + "sha256": "653cbd2fd62e220d49fb86f80133884207df5ae6752846345ae3085b93f6e4ed" + }, + { + "artifact_id": "semantic-feature-cycle-fixture", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/semantic-invalid-feature-cycle.sdl.yaml", + "sha256": "e1f66d95a9ad039687aec8cccbc8843b514072ff08e006c1b4ca6aa5cd8d4ed1" + }, + { + "artifact_id": "workflow-reachable-control-fixture", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/workflow-reachable.sdl.yaml", + "sha256": "54c40ceb98ad47247447d737973b2c55e8fb2045e209c7545c4fb20cf42dc3dc" + }, + { + "artifact_id": "workflow-unreachable-step-fixture", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/workflow-unreachable.sdl.yaml", + "sha256": "ef22ef2e260f1a7fd92d286f9b571716436b192ddfd54aea7bdfcfdda4ca52a2" + }, + { + "artifact_id": "compile-repeatability-control-fixture", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/determinism-a.sdl.yaml", + "sha256": "0bc40900d598c1af7a405d798ca19710405e53ced262d8733081abf12edf89fe" + }, + { + "artifact_id": "compile-non-vacuity-control-comparison-fixture", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/determinism-b.sdl.yaml", + "sha256": "d85338f89f20a45515b12da8640173c1a52e47eb17ca0f4f6b4f8f3306e863a1" + } + ], + "bundle_id": "raes-formal-semantic-validation", + "corpus_path": "docs/research/formal-semantic-validation/corpus/manifest-v4.json", + "corpus_sha256": "c57207af72406aa4f70882b9bbeb7cedcc79cf3854c878a95e3eb1fa59ea7a72", + "protocol_path": "docs/research/formal-semantic-validation/protocol-v2.json", + "protocol_sha256": "abf94093e344bf495dfb04e8b0c5985c0beaab8ebb17a75e15c8674fa81b1a7c", + "revision": "capture-75bb60563fe13054358a57d241c247b09e748313f70098d7b3510988af5c5a67", + "snapshot_path": "docs/research/formal-semantic-validation/captures/capture-75bb60563fe13054358a57d241c247b09e748313f70098d7b3510988af5c5a67/snapshot.json", + "snapshot_sha256": "787a94b8c2a3fe56b020687c9af0a1aa16a7db5f1d3efbe6d921bb7ccdc25461" +} diff --git a/docs/research/formal-semantic-validation/captures/capture-75bb60563fe13054358a57d241c247b09e748313f70098d7b3510988af5c5a67/snapshot.json b/docs/research/formal-semantic-validation/captures/capture-75bb60563fe13054358a57d241c247b09e748313f70098d7b3510988af5c5a67/snapshot.json new file mode 100644 index 0000000000..828483bc07 --- /dev/null +++ b/docs/research/formal-semantic-validation/captures/capture-75bb60563fe13054358a57d241c247b09e748313f70098d7b3510988af5c5a67/snapshot.json @@ -0,0 +1,653 @@ +{ + "baseline": { + "execution_id": "issue-1519-pr-1458-formal-execution", + "release_path": "docs/research/formal-semantic-validation/captures/capture-e7f39cbb85eaca4f953a7f64dc4be7bff1fe2c2625976bd5a324d5ba996d018d/manifest.json", + "release_revision": "capture-e7f39cbb85eaca4f953a7f64dc4be7bff1fe2c2625976bd5a324d5ba996d018d", + "release_sha256": "f8a66af765a1b1daab230f95970ee6c78e79c9e608f7576c91e1c3dc0d7f91e4" + }, + "captured_at": "2026-10-25T08:54:08.535564+00:00", + "commands": [ + { + "argv": [ + "implementations/python/.venv/bin/python", + "-c", + "import json, sys\nfrom pathlib import Path\nroot = Path.cwd().resolve()\nfor entry in (str(root), str(root / \"implementations\" / \"python\" / \"packages\")):\n if entry not in sys.path:\n sys.path.insert(0, entry)\nfrom tools.formal_semantic_validation._replay import replay_case\ncorpus = json.loads((root / \"docs/research/formal-semantic-validation/corpus/manifest-v4.json\").read_text(encoding=\"utf-8\"))\nskipped = set([\"exploit-path\", \"satisfiability\", \"unsupported\"])\nresults = {}\nfor case in corpus[\"cases\"]:\n if case.get(\"replay_mode\") in skipped:\n continue\n try:\n results[case[\"case_id\"]] = {\"ok\": True, **replay_case(root, case)}\n except Exception as exc:\n results[case[\"case_id\"]] = {\"ok\": False, \"error\": type(exc).__name__ + \": \" + str(exc)[:300]}\nprint(json.dumps(results, sort_keys=True))\n" + ], + "command_id": "retained-case-replay", + "network": "disabled" + }, + { + "argv": [ + "implementations/python/.venv/bin/pytest", + "-q", + "implementations/python/tests/test_sem_208_participant_behavior.py::test_hidden_truth_disclosure_is_separate_from_observable_projection", + "implementations/python/tests/test_sem_208_participant_behavior.py::test_hidden_truth_cannot_be_observed_without_explicit_disclosure_rule", + "implementations/python/tests/test_sem_211_participant_action_semantics.py::test_action_contract_declares_sem_211_classes_and_compiles_them", + "implementations/python/tests/test_sem_211_participant_action_semantics.py::test_action_result_rejects_success_when_preconditions_are_unresolved", + "implementations/python/tests/test_run_308_concurrent_participant_execution.py::test_runtime_snapshot_publishes_joint_action_and_time_context_records", + "implementations/python/tests/test_run_308_concurrent_participant_execution.py::test_joint_action_record_contract_rejects_unordered_conflicting_writes", + "implementations/python/tests/test_participant_runtime_invariants.py::test_order_discipline_accepts_supported_order_claim_strengths", + "implementations/python/tests/test_participant_runtime_invariants.py::test_order_discipline_rejects_wall_clock_causality", + "implementations/python/tests/test_sem_212_participant_attribution_semantics.py::test_attribution_edge_round_trips_on_terminal_observation", + "implementations/python/tests/test_sem_212_participant_attribution_semantics.py::test_timestamp_adjacency_cannot_be_reported_as_strong_causality", + "implementations/python/tests/test_sem_215_participant_outcome_interpretation.py::test_outcome_interpretation_rule_parses_and_compiles_explicit_layers", + "implementations/python/tests/test_sem_215_participant_outcome_interpretation.py::test_local_action_success_does_not_imply_objective_success_without_rule_record", + "implementations/python/tests/test_realization_honesty_conformance.py::test_constructive_envelope_runs_positive_and_negative_honesty_probes", + "implementations/python/tests/test_realization_honesty_conformance.py::test_only_native_live_can_support_native_conformance" + ], + "command_id": "participant-fixtures", + "network": "disabled" + }, + { + "argv": [ + "implementations/python/.venv/bin/raes", + "processor", + "satisfiability", + "docs/research/formal-semantic-validation/corpus/satisfiable-control.sdl.yaml", + "--profile", + "raes-finite-domain-satisfiability-v1" + ], + "command_id": "finite-domain-satisfiable-v2", + "network": "disabled" + }, + { + "argv": [ + "implementations/python/.venv/bin/raes", + "processor", + "satisfiability", + "docs/research/formal-semantic-validation/corpus/unsatisfiable-control.sdl.yaml", + "--profile", + "raes-finite-domain-satisfiability-v1" + ], + "command_id": "finite-domain-unsatisfiable-v2", + "network": "disabled" + }, + { + "argv": [ + "implementations/python/.venv/bin/raes", + "processor", + "exploit-path", + "docs/research/formal-semantic-validation/corpus/exploit-path-valid-v3.json", + "--profile", + "raes-exploit-path-analysis-v1" + ], + "command_id": "typed-exploit-path-valid-v2", + "network": "disabled" + }, + { + "argv": [ + "implementations/python/.venv/bin/raes", + "processor", + "exploit-path", + "docs/research/formal-semantic-validation/corpus/exploit-path-invalid-v3.json", + "--profile", + "raes-exploit-path-analysis-v1" + ], + "command_id": "typed-exploit-path-invalid-v2", + "network": "disabled" + } + ], + "configuration_id": "raes-python-reference-offline-v41", + "corpus_revision": "4.0.0", + "deviations": [], + "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", + "execution_status": "complete", + "observations": [ + { + "actual_outcome": "accepted", + "analysis_profile": null, + "case_id": "schema-valid-control", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": null, + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/schema-valid.sdl.yaml" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", + "limitations": [ + "A passing minimal source does not establish semantic correctness." + ], + "replayable": true, + "result_digest": "f7d364ef384df8a1526b489501835b635021c860793b5764f91d956710d2250c", + "source_digest": null + }, + { + "actual_outcome": "rejected", + "analysis_profile": null, + "case_id": "schema-unknown-field", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": "SDLParseError", + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/schema-invalid-unknown-field.sdl.yaml" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", + "limitations": [ + "The observation covers one unknown-field defect only." + ], + "replayable": true, + "result_digest": "f55d834b458f8e069e1c69061b4cc0a6d61e0e052bf90c670f2e6a5ad8b5bd98", + "source_digest": null + }, + { + "actual_outcome": "accepted", + "analysis_profile": null, + "case_id": "semantic-resolved-objective", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": null, + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/semantic-valid-participant-identity-v2.sdl.yaml" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", + "limitations": [ + "This is a positive control for one objective-reference slice." + ], + "replayable": true, + "result_digest": "652288785dc09095955ed3649f6407d616fb7c4d4f4188df4ed513ccb7537e0b", + "source_digest": null + }, + { + "actual_outcome": "rejected", + "analysis_profile": null, + "case_id": "semantic-dangling-assertion", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": "SDLValidationError", + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/semantic-invalid-dangling-ref-participant-identity-v2.sdl.yaml" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", + "limitations": [ + "A single dangling reference does not prove complete semantic coverage." + ], + "replayable": true, + "result_digest": "0207cf616b56708ca9b8c4499d3301abe22dbe52162cf8d58d3bec429d9db024", + "source_digest": null + }, + { + "actual_outcome": "rejected", + "analysis_profile": null, + "case_id": "semantic-ambiguous-reference", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": "SDLValidationError", + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/semantic-invalid-ambiguous-ref.sdl.yaml" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", + "limitations": [ + "One namespace collision does not enumerate every ambiguity surface." + ], + "replayable": true, + "result_digest": "9da4a87797d228e0012ab6b30459f4892e41aa6f224a9840be035fee4a2eea73", + "source_digest": null + }, + { + "actual_outcome": "rejected", + "analysis_profile": null, + "case_id": "semantic-feature-cycle", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": "SDLValidationError", + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/semantic-invalid-feature-cycle.sdl.yaml" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", + "limitations": [ + "One static dependency cycle does not establish general constraint satisfiability." + ], + "replayable": true, + "result_digest": "d15dbcd99fb4f20b965d7031b07dd6534576302270399c3fa656d29e7de02b83", + "source_digest": null + }, + { + "actual_outcome": "accepted", + "analysis_profile": null, + "case_id": "workflow-reachable-control", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": null, + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/workflow-reachable.sdl.yaml" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", + "limitations": [ + "The graph is workflow control flow only." + ], + "replayable": true, + "result_digest": "b1b49649b54bd59d4ef357b39cf9158da90f4eae560f8dd756acf97bd0827a06", + "source_digest": null + }, + { + "actual_outcome": "rejected", + "analysis_profile": null, + "case_id": "workflow-unreachable-step", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": "SDLValidationError", + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/workflow-unreachable.sdl.yaml" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", + "limitations": [ + "The result does not establish network, service, participant, or exploit reachability." + ], + "replayable": true, + "result_digest": "bb931d19346ef9193408ae6c85deb4079704378fc5f00dc5f47a2817cff21943", + "source_digest": null + }, + { + "actual_outcome": "unsupported", + "analysis_profile": null, + "case_id": "whole-scenario-satisfiable-request", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": null, + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/decisions/issue-168-formal-semantic-validation-reachability-preflight.md" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", + "limitations": [ + "No governed whole-scenario constraint theory or solver exists." + ], + "replayable": false, + "result_digest": null, + "source_digest": null + }, + { + "actual_outcome": "unsupported", + "analysis_profile": null, + "case_id": "whole-scenario-unsatisfiable-request", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": null, + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/decisions/issue-168-formal-semantic-validation-reachability-preflight.md" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", + "limitations": [ + "Local checks cannot produce a whole-scenario unsat certificate." + ], + "replayable": false, + "result_digest": null, + "source_digest": null + }, + { + "actual_outcome": "unsupported", + "analysis_profile": null, + "case_id": "valid-exploit-path-request", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": null, + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/decisions/issue-168-formal-semantic-validation-reachability-preflight.md" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", + "limitations": [ + "The issue-168 baseline had no canonical typed attack graph or path-query entrypoint." + ], + "replayable": false, + "result_digest": null, + "source_digest": null + }, + { + "actual_outcome": "unsupported", + "analysis_profile": null, + "case_id": "invalid-exploit-path-request", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": null, + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/decisions/issue-168-formal-semantic-validation-reachability-preflight.md" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", + "limitations": [ + "Vulnerability and topology declarations are not an invalid-path proof." + ], + "replayable": false, + "result_digest": null, + "source_digest": null + }, + { + "actual_outcome": "stable", + "analysis_profile": null, + "case_id": "compile-repeatability-control", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": null, + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/determinism-a.sdl.yaml" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", + "limitations": [ + "The witness ends at compiled output." + ], + "replayable": true, + "result_digest": "d7c098c5d063b8d1b0747e8df5daa90061456065cdda0bbedfa10918442f5daa", + "source_digest": null + }, + { + "actual_outcome": "distinguishable", + "analysis_profile": null, + "case_id": "compile-non-vacuity-control", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": null, + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/determinism-a.sdl.yaml", + "docs/research/formal-semantic-validation/corpus/determinism-b.sdl.yaml" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", + "limitations": [ + "Distinct digests are a non-vacuity control, not semantic non-equivalence proof." + ], + "replayable": true, + "result_digest": "a2fcebba3341592b133af813e8bb8e5f47270418bc58bfd471a89bfbc8ba46da", + "source_digest": null + }, + { + "actual_outcome": "unsupported", + "analysis_profile": null, + "case_id": "necessity-witness-request", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": null, + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/decisions/issue-168-formal-semantic-validation-reachability-preflight.md" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", + "limitations": [ + "No governed intervention or ablation protocol exists." + ], + "replayable": false, + "result_digest": null, + "source_digest": null + }, + { + "actual_outcome": "unsupported", + "analysis_profile": null, + "case_id": "non-necessity-control-request", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": null, + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/decisions/issue-168-formal-semantic-validation-reachability-preflight.md" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", + "limitations": [ + "Attribution and negative fixtures do not demonstrate non-necessity." + ], + "replayable": false, + "result_digest": null, + "source_digest": null + }, + { + "actual_outcome": "satisfiable", + "analysis_profile": "raes-finite-domain-satisfiability-v1", + "case_id": "finite-domain-satisfiable-v2", + "configuration_digest": "sha256:1204635e17e759e9ad3bd6be2ecb28c6de05c07ead6dfdd15936ed5d3d5b81b2", + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": "scenario-satisfiability-evidence/v1", + "evidence_artifact_path": "docs/research/formal-semantic-validation/evidence/finite-domain-satisfiable-v4.json", + "evidence_artifact_sha256": "554202313d678046958b5c028e2de26ff03c74895cfac552677eed74e8153add", + "evidence_digest": "sha256:23c2cae7d95d4cc83d77ca576e3911477b169ecc311c977cb45490345f633b5a", + "evidence_profile": "scenario-satisfiability-evidence/v1", + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/satisfiable-control.sdl.yaml", + "docs/research/formal-semantic-validation/evidence/finite-domain-satisfiable-v4.json", + "specs/formal/scenario-satisfiability/README.md" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", + "limitations": [ + "Demonstrates only the pinned finite-domain theory, translation, solver profile, and source." + ], + "replayable": true, + "result_digest": "sha256:23c2cae7d95d4cc83d77ca576e3911477b169ecc311c977cb45490345f633b5a", + "source_digest": "sha256:0ca9eaba9dc47171f7a042dc6753faa6c820c65ee966538f9d65fac5342202e8" + }, + { + "actual_outcome": "unsatisfiable", + "analysis_profile": "raes-finite-domain-satisfiability-v1", + "case_id": "finite-domain-unsatisfiable-v2", + "configuration_digest": "sha256:1204635e17e759e9ad3bd6be2ecb28c6de05c07ead6dfdd15936ed5d3d5b81b2", + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": "scenario-satisfiability-evidence/v1", + "evidence_artifact_path": "docs/research/formal-semantic-validation/evidence/finite-domain-unsatisfiable-v4.json", + "evidence_artifact_sha256": "c972725ef64822a75a60380afc11f08eac25b7fe9b091d39b058b3c9f7c8031d", + "evidence_digest": "sha256:317b5cad00aa7f4f7868dca66127611ba19d40ffd86f35815502622814df54c1", + "evidence_profile": "scenario-satisfiability-evidence/v1", + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/unsatisfiable-control.sdl.yaml", + "docs/research/formal-semantic-validation/evidence/finite-domain-unsatisfiable-v4.json", + "specs/formal/scenario-satisfiability/README.md" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", + "limitations": [ + "The subset-minimal core is evidence for the pinned translation and solver, not a proof certificate for arbitrary SDL." + ], + "replayable": true, + "result_digest": "sha256:317b5cad00aa7f4f7868dca66127611ba19d40ffd86f35815502622814df54c1", + "source_digest": "sha256:cfef56a1f56d5f0db9da195377fd75694bdd0f0b92932fdb8fafcbd3f7baf6c5" + }, + { + "actual_outcome": "valid-path", + "analysis_profile": "raes-exploit-path-analysis-v1", + "case_id": "typed-exploit-path-valid-v2", + "configuration_digest": "sha256:7f8876d81feb77d3a3239be2fb8337de8885e2744f8786728ba23e4e6027bc0a", + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": "exploit-path-analysis-evidence/v1", + "evidence_artifact_path": "docs/research/formal-semantic-validation/evidence/typed-exploit-path-valid-v4.json", + "evidence_artifact_sha256": "1b7f55d04db172da32658187c64a88c13b5f4d565267ce2be7cb86a9d04cb70c", + "evidence_digest": "sha256:2d4d1a362751abd9544beb8af7f8c6331d04dac8f4abc315fb261f81fbaf4387", + "evidence_profile": "exploit-path-analysis-evidence/v1", + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/exploit-path-valid-v3.json", + "docs/research/formal-semantic-validation/evidence/typed-exploit-path-valid-v4.json", + "specs/formal/exploit-path-analysis/README.md" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", + "limitations": [ + "The witness is bounded to the admitted snapshot, normalized graph, query, semantics, and search profile; it does not establish backend execution." + ], + "replayable": true, + "result_digest": "sha256:2d4d1a362751abd9544beb8af7f8c6331d04dac8f4abc315fb261f81fbaf4387", + "source_digest": "sha256:0afe635a63db5b6e6380ac70982fd61d09790745d51a10d670321304121e7c39" + }, + { + "actual_outcome": "invalid-path", + "analysis_profile": "raes-exploit-path-analysis-v1", + "case_id": "typed-exploit-path-invalid-v2", + "configuration_digest": "sha256:7f8876d81feb77d3a3239be2fb8337de8885e2744f8786728ba23e4e6027bc0a", + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": "exploit-path-analysis-evidence/v1", + "evidence_artifact_path": "docs/research/formal-semantic-validation/evidence/typed-exploit-path-invalid-v4.json", + "evidence_artifact_sha256": "244f895a64f14c10916ab0533ab462ce80a328021cd6a50c30a4aa59266d5533", + "evidence_digest": "sha256:1b416bb5a4d29d57c961b769cc9d3af5d9328624e3eebf104d57f39a94c5bb97", + "evidence_profile": "exploit-path-analysis-evidence/v1", + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/exploit-path-invalid-v3.json", + "docs/research/formal-semantic-validation/evidence/typed-exploit-path-invalid-v4.json", + "specs/formal/exploit-path-analysis/README.md" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", + "limitations": [ + "Structured rejection proves only that this bounded graph/query cannot reach its goal; it does not establish real-world non-exploitability." + ], + "replayable": true, + "result_digest": "sha256:1b416bb5a4d29d57c961b769cc9d3af5d9328624e3eebf104d57f39a94c5bb97", + "source_digest": "sha256:0b2293d4a8983515ff05c516be6e6b418a4f3f09e055250a00bf15fda861aab3" + } + ], + "participant_observations": [ + { + "evidence_refs": [ + "implementations/python/tests/test_sem_208_participant_behavior.py::test_hidden_truth_disclosure_is_separate_from_observable_projection", + "implementations/python/tests/test_sem_208_participant_behavior.py::test_hidden_truth_cannot_be_observed_without_explicit_disclosure_rule" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", + "limitations": [ + "Covers the reference SDL/contract path, not every backend projection." + ], + "negative_outcome": "passed", + "obligation_id": "hidden-vs-visible-projection", + "positive_outcome": "passed" + }, + { + "evidence_refs": [ + "implementations/python/tests/test_sem_211_participant_action_semantics.py::test_action_contract_declares_sem_211_classes_and_compiles_them", + "implementations/python/tests/test_sem_211_participant_action_semantics.py::test_action_result_rejects_success_when_preconditions_are_unresolved" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", + "limitations": [ + "Covers declared applicability and one unresolved-precondition failure." + ], + "negative_outcome": "passed", + "obligation_id": "fail-closed-action-applicability", + "positive_outcome": "passed" + }, + { + "evidence_refs": [ + "implementations/python/tests/test_run_308_concurrent_participant_execution.py::test_runtime_snapshot_publishes_joint_action_and_time_context_records", + "implementations/python/tests/test_run_308_concurrent_participant_execution.py::test_joint_action_record_contract_rejects_unordered_conflicting_writes" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", + "limitations": [ + "Contract evidence does not prove every backend's live concurrency fidelity." + ], + "negative_outcome": "passed", + "obligation_id": "shared-state-effects", + "positive_outcome": "passed" + }, + { + "evidence_refs": [ + "implementations/python/tests/test_participant_runtime_invariants.py::test_order_discipline_accepts_supported_order_claim_strengths", + "implementations/python/tests/test_participant_runtime_invariants.py::test_order_discipline_rejects_wall_clock_causality" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", + "limitations": [ + "Rejecting timestamp-only causality does not supply counterfactual proof." + ], + "negative_outcome": "passed", + "obligation_id": "ordering-before-causality", + "positive_outcome": "passed" + }, + { + "evidence_refs": [ + "implementations/python/tests/test_sem_212_participant_attribution_semantics.py::test_attribution_edge_round_trips_on_terminal_observation", + "implementations/python/tests/test_sem_212_participant_attribution_semantics.py::test_timestamp_adjacency_cannot_be_reported_as_strong_causality" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", + "limitations": [ + "Attribution labels disclose basis; they do not demonstrate necessity." + ], + "negative_outcome": "passed", + "obligation_id": "evidence-labeled-attribution", + "positive_outcome": "passed" + }, + { + "evidence_refs": [ + "implementations/python/tests/test_sem_215_participant_outcome_interpretation.py::test_outcome_interpretation_rule_parses_and_compiles_explicit_layers", + "implementations/python/tests/test_sem_215_participant_outcome_interpretation.py::test_local_action_success_does_not_imply_objective_success_without_rule_record" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", + "limitations": [ + "The fixtures establish layer separation, not outcome validity in every realization." + ], + "negative_outcome": "passed", + "obligation_id": "participant-local-outcome-separation", + "positive_outcome": "passed" + }, + { + "evidence_refs": [ + "implementations/python/tests/test_realization_honesty_conformance.py::test_constructive_envelope_runs_positive_and_negative_honesty_probes", + "implementations/python/tests/test_realization_honesty_conformance.py::test_only_native_live_can_support_native_conformance" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", + "limitations": [ + "Reference conformance evidence remains bounded to declared realization profiles." + ], + "negative_outcome": "passed", + "obligation_id": "realization-profile-honesty", + "positive_outcome": "passed" + } + ], + "protocol_revision": "2.0.0", + "raes_revision": "eb32f9f1aee62d1879b581aec5cb7980847ac534", + "source_state": { + "base_revision": "eb32f9f1aee62d1879b581aec5cb7980847ac534", + "checkout_state": "clean", + "implementation_digest": "d57e6b1838fd0e095a78282a3bf755e43c5c7aa0dafc4f598ba338dcf02cb1bf", + "profile": "python-reference-source/v2" + }, + "versions": { + "python": "3.12.13", + "raes": "7.0.0", + "z3_engine": "4.16.0", + "z3_solver": "4.16.0.0" + } +} diff --git a/docs/research/specification-coverage/capture-records/capture-917dcfe82f8ee8c7fda5cc4dc8f936c8ae254f68ac9da4624dbbdc8ff71da106.json b/docs/research/specification-coverage/capture-records/capture-917dcfe82f8ee8c7fda5cc4dc8f936c8ae254f68ac9da4624dbbdc8ff71da106.json new file mode 100644 index 0000000000..422e174279 --- /dev/null +++ b/docs/research/specification-coverage/capture-records/capture-917dcfe82f8ee8c7fda5cc4dc8f936c8ae254f68ac9da4624dbbdc8ff71da106.json @@ -0,0 +1,4 @@ +{ + "capture_path": "docs/research/specification-coverage/captures/capture-917dcfe82f8ee8c7fda5cc4dc8f936c8ae254f68ac9da4624dbbdc8ff71da106/manifest.json", + "capture_sha256": "8b69f20f0a3d94db7dccf5b867131c41e7b7ee0e672882ab87655823cc9b6fb1" +} diff --git a/docs/research/specification-coverage/captures/capture-917dcfe82f8ee8c7fda5cc4dc8f936c8ae254f68ac9da4624dbbdc8ff71da106/analysis.json b/docs/research/specification-coverage/captures/capture-917dcfe82f8ee8c7fda5cc4dc8f936c8ae254f68ac9da4624dbbdc8ff71da106/analysis.json new file mode 100644 index 0000000000..2cdc18fb44 --- /dev/null +++ b/docs/research/specification-coverage/captures/capture-917dcfe82f8ee8c7fda5cc4dc8f936c8ae254f68ac9da4624dbbdc8ff71da106/analysis.json @@ -0,0 +1,117 @@ +{ + "analysis_id": "issue-1479-oci-anonymous-token-specification-analysis-d57e6b1838fd", + "backend_leakage": [], + "claim": { + "allowed_evidence": [ + "pinned source metadata and bounded paraphrases", + "production parser, semantic, instantiation, admission, compiler, contract, and profile results", + "exact artifact digests and typed pointers", + "documented missing-concept and backend-specific dispositions" + ], + "claim_id": "raes-standardized-configurable-specification-coverage", + "disallowed_evidence": [ + "field-count or schema breadth alone", + "the existing scenario stress corpus as the representative request corpus", + "free-form metadata as typed coverage", + "backend-private interpretation", + "post-hoc removal or repair of falsifying concepts" + ], + "evidence_artifacts": [ + "docs/research/specification-coverage/protocol-v1.json", + "@snapshot", + "docs/research/specification-coverage/analysis-v68.json" + ], + "falsification_protocol": "docs/research/specification-coverage/protocol-v1.json", + "objective_fail_criteria": "A load-bearing concept is missing or lossy, an applicable stage fails, or backend vocabulary is required in core SDL while the result claims success.", + "objective_pass_criteria": "Every load-bearing concept passes at every owning stage, backend-specific mechanics stay outside core SDL, and no requested concept is silently lost.", + "statement": "RAES provides a standardized configurable portable specification surface for the preregistered representative cyber-agent evaluation environment requirements without backend vocabulary in core SDL.", + "threats_to_validity": [ + "The representative corpus contains four source strata and sixteen atomic concepts rather than every cyber-range requirement.", + "The reference processor and repository fixtures are not independent backend implementations.", + "No live range, simulator federation, or participant execution was part of this offline specification-coverage test." + ] + }, + "classification_counts": { + "deliberately-backend-specific": 1, + "directly-expressible": 10, + "missing": 3, + "profile-or-manifest-constraint": 2 + }, + "evidence_status": "partial", + "execution_status": "complete", + "generated_at": "2026-10-25T08:54:08.535564+00:00", + "limitations": [ + "This result demonstrates bounded specification coverage, not universal cyber-range coverage, usability, adoption, backend substitution, or behavioral equivalence.", + "The three missing concepts are evidence, not implementation tasks within this snapshot.", + "The retained protocol does not test recursive realization or plan-level profile semantics; this release only re-establishes its original bounded coverage result against the current implementation.", + "The retained protocol does not test evidence-requirement refinement lineage; the dedicated EXP-731 regression suite covers that production boundary.", + "Authoring-adapter transport behavior is outside this retained protocol.", + "Reviewed OCI mirror and pre-seed admission is covered by its own regression suites and the development artifact policy gate, not a new claim in this preregistered matrix.", + "Operational recovery observation and startup reconciliation are covered by their API-404 regression suite, not a new claim in this preregistered matrix.", + "Store ownership, immutable runtime scope, and provider shutdown ordering are covered by the API-404 CP-5 regression suite, not by this retained specification-coverage protocol.", + "Mixed/staged trial compilation and admission are covered by issue #1015 regression tests, not by this retained specification-coverage corpus; no live mixed-runtime result is claimed.", + "Issue #1186 control-plane recovery operations are covered by their runtime regression suite, not by this retained specification-coverage corpus.", + "Issue #1187 control-plane crash/profile conformance and HTTP security changes are covered by their dedicated regression suite, not promoted to new claims by this retained corpus.", + "Issue #1189 control-plane profile declarations are covered by their dedicated runtime suite, not promoted to new claims by the retained language corpus.", + "Issue #610's reconciliation demonstration harness is covered by its dedicated processor and CLI suite, not promoted to new claims by the retained language corpus.", + "Participant identity, organization ownership, and participant assignment are separated by issue #1338. This retained offline corpus does not establish participant autonomy, execution authority, live backend fidelity, or causal attribution.", + "Participant-local outcome state is verified by the ACT-618 tests; this retained corpus makes no additional outcome-state claim.", + "Backend operation supervision contracts are covered by issue #1360 contract tests; this retained offline corpus establishes no live backend supervision or recovery guarantee.", + "This capture replays the merged issue #1360 and #1357 source; the protocol makes no live backend execution or supervision claim.", + "This capture replays the merged issue #1360 and #1358 source; the protocol makes no live backend execution or supervision claim.", + "Issue #1389 participant inject delivery temporal-subject admission is covered by dedicated compiler tests; this retained matrix makes no new timing or execution claim.", + "Issue #971 adds offline crossing model construction; this retained protocol establishes no crossing equivalence or runtime-realization claim.", + "Issue #1359 control-plane route authority, participant-view scoping, and no-store HTTP boundary are covered by their dedicated HTTP-boundary suite; this retained matrix makes no new exposure or execution claim.", + "Issue #1401 required-evidence media-type coherence is verified by its dedicated suite; this retained matrix makes no new admission or capture claim.", + "Issue #1361 execution and recovery requirements are verified by dedicated policy, composition, and admission tests; this retained corpus establishes no live recovery, continuation, or trial-allocation guarantee.", + "The issue #1361 maintainability repair preserves policy semantics and retained corpus outcomes; it establishes no live recovery, continuation, or trial-allocation guarantee.", + "The issue #1361 resource type-hint repair preserves policy semantics and retained corpus outcomes; it establishes no live recovery, continuation, or trial-allocation guarantee.", + "The combined issue #1361 execution-policy and hatchling update preserves retained outcomes and bounded claims; it establishes no live recovery, continuation, or trial-allocation guarantee.", + "The issue #1418 runtime-fact export manifest split changes no contract, schema or behavior; this retained matrix makes no new admission or coverage claim.", + "The issue #1423 inject trigger request and occurrence contracts are new draft carriers that no SDL construct, compiler or runtime path reads; this retained matrix makes no new admission or coverage claim.", + "The issue #1366 inject readback, correlation and backend declaration contracts are new draft carriers; the shared backend allowlist also lets SDL participant behavior specifications cite inject-occurrence-v1 and inject-occurrence-outcome-v1 as evidence_contract_refs, which the compiler copies through uninterpreted, and no runtime path or shipped backend reads or declares them; this retained matrix makes no new admission or coverage claim.", + "This synchronization preserves the original inject and mixed-backend captures, binds their combined source, and adds no runtime or backend-adoption claim.", + "This second synchronization adds behavior-authoring source from issue #297; prior inject and behavior-authoring captures remain preserved. No additional runtime adoption is claimed.", + "Task-contract CLI admission and optional supplied-task reference checks are covered by test_issue_1519_experiment_tasks.py; the retained research corpus makes no additional task, artifact-content, or execution claim." + ], + "load_bearing_results": { + "failed": 0, + "missing": 0, + "passed": 10, + "total": 10 + }, + "plain_language_outcome": "The retained specification matrix reproduces its classifications on the combined source of current dev and issue #1479's anonymous bearer-token flow for OCI module fetches. Bounded claims and untested concepts are unchanged.", + "protocol_revision": "1.0.0", + "request_results": [ + { + "concept_count": 6, + "failed_stage_count": 0, + "missing_count": 0, + "request_id": "survey-representative-range", + "status": "demonstrated" + }, + { + "concept_count": 5, + "failed_stage_count": 1, + "missing_count": 1, + "request_id": "cyborg-participant-evaluation", + "status": "partial" + }, + { + "concept_count": 3, + "failed_stage_count": 1, + "missing_count": 1, + "request_id": "vsdl-configurable-infrastructure", + "status": "partial" + }, + { + "concept_count": 2, + "failed_stage_count": 1, + "missing_count": 1, + "request_id": "cyber-dem-federation", + "status": "partial" + } + ], + "snapshot_id": "issue-1479-oci-anonymous-token-specification-d57e6b1838fd", + "snapshot_sha256": "0c2f9325c5954591b3e54014656c90fa37e555bd71756fd89508886438767684" +} diff --git a/docs/research/specification-coverage/captures/capture-917dcfe82f8ee8c7fda5cc4dc8f936c8ae254f68ac9da4624dbbdc8ff71da106/manifest.json b/docs/research/specification-coverage/captures/capture-917dcfe82f8ee8c7fda5cc4dc8f936c8ae254f68ac9da4624dbbdc8ff71da106/manifest.json new file mode 100644 index 0000000000..d971c341ca --- /dev/null +++ b/docs/research/specification-coverage/captures/capture-917dcfe82f8ee8c7fda5cc4dc8f936c8ae254f68ac9da4624dbbdc8ff71da106/manifest.json @@ -0,0 +1,10 @@ +{ + "analysis_path": "docs/research/specification-coverage/captures/capture-917dcfe82f8ee8c7fda5cc4dc8f936c8ae254f68ac9da4624dbbdc8ff71da106/analysis.json", + "analysis_sha256": "0f466024cc8f91e0b864f576459ab9c2296e9f351df35be8a59b936394099707", + "bundle_id": "raes-standardized-specification-coverage", + "protocol_path": "docs/research/specification-coverage/protocol-v1.json", + "protocol_sha256": "e97a19e643e94c9e589dca823a63c6ce49d3329fe2a3cb888ab630838ed93125", + "revision": "capture-917dcfe82f8ee8c7fda5cc4dc8f936c8ae254f68ac9da4624dbbdc8ff71da106", + "snapshot_path": "docs/research/specification-coverage/captures/capture-917dcfe82f8ee8c7fda5cc4dc8f936c8ae254f68ac9da4624dbbdc8ff71da106/snapshot.json", + "snapshot_sha256": "010e46211dde5f496e065ca75356cf433ac24428006bcc8292f3a1519025c850" +} diff --git a/docs/research/specification-coverage/captures/capture-917dcfe82f8ee8c7fda5cc4dc8f936c8ae254f68ac9da4624dbbdc8ff71da106/snapshot.json b/docs/research/specification-coverage/captures/capture-917dcfe82f8ee8c7fda5cc4dc8f936c8ae254f68ac9da4624dbbdc8ff71da106/snapshot.json new file mode 100644 index 0000000000..f7fa4c7777 --- /dev/null +++ b/docs/research/specification-coverage/captures/capture-917dcfe82f8ee8c7fda5cc4dc8f936c8ae254f68ac9da4624dbbdc8ff71da106/snapshot.json @@ -0,0 +1,705 @@ +{ + "artifacts": [ + { + "artifact_id": "enterprise-participant-sdl", + "kind": "sdl", + "path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "sha256": "f7a8897beec243e188ee081975006fad32725f469f267db6e75a1e1cf5727032", + "validator": "raes parse, semantic, instantiation/admission, and compiler pipeline" + }, + { + "artifact_id": "port-range-sdl", + "kind": "sdl", + "path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "sha256": "0d5497ec946b863e6985284ec487dde7d7f6bf710a985be51401ac0e5e79dc4f", + "validator": "raes parse, semantic, instantiation/admission, and compiler pipeline" + }, + { + "artifact_id": "experiment-task-contract", + "kind": "experiment-task", + "path": "contracts/fixtures/experiment-core/experiment-task-v1/valid/reference.json", + "sha256": "f3edf713ac6af26bad609136851c6dd434bfb87ce919a2d8c4414c1035deeafc", + "validator": "raes_contracts.contracts.ExperimentTaskModel" + }, + { + "artifact_id": "apparatus-context-contract", + "kind": "experiment-apparatus-context", + "path": "contracts/fixtures/experiment-core/experiment-apparatus-context-v1/valid/reference.json", + "sha256": "e6fa559c5e961f0aab448d0f70dead24aa74fa8ba5f20e1b72f88e11473c9299", + "validator": "raes_contracts.contracts.ExperimentApparatusContextModel" + }, + { + "artifact_id": "backend-profile", + "kind": "backend-profile", + "path": "contracts/profiles/backend/orchestration-capable.json", + "sha256": "f70b8505a5c0055416db86c533e2e5bf08b11e5a514f076223b6d6c36215a092", + "validator": "raes_contracts.backend_profiles.BackendProfileModel" + }, + { + "artifact_id": "known-limitations", + "kind": "documentation", + "path": "docs/explain/sdl/limitations.md", + "sha256": "489eeab3ce682627682311581eb98af9abb9ff42a437145af266eefb71dc7fc4", + "validator": "documentation evidence only" + } + ], + "baseline": { + "release_revision": "1.1.0", + "release_sha256": "4020a1d56c7fe2831cec59ea64a12bbda9d38ccd94f93b916dd90f1a28f17fcb" + }, + "captured_at": "2026-10-25T08:54:08.535564+00:00", + "concept_results": [ + { + "backend_support": "not-evaluated", + "backend_vocabulary_occurrences": [], + "classification": "directly-expressible", + "completeness_disposition": "implemented", + "concept_id": "range-topology", + "rationale": "SDL nodes and infrastructure own host, network, link, and dependency meaning; the compiler emits canonical node deployment addresses.", + "stage_results": [ + { + "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "diagnostic_codes": [], + "note": "Typed VM declaration.", + "outcome": "passed", + "pointer": "/nodes/shipping-portal", + "stage_id": "authored", + "validation_strength": "structural" + }, + { + "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "diagnostic_codes": [], + "note": "Links and dependencies resolved.", + "outcome": "passed", + "pointer": "/infrastructure/shipping-portal", + "stage_id": "semantic", + "validation_strength": "semantic" + }, + { + "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "diagnostic_codes": [], + "note": "Published instantiated shape admitted.", + "outcome": "passed", + "pointer": "/nodes/shipping-portal", + "stage_id": "instantiated", + "validation_strength": "phase-admitted" + }, + { + "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "diagnostic_codes": [], + "note": "Canonical deployment address retained.", + "outcome": "passed", + "pointer": "/node_deployments/provision.node.shipping-portal", + "stage_id": "compiled", + "validation_strength": "compiled" + } + ], + "typed_pointer": "/nodes/shipping-portal" + }, + { + "backend_support": "not-evaluated", + "backend_vocabulary_occurrences": [], + "classification": "directly-expressible", + "completeness_disposition": "implemented", + "concept_id": "exercise-roles", + "rationale": "SDL entity roles own exercise responsibility without becoming control-plane identity or authorization.", + "stage_results": [ + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Typed red role.", + "outcome": "passed", + "pointer": "/entities/enterprise-participant/role", + "stage_id": "authored", + "validation_strength": "structural" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Entity references validated.", + "outcome": "passed", + "pointer": "/entities/enterprise-participant", + "stage_id": "semantic", + "validation_strength": "semantic" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Role retained after instantiation.", + "outcome": "passed", + "pointer": "/entities/enterprise-participant/role", + "stage_id": "instantiated", + "validation_strength": "phase-admitted" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Role retained in entity specification.", + "outcome": "passed", + "pointer": "/entity_specs/enterprise-participant/role", + "stage_id": "compiled", + "validation_strength": "compiled" + } + ], + "typed_pointer": "/entities/enterprise-participant/role" + }, + { + "backend_support": "not-evaluated", + "backend_vocabulary_occurrences": [], + "classification": "directly-expressible", + "completeness_disposition": "implemented", + "concept_id": "evaluation-objectives", + "rationale": "SDL objectives own organization ownership, participant assignment, targets, windows, and assertion-based success; measures remain experiment contracts.", + "stage_results": [ + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Typed objective declaration.", + "outcome": "passed", + "pointer": "/objectives/demonstrate-handoff", + "stage_id": "authored", + "validation_strength": "structural" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Owner, participant assignment, targets, assertions, and workflow refs resolved.", + "outcome": "passed", + "pointer": "/objectives/demonstrate-handoff/success", + "stage_id": "semantic", + "validation_strength": "semantic" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Objective retained in admitted artifact.", + "outcome": "passed", + "pointer": "/objectives/demonstrate-handoff", + "stage_id": "instantiated", + "validation_strength": "phase-admitted" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Canonical objective address retained.", + "outcome": "passed", + "pointer": "/objectives/evaluation.objective.demonstrate-handoff", + "stage_id": "compiled", + "validation_strength": "compiled" + } + ], + "typed_pointer": "/objectives/demonstrate-handoff" + }, + { + "backend_support": "not-evaluated", + "backend_vocabulary_occurrences": [], + "classification": "directly-expressible", + "completeness_disposition": "implemented", + "concept_id": "control-workflows", + "rationale": "SDL workflows own the portable control graph and compile to canonical orchestration state contracts.", + "stage_results": [ + { + "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "diagnostic_codes": [], + "note": "Typed control graph.", + "outcome": "passed", + "pointer": "/workflows/yard-recovery", + "stage_id": "authored", + "validation_strength": "structural" + }, + { + "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "diagnostic_codes": [], + "note": "Step graph and objective refs validated.", + "outcome": "passed", + "pointer": "/workflows/yard-recovery/steps", + "stage_id": "semantic", + "validation_strength": "semantic" + }, + { + "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "diagnostic_codes": [], + "note": "Workflow retained after instantiation.", + "outcome": "passed", + "pointer": "/workflows/yard-recovery", + "stage_id": "instantiated", + "validation_strength": "phase-admitted" + }, + { + "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "diagnostic_codes": [], + "note": "Canonical control graph retained.", + "outcome": "passed", + "pointer": "/workflows/orchestration.workflow.yard-recovery", + "stage_id": "compiled", + "validation_strength": "compiled" + } + ], + "typed_pointer": "/workflows/yard-recovery" + }, + { + "backend_support": "not-evaluated", + "backend_vocabulary_occurrences": [], + "classification": "directly-expressible", + "completeness_disposition": "implemented", + "concept_id": "authored-evidence-expectations", + "rationale": "SDL evidence requirements own portable capture intent and remain distinct from evidence records and measures.", + "stage_results": [ + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Typed capture obligation.", + "outcome": "passed", + "pointer": "/evidence_requirements/objective-truth-evidence", + "stage_id": "authored", + "validation_strength": "structural" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Source refs and bindings validated.", + "outcome": "passed", + "pointer": "/evidence_requirements/objective-truth-evidence", + "stage_id": "semantic", + "validation_strength": "semantic" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Evidence intent retained in admitted artifact.", + "outcome": "passed", + "pointer": "/evidence_requirements/objective-truth-evidence", + "stage_id": "instantiated", + "validation_strength": "phase-admitted" + } + ], + "typed_pointer": "/evidence_requirements/objective-truth-evidence" + }, + { + "backend_support": "profile-bound", + "backend_vocabulary_occurrences": [], + "classification": "profile-or-manifest-constraint", + "completeness_disposition": "implemented", + "concept_id": "apparatus-selection-constraints", + "rationale": "The experiment task contract binds processor/backend identities, manifest refs, and capabilities outside SDL.", + "stage_results": [ + { + "artifact_path": "contracts/fixtures/experiment-core/experiment-task-v1/valid/reference.json", + "diagnostic_codes": [], + "note": "Closed ExperimentTaskModel validated.", + "outcome": "passed", + "pointer": "/apparatus_constraints/allowed_backend_refs/0", + "stage_id": "contract", + "validation_strength": "contract" + } + ], + "typed_pointer": "/apparatus_constraints/allowed_backend_refs/0" + }, + { + "backend_support": "not-evaluated", + "backend_vocabulary_occurrences": [], + "classification": "directly-expressible", + "completeness_disposition": "implemented", + "concept_id": "participant-agent", + "rationale": "SDL agents own participant entity, knowledge, actions, observation boundaries, and operating scope.", + "stage_results": [ + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Typed participant declaration.", + "outcome": "passed", + "pointer": "/agents/participant-agent", + "stage_id": "authored", + "validation_strength": "structural" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Participant refs and scope validated.", + "outcome": "passed", + "pointer": "/agents/participant-agent/observation_boundaries", + "stage_id": "semantic", + "validation_strength": "semantic" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Participant retained in admitted artifact.", + "outcome": "passed", + "pointer": "/agents/participant-agent", + "stage_id": "instantiated", + "validation_strength": "phase-admitted" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Compiled participant scope retained.", + "outcome": "passed", + "pointer": "/agent_specs/participant-agent", + "stage_id": "compiled", + "validation_strength": "compiled" + } + ], + "typed_pointer": "/agents/participant-agent" + }, + { + "backend_support": "not-evaluated", + "backend_vocabulary_occurrences": [], + "classification": "directly-expressible", + "completeness_disposition": "implemented", + "concept_id": "participant-action-contract", + "rationale": "The action contract declares portable preconditions, effects, observations, evidence, and failure classes without a runner command.", + "stage_results": [ + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Typed action contract.", + "outcome": "passed", + "pointer": "/action_contracts/probe-customer-portal-login", + "stage_id": "authored", + "validation_strength": "structural" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Action refs and evidence bindings validated.", + "outcome": "passed", + "pointer": "/action_contracts/probe-customer-portal-login/effects", + "stage_id": "semantic", + "validation_strength": "semantic" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Action retained in admitted artifact.", + "outcome": "passed", + "pointer": "/action_contracts/probe-customer-portal-login", + "stage_id": "instantiated", + "validation_strength": "phase-admitted" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Canonical action address retained.", + "outcome": "passed", + "pointer": "/action_contracts/participant.action-contract.probe-customer-portal-login", + "stage_id": "compiled", + "validation_strength": "compiled" + } + ], + "typed_pointer": "/action_contracts/probe-customer-portal-login" + }, + { + "backend_support": "not-evaluated", + "backend_vocabulary_occurrences": [], + "classification": "directly-expressible", + "completeness_disposition": "implemented", + "concept_id": "participant-observation-boundary", + "rationale": "The observation boundary separately declares visible, hidden, and evidence-only information with transition rules.", + "stage_results": [ + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Typed observation boundary.", + "outcome": "passed", + "pointer": "/observation_boundaries/participant-view", + "stage_id": "authored", + "validation_strength": "structural" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Information refs and transitions validated.", + "outcome": "passed", + "pointer": "/observation_boundaries/participant-view/view_rules", + "stage_id": "semantic", + "validation_strength": "semantic" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Boundary retained in admitted artifact.", + "outcome": "passed", + "pointer": "/observation_boundaries/participant-view", + "stage_id": "instantiated", + "validation_strength": "phase-admitted" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Canonical boundary address retained.", + "outcome": "passed", + "pointer": "/observation_boundaries/participant.observation-boundary.participant-view", + "stage_id": "compiled", + "validation_strength": "compiled" + } + ], + "typed_pointer": "/observation_boundaries/participant-view" + }, + { + "backend_support": "not-evaluated", + "backend_vocabulary_occurrences": [], + "classification": "directly-expressible", + "completeness_disposition": "implemented", + "concept_id": "evaluation-measure", + "rationale": "ExperimentTaskModel owns metric construct, unit, direction, aggregation, and evidence requirements outside SDL objectives.", + "stage_results": [ + { + "artifact_path": "contracts/fixtures/experiment-core/experiment-task-v1/valid/reference.json", + "diagnostic_codes": [], + "note": "Closed task contract validated.", + "outcome": "passed", + "pointer": "/evaluation_protocol/metric_definitions/foothold-achieved", + "stage_id": "contract", + "validation_strength": "contract" + } + ], + "typed_pointer": "/evaluation_protocol/metric_definitions/foothold-achieved" + }, + { + "backend_support": "not-evaluated", + "backend_vocabulary_occurrences": [], + "classification": "missing", + "completeness_disposition": "documented-gap", + "concept_id": "participant-tool-affordance", + "rationale": "This preregistered matrix has no tested carrier for participant tool affordances. The retained missing classification records missing coverage evidence, not the absence of current participant-behavior capabilities.", + "stage_results": [ + { + "artifact_path": "docs/explain/sdl/limitations.md", + "diagnostic_codes": [], + "note": "The preregistered carrier slot was not run; metadata does not substitute for a typed coverage test.", + "outcome": "not_run", + "pointer": null, + "stage_id": "authored", + "validation_strength": "not-applicable" + } + ], + "typed_pointer": null + }, + { + "backend_support": "not-evaluated", + "backend_vocabulary_occurrences": [], + "classification": "directly-expressible", + "completeness_disposition": "implemented", + "concept_id": "resource-constrained-topology", + "rationale": "SDL node resources and infrastructure dependencies express portable resource intent without provider resource identifiers.", + "stage_results": [ + { + "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "diagnostic_codes": [], + "note": "Typed CPU and memory declaration.", + "outcome": "passed", + "pointer": "/nodes/shipping-portal/resources", + "stage_id": "authored", + "validation_strength": "structural" + }, + { + "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "diagnostic_codes": [], + "note": "Resource-bearing topology validated.", + "outcome": "passed", + "pointer": "/infrastructure/shipping-portal", + "stage_id": "semantic", + "validation_strength": "semantic" + }, + { + "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "diagnostic_codes": [], + "note": "Constraints retained in admitted artifact.", + "outcome": "passed", + "pointer": "/nodes/shipping-portal/resources", + "stage_id": "instantiated", + "validation_strength": "phase-admitted" + }, + { + "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "diagnostic_codes": [], + "note": "Deployment specification retains resource intent.", + "outcome": "passed", + "pointer": "/node_deployments/provision.node.shipping-portal", + "stage_id": "compiled", + "validation_strength": "compiled" + } + ], + "typed_pointer": "/nodes/shipping-portal/resources" + }, + { + "backend_support": "not-evaluated", + "backend_vocabulary_occurrences": [], + "classification": "missing", + "completeness_disposition": "documented-gap", + "concept_id": "formal-constraint-satisfiability", + "rationale": "This coverage matrix did not exercise a solver-backed carrier. The separate formal-semantic-validation release demonstrates its bounded finite-domain profile; that result is not silently imported into this protocol's missing carrier slot.", + "stage_results": [ + { + "artifact_path": "docs/explain/sdl/limitations.md", + "diagnostic_codes": [], + "note": "No coverage-carrier execution was performed here; independent solver evidence does not change this preregistered denominator.", + "outcome": "not_run", + "pointer": null, + "stage_id": "semantic", + "validation_strength": "not-applicable" + } + ], + "typed_pointer": null + }, + { + "backend_support": "profile-bound", + "backend_vocabulary_occurrences": [ + { + "allowed": true, + "artifact_path": "source:vsdl-paper", + "pointer": "source sections 4-5", + "reason": "Legitimate VSDL realization vocabulary, not RAES core SDL structure.", + "term": "OpenStack/Terraform/Packer" + } + ], + "classification": "deliberately-backend-specific", + "completeness_disposition": "external", + "concept_id": "provider-specific-provisioning", + "rationale": "Provider image selection and provisioning engines are realization mechanics and therefore remain outside core SDL.", + "stage_results": [ + { + "artifact_path": "contracts/profiles/backend/orchestration-capable.json", + "diagnostic_codes": [], + "note": "The portable boundary requires backend contracts; it does not standardize a provider engine.", + "outcome": "not_applicable", + "pointer": "/required_contracts", + "stage_id": "realization-disclosure", + "validation_strength": "profile" + } + ], + "typed_pointer": null + }, + { + "backend_support": "profile-bound", + "backend_vocabulary_occurrences": [], + "classification": "profile-or-manifest-constraint", + "completeness_disposition": "implemented", + "concept_id": "apparatus-clock-context", + "rationale": "ExperimentApparatusContextModel records clock authority, time domain, and synchronization as apparatus facts outside scenario meaning.", + "stage_results": [ + { + "artifact_path": "contracts/fixtures/experiment-core/experiment-apparatus-context-v1/valid/reference.json", + "diagnostic_codes": [], + "note": "Closed apparatus context contract validated.", + "outcome": "passed", + "pointer": "/clocks/0", + "stage_id": "contract", + "validation_strength": "contract" + } + ], + "typed_pointer": "/clocks/0" + }, + { + "backend_support": "not-evaluated", + "backend_vocabulary_occurrences": [], + "classification": "missing", + "completeness_disposition": "documented-gap", + "concept_id": "federated-object-event-exchange", + "rationale": "The federated cyber object/event exchange carrier was not exercised by this preregistered matrix. Runtime event internals are not treated as equivalent evidence.", + "stage_results": [ + { + "artifact_path": "docs/explain/sdl/limitations.md", + "diagnostic_codes": [], + "note": "The missing coverage-carrier test is recorded explicitly, without inferring an ecosystem-wide capability absence.", + "outcome": "not_run", + "pointer": null, + "stage_id": "contract", + "validation_strength": "not-applicable" + } + ], + "typed_pointer": null + } + ], + "deviations": [ + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "baseline_sha256": "54ba1a60220e27a55da9cd2a407d7d3ab836fa54460d0b0c6cad87c2e744ddbb", + "rationale": "Migrate participant affiliations and explicit objective assignment, retaining organizational intent and portable action-contract declarations without granting execution authority.", + "retest_sha256": "f7a8897beec243e188ee081975006fad32725f469f267db6e75a1e1cf5727032" + }, + { + "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "baseline_sha256": "a27c7a64e0c5c618fadaccafdf1a4e71600170a8b77b983190822b5141f00dec", + "rationale": "Migrate participant affiliations and explicit objective assignment, retaining organizational intent and portable action-contract declarations without granting execution authority.", + "retest_sha256": "0d5497ec946b863e6985284ec487dde7d7f6bf710a985be51401ac0e5e79dc4f" + }, + { + "artifact_path": "contracts/fixtures/experiment-core/experiment-task-v1/valid/reference.json", + "baseline_sha256": "21952a752f4e8581a9fc3b872e4bc308150548170d38bcfc83dbbe35ff5e0b9f", + "rationale": "Replay the retained preregistered artifact against the current evidence-provenance validation implementation.", + "retest_sha256": "f3edf713ac6af26bad609136851c6dd434bfb87ce919a2d8c4414c1035deeafc" + }, + { + "artifact_path": "contracts/fixtures/experiment-core/experiment-apparatus-context-v1/valid/reference.json", + "baseline_sha256": "9536d897a09cbc6920e667e4f8f9371e51307aa0b3b5ff3c7de682dd783420ab", + "rationale": "Replay the retained preregistered artifact against the current evidence-provenance validation implementation.", + "retest_sha256": "e6fa559c5e961f0aab448d0f70dead24aa74fa8ba5f20e1b72f88e11473c9299" + }, + { + "artifact_path": "docs/explain/sdl/limitations.md", + "baseline_sha256": "129cf17810aad4c51988bc872e28fe43ae95019a80053c42d800ff7e2b9cc93e", + "rationale": "Correct historical mandatory-profile guidance after issue #1207; retain the preregistered missing-concept classifications and coverage limits.", + "retest_sha256": "489eeab3ce682627682311581eb98af9abb9ff42a437145af266eefb71dc7fc4" + } + ], + "execution_status": "complete", + "implementation_surfaces": [ + { + "content_sha256": "87140df77ef39187fe1d847f325acba77295c82d2174bdc4275123970fe0d6c2", + "path": "implementations/python/packages/raes_contracts", + "surface_id": "contract-models" + }, + { + "content_sha256": "6507070e975b1b3210c2bae67aa05d5543f5e722eac87f6b07f4a987ebcbcfff", + "path": "implementations/python/packages/raes_processor", + "surface_id": "processor-pipeline" + }, + { + "content_sha256": "a92ad2182019386dad1e87e03c20d4361c0b0bedd5cdc209788ca3c10a29f9fb", + "path": "implementations/python/packages/raes", + "surface_id": "sdl-pipeline" + } + ], + "limitations": [ + "The execution validates the pinned reference implementation and published contracts, not an independent backend.", + "Repository-owned examples are exact execution artifacts but are not themselves the literature-derived request corpus; the protocol's requests and concepts are.", + "No live range, participant, simulator federation, or provider provisioning engine was executed.", + "Missing concepts remain frozen in this snapshot and require separately scoped product work before a later rerun.", + "This capture replays the retained protocol after EXP-732 run, apparatus, measurement-channel, and augmentation-producer provenance validation; it adds no independent backend or universal provenance assurance claim.", + "Materialization attestation is covered by its dedicated regression suite, not a new claim in this preregistered matrix.", + "This capture refreshes the corrected runtime limitations prose for issue #959; the protocol, coverage classifications and implementation source are unchanged.", + "This capture replays open-by-default augmentation scope integrated with the EXP-731 evidence refinements after composition type refinement; it does not evaluate native backend scope enforcement or broaden the preregistered coverage claims.", + "This capture replays the retained protocol after merging ACT-612 participant relationships with open-by-default augmentation scope; it adds no claim of realized participant relationships or native backend scope enforcement.", + "This capture replays issue #1299 partial listener descriptions on the integrated source state; endpoint completeness and backend admission remain outside this protocol's claims.", + "This capture also binds authoring-adapter semantic conformance to the integrated source; adapter transport behavior remains outside this protocol's claims.", + "Reviewed OCI mirror and pre-seed admission is covered by its own regression suites and the development artifact policy gate, not a new claim in this preregistered matrix.", + "This capture binds issue #1297 service-manager identity, native-name, and explicitly selected systemd-state contract changes to the integrated source. It exercises no live service manager and adds no backend-execution claim.", + "This capture replays the retained specification-coverage protocol after API-404 startup reconciliation added an operational recovery-observation contract. It does not evaluate crash recovery, classify provider effects, or broaden EXP-715 experiment-observation claims.", + "This capture binds API-404 single-owner store admission and immutable target/run scope to the integrated source. The retained offline protocol does not exercise process leases, SQLite lifecycle ordering, or crash recovery.", + "This capture binds issue #1015 deterministic mixed and staged trial admission to the integrated source. The retained offline language corpus does not execute mixed runtimes, phase transitions, backend handoff, or scheduler-driven realization.", + "This replay binds issue #1186 offline control-plane maintenance, readiness, and bounded audit code to the integrated source. The retained language corpus does not execute store recovery, HTTP health behavior, or audit redaction.", + "Issue #1187 control-plane crash/profile conformance and HTTP security changes are covered by their dedicated regression suite, not promoted to new claims by this retained corpus.", + "Issue #1189 control-plane profile declarations are covered by their dedicated runtime suite, not promoted to new claims by the retained language corpus.", + "Issue #1016 mixed-runtime coordination is covered by its dedicated runtime suite. The retained language corpus does not execute mixed providers or establish backend-native realization, multi-controller coordination, IFC, or equivalence.", + "Issue #610's reconciliation demonstration harness is covered by its dedicated processor and CLI suite, not promoted to new claims by the retained language corpus.", + "Participant identity, organization ownership, and participant assignment are separated by issue #1338. This retained offline corpus does not establish participant autonomy, execution authority, live backend fidelity, or causal attribution.", + "Issue #1361 execution and recovery requirements are verified by dedicated policy, composition, and admission tests; this retained corpus establishes no live recovery, continuation, or trial-allocation guarantee.", + "The issue #1361 maintainability repair preserves policy semantics and retained corpus outcomes; it establishes no live recovery, continuation, or trial-allocation guarantee.", + "The issue #1361 resource type-hint repair preserves policy semantics and retained corpus outcomes; it establishes no live recovery, continuation, or trial-allocation guarantee.", + "The combined issue #1361 execution-policy and hatchling update preserves retained outcomes and bounded claims; it establishes no live recovery, continuation, or trial-allocation guarantee.", + "Fresh bounded replay after issue #967 removed the bundled concrete backends and merged the issue #1396 and #1368 source; this retained protocol adds no backend realization claim." + ], + "protocol_revision": "1.0.0", + "protocol_sha256": "e97a19e643e94c9e589dca823a63c6ce49d3329fe2a3cb888ab630838ed93125", + "raes_revision": "eb32f9f1aee62d1879b581aec5cb7980847ac534", + "snapshot_id": "issue-1479-oci-anonymous-token-specification-d57e6b1838fd", + "snapshot_revision": "1.0.0", + "source_state": { + "base_revision": "eb32f9f1aee62d1879b581aec5cb7980847ac534", + "checkout_state": "clean", + "implementation_digest": "d57e6b1838fd0e095a78282a3bf755e43c5c7aa0dafc4f598ba338dcf02cb1bf", + "profile": "python-reference-source/v2" + } +} From 1bde15cbff6ac3dea1811fe34ba8f39588a967d1 Mon Sep 17 00:00:00 2001 From: Yernat Yestekov <2068106+doublewhy@users.noreply.github.com> Date: Thu, 29 Oct 2026 09:41:25 +0000 Subject: [PATCH 08/11] test: drop the issue #1479 captures recorded for the pre-merge source --- ...96f6012e0e4fe47d70da66f670b3be307f65f.json | 4 - ...247b09e748313f70098d7b3510988af5c5a67.json | 4 - .../analysis.json | 171 ----- .../manifest.json | 122 --- .../snapshot.json | 653 ---------------- .../analysis.json | 168 ----- .../manifest.json | 122 --- .../snapshot.json | 653 ---------------- ...936c8ae254f68ac9da4624dbbdc8ff71da106.json | 4 - ...8b3474dad595adcd83484f0738935cb9883e5.json | 4 - .../analysis.json | 117 --- .../manifest.json | 10 - .../snapshot.json | 705 ----------------- .../analysis.json | 118 --- .../manifest.json | 10 - .../snapshot.json | 708 ------------------ 16 files changed, 3573 deletions(-) delete mode 100644 docs/research/formal-semantic-validation/capture-records/capture-72bb493cff3e02dc25dbaf3c7aa96f6012e0e4fe47d70da66f670b3be307f65f.json delete mode 100644 docs/research/formal-semantic-validation/capture-records/capture-75bb60563fe13054358a57d241c247b09e748313f70098d7b3510988af5c5a67.json delete mode 100644 docs/research/formal-semantic-validation/captures/capture-72bb493cff3e02dc25dbaf3c7aa96f6012e0e4fe47d70da66f670b3be307f65f/analysis.json delete mode 100644 docs/research/formal-semantic-validation/captures/capture-72bb493cff3e02dc25dbaf3c7aa96f6012e0e4fe47d70da66f670b3be307f65f/manifest.json delete mode 100644 docs/research/formal-semantic-validation/captures/capture-72bb493cff3e02dc25dbaf3c7aa96f6012e0e4fe47d70da66f670b3be307f65f/snapshot.json delete mode 100644 docs/research/formal-semantic-validation/captures/capture-75bb60563fe13054358a57d241c247b09e748313f70098d7b3510988af5c5a67/analysis.json delete mode 100644 docs/research/formal-semantic-validation/captures/capture-75bb60563fe13054358a57d241c247b09e748313f70098d7b3510988af5c5a67/manifest.json delete mode 100644 docs/research/formal-semantic-validation/captures/capture-75bb60563fe13054358a57d241c247b09e748313f70098d7b3510988af5c5a67/snapshot.json delete mode 100644 docs/research/specification-coverage/capture-records/capture-917dcfe82f8ee8c7fda5cc4dc8f936c8ae254f68ac9da4624dbbdc8ff71da106.json delete mode 100644 docs/research/specification-coverage/capture-records/capture-aae28f85e4516ed1fe7aa76945a8b3474dad595adcd83484f0738935cb9883e5.json delete mode 100644 docs/research/specification-coverage/captures/capture-917dcfe82f8ee8c7fda5cc4dc8f936c8ae254f68ac9da4624dbbdc8ff71da106/analysis.json delete mode 100644 docs/research/specification-coverage/captures/capture-917dcfe82f8ee8c7fda5cc4dc8f936c8ae254f68ac9da4624dbbdc8ff71da106/manifest.json delete mode 100644 docs/research/specification-coverage/captures/capture-917dcfe82f8ee8c7fda5cc4dc8f936c8ae254f68ac9da4624dbbdc8ff71da106/snapshot.json delete mode 100644 docs/research/specification-coverage/captures/capture-aae28f85e4516ed1fe7aa76945a8b3474dad595adcd83484f0738935cb9883e5/analysis.json delete mode 100644 docs/research/specification-coverage/captures/capture-aae28f85e4516ed1fe7aa76945a8b3474dad595adcd83484f0738935cb9883e5/manifest.json delete mode 100644 docs/research/specification-coverage/captures/capture-aae28f85e4516ed1fe7aa76945a8b3474dad595adcd83484f0738935cb9883e5/snapshot.json diff --git a/docs/research/formal-semantic-validation/capture-records/capture-72bb493cff3e02dc25dbaf3c7aa96f6012e0e4fe47d70da66f670b3be307f65f.json b/docs/research/formal-semantic-validation/capture-records/capture-72bb493cff3e02dc25dbaf3c7aa96f6012e0e4fe47d70da66f670b3be307f65f.json deleted file mode 100644 index 772641ae75..0000000000 --- a/docs/research/formal-semantic-validation/capture-records/capture-72bb493cff3e02dc25dbaf3c7aa96f6012e0e4fe47d70da66f670b3be307f65f.json +++ /dev/null @@ -1,4 +0,0 @@ -{ - "capture_path": "docs/research/formal-semantic-validation/captures/capture-72bb493cff3e02dc25dbaf3c7aa96f6012e0e4fe47d70da66f670b3be307f65f/manifest.json", - "capture_sha256": "c56eec57a1bf503ae00a8fe5c96962d9f8ff37a5eb8b1e3d352375974c0905c1" -} diff --git a/docs/research/formal-semantic-validation/capture-records/capture-75bb60563fe13054358a57d241c247b09e748313f70098d7b3510988af5c5a67.json b/docs/research/formal-semantic-validation/capture-records/capture-75bb60563fe13054358a57d241c247b09e748313f70098d7b3510988af5c5a67.json deleted file mode 100644 index 6b8d95dd59..0000000000 --- a/docs/research/formal-semantic-validation/capture-records/capture-75bb60563fe13054358a57d241c247b09e748313f70098d7b3510988af5c5a67.json +++ /dev/null @@ -1,4 +0,0 @@ -{ - "capture_path": "docs/research/formal-semantic-validation/captures/capture-75bb60563fe13054358a57d241c247b09e748313f70098d7b3510988af5c5a67/manifest.json", - "capture_sha256": "932c0ea406a68188283e5cbac4543994f7589f17e68b75f08b7317036ea35d73" -} diff --git a/docs/research/formal-semantic-validation/captures/capture-72bb493cff3e02dc25dbaf3c7aa96f6012e0e4fe47d70da66f670b3be307f65f/analysis.json b/docs/research/formal-semantic-validation/captures/capture-72bb493cff3e02dc25dbaf3c7aa96f6012e0e4fe47d70da66f670b3be307f65f/analysis.json deleted file mode 100644 index 148a3bde6c..0000000000 --- a/docs/research/formal-semantic-validation/captures/capture-72bb493cff3e02dc25dbaf3c7aa96f6012e0e4fe47d70da66f670b3be307f65f/analysis.json +++ /dev/null @@ -1,171 +0,0 @@ -{ - "analysis_id": "issue-1479-oci-anonymous-token-formal-analysis-bee18848d137", - "claim": { - "allowed_evidence": [ - "production parser and semantic-validator results", - "canonical compiled digests", - "participant contract regression tests", - "pinned protocol, corpus, and execution snapshot" - ], - "claim_id": "asr-530-formal-semantic-validation-retest", - "disallowed_evidence": [ - "schema success as semantic proof", - "workflow reachability as network or exploit reachability", - "FM labels as gate outcomes", - "attribution as counterfactual proof", - "formal prose or maintainer confidence alone" - ], - "evidence_artifacts": [ - "docs/research/formal-semantic-validation/protocol-v2.json", - "docs/research/formal-semantic-validation/corpus/manifest-v4.json", - "@snapshot", - "docs/research/formal-semantic-validation/evidence/finite-domain-satisfiable-v4.json", - "docs/research/formal-semantic-validation/evidence/finite-domain-unsatisfiable-v4.json", - "docs/research/formal-semantic-validation/evidence/typed-exploit-path-valid-v4.json", - "docs/research/formal-semantic-validation/evidence/typed-exploit-path-invalid-v4.json" - ], - "falsification_protocol": "Replay every retained and new case through its production entrypoint, require complete digest and evidence joins, execute participant fixtures, and derive status from the recorded outcomes.", - "objective_fail_criteria": "A supported negative passes, a positive fails, an observation drifts, a required participant case is missing, or weaker evidence is promoted to solver, exploit-path, runtime-stability, or counterfactual assurance.", - "objective_pass_criteria": "Every claim class has positive and negative cases, all supported cases reproduce the frozen outcome, every participant obligation has passing positive and negative fixtures, and unsupported classes remain untested.", - "statement": "At the recorded source-state digest, the retained RAES controls have the bounded statuses recorded here; historical releases are integrity evidence, not current replay evidence.", - "threats_to_validity": [ - "The issue-specific corpus is intentionally small and does not enumerate every validator invariant.", - "The participant fixtures exercise reference production contracts and tests, not every independent backend realization.", - "The replay gate runs on one Python reference configuration and one pinned RAES revision.", - "Unsupported solver-level classes have protocol cases but no executable observations." - ] - }, - "claim_results": [ - { - "case_count": 2, - "claim_class_id": "schema-validity", - "evidence_status": "demonstrated", - "limitations": [ - "Bounded to the named source/model structural controls." - ], - "matching_case_count": 2, - "participant_obligation_count": 0, - "replayable_case_count": 2, - "unsupported_case_count": 0 - }, - { - "case_count": 4, - "claim_class_id": "semantic-consistency", - "evidence_status": "partial", - "limitations": [ - "Partial coverage of named static semantics and participant obligations, not universal consistency." - ], - "matching_case_count": 4, - "participant_obligation_count": 7, - "replayable_case_count": 4, - "unsupported_case_count": 0 - }, - { - "case_count": 2, - "claim_class_id": "graph-reachability", - "evidence_status": "partial", - "limitations": [ - "Partial workflow control-flow reachability only; not network, service, or exploit reachability." - ], - "matching_case_count": 2, - "participant_obligation_count": 0, - "replayable_case_count": 2, - "unsupported_case_count": 0 - }, - { - "case_count": 4, - "claim_class_id": "constraint-satisfiability", - "evidence_status": "demonstrated", - "limitations": [ - "Demonstrated only for raes-finite-domain-satisfiability-v1 and its pinned solver configuration." - ], - "matching_case_count": 4, - "participant_obligation_count": 0, - "replayable_case_count": 2, - "unsupported_case_count": 2 - }, - { - "case_count": 4, - "claim_class_id": "exploit-path-validity", - "evidence_status": "demonstrated", - "limitations": [ - "Demonstrated only for the admitted snapshot, typed graph, query, semantics, and bounded search profile." - ], - "matching_case_count": 4, - "participant_obligation_count": 0, - "replayable_case_count": 2, - "unsupported_case_count": 2 - }, - { - "case_count": 2, - "claim_class_id": "determinism-stability", - "evidence_status": "partial", - "limitations": [ - "Partial parse-to-compile repeatability only; runtime and backend determinism are untested." - ], - "matching_case_count": 2, - "participant_obligation_count": 0, - "replayable_case_count": 2, - "unsupported_case_count": 0 - }, - { - "case_count": 2, - "claim_class_id": "counterfactual-necessity", - "evidence_status": "untested", - "limitations": [ - "Untested because no governed intervention or ablation entrypoint ran." - ], - "matching_case_count": 2, - "participant_obligation_count": 0, - "replayable_case_count": 0, - "unsupported_case_count": 2 - } - ], - "corpus_revision": "4.0.0", - "evidence_status": "partial", - "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", - "generated_at": "2026-10-13T21:31:14.361582+00:00", - "limitations": [ - "Satisfiability is limited to raes-finite-domain-satisfiability-v1 and its exact translation, theory, and Z3 configuration.", - "The subset-minimal unsatisfiable core is not a universal proof certificate.", - "Exploit-path results are limited to the admitted snapshot, normalized graph, query, transition semantics, and bounded search profile.", - "A valid path is not backend execution and an invalid path is not real-world non-exploitability.", - "The production exploit-path JSON loader permits duplicate keys; the research loader rejects them without claiming stronger production behavior.", - "Participant replay inherits the host environment and is not described as hermetic.", - "Counterfactual necessity remains untested.", - "Scoped observation demand is not a claim class in this preregistration and is not promoted to demonstrated by this retest.", - "EXP-732 provenance joins are verified by their dedicated regression suite; this retained corpus makes no universal run, apparatus, source, or augmentation assurance claim.", - "This retained corpus does not establish native backend attestation fidelity; materialization contract checks remain separate operational provenance, not experimental observations.", - "Capture admission and evidence-proof authority are verified by issue-1237 regression tests, not promoted to a new claim class by this retained corpus.", - "Evidence-requirement refinement lineage is outside this retained formal claim set; this retest refreshes integrated source provenance without promoting that feature to a formal claim.", - "Authoring-adapter transport behavior is outside this retained formal claim set.", - "Operational recovery observation and startup reconciliation are verified by their API-404 regression suite, not promoted to a new formal claim class by this retained corpus.", - "Single-owner store admission, immutable target/run scope, and provider shutdown ordering are verified by their API-404 CP-5 regression suite, not promoted to a formal claim by this retained corpus.", - "Mixed and staged trial admission is verified by its SEM-234/SCE-002/API-407 regression suite, not promoted to a new formal claim class by this retained corpus.", - "Offline control-plane maintenance, readiness, and bounded audit behavior are verified by issue #1186 runtime tests, not promoted to a formal claim by this retained corpus.", - "Issue #1187 control-plane crash/profile conformance and HTTP security changes are covered by their dedicated regression suite, not promoted to new claims by this retained corpus.", - "Issue #1189 profile declarations and capability admission are covered by dedicated runtime tests; the retained formal corpus does not execute control-plane profile composition.", - "Issue #1016 mixed-runtime coordination is covered by dedicated runtime tests; the retained formal corpus does not establish backend-native mixed realization, multi-controller coordination, IFC, or equivalence.", - "Issue #610's reconciliation demonstration harness is covered by its dedicated processor and CLI suite, not promoted to new claims by the retained language corpus.", - "Participant identity, organization ownership, and participant assignment are separated by issue #1338. This retained offline corpus does not establish participant autonomy, execution authority, live backend fidelity, or causal attribution.", - "Issue #1389 temporal-subject admission is verified by dedicated compiler tests and adds no new formal-semantic claim to this retained corpus.", - "Issue #971 model construction is verified by its own tests; this retained corpus establishes no participant-crossing equivalence or runtime-realization claim.", - "Issue #1359 control-plane route authority, participant-view scoping, and no-store HTTP boundary are verified by their dedicated HTTP-boundary suite and add no new formal-semantic claim to this retained corpus.", - "Issue #1401 required-evidence media-type coherence is verified by its dedicated suite and adds no new formal-semantic claim to this retained corpus.", - "Issue #1361 execution and recovery requirements are verified by dedicated policy, composition, and admission tests; this retained corpus establishes no live recovery, continuation, or trial-allocation guarantee.", - "The issue #1361 maintainability repair preserves policy semantics and retained corpus outcomes; it establishes no live recovery, continuation, or trial-allocation guarantee.", - "The issue #1361 resource type-hint repair preserves policy semantics and retained corpus outcomes; it establishes no live recovery, continuation, or trial-allocation guarantee.", - "The combined issue #1361 execution-policy and hatchling update preserves retained outcomes and bounded claims; it establishes no live recovery, continuation, or trial-allocation guarantee.", - "The issue #1418 runtime-fact export manifest split changes no contract, schema or behavior and adds no new formal-semantic claim.", - "The issue #1423 inject trigger request and occurrence contracts are new draft carriers that no SDL construct, compiler or runtime path reads, and they add no new formal-semantic claim.", - "The issue #1366 inject readback, correlation and backend declaration contracts are new draft carriers; the shared backend allowlist also lets SDL participant behavior specifications cite inject-occurrence-v1 and inject-occurrence-outcome-v1 as evidence_contract_refs, which the compiler copies through uninterpreted, and no runtime path or shipped backend reads or declares them; they add no new formal-semantic claim.", - "This synchronization preserves the original inject baseline chain in the pre-sync archive, retains frozen production and participant evidence, and binds the combined contract source. CI independently verifies current evidence replay; no new runtime adoption is claimed.", - "This second synchronization binds behavior-authoring source from issue #297, retains frozen production and participant evidence, and pins the preserved first-sync release 75 as its baseline. CI independently verifies replay; no new runtime adoption is claimed.", - "Issue #1091 request-boundary admission is verified by its dedicated tests; this retained corpus does not execute the served HTTP adapter or broaden its bounded claims.", - "This combined-source capture replays the supported retained corpus and the 18 declared participant test cases. The inject contract repair has 126 passing request, occurrence and readback tests; no runtime inject execution or broader formal claim is established. CI independently verifies replay.", - "Issue #1395 adds a separate bounded two-operation crossing model profile. This retained corpus does not establish participant-crossing equivalence or runtime realization; those assurances remain separate.", - "Issue #1479 fetches OCI modules from public registries through the distribution anonymous bearer-token flow; this retained corpus makes no new claim." - ], - "plain_language_outcome": "The retained formal cases reproduce their outcomes after issue #1479 added the anonymous bearer-token flow to OCI module fetches. Bounded claims and unsupported classes are unchanged.", - "protocol_revision": "2.0.0" -} diff --git a/docs/research/formal-semantic-validation/captures/capture-72bb493cff3e02dc25dbaf3c7aa96f6012e0e4fe47d70da66f670b3be307f65f/manifest.json b/docs/research/formal-semantic-validation/captures/capture-72bb493cff3e02dc25dbaf3c7aa96f6012e0e4fe47d70da66f670b3be307f65f/manifest.json deleted file mode 100644 index fe1efc0f0e..0000000000 --- a/docs/research/formal-semantic-validation/captures/capture-72bb493cff3e02dc25dbaf3c7aa96f6012e0e4fe47d70da66f670b3be307f65f/manifest.json +++ /dev/null @@ -1,122 +0,0 @@ -{ - "analysis_path": "docs/research/formal-semantic-validation/captures/capture-72bb493cff3e02dc25dbaf3c7aa96f6012e0e4fe47d70da66f670b3be307f65f/analysis.json", - "analysis_sha256": "918c025d34773ef1e8c648c171d4e8f6d87f26d0d6e915f2d814e7a20043b499", - "artifacts": [ - { - "artifact_id": "finite-domain-satisfiable-v2-input", - "kind": "corpus-input", - "path": "docs/research/formal-semantic-validation/corpus/satisfiable-control.sdl.yaml", - "sha256": "0ca9eaba9dc47171f7a042dc6753faa6c820c65ee966538f9d65fac5342202e8" - }, - { - "artifact_id": "finite-domain-satisfiable-v2-evidence", - "kind": "production-evidence", - "path": "docs/research/formal-semantic-validation/evidence/finite-domain-satisfiable-v4.json", - "sha256": "554202313d678046958b5c028e2de26ff03c74895cfac552677eed74e8153add" - }, - { - "artifact_id": "finite-domain-unsatisfiable-v2-input", - "kind": "corpus-input", - "path": "docs/research/formal-semantic-validation/corpus/unsatisfiable-control.sdl.yaml", - "sha256": "cfef56a1f56d5f0db9da195377fd75694bdd0f0b92932fdb8fafcbd3f7baf6c5" - }, - { - "artifact_id": "finite-domain-unsatisfiable-v2-evidence", - "kind": "production-evidence", - "path": "docs/research/formal-semantic-validation/evidence/finite-domain-unsatisfiable-v4.json", - "sha256": "c972725ef64822a75a60380afc11f08eac25b7fe9b091d39b058b3c9f7c8031d" - }, - { - "artifact_id": "typed-exploit-path-valid-v2-input", - "kind": "corpus-input", - "path": "docs/research/formal-semantic-validation/corpus/exploit-path-valid-v3.json", - "sha256": "0afe635a63db5b6e6380ac70982fd61d09790745d51a10d670321304121e7c39" - }, - { - "artifact_id": "typed-exploit-path-valid-v2-evidence", - "kind": "production-evidence", - "path": "docs/research/formal-semantic-validation/evidence/typed-exploit-path-valid-v4.json", - "sha256": "1b7f55d04db172da32658187c64a88c13b5f4d565267ce2be7cb86a9d04cb70c" - }, - { - "artifact_id": "typed-exploit-path-invalid-v2-input", - "kind": "corpus-input", - "path": "docs/research/formal-semantic-validation/corpus/exploit-path-invalid-v3.json", - "sha256": "0b2293d4a8983515ff05c516be6e6b418a4f3f09e055250a00bf15fda861aab3" - }, - { - "artifact_id": "typed-exploit-path-invalid-v2-evidence", - "kind": "production-evidence", - "path": "docs/research/formal-semantic-validation/evidence/typed-exploit-path-invalid-v4.json", - "sha256": "244f895a64f14c10916ab0533ab462ce80a328021cd6a50c30a4aa59266d5533" - }, - { - "artifact_id": "schema-valid-control-fixture", - "kind": "corpus-input", - "path": "docs/research/formal-semantic-validation/corpus/schema-valid.sdl.yaml", - "sha256": "41a9adffdf9f5f2ccc2f887dcf7b15fba3b47c83a1af15f33db872c4a2449d67" - }, - { - "artifact_id": "schema-unknown-field-fixture", - "kind": "corpus-input", - "path": "docs/research/formal-semantic-validation/corpus/schema-invalid-unknown-field.sdl.yaml", - "sha256": "51cf62319a86c95a2517995939d1f370573051835e4b55bb6d5beaf049640481" - }, - { - "artifact_id": "semantic-resolved-objective-fixture", - "kind": "corpus-input", - "path": "docs/research/formal-semantic-validation/corpus/semantic-valid-participant-identity-v2.sdl.yaml", - "sha256": "75834bdc883e2003e1c473870bdf75700978955bb83095c6bd718ba6bd3908a6" - }, - { - "artifact_id": "semantic-dangling-assertion-fixture", - "kind": "corpus-input", - "path": "docs/research/formal-semantic-validation/corpus/semantic-invalid-dangling-ref-participant-identity-v2.sdl.yaml", - "sha256": "1d25bee5f556054e5f0a518df025e4c62e080e1964035e3c1a12e074d88d3a5d" - }, - { - "artifact_id": "semantic-ambiguous-reference-fixture", - "kind": "corpus-input", - "path": "docs/research/formal-semantic-validation/corpus/semantic-invalid-ambiguous-ref.sdl.yaml", - "sha256": "653cbd2fd62e220d49fb86f80133884207df5ae6752846345ae3085b93f6e4ed" - }, - { - "artifact_id": "semantic-feature-cycle-fixture", - "kind": "corpus-input", - "path": "docs/research/formal-semantic-validation/corpus/semantic-invalid-feature-cycle.sdl.yaml", - "sha256": "e1f66d95a9ad039687aec8cccbc8843b514072ff08e006c1b4ca6aa5cd8d4ed1" - }, - { - "artifact_id": "workflow-reachable-control-fixture", - "kind": "corpus-input", - "path": "docs/research/formal-semantic-validation/corpus/workflow-reachable.sdl.yaml", - "sha256": "54c40ceb98ad47247447d737973b2c55e8fb2045e209c7545c4fb20cf42dc3dc" - }, - { - "artifact_id": "workflow-unreachable-step-fixture", - "kind": "corpus-input", - "path": "docs/research/formal-semantic-validation/corpus/workflow-unreachable.sdl.yaml", - "sha256": "ef22ef2e260f1a7fd92d286f9b571716436b192ddfd54aea7bdfcfdda4ca52a2" - }, - { - "artifact_id": "compile-repeatability-control-fixture", - "kind": "corpus-input", - "path": "docs/research/formal-semantic-validation/corpus/determinism-a.sdl.yaml", - "sha256": "0bc40900d598c1af7a405d798ca19710405e53ced262d8733081abf12edf89fe" - }, - { - "artifact_id": "compile-non-vacuity-control-comparison-fixture", - "kind": "corpus-input", - "path": "docs/research/formal-semantic-validation/corpus/determinism-b.sdl.yaml", - "sha256": "d85338f89f20a45515b12da8640173c1a52e47eb17ca0f4f6b4f8f3306e863a1" - } - ], - "bundle_id": "raes-formal-semantic-validation", - "corpus_path": "docs/research/formal-semantic-validation/corpus/manifest-v4.json", - "corpus_sha256": "c57207af72406aa4f70882b9bbeb7cedcc79cf3854c878a95e3eb1fa59ea7a72", - "protocol_path": "docs/research/formal-semantic-validation/protocol-v2.json", - "protocol_sha256": "abf94093e344bf495dfb04e8b0c5985c0beaab8ebb17a75e15c8674fa81b1a7c", - "revision": "capture-72bb493cff3e02dc25dbaf3c7aa96f6012e0e4fe47d70da66f670b3be307f65f", - "snapshot_path": "docs/research/formal-semantic-validation/captures/capture-72bb493cff3e02dc25dbaf3c7aa96f6012e0e4fe47d70da66f670b3be307f65f/snapshot.json", - "snapshot_sha256": "57846ec96752167f833cf99061a7aa98321892667dabb50c2fc40d11f91b0e6d" -} diff --git a/docs/research/formal-semantic-validation/captures/capture-72bb493cff3e02dc25dbaf3c7aa96f6012e0e4fe47d70da66f670b3be307f65f/snapshot.json b/docs/research/formal-semantic-validation/captures/capture-72bb493cff3e02dc25dbaf3c7aa96f6012e0e4fe47d70da66f670b3be307f65f/snapshot.json deleted file mode 100644 index 0ebadbc936..0000000000 --- a/docs/research/formal-semantic-validation/captures/capture-72bb493cff3e02dc25dbaf3c7aa96f6012e0e4fe47d70da66f670b3be307f65f/snapshot.json +++ /dev/null @@ -1,653 +0,0 @@ -{ - "baseline": { - "execution_id": "issue-1395-crossing-formal-3c684ef5d50a", - "release_path": "docs/research/formal-semantic-validation/captures/capture-3bad394534ce94f3cfc052a52e3305495c2733ddda860ab3b1e5c24758a3f62c/manifest.json", - "release_revision": "capture-3bad394534ce94f3cfc052a52e3305495c2733ddda860ab3b1e5c24758a3f62c", - "release_sha256": "f9544867cb1bedeb1cc1d0903e0dde2fdf22d1bda17819d90dad28de395ecc61" - }, - "captured_at": "2026-10-13T21:31:14.361582+00:00", - "commands": [ - { - "argv": [ - "implementations/python/.venv/bin/python", - "-c", - "import json, sys\nfrom pathlib import Path\nroot = Path.cwd().resolve()\nfor entry in (str(root), str(root / \"implementations\" / \"python\" / \"packages\")):\n if entry not in sys.path:\n sys.path.insert(0, entry)\nfrom tools.formal_semantic_validation._replay import replay_case\ncorpus = json.loads((root / \"docs/research/formal-semantic-validation/corpus/manifest-v4.json\").read_text(encoding=\"utf-8\"))\nskipped = set([\"exploit-path\", \"satisfiability\", \"unsupported\"])\nresults = {}\nfor case in corpus[\"cases\"]:\n if case.get(\"replay_mode\") in skipped:\n continue\n try:\n results[case[\"case_id\"]] = {\"ok\": True, **replay_case(root, case)}\n except Exception as exc:\n results[case[\"case_id\"]] = {\"ok\": False, \"error\": type(exc).__name__ + \": \" + str(exc)[:300]}\nprint(json.dumps(results, sort_keys=True))\n" - ], - "command_id": "retained-case-replay", - "network": "disabled" - }, - { - "argv": [ - "implementations/python/.venv/bin/pytest", - "-q", - "implementations/python/tests/test_sem_208_participant_behavior.py::test_hidden_truth_disclosure_is_separate_from_observable_projection", - "implementations/python/tests/test_sem_208_participant_behavior.py::test_hidden_truth_cannot_be_observed_without_explicit_disclosure_rule", - "implementations/python/tests/test_sem_211_participant_action_semantics.py::test_action_contract_declares_sem_211_classes_and_compiles_them", - "implementations/python/tests/test_sem_211_participant_action_semantics.py::test_action_result_rejects_success_when_preconditions_are_unresolved", - "implementations/python/tests/test_run_308_concurrent_participant_execution.py::test_runtime_snapshot_publishes_joint_action_and_time_context_records", - "implementations/python/tests/test_run_308_concurrent_participant_execution.py::test_joint_action_record_contract_rejects_unordered_conflicting_writes", - "implementations/python/tests/test_participant_runtime_invariants.py::test_order_discipline_accepts_supported_order_claim_strengths", - "implementations/python/tests/test_participant_runtime_invariants.py::test_order_discipline_rejects_wall_clock_causality", - "implementations/python/tests/test_sem_212_participant_attribution_semantics.py::test_attribution_edge_round_trips_on_terminal_observation", - "implementations/python/tests/test_sem_212_participant_attribution_semantics.py::test_timestamp_adjacency_cannot_be_reported_as_strong_causality", - "implementations/python/tests/test_sem_215_participant_outcome_interpretation.py::test_outcome_interpretation_rule_parses_and_compiles_explicit_layers", - "implementations/python/tests/test_sem_215_participant_outcome_interpretation.py::test_local_action_success_does_not_imply_objective_success_without_rule_record", - "implementations/python/tests/test_realization_honesty_conformance.py::test_constructive_envelope_runs_positive_and_negative_honesty_probes", - "implementations/python/tests/test_realization_honesty_conformance.py::test_only_native_live_can_support_native_conformance" - ], - "command_id": "participant-fixtures", - "network": "disabled" - }, - { - "argv": [ - "implementations/python/.venv/bin/raes", - "processor", - "satisfiability", - "docs/research/formal-semantic-validation/corpus/satisfiable-control.sdl.yaml", - "--profile", - "raes-finite-domain-satisfiability-v1" - ], - "command_id": "finite-domain-satisfiable-v2", - "network": "disabled" - }, - { - "argv": [ - "implementations/python/.venv/bin/raes", - "processor", - "satisfiability", - "docs/research/formal-semantic-validation/corpus/unsatisfiable-control.sdl.yaml", - "--profile", - "raes-finite-domain-satisfiability-v1" - ], - "command_id": "finite-domain-unsatisfiable-v2", - "network": "disabled" - }, - { - "argv": [ - "implementations/python/.venv/bin/raes", - "processor", - "exploit-path", - "docs/research/formal-semantic-validation/corpus/exploit-path-valid-v3.json", - "--profile", - "raes-exploit-path-analysis-v1" - ], - "command_id": "typed-exploit-path-valid-v2", - "network": "disabled" - }, - { - "argv": [ - "implementations/python/.venv/bin/raes", - "processor", - "exploit-path", - "docs/research/formal-semantic-validation/corpus/exploit-path-invalid-v3.json", - "--profile", - "raes-exploit-path-analysis-v1" - ], - "command_id": "typed-exploit-path-invalid-v2", - "network": "disabled" - } - ], - "configuration_id": "raes-python-reference-offline-v41", - "corpus_revision": "4.0.0", - "deviations": [], - "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", - "execution_status": "complete", - "observations": [ - { - "actual_outcome": "accepted", - "analysis_profile": null, - "case_id": "schema-valid-control", - "configuration_digest": null, - "configuration_id": "raes-python-reference-offline-v41", - "diagnostic_kind": null, - "evidence_artifact_path": null, - "evidence_artifact_sha256": null, - "evidence_digest": null, - "evidence_profile": null, - "evidence_refs": [ - "docs/research/formal-semantic-validation/corpus/schema-valid.sdl.yaml" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", - "limitations": [ - "A passing minimal source does not establish semantic correctness." - ], - "replayable": true, - "result_digest": "f7d364ef384df8a1526b489501835b635021c860793b5764f91d956710d2250c", - "source_digest": null - }, - { - "actual_outcome": "rejected", - "analysis_profile": null, - "case_id": "schema-unknown-field", - "configuration_digest": null, - "configuration_id": "raes-python-reference-offline-v41", - "diagnostic_kind": "SDLParseError", - "evidence_artifact_path": null, - "evidence_artifact_sha256": null, - "evidence_digest": null, - "evidence_profile": null, - "evidence_refs": [ - "docs/research/formal-semantic-validation/corpus/schema-invalid-unknown-field.sdl.yaml" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", - "limitations": [ - "The observation covers one unknown-field defect only." - ], - "replayable": true, - "result_digest": "f55d834b458f8e069e1c69061b4cc0a6d61e0e052bf90c670f2e6a5ad8b5bd98", - "source_digest": null - }, - { - "actual_outcome": "accepted", - "analysis_profile": null, - "case_id": "semantic-resolved-objective", - "configuration_digest": null, - "configuration_id": "raes-python-reference-offline-v41", - "diagnostic_kind": null, - "evidence_artifact_path": null, - "evidence_artifact_sha256": null, - "evidence_digest": null, - "evidence_profile": null, - "evidence_refs": [ - "docs/research/formal-semantic-validation/corpus/semantic-valid-participant-identity-v2.sdl.yaml" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", - "limitations": [ - "This is a positive control for one objective-reference slice." - ], - "replayable": true, - "result_digest": "652288785dc09095955ed3649f6407d616fb7c4d4f4188df4ed513ccb7537e0b", - "source_digest": null - }, - { - "actual_outcome": "rejected", - "analysis_profile": null, - "case_id": "semantic-dangling-assertion", - "configuration_digest": null, - "configuration_id": "raes-python-reference-offline-v41", - "diagnostic_kind": "SDLValidationError", - "evidence_artifact_path": null, - "evidence_artifact_sha256": null, - "evidence_digest": null, - "evidence_profile": null, - "evidence_refs": [ - "docs/research/formal-semantic-validation/corpus/semantic-invalid-dangling-ref-participant-identity-v2.sdl.yaml" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", - "limitations": [ - "A single dangling reference does not prove complete semantic coverage." - ], - "replayable": true, - "result_digest": "0207cf616b56708ca9b8c4499d3301abe22dbe52162cf8d58d3bec429d9db024", - "source_digest": null - }, - { - "actual_outcome": "rejected", - "analysis_profile": null, - "case_id": "semantic-ambiguous-reference", - "configuration_digest": null, - "configuration_id": "raes-python-reference-offline-v41", - "diagnostic_kind": "SDLValidationError", - "evidence_artifact_path": null, - "evidence_artifact_sha256": null, - "evidence_digest": null, - "evidence_profile": null, - "evidence_refs": [ - "docs/research/formal-semantic-validation/corpus/semantic-invalid-ambiguous-ref.sdl.yaml" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", - "limitations": [ - "One namespace collision does not enumerate every ambiguity surface." - ], - "replayable": true, - "result_digest": "9da4a87797d228e0012ab6b30459f4892e41aa6f224a9840be035fee4a2eea73", - "source_digest": null - }, - { - "actual_outcome": "rejected", - "analysis_profile": null, - "case_id": "semantic-feature-cycle", - "configuration_digest": null, - "configuration_id": "raes-python-reference-offline-v41", - "diagnostic_kind": "SDLValidationError", - "evidence_artifact_path": null, - "evidence_artifact_sha256": null, - "evidence_digest": null, - "evidence_profile": null, - "evidence_refs": [ - "docs/research/formal-semantic-validation/corpus/semantic-invalid-feature-cycle.sdl.yaml" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", - "limitations": [ - "One static dependency cycle does not establish general constraint satisfiability." - ], - "replayable": true, - "result_digest": "d15dbcd99fb4f20b965d7031b07dd6534576302270399c3fa656d29e7de02b83", - "source_digest": null - }, - { - "actual_outcome": "accepted", - "analysis_profile": null, - "case_id": "workflow-reachable-control", - "configuration_digest": null, - "configuration_id": "raes-python-reference-offline-v41", - "diagnostic_kind": null, - "evidence_artifact_path": null, - "evidence_artifact_sha256": null, - "evidence_digest": null, - "evidence_profile": null, - "evidence_refs": [ - "docs/research/formal-semantic-validation/corpus/workflow-reachable.sdl.yaml" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", - "limitations": [ - "The graph is workflow control flow only." - ], - "replayable": true, - "result_digest": "b1b49649b54bd59d4ef357b39cf9158da90f4eae560f8dd756acf97bd0827a06", - "source_digest": null - }, - { - "actual_outcome": "rejected", - "analysis_profile": null, - "case_id": "workflow-unreachable-step", - "configuration_digest": null, - "configuration_id": "raes-python-reference-offline-v41", - "diagnostic_kind": "SDLValidationError", - "evidence_artifact_path": null, - "evidence_artifact_sha256": null, - "evidence_digest": null, - "evidence_profile": null, - "evidence_refs": [ - "docs/research/formal-semantic-validation/corpus/workflow-unreachable.sdl.yaml" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", - "limitations": [ - "The result does not establish network, service, participant, or exploit reachability." - ], - "replayable": true, - "result_digest": "bb931d19346ef9193408ae6c85deb4079704378fc5f00dc5f47a2817cff21943", - "source_digest": null - }, - { - "actual_outcome": "unsupported", - "analysis_profile": null, - "case_id": "whole-scenario-satisfiable-request", - "configuration_digest": null, - "configuration_id": "raes-python-reference-offline-v41", - "diagnostic_kind": null, - "evidence_artifact_path": null, - "evidence_artifact_sha256": null, - "evidence_digest": null, - "evidence_profile": null, - "evidence_refs": [ - "docs/decisions/issue-168-formal-semantic-validation-reachability-preflight.md" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", - "limitations": [ - "No governed whole-scenario constraint theory or solver exists." - ], - "replayable": false, - "result_digest": null, - "source_digest": null - }, - { - "actual_outcome": "unsupported", - "analysis_profile": null, - "case_id": "whole-scenario-unsatisfiable-request", - "configuration_digest": null, - "configuration_id": "raes-python-reference-offline-v41", - "diagnostic_kind": null, - "evidence_artifact_path": null, - "evidence_artifact_sha256": null, - "evidence_digest": null, - "evidence_profile": null, - "evidence_refs": [ - "docs/decisions/issue-168-formal-semantic-validation-reachability-preflight.md" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", - "limitations": [ - "Local checks cannot produce a whole-scenario unsat certificate." - ], - "replayable": false, - "result_digest": null, - "source_digest": null - }, - { - "actual_outcome": "unsupported", - "analysis_profile": null, - "case_id": "valid-exploit-path-request", - "configuration_digest": null, - "configuration_id": "raes-python-reference-offline-v41", - "diagnostic_kind": null, - "evidence_artifact_path": null, - "evidence_artifact_sha256": null, - "evidence_digest": null, - "evidence_profile": null, - "evidence_refs": [ - "docs/decisions/issue-168-formal-semantic-validation-reachability-preflight.md" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", - "limitations": [ - "The issue-168 baseline had no canonical typed attack graph or path-query entrypoint." - ], - "replayable": false, - "result_digest": null, - "source_digest": null - }, - { - "actual_outcome": "unsupported", - "analysis_profile": null, - "case_id": "invalid-exploit-path-request", - "configuration_digest": null, - "configuration_id": "raes-python-reference-offline-v41", - "diagnostic_kind": null, - "evidence_artifact_path": null, - "evidence_artifact_sha256": null, - "evidence_digest": null, - "evidence_profile": null, - "evidence_refs": [ - "docs/decisions/issue-168-formal-semantic-validation-reachability-preflight.md" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", - "limitations": [ - "Vulnerability and topology declarations are not an invalid-path proof." - ], - "replayable": false, - "result_digest": null, - "source_digest": null - }, - { - "actual_outcome": "stable", - "analysis_profile": null, - "case_id": "compile-repeatability-control", - "configuration_digest": null, - "configuration_id": "raes-python-reference-offline-v41", - "diagnostic_kind": null, - "evidence_artifact_path": null, - "evidence_artifact_sha256": null, - "evidence_digest": null, - "evidence_profile": null, - "evidence_refs": [ - "docs/research/formal-semantic-validation/corpus/determinism-a.sdl.yaml" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", - "limitations": [ - "The witness ends at compiled output." - ], - "replayable": true, - "result_digest": "d7c098c5d063b8d1b0747e8df5daa90061456065cdda0bbedfa10918442f5daa", - "source_digest": null - }, - { - "actual_outcome": "distinguishable", - "analysis_profile": null, - "case_id": "compile-non-vacuity-control", - "configuration_digest": null, - "configuration_id": "raes-python-reference-offline-v41", - "diagnostic_kind": null, - "evidence_artifact_path": null, - "evidence_artifact_sha256": null, - "evidence_digest": null, - "evidence_profile": null, - "evidence_refs": [ - "docs/research/formal-semantic-validation/corpus/determinism-a.sdl.yaml", - "docs/research/formal-semantic-validation/corpus/determinism-b.sdl.yaml" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", - "limitations": [ - "Distinct digests are a non-vacuity control, not semantic non-equivalence proof." - ], - "replayable": true, - "result_digest": "a2fcebba3341592b133af813e8bb8e5f47270418bc58bfd471a89bfbc8ba46da", - "source_digest": null - }, - { - "actual_outcome": "unsupported", - "analysis_profile": null, - "case_id": "necessity-witness-request", - "configuration_digest": null, - "configuration_id": "raes-python-reference-offline-v41", - "diagnostic_kind": null, - "evidence_artifact_path": null, - "evidence_artifact_sha256": null, - "evidence_digest": null, - "evidence_profile": null, - "evidence_refs": [ - "docs/decisions/issue-168-formal-semantic-validation-reachability-preflight.md" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", - "limitations": [ - "No governed intervention or ablation protocol exists." - ], - "replayable": false, - "result_digest": null, - "source_digest": null - }, - { - "actual_outcome": "unsupported", - "analysis_profile": null, - "case_id": "non-necessity-control-request", - "configuration_digest": null, - "configuration_id": "raes-python-reference-offline-v41", - "diagnostic_kind": null, - "evidence_artifact_path": null, - "evidence_artifact_sha256": null, - "evidence_digest": null, - "evidence_profile": null, - "evidence_refs": [ - "docs/decisions/issue-168-formal-semantic-validation-reachability-preflight.md" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", - "limitations": [ - "Attribution and negative fixtures do not demonstrate non-necessity." - ], - "replayable": false, - "result_digest": null, - "source_digest": null - }, - { - "actual_outcome": "satisfiable", - "analysis_profile": "raes-finite-domain-satisfiability-v1", - "case_id": "finite-domain-satisfiable-v2", - "configuration_digest": "sha256:1204635e17e759e9ad3bd6be2ecb28c6de05c07ead6dfdd15936ed5d3d5b81b2", - "configuration_id": "raes-python-reference-offline-v41", - "diagnostic_kind": "scenario-satisfiability-evidence/v1", - "evidence_artifact_path": "docs/research/formal-semantic-validation/evidence/finite-domain-satisfiable-v4.json", - "evidence_artifact_sha256": "554202313d678046958b5c028e2de26ff03c74895cfac552677eed74e8153add", - "evidence_digest": "sha256:23c2cae7d95d4cc83d77ca576e3911477b169ecc311c977cb45490345f633b5a", - "evidence_profile": "scenario-satisfiability-evidence/v1", - "evidence_refs": [ - "docs/research/formal-semantic-validation/corpus/satisfiable-control.sdl.yaml", - "docs/research/formal-semantic-validation/evidence/finite-domain-satisfiable-v4.json", - "specs/formal/scenario-satisfiability/README.md" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", - "limitations": [ - "Demonstrates only the pinned finite-domain theory, translation, solver profile, and source." - ], - "replayable": true, - "result_digest": "sha256:23c2cae7d95d4cc83d77ca576e3911477b169ecc311c977cb45490345f633b5a", - "source_digest": "sha256:0ca9eaba9dc47171f7a042dc6753faa6c820c65ee966538f9d65fac5342202e8" - }, - { - "actual_outcome": "unsatisfiable", - "analysis_profile": "raes-finite-domain-satisfiability-v1", - "case_id": "finite-domain-unsatisfiable-v2", - "configuration_digest": "sha256:1204635e17e759e9ad3bd6be2ecb28c6de05c07ead6dfdd15936ed5d3d5b81b2", - "configuration_id": "raes-python-reference-offline-v41", - "diagnostic_kind": "scenario-satisfiability-evidence/v1", - "evidence_artifact_path": "docs/research/formal-semantic-validation/evidence/finite-domain-unsatisfiable-v4.json", - "evidence_artifact_sha256": "c972725ef64822a75a60380afc11f08eac25b7fe9b091d39b058b3c9f7c8031d", - "evidence_digest": "sha256:317b5cad00aa7f4f7868dca66127611ba19d40ffd86f35815502622814df54c1", - "evidence_profile": "scenario-satisfiability-evidence/v1", - "evidence_refs": [ - "docs/research/formal-semantic-validation/corpus/unsatisfiable-control.sdl.yaml", - "docs/research/formal-semantic-validation/evidence/finite-domain-unsatisfiable-v4.json", - "specs/formal/scenario-satisfiability/README.md" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", - "limitations": [ - "The subset-minimal core is evidence for the pinned translation and solver, not a proof certificate for arbitrary SDL." - ], - "replayable": true, - "result_digest": "sha256:317b5cad00aa7f4f7868dca66127611ba19d40ffd86f35815502622814df54c1", - "source_digest": "sha256:cfef56a1f56d5f0db9da195377fd75694bdd0f0b92932fdb8fafcbd3f7baf6c5" - }, - { - "actual_outcome": "valid-path", - "analysis_profile": "raes-exploit-path-analysis-v1", - "case_id": "typed-exploit-path-valid-v2", - "configuration_digest": "sha256:7f8876d81feb77d3a3239be2fb8337de8885e2744f8786728ba23e4e6027bc0a", - "configuration_id": "raes-python-reference-offline-v41", - "diagnostic_kind": "exploit-path-analysis-evidence/v1", - "evidence_artifact_path": "docs/research/formal-semantic-validation/evidence/typed-exploit-path-valid-v4.json", - "evidence_artifact_sha256": "1b7f55d04db172da32658187c64a88c13b5f4d565267ce2be7cb86a9d04cb70c", - "evidence_digest": "sha256:2d4d1a362751abd9544beb8af7f8c6331d04dac8f4abc315fb261f81fbaf4387", - "evidence_profile": "exploit-path-analysis-evidence/v1", - "evidence_refs": [ - "docs/research/formal-semantic-validation/corpus/exploit-path-valid-v3.json", - "docs/research/formal-semantic-validation/evidence/typed-exploit-path-valid-v4.json", - "specs/formal/exploit-path-analysis/README.md" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", - "limitations": [ - "The witness is bounded to the admitted snapshot, normalized graph, query, semantics, and search profile; it does not establish backend execution." - ], - "replayable": true, - "result_digest": "sha256:2d4d1a362751abd9544beb8af7f8c6331d04dac8f4abc315fb261f81fbaf4387", - "source_digest": "sha256:0afe635a63db5b6e6380ac70982fd61d09790745d51a10d670321304121e7c39" - }, - { - "actual_outcome": "invalid-path", - "analysis_profile": "raes-exploit-path-analysis-v1", - "case_id": "typed-exploit-path-invalid-v2", - "configuration_digest": "sha256:7f8876d81feb77d3a3239be2fb8337de8885e2744f8786728ba23e4e6027bc0a", - "configuration_id": "raes-python-reference-offline-v41", - "diagnostic_kind": "exploit-path-analysis-evidence/v1", - "evidence_artifact_path": "docs/research/formal-semantic-validation/evidence/typed-exploit-path-invalid-v4.json", - "evidence_artifact_sha256": "244f895a64f14c10916ab0533ab462ce80a328021cd6a50c30a4aa59266d5533", - "evidence_digest": "sha256:1b416bb5a4d29d57c961b769cc9d3af5d9328624e3eebf104d57f39a94c5bb97", - "evidence_profile": "exploit-path-analysis-evidence/v1", - "evidence_refs": [ - "docs/research/formal-semantic-validation/corpus/exploit-path-invalid-v3.json", - "docs/research/formal-semantic-validation/evidence/typed-exploit-path-invalid-v4.json", - "specs/formal/exploit-path-analysis/README.md" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", - "limitations": [ - "Structured rejection proves only that this bounded graph/query cannot reach its goal; it does not establish real-world non-exploitability." - ], - "replayable": true, - "result_digest": "sha256:1b416bb5a4d29d57c961b769cc9d3af5d9328624e3eebf104d57f39a94c5bb97", - "source_digest": "sha256:0b2293d4a8983515ff05c516be6e6b418a4f3f09e055250a00bf15fda861aab3" - } - ], - "participant_observations": [ - { - "evidence_refs": [ - "implementations/python/tests/test_sem_208_participant_behavior.py::test_hidden_truth_disclosure_is_separate_from_observable_projection", - "implementations/python/tests/test_sem_208_participant_behavior.py::test_hidden_truth_cannot_be_observed_without_explicit_disclosure_rule" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", - "limitations": [ - "Covers the reference SDL/contract path, not every backend projection." - ], - "negative_outcome": "passed", - "obligation_id": "hidden-vs-visible-projection", - "positive_outcome": "passed" - }, - { - "evidence_refs": [ - "implementations/python/tests/test_sem_211_participant_action_semantics.py::test_action_contract_declares_sem_211_classes_and_compiles_them", - "implementations/python/tests/test_sem_211_participant_action_semantics.py::test_action_result_rejects_success_when_preconditions_are_unresolved" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", - "limitations": [ - "Covers declared applicability and one unresolved-precondition failure." - ], - "negative_outcome": "passed", - "obligation_id": "fail-closed-action-applicability", - "positive_outcome": "passed" - }, - { - "evidence_refs": [ - "implementations/python/tests/test_run_308_concurrent_participant_execution.py::test_runtime_snapshot_publishes_joint_action_and_time_context_records", - "implementations/python/tests/test_run_308_concurrent_participant_execution.py::test_joint_action_record_contract_rejects_unordered_conflicting_writes" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", - "limitations": [ - "Contract evidence does not prove every backend's live concurrency fidelity." - ], - "negative_outcome": "passed", - "obligation_id": "shared-state-effects", - "positive_outcome": "passed" - }, - { - "evidence_refs": [ - "implementations/python/tests/test_participant_runtime_invariants.py::test_order_discipline_accepts_supported_order_claim_strengths", - "implementations/python/tests/test_participant_runtime_invariants.py::test_order_discipline_rejects_wall_clock_causality" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", - "limitations": [ - "Rejecting timestamp-only causality does not supply counterfactual proof." - ], - "negative_outcome": "passed", - "obligation_id": "ordering-before-causality", - "positive_outcome": "passed" - }, - { - "evidence_refs": [ - "implementations/python/tests/test_sem_212_participant_attribution_semantics.py::test_attribution_edge_round_trips_on_terminal_observation", - "implementations/python/tests/test_sem_212_participant_attribution_semantics.py::test_timestamp_adjacency_cannot_be_reported_as_strong_causality" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", - "limitations": [ - "Attribution labels disclose basis; they do not demonstrate necessity." - ], - "negative_outcome": "passed", - "obligation_id": "evidence-labeled-attribution", - "positive_outcome": "passed" - }, - { - "evidence_refs": [ - "implementations/python/tests/test_sem_215_participant_outcome_interpretation.py::test_outcome_interpretation_rule_parses_and_compiles_explicit_layers", - "implementations/python/tests/test_sem_215_participant_outcome_interpretation.py::test_local_action_success_does_not_imply_objective_success_without_rule_record" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", - "limitations": [ - "The fixtures establish layer separation, not outcome validity in every realization." - ], - "negative_outcome": "passed", - "obligation_id": "participant-local-outcome-separation", - "positive_outcome": "passed" - }, - { - "evidence_refs": [ - "implementations/python/tests/test_realization_honesty_conformance.py::test_constructive_envelope_runs_positive_and_negative_honesty_probes", - "implementations/python/tests/test_realization_honesty_conformance.py::test_only_native_live_can_support_native_conformance" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-bee18848d137", - "limitations": [ - "Reference conformance evidence remains bounded to declared realization profiles." - ], - "negative_outcome": "passed", - "obligation_id": "realization-profile-honesty", - "positive_outcome": "passed" - } - ], - "protocol_revision": "2.0.0", - "raes_revision": "3d7b88e2b465ffa0c0a4a6b3b8894de8e95ca2b6", - "source_state": { - "base_revision": "3d7b88e2b465ffa0c0a4a6b3b8894de8e95ca2b6", - "checkout_state": "clean", - "implementation_digest": "bee18848d1372ba29188de8a8443c494d377824261645f88cf4c2d9353677cf8", - "profile": "python-reference-source/v2" - }, - "versions": { - "python": "3.12.3", - "raes": "5.0.0", - "z3_engine": "4.16.0", - "z3_solver": "4.16.0.0" - } -} diff --git a/docs/research/formal-semantic-validation/captures/capture-75bb60563fe13054358a57d241c247b09e748313f70098d7b3510988af5c5a67/analysis.json b/docs/research/formal-semantic-validation/captures/capture-75bb60563fe13054358a57d241c247b09e748313f70098d7b3510988af5c5a67/analysis.json deleted file mode 100644 index cb8d2925c3..0000000000 --- a/docs/research/formal-semantic-validation/captures/capture-75bb60563fe13054358a57d241c247b09e748313f70098d7b3510988af5c5a67/analysis.json +++ /dev/null @@ -1,168 +0,0 @@ -{ - "analysis_id": "issue-1479-oci-anonymous-token-formal-analysis-d57e6b1838fd", - "claim": { - "allowed_evidence": [ - "production parser and semantic-validator results", - "canonical compiled digests", - "participant contract regression tests", - "pinned protocol, corpus, and execution snapshot" - ], - "claim_id": "asr-530-formal-semantic-validation-retest", - "disallowed_evidence": [ - "schema success as semantic proof", - "workflow reachability as network or exploit reachability", - "FM labels as gate outcomes", - "attribution as counterfactual proof", - "formal prose or maintainer confidence alone" - ], - "evidence_artifacts": [ - "docs/research/formal-semantic-validation/protocol-v2.json", - "docs/research/formal-semantic-validation/corpus/manifest-v4.json", - "@snapshot", - "docs/research/formal-semantic-validation/evidence/finite-domain-satisfiable-v4.json", - "docs/research/formal-semantic-validation/evidence/finite-domain-unsatisfiable-v4.json", - "docs/research/formal-semantic-validation/evidence/typed-exploit-path-valid-v4.json", - "docs/research/formal-semantic-validation/evidence/typed-exploit-path-invalid-v4.json" - ], - "falsification_protocol": "Replay every retained and new case through its production entrypoint, require complete digest and evidence joins, execute participant fixtures, and derive status from the recorded outcomes.", - "objective_fail_criteria": "A supported negative passes, a positive fails, an observation drifts, a required participant case is missing, or weaker evidence is promoted to solver, exploit-path, runtime-stability, or counterfactual assurance.", - "objective_pass_criteria": "Every claim class has positive and negative cases, all supported cases reproduce the frozen outcome, every participant obligation has passing positive and negative fixtures, and unsupported classes remain untested.", - "statement": "At the recorded source-state digest, the retained RAES controls have the bounded statuses recorded here; historical releases are integrity evidence, not current replay evidence.", - "threats_to_validity": [ - "The issue-specific corpus is intentionally small and does not enumerate every validator invariant.", - "The participant fixtures exercise reference production contracts and tests, not every independent backend realization.", - "The replay gate runs on one Python reference configuration and one pinned RAES revision.", - "Unsupported solver-level classes have protocol cases but no executable observations." - ] - }, - "claim_results": [ - { - "case_count": 2, - "claim_class_id": "schema-validity", - "evidence_status": "demonstrated", - "limitations": [ - "Bounded to the named source/model structural controls." - ], - "matching_case_count": 2, - "participant_obligation_count": 0, - "replayable_case_count": 2, - "unsupported_case_count": 0 - }, - { - "case_count": 4, - "claim_class_id": "semantic-consistency", - "evidence_status": "partial", - "limitations": [ - "Partial coverage of named static semantics and participant obligations, not universal consistency." - ], - "matching_case_count": 4, - "participant_obligation_count": 7, - "replayable_case_count": 4, - "unsupported_case_count": 0 - }, - { - "case_count": 2, - "claim_class_id": "graph-reachability", - "evidence_status": "partial", - "limitations": [ - "Partial workflow control-flow reachability only; not network, service, or exploit reachability." - ], - "matching_case_count": 2, - "participant_obligation_count": 0, - "replayable_case_count": 2, - "unsupported_case_count": 0 - }, - { - "case_count": 4, - "claim_class_id": "constraint-satisfiability", - "evidence_status": "demonstrated", - "limitations": [ - "Demonstrated only for raes-finite-domain-satisfiability-v1 and its pinned solver configuration." - ], - "matching_case_count": 4, - "participant_obligation_count": 0, - "replayable_case_count": 2, - "unsupported_case_count": 2 - }, - { - "case_count": 4, - "claim_class_id": "exploit-path-validity", - "evidence_status": "demonstrated", - "limitations": [ - "Demonstrated only for the admitted snapshot, typed graph, query, semantics, and bounded search profile." - ], - "matching_case_count": 4, - "participant_obligation_count": 0, - "replayable_case_count": 2, - "unsupported_case_count": 2 - }, - { - "case_count": 2, - "claim_class_id": "determinism-stability", - "evidence_status": "partial", - "limitations": [ - "Partial parse-to-compile repeatability only; runtime and backend determinism are untested." - ], - "matching_case_count": 2, - "participant_obligation_count": 0, - "replayable_case_count": 2, - "unsupported_case_count": 0 - }, - { - "case_count": 2, - "claim_class_id": "counterfactual-necessity", - "evidence_status": "untested", - "limitations": [ - "Untested because no governed intervention or ablation entrypoint ran." - ], - "matching_case_count": 2, - "participant_obligation_count": 0, - "replayable_case_count": 0, - "unsupported_case_count": 2 - } - ], - "corpus_revision": "4.0.0", - "evidence_status": "partial", - "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", - "generated_at": "2026-10-25T08:54:08.535564+00:00", - "limitations": [ - "Satisfiability is limited to raes-finite-domain-satisfiability-v1 and its exact translation, theory, and Z3 configuration.", - "The subset-minimal unsatisfiable core is not a universal proof certificate.", - "Exploit-path results are limited to the admitted snapshot, normalized graph, query, transition semantics, and bounded search profile.", - "A valid path is not backend execution and an invalid path is not real-world non-exploitability.", - "The production exploit-path JSON loader permits duplicate keys; the research loader rejects them without claiming stronger production behavior.", - "Participant replay inherits the host environment and is not described as hermetic.", - "Counterfactual necessity remains untested.", - "Scoped observation demand is not a claim class in this preregistration and is not promoted to demonstrated by this retest.", - "EXP-732 provenance joins are verified by their dedicated regression suite; this retained corpus makes no universal run, apparatus, source, or augmentation assurance claim.", - "This retained corpus does not establish native backend attestation fidelity; materialization contract checks remain separate operational provenance, not experimental observations.", - "Capture admission and evidence-proof authority are verified by issue-1237 regression tests, not promoted to a new claim class by this retained corpus.", - "Evidence-requirement refinement lineage is outside this retained formal claim set; this retest refreshes integrated source provenance without promoting that feature to a formal claim.", - "Authoring-adapter transport behavior is outside this retained formal claim set.", - "Operational recovery observation and startup reconciliation are verified by their API-404 regression suite, not promoted to a new formal claim class by this retained corpus.", - "Single-owner store admission, immutable target/run scope, and provider shutdown ordering are verified by their API-404 CP-5 regression suite, not promoted to a formal claim by this retained corpus.", - "Mixed and staged trial admission is verified by its SEM-234/SCE-002/API-407 regression suite, not promoted to a new formal claim class by this retained corpus.", - "Offline control-plane maintenance, readiness, and bounded audit behavior are verified by issue #1186 runtime tests, not promoted to a formal claim by this retained corpus.", - "Issue #1187 control-plane crash/profile conformance and HTTP security changes are covered by their dedicated regression suite, not promoted to new claims by this retained corpus.", - "Issue #1189 profile declarations and capability admission are covered by dedicated runtime tests; the retained formal corpus does not execute control-plane profile composition.", - "Issue #1016 mixed-runtime coordination is covered by dedicated runtime tests; the retained formal corpus does not establish backend-native mixed realization, multi-controller coordination, IFC, or equivalence.", - "Issue #610's reconciliation demonstration harness is covered by its dedicated processor and CLI suite, not promoted to new claims by the retained language corpus.", - "Participant identity, organization ownership, and participant assignment are separated by issue #1338. This retained offline corpus does not establish participant autonomy, execution authority, live backend fidelity, or causal attribution.", - "Issue #1389 temporal-subject admission is verified by dedicated compiler tests and adds no new formal-semantic claim to this retained corpus.", - "Issue #971 model construction is verified by its own tests; this retained corpus establishes no participant-crossing equivalence or runtime-realization claim.", - "Issue #1359 control-plane route authority, participant-view scoping, and no-store HTTP boundary are verified by their dedicated HTTP-boundary suite and add no new formal-semantic claim to this retained corpus.", - "Issue #1401 required-evidence media-type coherence is verified by its dedicated suite and adds no new formal-semantic claim to this retained corpus.", - "Issue #1361 execution and recovery requirements are verified by dedicated policy, composition, and admission tests; this retained corpus establishes no live recovery, continuation, or trial-allocation guarantee.", - "The issue #1361 maintainability repair preserves policy semantics and retained corpus outcomes; it establishes no live recovery, continuation, or trial-allocation guarantee.", - "The issue #1361 resource type-hint repair preserves policy semantics and retained corpus outcomes; it establishes no live recovery, continuation, or trial-allocation guarantee.", - "The combined issue #1361 execution-policy and hatchling update preserves retained outcomes and bounded claims; it establishes no live recovery, continuation, or trial-allocation guarantee.", - "The issue #1418 runtime-fact export manifest split changes no contract, schema or behavior and adds no new formal-semantic claim.", - "The issue #1423 inject trigger request and occurrence contracts are new draft carriers that no SDL construct, compiler or runtime path reads, and they add no new formal-semantic claim.", - "The issue #1366 inject readback, correlation and backend declaration contracts are new draft carriers; the shared backend allowlist also lets SDL participant behavior specifications cite inject-occurrence-v1 and inject-occurrence-outcome-v1 as evidence_contract_refs, which the compiler copies through uninterpreted, and no runtime path or shipped backend reads or declares them; they add no new formal-semantic claim.", - "This synchronization preserves the original inject baseline chain in the pre-sync archive, retains frozen production and participant evidence, and binds the combined contract source. CI independently verifies current evidence replay; no new runtime adoption is claimed.", - "This second synchronization binds behavior-authoring source from issue #297, retains frozen production and participant evidence, and pins the preserved first-sync release 75 as its baseline. CI independently verifies replay; no new runtime adoption is claimed.", - "Task-contract CLI admission and optional supplied-task reference checks are covered by test_issue_1519_experiment_tasks.py; the retained research corpus makes no additional task, artifact-content, or execution claim." - ], - "plain_language_outcome": "The retained formal cases reproduce their outcomes on the combined source of current dev and issue #1479's anonymous bearer-token flow for OCI module fetches. Bounded claims and unsupported classes are unchanged.", - "protocol_revision": "2.0.0" -} diff --git a/docs/research/formal-semantic-validation/captures/capture-75bb60563fe13054358a57d241c247b09e748313f70098d7b3510988af5c5a67/manifest.json b/docs/research/formal-semantic-validation/captures/capture-75bb60563fe13054358a57d241c247b09e748313f70098d7b3510988af5c5a67/manifest.json deleted file mode 100644 index cb809d54ef..0000000000 --- a/docs/research/formal-semantic-validation/captures/capture-75bb60563fe13054358a57d241c247b09e748313f70098d7b3510988af5c5a67/manifest.json +++ /dev/null @@ -1,122 +0,0 @@ -{ - "analysis_path": "docs/research/formal-semantic-validation/captures/capture-75bb60563fe13054358a57d241c247b09e748313f70098d7b3510988af5c5a67/analysis.json", - "analysis_sha256": "821651b8ae4a93e4deb2e11f54c1bd3ca406e885a95e3c7ee45903083752531a", - "artifacts": [ - { - "artifact_id": "finite-domain-satisfiable-v2-input", - "kind": "corpus-input", - "path": "docs/research/formal-semantic-validation/corpus/satisfiable-control.sdl.yaml", - "sha256": "0ca9eaba9dc47171f7a042dc6753faa6c820c65ee966538f9d65fac5342202e8" - }, - { - "artifact_id": "finite-domain-satisfiable-v2-evidence", - "kind": "production-evidence", - "path": "docs/research/formal-semantic-validation/evidence/finite-domain-satisfiable-v4.json", - "sha256": "554202313d678046958b5c028e2de26ff03c74895cfac552677eed74e8153add" - }, - { - "artifact_id": "finite-domain-unsatisfiable-v2-input", - "kind": "corpus-input", - "path": "docs/research/formal-semantic-validation/corpus/unsatisfiable-control.sdl.yaml", - "sha256": "cfef56a1f56d5f0db9da195377fd75694bdd0f0b92932fdb8fafcbd3f7baf6c5" - }, - { - "artifact_id": "finite-domain-unsatisfiable-v2-evidence", - "kind": "production-evidence", - "path": "docs/research/formal-semantic-validation/evidence/finite-domain-unsatisfiable-v4.json", - "sha256": "c972725ef64822a75a60380afc11f08eac25b7fe9b091d39b058b3c9f7c8031d" - }, - { - "artifact_id": "typed-exploit-path-valid-v2-input", - "kind": "corpus-input", - "path": "docs/research/formal-semantic-validation/corpus/exploit-path-valid-v3.json", - "sha256": "0afe635a63db5b6e6380ac70982fd61d09790745d51a10d670321304121e7c39" - }, - { - "artifact_id": "typed-exploit-path-valid-v2-evidence", - "kind": "production-evidence", - "path": "docs/research/formal-semantic-validation/evidence/typed-exploit-path-valid-v4.json", - "sha256": "1b7f55d04db172da32658187c64a88c13b5f4d565267ce2be7cb86a9d04cb70c" - }, - { - "artifact_id": "typed-exploit-path-invalid-v2-input", - "kind": "corpus-input", - "path": "docs/research/formal-semantic-validation/corpus/exploit-path-invalid-v3.json", - "sha256": "0b2293d4a8983515ff05c516be6e6b418a4f3f09e055250a00bf15fda861aab3" - }, - { - "artifact_id": "typed-exploit-path-invalid-v2-evidence", - "kind": "production-evidence", - "path": "docs/research/formal-semantic-validation/evidence/typed-exploit-path-invalid-v4.json", - "sha256": "244f895a64f14c10916ab0533ab462ce80a328021cd6a50c30a4aa59266d5533" - }, - { - "artifact_id": "schema-valid-control-fixture", - "kind": "corpus-input", - "path": "docs/research/formal-semantic-validation/corpus/schema-valid.sdl.yaml", - "sha256": "41a9adffdf9f5f2ccc2f887dcf7b15fba3b47c83a1af15f33db872c4a2449d67" - }, - { - "artifact_id": "schema-unknown-field-fixture", - "kind": "corpus-input", - "path": "docs/research/formal-semantic-validation/corpus/schema-invalid-unknown-field.sdl.yaml", - "sha256": "51cf62319a86c95a2517995939d1f370573051835e4b55bb6d5beaf049640481" - }, - { - "artifact_id": "semantic-resolved-objective-fixture", - "kind": "corpus-input", - "path": "docs/research/formal-semantic-validation/corpus/semantic-valid-participant-identity-v2.sdl.yaml", - "sha256": "75834bdc883e2003e1c473870bdf75700978955bb83095c6bd718ba6bd3908a6" - }, - { - "artifact_id": "semantic-dangling-assertion-fixture", - "kind": "corpus-input", - "path": "docs/research/formal-semantic-validation/corpus/semantic-invalid-dangling-ref-participant-identity-v2.sdl.yaml", - "sha256": "1d25bee5f556054e5f0a518df025e4c62e080e1964035e3c1a12e074d88d3a5d" - }, - { - "artifact_id": "semantic-ambiguous-reference-fixture", - "kind": "corpus-input", - "path": "docs/research/formal-semantic-validation/corpus/semantic-invalid-ambiguous-ref.sdl.yaml", - "sha256": "653cbd2fd62e220d49fb86f80133884207df5ae6752846345ae3085b93f6e4ed" - }, - { - "artifact_id": "semantic-feature-cycle-fixture", - "kind": "corpus-input", - "path": "docs/research/formal-semantic-validation/corpus/semantic-invalid-feature-cycle.sdl.yaml", - "sha256": "e1f66d95a9ad039687aec8cccbc8843b514072ff08e006c1b4ca6aa5cd8d4ed1" - }, - { - "artifact_id": "workflow-reachable-control-fixture", - "kind": "corpus-input", - "path": "docs/research/formal-semantic-validation/corpus/workflow-reachable.sdl.yaml", - "sha256": "54c40ceb98ad47247447d737973b2c55e8fb2045e209c7545c4fb20cf42dc3dc" - }, - { - "artifact_id": "workflow-unreachable-step-fixture", - "kind": "corpus-input", - "path": "docs/research/formal-semantic-validation/corpus/workflow-unreachable.sdl.yaml", - "sha256": "ef22ef2e260f1a7fd92d286f9b571716436b192ddfd54aea7bdfcfdda4ca52a2" - }, - { - "artifact_id": "compile-repeatability-control-fixture", - "kind": "corpus-input", - "path": "docs/research/formal-semantic-validation/corpus/determinism-a.sdl.yaml", - "sha256": "0bc40900d598c1af7a405d798ca19710405e53ced262d8733081abf12edf89fe" - }, - { - "artifact_id": "compile-non-vacuity-control-comparison-fixture", - "kind": "corpus-input", - "path": "docs/research/formal-semantic-validation/corpus/determinism-b.sdl.yaml", - "sha256": "d85338f89f20a45515b12da8640173c1a52e47eb17ca0f4f6b4f8f3306e863a1" - } - ], - "bundle_id": "raes-formal-semantic-validation", - "corpus_path": "docs/research/formal-semantic-validation/corpus/manifest-v4.json", - "corpus_sha256": "c57207af72406aa4f70882b9bbeb7cedcc79cf3854c878a95e3eb1fa59ea7a72", - "protocol_path": "docs/research/formal-semantic-validation/protocol-v2.json", - "protocol_sha256": "abf94093e344bf495dfb04e8b0c5985c0beaab8ebb17a75e15c8674fa81b1a7c", - "revision": "capture-75bb60563fe13054358a57d241c247b09e748313f70098d7b3510988af5c5a67", - "snapshot_path": "docs/research/formal-semantic-validation/captures/capture-75bb60563fe13054358a57d241c247b09e748313f70098d7b3510988af5c5a67/snapshot.json", - "snapshot_sha256": "787a94b8c2a3fe56b020687c9af0a1aa16a7db5f1d3efbe6d921bb7ccdc25461" -} diff --git a/docs/research/formal-semantic-validation/captures/capture-75bb60563fe13054358a57d241c247b09e748313f70098d7b3510988af5c5a67/snapshot.json b/docs/research/formal-semantic-validation/captures/capture-75bb60563fe13054358a57d241c247b09e748313f70098d7b3510988af5c5a67/snapshot.json deleted file mode 100644 index 828483bc07..0000000000 --- a/docs/research/formal-semantic-validation/captures/capture-75bb60563fe13054358a57d241c247b09e748313f70098d7b3510988af5c5a67/snapshot.json +++ /dev/null @@ -1,653 +0,0 @@ -{ - "baseline": { - "execution_id": "issue-1519-pr-1458-formal-execution", - "release_path": "docs/research/formal-semantic-validation/captures/capture-e7f39cbb85eaca4f953a7f64dc4be7bff1fe2c2625976bd5a324d5ba996d018d/manifest.json", - "release_revision": "capture-e7f39cbb85eaca4f953a7f64dc4be7bff1fe2c2625976bd5a324d5ba996d018d", - "release_sha256": "f8a66af765a1b1daab230f95970ee6c78e79c9e608f7576c91e1c3dc0d7f91e4" - }, - "captured_at": "2026-10-25T08:54:08.535564+00:00", - "commands": [ - { - "argv": [ - "implementations/python/.venv/bin/python", - "-c", - "import json, sys\nfrom pathlib import Path\nroot = Path.cwd().resolve()\nfor entry in (str(root), str(root / \"implementations\" / \"python\" / \"packages\")):\n if entry not in sys.path:\n sys.path.insert(0, entry)\nfrom tools.formal_semantic_validation._replay import replay_case\ncorpus = json.loads((root / \"docs/research/formal-semantic-validation/corpus/manifest-v4.json\").read_text(encoding=\"utf-8\"))\nskipped = set([\"exploit-path\", \"satisfiability\", \"unsupported\"])\nresults = {}\nfor case in corpus[\"cases\"]:\n if case.get(\"replay_mode\") in skipped:\n continue\n try:\n results[case[\"case_id\"]] = {\"ok\": True, **replay_case(root, case)}\n except Exception as exc:\n results[case[\"case_id\"]] = {\"ok\": False, \"error\": type(exc).__name__ + \": \" + str(exc)[:300]}\nprint(json.dumps(results, sort_keys=True))\n" - ], - "command_id": "retained-case-replay", - "network": "disabled" - }, - { - "argv": [ - "implementations/python/.venv/bin/pytest", - "-q", - "implementations/python/tests/test_sem_208_participant_behavior.py::test_hidden_truth_disclosure_is_separate_from_observable_projection", - "implementations/python/tests/test_sem_208_participant_behavior.py::test_hidden_truth_cannot_be_observed_without_explicit_disclosure_rule", - "implementations/python/tests/test_sem_211_participant_action_semantics.py::test_action_contract_declares_sem_211_classes_and_compiles_them", - "implementations/python/tests/test_sem_211_participant_action_semantics.py::test_action_result_rejects_success_when_preconditions_are_unresolved", - "implementations/python/tests/test_run_308_concurrent_participant_execution.py::test_runtime_snapshot_publishes_joint_action_and_time_context_records", - "implementations/python/tests/test_run_308_concurrent_participant_execution.py::test_joint_action_record_contract_rejects_unordered_conflicting_writes", - "implementations/python/tests/test_participant_runtime_invariants.py::test_order_discipline_accepts_supported_order_claim_strengths", - "implementations/python/tests/test_participant_runtime_invariants.py::test_order_discipline_rejects_wall_clock_causality", - "implementations/python/tests/test_sem_212_participant_attribution_semantics.py::test_attribution_edge_round_trips_on_terminal_observation", - "implementations/python/tests/test_sem_212_participant_attribution_semantics.py::test_timestamp_adjacency_cannot_be_reported_as_strong_causality", - "implementations/python/tests/test_sem_215_participant_outcome_interpretation.py::test_outcome_interpretation_rule_parses_and_compiles_explicit_layers", - "implementations/python/tests/test_sem_215_participant_outcome_interpretation.py::test_local_action_success_does_not_imply_objective_success_without_rule_record", - "implementations/python/tests/test_realization_honesty_conformance.py::test_constructive_envelope_runs_positive_and_negative_honesty_probes", - "implementations/python/tests/test_realization_honesty_conformance.py::test_only_native_live_can_support_native_conformance" - ], - "command_id": "participant-fixtures", - "network": "disabled" - }, - { - "argv": [ - "implementations/python/.venv/bin/raes", - "processor", - "satisfiability", - "docs/research/formal-semantic-validation/corpus/satisfiable-control.sdl.yaml", - "--profile", - "raes-finite-domain-satisfiability-v1" - ], - "command_id": "finite-domain-satisfiable-v2", - "network": "disabled" - }, - { - "argv": [ - "implementations/python/.venv/bin/raes", - "processor", - "satisfiability", - "docs/research/formal-semantic-validation/corpus/unsatisfiable-control.sdl.yaml", - "--profile", - "raes-finite-domain-satisfiability-v1" - ], - "command_id": "finite-domain-unsatisfiable-v2", - "network": "disabled" - }, - { - "argv": [ - "implementations/python/.venv/bin/raes", - "processor", - "exploit-path", - "docs/research/formal-semantic-validation/corpus/exploit-path-valid-v3.json", - "--profile", - "raes-exploit-path-analysis-v1" - ], - "command_id": "typed-exploit-path-valid-v2", - "network": "disabled" - }, - { - "argv": [ - "implementations/python/.venv/bin/raes", - "processor", - "exploit-path", - "docs/research/formal-semantic-validation/corpus/exploit-path-invalid-v3.json", - "--profile", - "raes-exploit-path-analysis-v1" - ], - "command_id": "typed-exploit-path-invalid-v2", - "network": "disabled" - } - ], - "configuration_id": "raes-python-reference-offline-v41", - "corpus_revision": "4.0.0", - "deviations": [], - "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", - "execution_status": "complete", - "observations": [ - { - "actual_outcome": "accepted", - "analysis_profile": null, - "case_id": "schema-valid-control", - "configuration_digest": null, - "configuration_id": "raes-python-reference-offline-v41", - "diagnostic_kind": null, - "evidence_artifact_path": null, - "evidence_artifact_sha256": null, - "evidence_digest": null, - "evidence_profile": null, - "evidence_refs": [ - "docs/research/formal-semantic-validation/corpus/schema-valid.sdl.yaml" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", - "limitations": [ - "A passing minimal source does not establish semantic correctness." - ], - "replayable": true, - "result_digest": "f7d364ef384df8a1526b489501835b635021c860793b5764f91d956710d2250c", - "source_digest": null - }, - { - "actual_outcome": "rejected", - "analysis_profile": null, - "case_id": "schema-unknown-field", - "configuration_digest": null, - "configuration_id": "raes-python-reference-offline-v41", - "diagnostic_kind": "SDLParseError", - "evidence_artifact_path": null, - "evidence_artifact_sha256": null, - "evidence_digest": null, - "evidence_profile": null, - "evidence_refs": [ - "docs/research/formal-semantic-validation/corpus/schema-invalid-unknown-field.sdl.yaml" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", - "limitations": [ - "The observation covers one unknown-field defect only." - ], - "replayable": true, - "result_digest": "f55d834b458f8e069e1c69061b4cc0a6d61e0e052bf90c670f2e6a5ad8b5bd98", - "source_digest": null - }, - { - "actual_outcome": "accepted", - "analysis_profile": null, - "case_id": "semantic-resolved-objective", - "configuration_digest": null, - "configuration_id": "raes-python-reference-offline-v41", - "diagnostic_kind": null, - "evidence_artifact_path": null, - "evidence_artifact_sha256": null, - "evidence_digest": null, - "evidence_profile": null, - "evidence_refs": [ - "docs/research/formal-semantic-validation/corpus/semantic-valid-participant-identity-v2.sdl.yaml" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", - "limitations": [ - "This is a positive control for one objective-reference slice." - ], - "replayable": true, - "result_digest": "652288785dc09095955ed3649f6407d616fb7c4d4f4188df4ed513ccb7537e0b", - "source_digest": null - }, - { - "actual_outcome": "rejected", - "analysis_profile": null, - "case_id": "semantic-dangling-assertion", - "configuration_digest": null, - "configuration_id": "raes-python-reference-offline-v41", - "diagnostic_kind": "SDLValidationError", - "evidence_artifact_path": null, - "evidence_artifact_sha256": null, - "evidence_digest": null, - "evidence_profile": null, - "evidence_refs": [ - "docs/research/formal-semantic-validation/corpus/semantic-invalid-dangling-ref-participant-identity-v2.sdl.yaml" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", - "limitations": [ - "A single dangling reference does not prove complete semantic coverage." - ], - "replayable": true, - "result_digest": "0207cf616b56708ca9b8c4499d3301abe22dbe52162cf8d58d3bec429d9db024", - "source_digest": null - }, - { - "actual_outcome": "rejected", - "analysis_profile": null, - "case_id": "semantic-ambiguous-reference", - "configuration_digest": null, - "configuration_id": "raes-python-reference-offline-v41", - "diagnostic_kind": "SDLValidationError", - "evidence_artifact_path": null, - "evidence_artifact_sha256": null, - "evidence_digest": null, - "evidence_profile": null, - "evidence_refs": [ - "docs/research/formal-semantic-validation/corpus/semantic-invalid-ambiguous-ref.sdl.yaml" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", - "limitations": [ - "One namespace collision does not enumerate every ambiguity surface." - ], - "replayable": true, - "result_digest": "9da4a87797d228e0012ab6b30459f4892e41aa6f224a9840be035fee4a2eea73", - "source_digest": null - }, - { - "actual_outcome": "rejected", - "analysis_profile": null, - "case_id": "semantic-feature-cycle", - "configuration_digest": null, - "configuration_id": "raes-python-reference-offline-v41", - "diagnostic_kind": "SDLValidationError", - "evidence_artifact_path": null, - "evidence_artifact_sha256": null, - "evidence_digest": null, - "evidence_profile": null, - "evidence_refs": [ - "docs/research/formal-semantic-validation/corpus/semantic-invalid-feature-cycle.sdl.yaml" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", - "limitations": [ - "One static dependency cycle does not establish general constraint satisfiability." - ], - "replayable": true, - "result_digest": "d15dbcd99fb4f20b965d7031b07dd6534576302270399c3fa656d29e7de02b83", - "source_digest": null - }, - { - "actual_outcome": "accepted", - "analysis_profile": null, - "case_id": "workflow-reachable-control", - "configuration_digest": null, - "configuration_id": "raes-python-reference-offline-v41", - "diagnostic_kind": null, - "evidence_artifact_path": null, - "evidence_artifact_sha256": null, - "evidence_digest": null, - "evidence_profile": null, - "evidence_refs": [ - "docs/research/formal-semantic-validation/corpus/workflow-reachable.sdl.yaml" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", - "limitations": [ - "The graph is workflow control flow only." - ], - "replayable": true, - "result_digest": "b1b49649b54bd59d4ef357b39cf9158da90f4eae560f8dd756acf97bd0827a06", - "source_digest": null - }, - { - "actual_outcome": "rejected", - "analysis_profile": null, - "case_id": "workflow-unreachable-step", - "configuration_digest": null, - "configuration_id": "raes-python-reference-offline-v41", - "diagnostic_kind": "SDLValidationError", - "evidence_artifact_path": null, - "evidence_artifact_sha256": null, - "evidence_digest": null, - "evidence_profile": null, - "evidence_refs": [ - "docs/research/formal-semantic-validation/corpus/workflow-unreachable.sdl.yaml" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", - "limitations": [ - "The result does not establish network, service, participant, or exploit reachability." - ], - "replayable": true, - "result_digest": "bb931d19346ef9193408ae6c85deb4079704378fc5f00dc5f47a2817cff21943", - "source_digest": null - }, - { - "actual_outcome": "unsupported", - "analysis_profile": null, - "case_id": "whole-scenario-satisfiable-request", - "configuration_digest": null, - "configuration_id": "raes-python-reference-offline-v41", - "diagnostic_kind": null, - "evidence_artifact_path": null, - "evidence_artifact_sha256": null, - "evidence_digest": null, - "evidence_profile": null, - "evidence_refs": [ - "docs/decisions/issue-168-formal-semantic-validation-reachability-preflight.md" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", - "limitations": [ - "No governed whole-scenario constraint theory or solver exists." - ], - "replayable": false, - "result_digest": null, - "source_digest": null - }, - { - "actual_outcome": "unsupported", - "analysis_profile": null, - "case_id": "whole-scenario-unsatisfiable-request", - "configuration_digest": null, - "configuration_id": "raes-python-reference-offline-v41", - "diagnostic_kind": null, - "evidence_artifact_path": null, - "evidence_artifact_sha256": null, - "evidence_digest": null, - "evidence_profile": null, - "evidence_refs": [ - "docs/decisions/issue-168-formal-semantic-validation-reachability-preflight.md" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", - "limitations": [ - "Local checks cannot produce a whole-scenario unsat certificate." - ], - "replayable": false, - "result_digest": null, - "source_digest": null - }, - { - "actual_outcome": "unsupported", - "analysis_profile": null, - "case_id": "valid-exploit-path-request", - "configuration_digest": null, - "configuration_id": "raes-python-reference-offline-v41", - "diagnostic_kind": null, - "evidence_artifact_path": null, - "evidence_artifact_sha256": null, - "evidence_digest": null, - "evidence_profile": null, - "evidence_refs": [ - "docs/decisions/issue-168-formal-semantic-validation-reachability-preflight.md" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", - "limitations": [ - "The issue-168 baseline had no canonical typed attack graph or path-query entrypoint." - ], - "replayable": false, - "result_digest": null, - "source_digest": null - }, - { - "actual_outcome": "unsupported", - "analysis_profile": null, - "case_id": "invalid-exploit-path-request", - "configuration_digest": null, - "configuration_id": "raes-python-reference-offline-v41", - "diagnostic_kind": null, - "evidence_artifact_path": null, - "evidence_artifact_sha256": null, - "evidence_digest": null, - "evidence_profile": null, - "evidence_refs": [ - "docs/decisions/issue-168-formal-semantic-validation-reachability-preflight.md" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", - "limitations": [ - "Vulnerability and topology declarations are not an invalid-path proof." - ], - "replayable": false, - "result_digest": null, - "source_digest": null - }, - { - "actual_outcome": "stable", - "analysis_profile": null, - "case_id": "compile-repeatability-control", - "configuration_digest": null, - "configuration_id": "raes-python-reference-offline-v41", - "diagnostic_kind": null, - "evidence_artifact_path": null, - "evidence_artifact_sha256": null, - "evidence_digest": null, - "evidence_profile": null, - "evidence_refs": [ - "docs/research/formal-semantic-validation/corpus/determinism-a.sdl.yaml" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", - "limitations": [ - "The witness ends at compiled output." - ], - "replayable": true, - "result_digest": "d7c098c5d063b8d1b0747e8df5daa90061456065cdda0bbedfa10918442f5daa", - "source_digest": null - }, - { - "actual_outcome": "distinguishable", - "analysis_profile": null, - "case_id": "compile-non-vacuity-control", - "configuration_digest": null, - "configuration_id": "raes-python-reference-offline-v41", - "diagnostic_kind": null, - "evidence_artifact_path": null, - "evidence_artifact_sha256": null, - "evidence_digest": null, - "evidence_profile": null, - "evidence_refs": [ - "docs/research/formal-semantic-validation/corpus/determinism-a.sdl.yaml", - "docs/research/formal-semantic-validation/corpus/determinism-b.sdl.yaml" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", - "limitations": [ - "Distinct digests are a non-vacuity control, not semantic non-equivalence proof." - ], - "replayable": true, - "result_digest": "a2fcebba3341592b133af813e8bb8e5f47270418bc58bfd471a89bfbc8ba46da", - "source_digest": null - }, - { - "actual_outcome": "unsupported", - "analysis_profile": null, - "case_id": "necessity-witness-request", - "configuration_digest": null, - "configuration_id": "raes-python-reference-offline-v41", - "diagnostic_kind": null, - "evidence_artifact_path": null, - "evidence_artifact_sha256": null, - "evidence_digest": null, - "evidence_profile": null, - "evidence_refs": [ - "docs/decisions/issue-168-formal-semantic-validation-reachability-preflight.md" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", - "limitations": [ - "No governed intervention or ablation protocol exists." - ], - "replayable": false, - "result_digest": null, - "source_digest": null - }, - { - "actual_outcome": "unsupported", - "analysis_profile": null, - "case_id": "non-necessity-control-request", - "configuration_digest": null, - "configuration_id": "raes-python-reference-offline-v41", - "diagnostic_kind": null, - "evidence_artifact_path": null, - "evidence_artifact_sha256": null, - "evidence_digest": null, - "evidence_profile": null, - "evidence_refs": [ - "docs/decisions/issue-168-formal-semantic-validation-reachability-preflight.md" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", - "limitations": [ - "Attribution and negative fixtures do not demonstrate non-necessity." - ], - "replayable": false, - "result_digest": null, - "source_digest": null - }, - { - "actual_outcome": "satisfiable", - "analysis_profile": "raes-finite-domain-satisfiability-v1", - "case_id": "finite-domain-satisfiable-v2", - "configuration_digest": "sha256:1204635e17e759e9ad3bd6be2ecb28c6de05c07ead6dfdd15936ed5d3d5b81b2", - "configuration_id": "raes-python-reference-offline-v41", - "diagnostic_kind": "scenario-satisfiability-evidence/v1", - "evidence_artifact_path": "docs/research/formal-semantic-validation/evidence/finite-domain-satisfiable-v4.json", - "evidence_artifact_sha256": "554202313d678046958b5c028e2de26ff03c74895cfac552677eed74e8153add", - "evidence_digest": "sha256:23c2cae7d95d4cc83d77ca576e3911477b169ecc311c977cb45490345f633b5a", - "evidence_profile": "scenario-satisfiability-evidence/v1", - "evidence_refs": [ - "docs/research/formal-semantic-validation/corpus/satisfiable-control.sdl.yaml", - "docs/research/formal-semantic-validation/evidence/finite-domain-satisfiable-v4.json", - "specs/formal/scenario-satisfiability/README.md" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", - "limitations": [ - "Demonstrates only the pinned finite-domain theory, translation, solver profile, and source." - ], - "replayable": true, - "result_digest": "sha256:23c2cae7d95d4cc83d77ca576e3911477b169ecc311c977cb45490345f633b5a", - "source_digest": "sha256:0ca9eaba9dc47171f7a042dc6753faa6c820c65ee966538f9d65fac5342202e8" - }, - { - "actual_outcome": "unsatisfiable", - "analysis_profile": "raes-finite-domain-satisfiability-v1", - "case_id": "finite-domain-unsatisfiable-v2", - "configuration_digest": "sha256:1204635e17e759e9ad3bd6be2ecb28c6de05c07ead6dfdd15936ed5d3d5b81b2", - "configuration_id": "raes-python-reference-offline-v41", - "diagnostic_kind": "scenario-satisfiability-evidence/v1", - "evidence_artifact_path": "docs/research/formal-semantic-validation/evidence/finite-domain-unsatisfiable-v4.json", - "evidence_artifact_sha256": "c972725ef64822a75a60380afc11f08eac25b7fe9b091d39b058b3c9f7c8031d", - "evidence_digest": "sha256:317b5cad00aa7f4f7868dca66127611ba19d40ffd86f35815502622814df54c1", - "evidence_profile": "scenario-satisfiability-evidence/v1", - "evidence_refs": [ - "docs/research/formal-semantic-validation/corpus/unsatisfiable-control.sdl.yaml", - "docs/research/formal-semantic-validation/evidence/finite-domain-unsatisfiable-v4.json", - "specs/formal/scenario-satisfiability/README.md" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", - "limitations": [ - "The subset-minimal core is evidence for the pinned translation and solver, not a proof certificate for arbitrary SDL." - ], - "replayable": true, - "result_digest": "sha256:317b5cad00aa7f4f7868dca66127611ba19d40ffd86f35815502622814df54c1", - "source_digest": "sha256:cfef56a1f56d5f0db9da195377fd75694bdd0f0b92932fdb8fafcbd3f7baf6c5" - }, - { - "actual_outcome": "valid-path", - "analysis_profile": "raes-exploit-path-analysis-v1", - "case_id": "typed-exploit-path-valid-v2", - "configuration_digest": "sha256:7f8876d81feb77d3a3239be2fb8337de8885e2744f8786728ba23e4e6027bc0a", - "configuration_id": "raes-python-reference-offline-v41", - "diagnostic_kind": "exploit-path-analysis-evidence/v1", - "evidence_artifact_path": "docs/research/formal-semantic-validation/evidence/typed-exploit-path-valid-v4.json", - "evidence_artifact_sha256": "1b7f55d04db172da32658187c64a88c13b5f4d565267ce2be7cb86a9d04cb70c", - "evidence_digest": "sha256:2d4d1a362751abd9544beb8af7f8c6331d04dac8f4abc315fb261f81fbaf4387", - "evidence_profile": "exploit-path-analysis-evidence/v1", - "evidence_refs": [ - "docs/research/formal-semantic-validation/corpus/exploit-path-valid-v3.json", - "docs/research/formal-semantic-validation/evidence/typed-exploit-path-valid-v4.json", - "specs/formal/exploit-path-analysis/README.md" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", - "limitations": [ - "The witness is bounded to the admitted snapshot, normalized graph, query, semantics, and search profile; it does not establish backend execution." - ], - "replayable": true, - "result_digest": "sha256:2d4d1a362751abd9544beb8af7f8c6331d04dac8f4abc315fb261f81fbaf4387", - "source_digest": "sha256:0afe635a63db5b6e6380ac70982fd61d09790745d51a10d670321304121e7c39" - }, - { - "actual_outcome": "invalid-path", - "analysis_profile": "raes-exploit-path-analysis-v1", - "case_id": "typed-exploit-path-invalid-v2", - "configuration_digest": "sha256:7f8876d81feb77d3a3239be2fb8337de8885e2744f8786728ba23e4e6027bc0a", - "configuration_id": "raes-python-reference-offline-v41", - "diagnostic_kind": "exploit-path-analysis-evidence/v1", - "evidence_artifact_path": "docs/research/formal-semantic-validation/evidence/typed-exploit-path-invalid-v4.json", - "evidence_artifact_sha256": "244f895a64f14c10916ab0533ab462ce80a328021cd6a50c30a4aa59266d5533", - "evidence_digest": "sha256:1b416bb5a4d29d57c961b769cc9d3af5d9328624e3eebf104d57f39a94c5bb97", - "evidence_profile": "exploit-path-analysis-evidence/v1", - "evidence_refs": [ - "docs/research/formal-semantic-validation/corpus/exploit-path-invalid-v3.json", - "docs/research/formal-semantic-validation/evidence/typed-exploit-path-invalid-v4.json", - "specs/formal/exploit-path-analysis/README.md" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", - "limitations": [ - "Structured rejection proves only that this bounded graph/query cannot reach its goal; it does not establish real-world non-exploitability." - ], - "replayable": true, - "result_digest": "sha256:1b416bb5a4d29d57c961b769cc9d3af5d9328624e3eebf104d57f39a94c5bb97", - "source_digest": "sha256:0b2293d4a8983515ff05c516be6e6b418a4f3f09e055250a00bf15fda861aab3" - } - ], - "participant_observations": [ - { - "evidence_refs": [ - "implementations/python/tests/test_sem_208_participant_behavior.py::test_hidden_truth_disclosure_is_separate_from_observable_projection", - "implementations/python/tests/test_sem_208_participant_behavior.py::test_hidden_truth_cannot_be_observed_without_explicit_disclosure_rule" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", - "limitations": [ - "Covers the reference SDL/contract path, not every backend projection." - ], - "negative_outcome": "passed", - "obligation_id": "hidden-vs-visible-projection", - "positive_outcome": "passed" - }, - { - "evidence_refs": [ - "implementations/python/tests/test_sem_211_participant_action_semantics.py::test_action_contract_declares_sem_211_classes_and_compiles_them", - "implementations/python/tests/test_sem_211_participant_action_semantics.py::test_action_result_rejects_success_when_preconditions_are_unresolved" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", - "limitations": [ - "Covers declared applicability and one unresolved-precondition failure." - ], - "negative_outcome": "passed", - "obligation_id": "fail-closed-action-applicability", - "positive_outcome": "passed" - }, - { - "evidence_refs": [ - "implementations/python/tests/test_run_308_concurrent_participant_execution.py::test_runtime_snapshot_publishes_joint_action_and_time_context_records", - "implementations/python/tests/test_run_308_concurrent_participant_execution.py::test_joint_action_record_contract_rejects_unordered_conflicting_writes" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", - "limitations": [ - "Contract evidence does not prove every backend's live concurrency fidelity." - ], - "negative_outcome": "passed", - "obligation_id": "shared-state-effects", - "positive_outcome": "passed" - }, - { - "evidence_refs": [ - "implementations/python/tests/test_participant_runtime_invariants.py::test_order_discipline_accepts_supported_order_claim_strengths", - "implementations/python/tests/test_participant_runtime_invariants.py::test_order_discipline_rejects_wall_clock_causality" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", - "limitations": [ - "Rejecting timestamp-only causality does not supply counterfactual proof." - ], - "negative_outcome": "passed", - "obligation_id": "ordering-before-causality", - "positive_outcome": "passed" - }, - { - "evidence_refs": [ - "implementations/python/tests/test_sem_212_participant_attribution_semantics.py::test_attribution_edge_round_trips_on_terminal_observation", - "implementations/python/tests/test_sem_212_participant_attribution_semantics.py::test_timestamp_adjacency_cannot_be_reported_as_strong_causality" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", - "limitations": [ - "Attribution labels disclose basis; they do not demonstrate necessity." - ], - "negative_outcome": "passed", - "obligation_id": "evidence-labeled-attribution", - "positive_outcome": "passed" - }, - { - "evidence_refs": [ - "implementations/python/tests/test_sem_215_participant_outcome_interpretation.py::test_outcome_interpretation_rule_parses_and_compiles_explicit_layers", - "implementations/python/tests/test_sem_215_participant_outcome_interpretation.py::test_local_action_success_does_not_imply_objective_success_without_rule_record" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", - "limitations": [ - "The fixtures establish layer separation, not outcome validity in every realization." - ], - "negative_outcome": "passed", - "obligation_id": "participant-local-outcome-separation", - "positive_outcome": "passed" - }, - { - "evidence_refs": [ - "implementations/python/tests/test_realization_honesty_conformance.py::test_constructive_envelope_runs_positive_and_negative_honesty_probes", - "implementations/python/tests/test_realization_honesty_conformance.py::test_only_native_live_can_support_native_conformance" - ], - "execution_id": "issue-1479-oci-anonymous-token-formal-d57e6b1838fd", - "limitations": [ - "Reference conformance evidence remains bounded to declared realization profiles." - ], - "negative_outcome": "passed", - "obligation_id": "realization-profile-honesty", - "positive_outcome": "passed" - } - ], - "protocol_revision": "2.0.0", - "raes_revision": "eb32f9f1aee62d1879b581aec5cb7980847ac534", - "source_state": { - "base_revision": "eb32f9f1aee62d1879b581aec5cb7980847ac534", - "checkout_state": "clean", - "implementation_digest": "d57e6b1838fd0e095a78282a3bf755e43c5c7aa0dafc4f598ba338dcf02cb1bf", - "profile": "python-reference-source/v2" - }, - "versions": { - "python": "3.12.13", - "raes": "7.0.0", - "z3_engine": "4.16.0", - "z3_solver": "4.16.0.0" - } -} diff --git a/docs/research/specification-coverage/capture-records/capture-917dcfe82f8ee8c7fda5cc4dc8f936c8ae254f68ac9da4624dbbdc8ff71da106.json b/docs/research/specification-coverage/capture-records/capture-917dcfe82f8ee8c7fda5cc4dc8f936c8ae254f68ac9da4624dbbdc8ff71da106.json deleted file mode 100644 index 422e174279..0000000000 --- a/docs/research/specification-coverage/capture-records/capture-917dcfe82f8ee8c7fda5cc4dc8f936c8ae254f68ac9da4624dbbdc8ff71da106.json +++ /dev/null @@ -1,4 +0,0 @@ -{ - "capture_path": "docs/research/specification-coverage/captures/capture-917dcfe82f8ee8c7fda5cc4dc8f936c8ae254f68ac9da4624dbbdc8ff71da106/manifest.json", - "capture_sha256": "8b69f20f0a3d94db7dccf5b867131c41e7b7ee0e672882ab87655823cc9b6fb1" -} diff --git a/docs/research/specification-coverage/capture-records/capture-aae28f85e4516ed1fe7aa76945a8b3474dad595adcd83484f0738935cb9883e5.json b/docs/research/specification-coverage/capture-records/capture-aae28f85e4516ed1fe7aa76945a8b3474dad595adcd83484f0738935cb9883e5.json deleted file mode 100644 index dd8b443ded..0000000000 --- a/docs/research/specification-coverage/capture-records/capture-aae28f85e4516ed1fe7aa76945a8b3474dad595adcd83484f0738935cb9883e5.json +++ /dev/null @@ -1,4 +0,0 @@ -{ - "capture_path": "docs/research/specification-coverage/captures/capture-aae28f85e4516ed1fe7aa76945a8b3474dad595adcd83484f0738935cb9883e5/manifest.json", - "capture_sha256": "5c2cd5c8dd87cb3872287f28457807dfe69f0bc316e1abd241e7d948df92de85" -} diff --git a/docs/research/specification-coverage/captures/capture-917dcfe82f8ee8c7fda5cc4dc8f936c8ae254f68ac9da4624dbbdc8ff71da106/analysis.json b/docs/research/specification-coverage/captures/capture-917dcfe82f8ee8c7fda5cc4dc8f936c8ae254f68ac9da4624dbbdc8ff71da106/analysis.json deleted file mode 100644 index 2cdc18fb44..0000000000 --- a/docs/research/specification-coverage/captures/capture-917dcfe82f8ee8c7fda5cc4dc8f936c8ae254f68ac9da4624dbbdc8ff71da106/analysis.json +++ /dev/null @@ -1,117 +0,0 @@ -{ - "analysis_id": "issue-1479-oci-anonymous-token-specification-analysis-d57e6b1838fd", - "backend_leakage": [], - "claim": { - "allowed_evidence": [ - "pinned source metadata and bounded paraphrases", - "production parser, semantic, instantiation, admission, compiler, contract, and profile results", - "exact artifact digests and typed pointers", - "documented missing-concept and backend-specific dispositions" - ], - "claim_id": "raes-standardized-configurable-specification-coverage", - "disallowed_evidence": [ - "field-count or schema breadth alone", - "the existing scenario stress corpus as the representative request corpus", - "free-form metadata as typed coverage", - "backend-private interpretation", - "post-hoc removal or repair of falsifying concepts" - ], - "evidence_artifacts": [ - "docs/research/specification-coverage/protocol-v1.json", - "@snapshot", - "docs/research/specification-coverage/analysis-v68.json" - ], - "falsification_protocol": "docs/research/specification-coverage/protocol-v1.json", - "objective_fail_criteria": "A load-bearing concept is missing or lossy, an applicable stage fails, or backend vocabulary is required in core SDL while the result claims success.", - "objective_pass_criteria": "Every load-bearing concept passes at every owning stage, backend-specific mechanics stay outside core SDL, and no requested concept is silently lost.", - "statement": "RAES provides a standardized configurable portable specification surface for the preregistered representative cyber-agent evaluation environment requirements without backend vocabulary in core SDL.", - "threats_to_validity": [ - "The representative corpus contains four source strata and sixteen atomic concepts rather than every cyber-range requirement.", - "The reference processor and repository fixtures are not independent backend implementations.", - "No live range, simulator federation, or participant execution was part of this offline specification-coverage test." - ] - }, - "classification_counts": { - "deliberately-backend-specific": 1, - "directly-expressible": 10, - "missing": 3, - "profile-or-manifest-constraint": 2 - }, - "evidence_status": "partial", - "execution_status": "complete", - "generated_at": "2026-10-25T08:54:08.535564+00:00", - "limitations": [ - "This result demonstrates bounded specification coverage, not universal cyber-range coverage, usability, adoption, backend substitution, or behavioral equivalence.", - "The three missing concepts are evidence, not implementation tasks within this snapshot.", - "The retained protocol does not test recursive realization or plan-level profile semantics; this release only re-establishes its original bounded coverage result against the current implementation.", - "The retained protocol does not test evidence-requirement refinement lineage; the dedicated EXP-731 regression suite covers that production boundary.", - "Authoring-adapter transport behavior is outside this retained protocol.", - "Reviewed OCI mirror and pre-seed admission is covered by its own regression suites and the development artifact policy gate, not a new claim in this preregistered matrix.", - "Operational recovery observation and startup reconciliation are covered by their API-404 regression suite, not a new claim in this preregistered matrix.", - "Store ownership, immutable runtime scope, and provider shutdown ordering are covered by the API-404 CP-5 regression suite, not by this retained specification-coverage protocol.", - "Mixed/staged trial compilation and admission are covered by issue #1015 regression tests, not by this retained specification-coverage corpus; no live mixed-runtime result is claimed.", - "Issue #1186 control-plane recovery operations are covered by their runtime regression suite, not by this retained specification-coverage corpus.", - "Issue #1187 control-plane crash/profile conformance and HTTP security changes are covered by their dedicated regression suite, not promoted to new claims by this retained corpus.", - "Issue #1189 control-plane profile declarations are covered by their dedicated runtime suite, not promoted to new claims by the retained language corpus.", - "Issue #610's reconciliation demonstration harness is covered by its dedicated processor and CLI suite, not promoted to new claims by the retained language corpus.", - "Participant identity, organization ownership, and participant assignment are separated by issue #1338. This retained offline corpus does not establish participant autonomy, execution authority, live backend fidelity, or causal attribution.", - "Participant-local outcome state is verified by the ACT-618 tests; this retained corpus makes no additional outcome-state claim.", - "Backend operation supervision contracts are covered by issue #1360 contract tests; this retained offline corpus establishes no live backend supervision or recovery guarantee.", - "This capture replays the merged issue #1360 and #1357 source; the protocol makes no live backend execution or supervision claim.", - "This capture replays the merged issue #1360 and #1358 source; the protocol makes no live backend execution or supervision claim.", - "Issue #1389 participant inject delivery temporal-subject admission is covered by dedicated compiler tests; this retained matrix makes no new timing or execution claim.", - "Issue #971 adds offline crossing model construction; this retained protocol establishes no crossing equivalence or runtime-realization claim.", - "Issue #1359 control-plane route authority, participant-view scoping, and no-store HTTP boundary are covered by their dedicated HTTP-boundary suite; this retained matrix makes no new exposure or execution claim.", - "Issue #1401 required-evidence media-type coherence is verified by its dedicated suite; this retained matrix makes no new admission or capture claim.", - "Issue #1361 execution and recovery requirements are verified by dedicated policy, composition, and admission tests; this retained corpus establishes no live recovery, continuation, or trial-allocation guarantee.", - "The issue #1361 maintainability repair preserves policy semantics and retained corpus outcomes; it establishes no live recovery, continuation, or trial-allocation guarantee.", - "The issue #1361 resource type-hint repair preserves policy semantics and retained corpus outcomes; it establishes no live recovery, continuation, or trial-allocation guarantee.", - "The combined issue #1361 execution-policy and hatchling update preserves retained outcomes and bounded claims; it establishes no live recovery, continuation, or trial-allocation guarantee.", - "The issue #1418 runtime-fact export manifest split changes no contract, schema or behavior; this retained matrix makes no new admission or coverage claim.", - "The issue #1423 inject trigger request and occurrence contracts are new draft carriers that no SDL construct, compiler or runtime path reads; this retained matrix makes no new admission or coverage claim.", - "The issue #1366 inject readback, correlation and backend declaration contracts are new draft carriers; the shared backend allowlist also lets SDL participant behavior specifications cite inject-occurrence-v1 and inject-occurrence-outcome-v1 as evidence_contract_refs, which the compiler copies through uninterpreted, and no runtime path or shipped backend reads or declares them; this retained matrix makes no new admission or coverage claim.", - "This synchronization preserves the original inject and mixed-backend captures, binds their combined source, and adds no runtime or backend-adoption claim.", - "This second synchronization adds behavior-authoring source from issue #297; prior inject and behavior-authoring captures remain preserved. No additional runtime adoption is claimed.", - "Task-contract CLI admission and optional supplied-task reference checks are covered by test_issue_1519_experiment_tasks.py; the retained research corpus makes no additional task, artifact-content, or execution claim." - ], - "load_bearing_results": { - "failed": 0, - "missing": 0, - "passed": 10, - "total": 10 - }, - "plain_language_outcome": "The retained specification matrix reproduces its classifications on the combined source of current dev and issue #1479's anonymous bearer-token flow for OCI module fetches. Bounded claims and untested concepts are unchanged.", - "protocol_revision": "1.0.0", - "request_results": [ - { - "concept_count": 6, - "failed_stage_count": 0, - "missing_count": 0, - "request_id": "survey-representative-range", - "status": "demonstrated" - }, - { - "concept_count": 5, - "failed_stage_count": 1, - "missing_count": 1, - "request_id": "cyborg-participant-evaluation", - "status": "partial" - }, - { - "concept_count": 3, - "failed_stage_count": 1, - "missing_count": 1, - "request_id": "vsdl-configurable-infrastructure", - "status": "partial" - }, - { - "concept_count": 2, - "failed_stage_count": 1, - "missing_count": 1, - "request_id": "cyber-dem-federation", - "status": "partial" - } - ], - "snapshot_id": "issue-1479-oci-anonymous-token-specification-d57e6b1838fd", - "snapshot_sha256": "0c2f9325c5954591b3e54014656c90fa37e555bd71756fd89508886438767684" -} diff --git a/docs/research/specification-coverage/captures/capture-917dcfe82f8ee8c7fda5cc4dc8f936c8ae254f68ac9da4624dbbdc8ff71da106/manifest.json b/docs/research/specification-coverage/captures/capture-917dcfe82f8ee8c7fda5cc4dc8f936c8ae254f68ac9da4624dbbdc8ff71da106/manifest.json deleted file mode 100644 index d971c341ca..0000000000 --- a/docs/research/specification-coverage/captures/capture-917dcfe82f8ee8c7fda5cc4dc8f936c8ae254f68ac9da4624dbbdc8ff71da106/manifest.json +++ /dev/null @@ -1,10 +0,0 @@ -{ - "analysis_path": "docs/research/specification-coverage/captures/capture-917dcfe82f8ee8c7fda5cc4dc8f936c8ae254f68ac9da4624dbbdc8ff71da106/analysis.json", - "analysis_sha256": "0f466024cc8f91e0b864f576459ab9c2296e9f351df35be8a59b936394099707", - "bundle_id": "raes-standardized-specification-coverage", - "protocol_path": "docs/research/specification-coverage/protocol-v1.json", - "protocol_sha256": "e97a19e643e94c9e589dca823a63c6ce49d3329fe2a3cb888ab630838ed93125", - "revision": "capture-917dcfe82f8ee8c7fda5cc4dc8f936c8ae254f68ac9da4624dbbdc8ff71da106", - "snapshot_path": "docs/research/specification-coverage/captures/capture-917dcfe82f8ee8c7fda5cc4dc8f936c8ae254f68ac9da4624dbbdc8ff71da106/snapshot.json", - "snapshot_sha256": "010e46211dde5f496e065ca75356cf433ac24428006bcc8292f3a1519025c850" -} diff --git a/docs/research/specification-coverage/captures/capture-917dcfe82f8ee8c7fda5cc4dc8f936c8ae254f68ac9da4624dbbdc8ff71da106/snapshot.json b/docs/research/specification-coverage/captures/capture-917dcfe82f8ee8c7fda5cc4dc8f936c8ae254f68ac9da4624dbbdc8ff71da106/snapshot.json deleted file mode 100644 index f7fa4c7777..0000000000 --- a/docs/research/specification-coverage/captures/capture-917dcfe82f8ee8c7fda5cc4dc8f936c8ae254f68ac9da4624dbbdc8ff71da106/snapshot.json +++ /dev/null @@ -1,705 +0,0 @@ -{ - "artifacts": [ - { - "artifact_id": "enterprise-participant-sdl", - "kind": "sdl", - "path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "sha256": "f7a8897beec243e188ee081975006fad32725f469f267db6e75a1e1cf5727032", - "validator": "raes parse, semantic, instantiation/admission, and compiler pipeline" - }, - { - "artifact_id": "port-range-sdl", - "kind": "sdl", - "path": "examples/scenarios/port-authority-surge-response.sdl.yaml", - "sha256": "0d5497ec946b863e6985284ec487dde7d7f6bf710a985be51401ac0e5e79dc4f", - "validator": "raes parse, semantic, instantiation/admission, and compiler pipeline" - }, - { - "artifact_id": "experiment-task-contract", - "kind": "experiment-task", - "path": "contracts/fixtures/experiment-core/experiment-task-v1/valid/reference.json", - "sha256": "f3edf713ac6af26bad609136851c6dd434bfb87ce919a2d8c4414c1035deeafc", - "validator": "raes_contracts.contracts.ExperimentTaskModel" - }, - { - "artifact_id": "apparatus-context-contract", - "kind": "experiment-apparatus-context", - "path": "contracts/fixtures/experiment-core/experiment-apparatus-context-v1/valid/reference.json", - "sha256": "e6fa559c5e961f0aab448d0f70dead24aa74fa8ba5f20e1b72f88e11473c9299", - "validator": "raes_contracts.contracts.ExperimentApparatusContextModel" - }, - { - "artifact_id": "backend-profile", - "kind": "backend-profile", - "path": "contracts/profiles/backend/orchestration-capable.json", - "sha256": "f70b8505a5c0055416db86c533e2e5bf08b11e5a514f076223b6d6c36215a092", - "validator": "raes_contracts.backend_profiles.BackendProfileModel" - }, - { - "artifact_id": "known-limitations", - "kind": "documentation", - "path": "docs/explain/sdl/limitations.md", - "sha256": "489eeab3ce682627682311581eb98af9abb9ff42a437145af266eefb71dc7fc4", - "validator": "documentation evidence only" - } - ], - "baseline": { - "release_revision": "1.1.0", - "release_sha256": "4020a1d56c7fe2831cec59ea64a12bbda9d38ccd94f93b916dd90f1a28f17fcb" - }, - "captured_at": "2026-10-25T08:54:08.535564+00:00", - "concept_results": [ - { - "backend_support": "not-evaluated", - "backend_vocabulary_occurrences": [], - "classification": "directly-expressible", - "completeness_disposition": "implemented", - "concept_id": "range-topology", - "rationale": "SDL nodes and infrastructure own host, network, link, and dependency meaning; the compiler emits canonical node deployment addresses.", - "stage_results": [ - { - "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", - "diagnostic_codes": [], - "note": "Typed VM declaration.", - "outcome": "passed", - "pointer": "/nodes/shipping-portal", - "stage_id": "authored", - "validation_strength": "structural" - }, - { - "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", - "diagnostic_codes": [], - "note": "Links and dependencies resolved.", - "outcome": "passed", - "pointer": "/infrastructure/shipping-portal", - "stage_id": "semantic", - "validation_strength": "semantic" - }, - { - "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", - "diagnostic_codes": [], - "note": "Published instantiated shape admitted.", - "outcome": "passed", - "pointer": "/nodes/shipping-portal", - "stage_id": "instantiated", - "validation_strength": "phase-admitted" - }, - { - "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", - "diagnostic_codes": [], - "note": "Canonical deployment address retained.", - "outcome": "passed", - "pointer": "/node_deployments/provision.node.shipping-portal", - "stage_id": "compiled", - "validation_strength": "compiled" - } - ], - "typed_pointer": "/nodes/shipping-portal" - }, - { - "backend_support": "not-evaluated", - "backend_vocabulary_occurrences": [], - "classification": "directly-expressible", - "completeness_disposition": "implemented", - "concept_id": "exercise-roles", - "rationale": "SDL entity roles own exercise responsibility without becoming control-plane identity or authorization.", - "stage_results": [ - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Typed red role.", - "outcome": "passed", - "pointer": "/entities/enterprise-participant/role", - "stage_id": "authored", - "validation_strength": "structural" - }, - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Entity references validated.", - "outcome": "passed", - "pointer": "/entities/enterprise-participant", - "stage_id": "semantic", - "validation_strength": "semantic" - }, - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Role retained after instantiation.", - "outcome": "passed", - "pointer": "/entities/enterprise-participant/role", - "stage_id": "instantiated", - "validation_strength": "phase-admitted" - }, - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Role retained in entity specification.", - "outcome": "passed", - "pointer": "/entity_specs/enterprise-participant/role", - "stage_id": "compiled", - "validation_strength": "compiled" - } - ], - "typed_pointer": "/entities/enterprise-participant/role" - }, - { - "backend_support": "not-evaluated", - "backend_vocabulary_occurrences": [], - "classification": "directly-expressible", - "completeness_disposition": "implemented", - "concept_id": "evaluation-objectives", - "rationale": "SDL objectives own organization ownership, participant assignment, targets, windows, and assertion-based success; measures remain experiment contracts.", - "stage_results": [ - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Typed objective declaration.", - "outcome": "passed", - "pointer": "/objectives/demonstrate-handoff", - "stage_id": "authored", - "validation_strength": "structural" - }, - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Owner, participant assignment, targets, assertions, and workflow refs resolved.", - "outcome": "passed", - "pointer": "/objectives/demonstrate-handoff/success", - "stage_id": "semantic", - "validation_strength": "semantic" - }, - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Objective retained in admitted artifact.", - "outcome": "passed", - "pointer": "/objectives/demonstrate-handoff", - "stage_id": "instantiated", - "validation_strength": "phase-admitted" - }, - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Canonical objective address retained.", - "outcome": "passed", - "pointer": "/objectives/evaluation.objective.demonstrate-handoff", - "stage_id": "compiled", - "validation_strength": "compiled" - } - ], - "typed_pointer": "/objectives/demonstrate-handoff" - }, - { - "backend_support": "not-evaluated", - "backend_vocabulary_occurrences": [], - "classification": "directly-expressible", - "completeness_disposition": "implemented", - "concept_id": "control-workflows", - "rationale": "SDL workflows own the portable control graph and compile to canonical orchestration state contracts.", - "stage_results": [ - { - "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", - "diagnostic_codes": [], - "note": "Typed control graph.", - "outcome": "passed", - "pointer": "/workflows/yard-recovery", - "stage_id": "authored", - "validation_strength": "structural" - }, - { - "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", - "diagnostic_codes": [], - "note": "Step graph and objective refs validated.", - "outcome": "passed", - "pointer": "/workflows/yard-recovery/steps", - "stage_id": "semantic", - "validation_strength": "semantic" - }, - { - "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", - "diagnostic_codes": [], - "note": "Workflow retained after instantiation.", - "outcome": "passed", - "pointer": "/workflows/yard-recovery", - "stage_id": "instantiated", - "validation_strength": "phase-admitted" - }, - { - "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", - "diagnostic_codes": [], - "note": "Canonical control graph retained.", - "outcome": "passed", - "pointer": "/workflows/orchestration.workflow.yard-recovery", - "stage_id": "compiled", - "validation_strength": "compiled" - } - ], - "typed_pointer": "/workflows/yard-recovery" - }, - { - "backend_support": "not-evaluated", - "backend_vocabulary_occurrences": [], - "classification": "directly-expressible", - "completeness_disposition": "implemented", - "concept_id": "authored-evidence-expectations", - "rationale": "SDL evidence requirements own portable capture intent and remain distinct from evidence records and measures.", - "stage_results": [ - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Typed capture obligation.", - "outcome": "passed", - "pointer": "/evidence_requirements/objective-truth-evidence", - "stage_id": "authored", - "validation_strength": "structural" - }, - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Source refs and bindings validated.", - "outcome": "passed", - "pointer": "/evidence_requirements/objective-truth-evidence", - "stage_id": "semantic", - "validation_strength": "semantic" - }, - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Evidence intent retained in admitted artifact.", - "outcome": "passed", - "pointer": "/evidence_requirements/objective-truth-evidence", - "stage_id": "instantiated", - "validation_strength": "phase-admitted" - } - ], - "typed_pointer": "/evidence_requirements/objective-truth-evidence" - }, - { - "backend_support": "profile-bound", - "backend_vocabulary_occurrences": [], - "classification": "profile-or-manifest-constraint", - "completeness_disposition": "implemented", - "concept_id": "apparatus-selection-constraints", - "rationale": "The experiment task contract binds processor/backend identities, manifest refs, and capabilities outside SDL.", - "stage_results": [ - { - "artifact_path": "contracts/fixtures/experiment-core/experiment-task-v1/valid/reference.json", - "diagnostic_codes": [], - "note": "Closed ExperimentTaskModel validated.", - "outcome": "passed", - "pointer": "/apparatus_constraints/allowed_backend_refs/0", - "stage_id": "contract", - "validation_strength": "contract" - } - ], - "typed_pointer": "/apparatus_constraints/allowed_backend_refs/0" - }, - { - "backend_support": "not-evaluated", - "backend_vocabulary_occurrences": [], - "classification": "directly-expressible", - "completeness_disposition": "implemented", - "concept_id": "participant-agent", - "rationale": "SDL agents own participant entity, knowledge, actions, observation boundaries, and operating scope.", - "stage_results": [ - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Typed participant declaration.", - "outcome": "passed", - "pointer": "/agents/participant-agent", - "stage_id": "authored", - "validation_strength": "structural" - }, - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Participant refs and scope validated.", - "outcome": "passed", - "pointer": "/agents/participant-agent/observation_boundaries", - "stage_id": "semantic", - "validation_strength": "semantic" - }, - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Participant retained in admitted artifact.", - "outcome": "passed", - "pointer": "/agents/participant-agent", - "stage_id": "instantiated", - "validation_strength": "phase-admitted" - }, - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Compiled participant scope retained.", - "outcome": "passed", - "pointer": "/agent_specs/participant-agent", - "stage_id": "compiled", - "validation_strength": "compiled" - } - ], - "typed_pointer": "/agents/participant-agent" - }, - { - "backend_support": "not-evaluated", - "backend_vocabulary_occurrences": [], - "classification": "directly-expressible", - "completeness_disposition": "implemented", - "concept_id": "participant-action-contract", - "rationale": "The action contract declares portable preconditions, effects, observations, evidence, and failure classes without a runner command.", - "stage_results": [ - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Typed action contract.", - "outcome": "passed", - "pointer": "/action_contracts/probe-customer-portal-login", - "stage_id": "authored", - "validation_strength": "structural" - }, - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Action refs and evidence bindings validated.", - "outcome": "passed", - "pointer": "/action_contracts/probe-customer-portal-login/effects", - "stage_id": "semantic", - "validation_strength": "semantic" - }, - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Action retained in admitted artifact.", - "outcome": "passed", - "pointer": "/action_contracts/probe-customer-portal-login", - "stage_id": "instantiated", - "validation_strength": "phase-admitted" - }, - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Canonical action address retained.", - "outcome": "passed", - "pointer": "/action_contracts/participant.action-contract.probe-customer-portal-login", - "stage_id": "compiled", - "validation_strength": "compiled" - } - ], - "typed_pointer": "/action_contracts/probe-customer-portal-login" - }, - { - "backend_support": "not-evaluated", - "backend_vocabulary_occurrences": [], - "classification": "directly-expressible", - "completeness_disposition": "implemented", - "concept_id": "participant-observation-boundary", - "rationale": "The observation boundary separately declares visible, hidden, and evidence-only information with transition rules.", - "stage_results": [ - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Typed observation boundary.", - "outcome": "passed", - "pointer": "/observation_boundaries/participant-view", - "stage_id": "authored", - "validation_strength": "structural" - }, - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Information refs and transitions validated.", - "outcome": "passed", - "pointer": "/observation_boundaries/participant-view/view_rules", - "stage_id": "semantic", - "validation_strength": "semantic" - }, - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Boundary retained in admitted artifact.", - "outcome": "passed", - "pointer": "/observation_boundaries/participant-view", - "stage_id": "instantiated", - "validation_strength": "phase-admitted" - }, - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Canonical boundary address retained.", - "outcome": "passed", - "pointer": "/observation_boundaries/participant.observation-boundary.participant-view", - "stage_id": "compiled", - "validation_strength": "compiled" - } - ], - "typed_pointer": "/observation_boundaries/participant-view" - }, - { - "backend_support": "not-evaluated", - "backend_vocabulary_occurrences": [], - "classification": "directly-expressible", - "completeness_disposition": "implemented", - "concept_id": "evaluation-measure", - "rationale": "ExperimentTaskModel owns metric construct, unit, direction, aggregation, and evidence requirements outside SDL objectives.", - "stage_results": [ - { - "artifact_path": "contracts/fixtures/experiment-core/experiment-task-v1/valid/reference.json", - "diagnostic_codes": [], - "note": "Closed task contract validated.", - "outcome": "passed", - "pointer": "/evaluation_protocol/metric_definitions/foothold-achieved", - "stage_id": "contract", - "validation_strength": "contract" - } - ], - "typed_pointer": "/evaluation_protocol/metric_definitions/foothold-achieved" - }, - { - "backend_support": "not-evaluated", - "backend_vocabulary_occurrences": [], - "classification": "missing", - "completeness_disposition": "documented-gap", - "concept_id": "participant-tool-affordance", - "rationale": "This preregistered matrix has no tested carrier for participant tool affordances. The retained missing classification records missing coverage evidence, not the absence of current participant-behavior capabilities.", - "stage_results": [ - { - "artifact_path": "docs/explain/sdl/limitations.md", - "diagnostic_codes": [], - "note": "The preregistered carrier slot was not run; metadata does not substitute for a typed coverage test.", - "outcome": "not_run", - "pointer": null, - "stage_id": "authored", - "validation_strength": "not-applicable" - } - ], - "typed_pointer": null - }, - { - "backend_support": "not-evaluated", - "backend_vocabulary_occurrences": [], - "classification": "directly-expressible", - "completeness_disposition": "implemented", - "concept_id": "resource-constrained-topology", - "rationale": "SDL node resources and infrastructure dependencies express portable resource intent without provider resource identifiers.", - "stage_results": [ - { - "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", - "diagnostic_codes": [], - "note": "Typed CPU and memory declaration.", - "outcome": "passed", - "pointer": "/nodes/shipping-portal/resources", - "stage_id": "authored", - "validation_strength": "structural" - }, - { - "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", - "diagnostic_codes": [], - "note": "Resource-bearing topology validated.", - "outcome": "passed", - "pointer": "/infrastructure/shipping-portal", - "stage_id": "semantic", - "validation_strength": "semantic" - }, - { - "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", - "diagnostic_codes": [], - "note": "Constraints retained in admitted artifact.", - "outcome": "passed", - "pointer": "/nodes/shipping-portal/resources", - "stage_id": "instantiated", - "validation_strength": "phase-admitted" - }, - { - "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", - "diagnostic_codes": [], - "note": "Deployment specification retains resource intent.", - "outcome": "passed", - "pointer": "/node_deployments/provision.node.shipping-portal", - "stage_id": "compiled", - "validation_strength": "compiled" - } - ], - "typed_pointer": "/nodes/shipping-portal/resources" - }, - { - "backend_support": "not-evaluated", - "backend_vocabulary_occurrences": [], - "classification": "missing", - "completeness_disposition": "documented-gap", - "concept_id": "formal-constraint-satisfiability", - "rationale": "This coverage matrix did not exercise a solver-backed carrier. The separate formal-semantic-validation release demonstrates its bounded finite-domain profile; that result is not silently imported into this protocol's missing carrier slot.", - "stage_results": [ - { - "artifact_path": "docs/explain/sdl/limitations.md", - "diagnostic_codes": [], - "note": "No coverage-carrier execution was performed here; independent solver evidence does not change this preregistered denominator.", - "outcome": "not_run", - "pointer": null, - "stage_id": "semantic", - "validation_strength": "not-applicable" - } - ], - "typed_pointer": null - }, - { - "backend_support": "profile-bound", - "backend_vocabulary_occurrences": [ - { - "allowed": true, - "artifact_path": "source:vsdl-paper", - "pointer": "source sections 4-5", - "reason": "Legitimate VSDL realization vocabulary, not RAES core SDL structure.", - "term": "OpenStack/Terraform/Packer" - } - ], - "classification": "deliberately-backend-specific", - "completeness_disposition": "external", - "concept_id": "provider-specific-provisioning", - "rationale": "Provider image selection and provisioning engines are realization mechanics and therefore remain outside core SDL.", - "stage_results": [ - { - "artifact_path": "contracts/profiles/backend/orchestration-capable.json", - "diagnostic_codes": [], - "note": "The portable boundary requires backend contracts; it does not standardize a provider engine.", - "outcome": "not_applicable", - "pointer": "/required_contracts", - "stage_id": "realization-disclosure", - "validation_strength": "profile" - } - ], - "typed_pointer": null - }, - { - "backend_support": "profile-bound", - "backend_vocabulary_occurrences": [], - "classification": "profile-or-manifest-constraint", - "completeness_disposition": "implemented", - "concept_id": "apparatus-clock-context", - "rationale": "ExperimentApparatusContextModel records clock authority, time domain, and synchronization as apparatus facts outside scenario meaning.", - "stage_results": [ - { - "artifact_path": "contracts/fixtures/experiment-core/experiment-apparatus-context-v1/valid/reference.json", - "diagnostic_codes": [], - "note": "Closed apparatus context contract validated.", - "outcome": "passed", - "pointer": "/clocks/0", - "stage_id": "contract", - "validation_strength": "contract" - } - ], - "typed_pointer": "/clocks/0" - }, - { - "backend_support": "not-evaluated", - "backend_vocabulary_occurrences": [], - "classification": "missing", - "completeness_disposition": "documented-gap", - "concept_id": "federated-object-event-exchange", - "rationale": "The federated cyber object/event exchange carrier was not exercised by this preregistered matrix. Runtime event internals are not treated as equivalent evidence.", - "stage_results": [ - { - "artifact_path": "docs/explain/sdl/limitations.md", - "diagnostic_codes": [], - "note": "The missing coverage-carrier test is recorded explicitly, without inferring an ecosystem-wide capability absence.", - "outcome": "not_run", - "pointer": null, - "stage_id": "contract", - "validation_strength": "not-applicable" - } - ], - "typed_pointer": null - } - ], - "deviations": [ - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "baseline_sha256": "54ba1a60220e27a55da9cd2a407d7d3ab836fa54460d0b0c6cad87c2e744ddbb", - "rationale": "Migrate participant affiliations and explicit objective assignment, retaining organizational intent and portable action-contract declarations without granting execution authority.", - "retest_sha256": "f7a8897beec243e188ee081975006fad32725f469f267db6e75a1e1cf5727032" - }, - { - "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", - "baseline_sha256": "a27c7a64e0c5c618fadaccafdf1a4e71600170a8b77b983190822b5141f00dec", - "rationale": "Migrate participant affiliations and explicit objective assignment, retaining organizational intent and portable action-contract declarations without granting execution authority.", - "retest_sha256": "0d5497ec946b863e6985284ec487dde7d7f6bf710a985be51401ac0e5e79dc4f" - }, - { - "artifact_path": "contracts/fixtures/experiment-core/experiment-task-v1/valid/reference.json", - "baseline_sha256": "21952a752f4e8581a9fc3b872e4bc308150548170d38bcfc83dbbe35ff5e0b9f", - "rationale": "Replay the retained preregistered artifact against the current evidence-provenance validation implementation.", - "retest_sha256": "f3edf713ac6af26bad609136851c6dd434bfb87ce919a2d8c4414c1035deeafc" - }, - { - "artifact_path": "contracts/fixtures/experiment-core/experiment-apparatus-context-v1/valid/reference.json", - "baseline_sha256": "9536d897a09cbc6920e667e4f8f9371e51307aa0b3b5ff3c7de682dd783420ab", - "rationale": "Replay the retained preregistered artifact against the current evidence-provenance validation implementation.", - "retest_sha256": "e6fa559c5e961f0aab448d0f70dead24aa74fa8ba5f20e1b72f88e11473c9299" - }, - { - "artifact_path": "docs/explain/sdl/limitations.md", - "baseline_sha256": "129cf17810aad4c51988bc872e28fe43ae95019a80053c42d800ff7e2b9cc93e", - "rationale": "Correct historical mandatory-profile guidance after issue #1207; retain the preregistered missing-concept classifications and coverage limits.", - "retest_sha256": "489eeab3ce682627682311581eb98af9abb9ff42a437145af266eefb71dc7fc4" - } - ], - "execution_status": "complete", - "implementation_surfaces": [ - { - "content_sha256": "87140df77ef39187fe1d847f325acba77295c82d2174bdc4275123970fe0d6c2", - "path": "implementations/python/packages/raes_contracts", - "surface_id": "contract-models" - }, - { - "content_sha256": "6507070e975b1b3210c2bae67aa05d5543f5e722eac87f6b07f4a987ebcbcfff", - "path": "implementations/python/packages/raes_processor", - "surface_id": "processor-pipeline" - }, - { - "content_sha256": "a92ad2182019386dad1e87e03c20d4361c0b0bedd5cdc209788ca3c10a29f9fb", - "path": "implementations/python/packages/raes", - "surface_id": "sdl-pipeline" - } - ], - "limitations": [ - "The execution validates the pinned reference implementation and published contracts, not an independent backend.", - "Repository-owned examples are exact execution artifacts but are not themselves the literature-derived request corpus; the protocol's requests and concepts are.", - "No live range, participant, simulator federation, or provider provisioning engine was executed.", - "Missing concepts remain frozen in this snapshot and require separately scoped product work before a later rerun.", - "This capture replays the retained protocol after EXP-732 run, apparatus, measurement-channel, and augmentation-producer provenance validation; it adds no independent backend or universal provenance assurance claim.", - "Materialization attestation is covered by its dedicated regression suite, not a new claim in this preregistered matrix.", - "This capture refreshes the corrected runtime limitations prose for issue #959; the protocol, coverage classifications and implementation source are unchanged.", - "This capture replays open-by-default augmentation scope integrated with the EXP-731 evidence refinements after composition type refinement; it does not evaluate native backend scope enforcement or broaden the preregistered coverage claims.", - "This capture replays the retained protocol after merging ACT-612 participant relationships with open-by-default augmentation scope; it adds no claim of realized participant relationships or native backend scope enforcement.", - "This capture replays issue #1299 partial listener descriptions on the integrated source state; endpoint completeness and backend admission remain outside this protocol's claims.", - "This capture also binds authoring-adapter semantic conformance to the integrated source; adapter transport behavior remains outside this protocol's claims.", - "Reviewed OCI mirror and pre-seed admission is covered by its own regression suites and the development artifact policy gate, not a new claim in this preregistered matrix.", - "This capture binds issue #1297 service-manager identity, native-name, and explicitly selected systemd-state contract changes to the integrated source. It exercises no live service manager and adds no backend-execution claim.", - "This capture replays the retained specification-coverage protocol after API-404 startup reconciliation added an operational recovery-observation contract. It does not evaluate crash recovery, classify provider effects, or broaden EXP-715 experiment-observation claims.", - "This capture binds API-404 single-owner store admission and immutable target/run scope to the integrated source. The retained offline protocol does not exercise process leases, SQLite lifecycle ordering, or crash recovery.", - "This capture binds issue #1015 deterministic mixed and staged trial admission to the integrated source. The retained offline language corpus does not execute mixed runtimes, phase transitions, backend handoff, or scheduler-driven realization.", - "This replay binds issue #1186 offline control-plane maintenance, readiness, and bounded audit code to the integrated source. The retained language corpus does not execute store recovery, HTTP health behavior, or audit redaction.", - "Issue #1187 control-plane crash/profile conformance and HTTP security changes are covered by their dedicated regression suite, not promoted to new claims by this retained corpus.", - "Issue #1189 control-plane profile declarations are covered by their dedicated runtime suite, not promoted to new claims by the retained language corpus.", - "Issue #1016 mixed-runtime coordination is covered by its dedicated runtime suite. The retained language corpus does not execute mixed providers or establish backend-native realization, multi-controller coordination, IFC, or equivalence.", - "Issue #610's reconciliation demonstration harness is covered by its dedicated processor and CLI suite, not promoted to new claims by the retained language corpus.", - "Participant identity, organization ownership, and participant assignment are separated by issue #1338. This retained offline corpus does not establish participant autonomy, execution authority, live backend fidelity, or causal attribution.", - "Issue #1361 execution and recovery requirements are verified by dedicated policy, composition, and admission tests; this retained corpus establishes no live recovery, continuation, or trial-allocation guarantee.", - "The issue #1361 maintainability repair preserves policy semantics and retained corpus outcomes; it establishes no live recovery, continuation, or trial-allocation guarantee.", - "The issue #1361 resource type-hint repair preserves policy semantics and retained corpus outcomes; it establishes no live recovery, continuation, or trial-allocation guarantee.", - "The combined issue #1361 execution-policy and hatchling update preserves retained outcomes and bounded claims; it establishes no live recovery, continuation, or trial-allocation guarantee.", - "Fresh bounded replay after issue #967 removed the bundled concrete backends and merged the issue #1396 and #1368 source; this retained protocol adds no backend realization claim." - ], - "protocol_revision": "1.0.0", - "protocol_sha256": "e97a19e643e94c9e589dca823a63c6ce49d3329fe2a3cb888ab630838ed93125", - "raes_revision": "eb32f9f1aee62d1879b581aec5cb7980847ac534", - "snapshot_id": "issue-1479-oci-anonymous-token-specification-d57e6b1838fd", - "snapshot_revision": "1.0.0", - "source_state": { - "base_revision": "eb32f9f1aee62d1879b581aec5cb7980847ac534", - "checkout_state": "clean", - "implementation_digest": "d57e6b1838fd0e095a78282a3bf755e43c5c7aa0dafc4f598ba338dcf02cb1bf", - "profile": "python-reference-source/v2" - } -} diff --git a/docs/research/specification-coverage/captures/capture-aae28f85e4516ed1fe7aa76945a8b3474dad595adcd83484f0738935cb9883e5/analysis.json b/docs/research/specification-coverage/captures/capture-aae28f85e4516ed1fe7aa76945a8b3474dad595adcd83484f0738935cb9883e5/analysis.json deleted file mode 100644 index 31c46c1b9a..0000000000 --- a/docs/research/specification-coverage/captures/capture-aae28f85e4516ed1fe7aa76945a8b3474dad595adcd83484f0738935cb9883e5/analysis.json +++ /dev/null @@ -1,118 +0,0 @@ -{ - "analysis_id": "issue-1479-oci-anonymous-token-specification-analysis-bee18848d137", - "backend_leakage": [], - "claim": { - "allowed_evidence": [ - "pinned source metadata and bounded paraphrases", - "production parser, semantic, instantiation, admission, compiler, contract, and profile results", - "exact artifact digests and typed pointers", - "documented missing-concept and backend-specific dispositions" - ], - "claim_id": "raes-standardized-configurable-specification-coverage", - "disallowed_evidence": [ - "field-count or schema breadth alone", - "the existing scenario stress corpus as the representative request corpus", - "free-form metadata as typed coverage", - "backend-private interpretation", - "post-hoc removal or repair of falsifying concepts" - ], - "evidence_artifacts": [ - "docs/research/specification-coverage/protocol-v1.json", - "@snapshot" - ], - "falsification_protocol": "docs/research/specification-coverage/protocol-v1.json", - "objective_fail_criteria": "A load-bearing concept is missing or lossy, an applicable stage fails, or backend vocabulary is required in core SDL while the result claims success.", - "objective_pass_criteria": "Every load-bearing concept passes at every owning stage, backend-specific mechanics stay outside core SDL, and no requested concept is silently lost.", - "statement": "RAES provides a standardized configurable portable specification surface for the preregistered representative cyber-agent evaluation environment requirements without backend vocabulary in core SDL.", - "threats_to_validity": [ - "The representative corpus contains four source strata and sixteen atomic concepts rather than every cyber-range requirement.", - "The reference processor and repository fixtures are not independent backend implementations.", - "No live range, simulator federation, or participant execution was part of this offline specification-coverage test." - ] - }, - "classification_counts": { - "deliberately-backend-specific": 1, - "directly-expressible": 10, - "missing": 3, - "profile-or-manifest-constraint": 2 - }, - "evidence_status": "partial", - "execution_status": "complete", - "generated_at": "2026-10-13T21:31:14.361582+00:00", - "limitations": [ - "This result demonstrates bounded specification coverage, not universal cyber-range coverage, usability, adoption, backend substitution, or behavioral equivalence.", - "The three missing concepts are evidence, not implementation tasks within this snapshot.", - "The retained protocol does not test recursive realization or plan-level profile semantics; this release only re-establishes its original bounded coverage result against the current implementation.", - "The retained protocol does not test evidence-requirement refinement lineage; the dedicated EXP-731 regression suite covers that production boundary.", - "Authoring-adapter transport behavior is outside this retained protocol.", - "Reviewed OCI mirror and pre-seed admission is covered by its own regression suites and the development artifact policy gate, not a new claim in this preregistered matrix.", - "Operational recovery observation and startup reconciliation are covered by their API-404 regression suite, not a new claim in this preregistered matrix.", - "Store ownership, immutable runtime scope, and provider shutdown ordering are covered by the API-404 CP-5 regression suite, not by this retained specification-coverage protocol.", - "Mixed/staged trial compilation and admission are covered by issue #1015 regression tests, not by this retained specification-coverage corpus; no live mixed-runtime result is claimed.", - "Issue #1186 control-plane recovery operations are covered by their runtime regression suite, not by this retained specification-coverage corpus.", - "Issue #1187 control-plane crash/profile conformance and HTTP security changes are covered by their dedicated regression suite, not promoted to new claims by this retained corpus.", - "Issue #1189 control-plane profile declarations are covered by their dedicated runtime suite, not promoted to new claims by the retained language corpus.", - "Issue #610's reconciliation demonstration harness is covered by its dedicated processor and CLI suite, not promoted to new claims by the retained language corpus.", - "Participant identity, organization ownership, and participant assignment are separated by issue #1338. This retained offline corpus does not establish participant autonomy, execution authority, live backend fidelity, or causal attribution.", - "Participant-local outcome state is verified by the ACT-618 tests; this retained corpus makes no additional outcome-state claim.", - "Backend operation supervision contracts are covered by issue #1360 contract tests; this retained offline corpus establishes no live backend supervision or recovery guarantee.", - "This capture replays the merged issue #1360 and #1357 source; the protocol makes no live backend execution or supervision claim.", - "This capture replays the merged issue #1360 and #1358 source; the protocol makes no live backend execution or supervision claim.", - "Issue #1389 participant inject delivery temporal-subject admission is covered by dedicated compiler tests; this retained matrix makes no new timing or execution claim.", - "Issue #971 adds offline crossing model construction; this retained protocol establishes no crossing equivalence or runtime-realization claim.", - "Issue #1359 control-plane route authority, participant-view scoping, and no-store HTTP boundary are covered by their dedicated HTTP-boundary suite; this retained matrix makes no new exposure or execution claim.", - "Issue #1401 required-evidence media-type coherence is verified by its dedicated suite; this retained matrix makes no new admission or capture claim.", - "Issue #1361 execution and recovery requirements are verified by dedicated policy, composition, and admission tests; this retained corpus establishes no live recovery, continuation, or trial-allocation guarantee.", - "The issue #1361 maintainability repair preserves policy semantics and retained corpus outcomes; it establishes no live recovery, continuation, or trial-allocation guarantee.", - "The issue #1361 resource type-hint repair preserves policy semantics and retained corpus outcomes; it establishes no live recovery, continuation, or trial-allocation guarantee.", - "The combined issue #1361 execution-policy and hatchling update preserves retained outcomes and bounded claims; it establishes no live recovery, continuation, or trial-allocation guarantee.", - "The issue #1418 runtime-fact export manifest split changes no contract, schema or behavior; this retained matrix makes no new admission or coverage claim.", - "The issue #1423 inject trigger request and occurrence contracts are new draft carriers that no SDL construct, compiler or runtime path reads; this retained matrix makes no new admission or coverage claim.", - "The issue #1366 inject readback, correlation and backend declaration contracts are new draft carriers; the shared backend allowlist also lets SDL participant behavior specifications cite inject-occurrence-v1 and inject-occurrence-outcome-v1 as evidence_contract_refs, which the compiler copies through uninterpreted, and no runtime path or shipped backend reads or declares them; this retained matrix makes no new admission or coverage claim.", - "This synchronization preserves the original inject and mixed-backend captures, binds their combined source, and adds no runtime or backend-adoption claim.", - "This second synchronization adds behavior-authoring source from issue #297; prior inject and behavior-authoring captures remain preserved. No additional runtime adoption is claimed.", - "Issue #1091 request-boundary admission is verified by its dedicated tests; this retained corpus does not execute the served HTTP adapter or broaden its bounded claims.", - "Issue #1395 adds a separate bounded two-operation crossing model profile. This retained corpus does not establish participant-crossing equivalence or runtime realization; those assurances remain separate.", - "Issue #1479 fetches OCI modules from public registries through the distribution anonymous bearer-token flow; this retained corpus makes no new claim." - ], - "load_bearing_results": { - "failed": 0, - "missing": 0, - "passed": 10, - "total": 10 - }, - "plain_language_outcome": "The retained specification matrix reproduces its classifications after issue #1479 added the anonymous bearer-token flow to OCI module fetches. Bounded claims and untested concepts are unchanged.", - "protocol_revision": "1.0.0", - "request_results": [ - { - "concept_count": 6, - "failed_stage_count": 0, - "missing_count": 0, - "request_id": "survey-representative-range", - "status": "demonstrated" - }, - { - "concept_count": 5, - "failed_stage_count": 1, - "missing_count": 1, - "request_id": "cyborg-participant-evaluation", - "status": "partial" - }, - { - "concept_count": 3, - "failed_stage_count": 1, - "missing_count": 1, - "request_id": "vsdl-configurable-infrastructure", - "status": "partial" - }, - { - "concept_count": 2, - "failed_stage_count": 1, - "missing_count": 1, - "request_id": "cyber-dem-federation", - "status": "partial" - } - ], - "snapshot_id": "issue-1479-oci-anonymous-token-specification-bee18848d137", - "snapshot_sha256": "373339f30461ebe2e2839eb2aa6d024d9eebbc26c14244a92864f4356d2fbbc0" -} diff --git a/docs/research/specification-coverage/captures/capture-aae28f85e4516ed1fe7aa76945a8b3474dad595adcd83484f0738935cb9883e5/manifest.json b/docs/research/specification-coverage/captures/capture-aae28f85e4516ed1fe7aa76945a8b3474dad595adcd83484f0738935cb9883e5/manifest.json deleted file mode 100644 index a9d21de142..0000000000 --- a/docs/research/specification-coverage/captures/capture-aae28f85e4516ed1fe7aa76945a8b3474dad595adcd83484f0738935cb9883e5/manifest.json +++ /dev/null @@ -1,10 +0,0 @@ -{ - "analysis_path": "docs/research/specification-coverage/captures/capture-aae28f85e4516ed1fe7aa76945a8b3474dad595adcd83484f0738935cb9883e5/analysis.json", - "analysis_sha256": "dd5d4467a1c6fa0ef080bc7a9b17d3927ff89d1680b63d7f359e152fb07d4ce5", - "bundle_id": "raes-standardized-specification-coverage", - "protocol_path": "docs/research/specification-coverage/protocol-v1.json", - "protocol_sha256": "e97a19e643e94c9e589dca823a63c6ce49d3329fe2a3cb888ab630838ed93125", - "revision": "capture-aae28f85e4516ed1fe7aa76945a8b3474dad595adcd83484f0738935cb9883e5", - "snapshot_path": "docs/research/specification-coverage/captures/capture-aae28f85e4516ed1fe7aa76945a8b3474dad595adcd83484f0738935cb9883e5/snapshot.json", - "snapshot_sha256": "e97582c266c17ec04b051381565b81ad0e4773ffe1bf6c9ce02810b19c33e6d3" -} diff --git a/docs/research/specification-coverage/captures/capture-aae28f85e4516ed1fe7aa76945a8b3474dad595adcd83484f0738935cb9883e5/snapshot.json b/docs/research/specification-coverage/captures/capture-aae28f85e4516ed1fe7aa76945a8b3474dad595adcd83484f0738935cb9883e5/snapshot.json deleted file mode 100644 index eaf01e3f37..0000000000 --- a/docs/research/specification-coverage/captures/capture-aae28f85e4516ed1fe7aa76945a8b3474dad595adcd83484f0738935cb9883e5/snapshot.json +++ /dev/null @@ -1,708 +0,0 @@ -{ - "artifacts": [ - { - "artifact_id": "enterprise-participant-sdl", - "kind": "sdl", - "path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "sha256": "f7a8897beec243e188ee081975006fad32725f469f267db6e75a1e1cf5727032", - "validator": "raes parse, semantic, instantiation/admission, and compiler pipeline" - }, - { - "artifact_id": "port-range-sdl", - "kind": "sdl", - "path": "examples/scenarios/port-authority-surge-response.sdl.yaml", - "sha256": "0d5497ec946b863e6985284ec487dde7d7f6bf710a985be51401ac0e5e79dc4f", - "validator": "raes parse, semantic, instantiation/admission, and compiler pipeline" - }, - { - "artifact_id": "experiment-task-contract", - "kind": "experiment-task", - "path": "contracts/fixtures/experiment-core/experiment-task-v1/valid/reference.json", - "sha256": "f3edf713ac6af26bad609136851c6dd434bfb87ce919a2d8c4414c1035deeafc", - "validator": "raes_contracts.contracts.ExperimentTaskModel" - }, - { - "artifact_id": "apparatus-context-contract", - "kind": "experiment-apparatus-context", - "path": "contracts/fixtures/experiment-core/experiment-apparatus-context-v1/valid/reference.json", - "sha256": "e6fa559c5e961f0aab448d0f70dead24aa74fa8ba5f20e1b72f88e11473c9299", - "validator": "raes_contracts.contracts.ExperimentApparatusContextModel" - }, - { - "artifact_id": "backend-profile", - "kind": "backend-profile", - "path": "contracts/profiles/backend/orchestration-capable.json", - "sha256": "f70b8505a5c0055416db86c533e2e5bf08b11e5a514f076223b6d6c36215a092", - "validator": "raes_contracts.backend_profiles.BackendProfileModel" - }, - { - "artifact_id": "known-limitations", - "kind": "documentation", - "path": "docs/explain/sdl/limitations.md", - "sha256": "489eeab3ce682627682311581eb98af9abb9ff42a437145af266eefb71dc7fc4", - "validator": "documentation evidence only" - } - ], - "baseline": { - "release_revision": "1.1.0", - "release_sha256": "4020a1d56c7fe2831cec59ea64a12bbda9d38ccd94f93b916dd90f1a28f17fcb" - }, - "captured_at": "2026-10-13T21:31:14.361582+00:00", - "concept_results": [ - { - "backend_support": "not-evaluated", - "backend_vocabulary_occurrences": [], - "classification": "directly-expressible", - "completeness_disposition": "implemented", - "concept_id": "range-topology", - "rationale": "SDL nodes and infrastructure own host, network, link, and dependency meaning; the compiler emits canonical node deployment addresses.", - "stage_results": [ - { - "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", - "diagnostic_codes": [], - "note": "Typed VM declaration.", - "outcome": "passed", - "pointer": "/nodes/shipping-portal", - "stage_id": "authored", - "validation_strength": "structural" - }, - { - "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", - "diagnostic_codes": [], - "note": "Links and dependencies resolved.", - "outcome": "passed", - "pointer": "/infrastructure/shipping-portal", - "stage_id": "semantic", - "validation_strength": "semantic" - }, - { - "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", - "diagnostic_codes": [], - "note": "Published instantiated shape admitted.", - "outcome": "passed", - "pointer": "/nodes/shipping-portal", - "stage_id": "instantiated", - "validation_strength": "phase-admitted" - }, - { - "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", - "diagnostic_codes": [], - "note": "Canonical deployment address retained.", - "outcome": "passed", - "pointer": "/node_deployments/provision.node.shipping-portal", - "stage_id": "compiled", - "validation_strength": "compiled" - } - ], - "typed_pointer": "/nodes/shipping-portal" - }, - { - "backend_support": "not-evaluated", - "backend_vocabulary_occurrences": [], - "classification": "directly-expressible", - "completeness_disposition": "implemented", - "concept_id": "exercise-roles", - "rationale": "SDL entity roles own exercise responsibility without becoming control-plane identity or authorization.", - "stage_results": [ - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Typed red role.", - "outcome": "passed", - "pointer": "/entities/enterprise-participant/role", - "stage_id": "authored", - "validation_strength": "structural" - }, - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Entity references validated.", - "outcome": "passed", - "pointer": "/entities/enterprise-participant", - "stage_id": "semantic", - "validation_strength": "semantic" - }, - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Role retained after instantiation.", - "outcome": "passed", - "pointer": "/entities/enterprise-participant/role", - "stage_id": "instantiated", - "validation_strength": "phase-admitted" - }, - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Role retained in entity specification.", - "outcome": "passed", - "pointer": "/entity_specs/enterprise-participant/role", - "stage_id": "compiled", - "validation_strength": "compiled" - } - ], - "typed_pointer": "/entities/enterprise-participant/role" - }, - { - "backend_support": "not-evaluated", - "backend_vocabulary_occurrences": [], - "classification": "directly-expressible", - "completeness_disposition": "implemented", - "concept_id": "evaluation-objectives", - "rationale": "SDL objectives own organization ownership, participant assignment, targets, windows, and assertion-based success; measures remain experiment contracts.", - "stage_results": [ - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Typed objective declaration.", - "outcome": "passed", - "pointer": "/objectives/demonstrate-handoff", - "stage_id": "authored", - "validation_strength": "structural" - }, - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Owner, participant assignment, targets, assertions, and workflow refs resolved.", - "outcome": "passed", - "pointer": "/objectives/demonstrate-handoff/success", - "stage_id": "semantic", - "validation_strength": "semantic" - }, - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Objective retained in admitted artifact.", - "outcome": "passed", - "pointer": "/objectives/demonstrate-handoff", - "stage_id": "instantiated", - "validation_strength": "phase-admitted" - }, - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Canonical objective address retained.", - "outcome": "passed", - "pointer": "/objectives/evaluation.objective.demonstrate-handoff", - "stage_id": "compiled", - "validation_strength": "compiled" - } - ], - "typed_pointer": "/objectives/demonstrate-handoff" - }, - { - "backend_support": "not-evaluated", - "backend_vocabulary_occurrences": [], - "classification": "directly-expressible", - "completeness_disposition": "implemented", - "concept_id": "control-workflows", - "rationale": "SDL workflows own the portable control graph and compile to canonical orchestration state contracts.", - "stage_results": [ - { - "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", - "diagnostic_codes": [], - "note": "Typed control graph.", - "outcome": "passed", - "pointer": "/workflows/yard-recovery", - "stage_id": "authored", - "validation_strength": "structural" - }, - { - "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", - "diagnostic_codes": [], - "note": "Step graph and objective refs validated.", - "outcome": "passed", - "pointer": "/workflows/yard-recovery/steps", - "stage_id": "semantic", - "validation_strength": "semantic" - }, - { - "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", - "diagnostic_codes": [], - "note": "Workflow retained after instantiation.", - "outcome": "passed", - "pointer": "/workflows/yard-recovery", - "stage_id": "instantiated", - "validation_strength": "phase-admitted" - }, - { - "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", - "diagnostic_codes": [], - "note": "Canonical control graph retained.", - "outcome": "passed", - "pointer": "/workflows/orchestration.workflow.yard-recovery", - "stage_id": "compiled", - "validation_strength": "compiled" - } - ], - "typed_pointer": "/workflows/yard-recovery" - }, - { - "backend_support": "not-evaluated", - "backend_vocabulary_occurrences": [], - "classification": "directly-expressible", - "completeness_disposition": "implemented", - "concept_id": "authored-evidence-expectations", - "rationale": "SDL evidence requirements own portable capture intent and remain distinct from evidence records and measures.", - "stage_results": [ - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Typed capture obligation.", - "outcome": "passed", - "pointer": "/evidence_requirements/objective-truth-evidence", - "stage_id": "authored", - "validation_strength": "structural" - }, - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Source refs and bindings validated.", - "outcome": "passed", - "pointer": "/evidence_requirements/objective-truth-evidence", - "stage_id": "semantic", - "validation_strength": "semantic" - }, - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Evidence intent retained in admitted artifact.", - "outcome": "passed", - "pointer": "/evidence_requirements/objective-truth-evidence", - "stage_id": "instantiated", - "validation_strength": "phase-admitted" - } - ], - "typed_pointer": "/evidence_requirements/objective-truth-evidence" - }, - { - "backend_support": "profile-bound", - "backend_vocabulary_occurrences": [], - "classification": "profile-or-manifest-constraint", - "completeness_disposition": "implemented", - "concept_id": "apparatus-selection-constraints", - "rationale": "The experiment task contract binds processor/backend identities, manifest refs, and capabilities outside SDL.", - "stage_results": [ - { - "artifact_path": "contracts/fixtures/experiment-core/experiment-task-v1/valid/reference.json", - "diagnostic_codes": [], - "note": "Closed ExperimentTaskModel validated.", - "outcome": "passed", - "pointer": "/apparatus_constraints/allowed_backend_refs/0", - "stage_id": "contract", - "validation_strength": "contract" - } - ], - "typed_pointer": "/apparatus_constraints/allowed_backend_refs/0" - }, - { - "backend_support": "not-evaluated", - "backend_vocabulary_occurrences": [], - "classification": "directly-expressible", - "completeness_disposition": "implemented", - "concept_id": "participant-agent", - "rationale": "SDL agents own participant entity, knowledge, actions, observation boundaries, and operating scope.", - "stage_results": [ - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Typed participant declaration.", - "outcome": "passed", - "pointer": "/agents/participant-agent", - "stage_id": "authored", - "validation_strength": "structural" - }, - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Participant refs and scope validated.", - "outcome": "passed", - "pointer": "/agents/participant-agent/observation_boundaries", - "stage_id": "semantic", - "validation_strength": "semantic" - }, - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Participant retained in admitted artifact.", - "outcome": "passed", - "pointer": "/agents/participant-agent", - "stage_id": "instantiated", - "validation_strength": "phase-admitted" - }, - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Compiled participant scope retained.", - "outcome": "passed", - "pointer": "/agent_specs/participant-agent", - "stage_id": "compiled", - "validation_strength": "compiled" - } - ], - "typed_pointer": "/agents/participant-agent" - }, - { - "backend_support": "not-evaluated", - "backend_vocabulary_occurrences": [], - "classification": "directly-expressible", - "completeness_disposition": "implemented", - "concept_id": "participant-action-contract", - "rationale": "The action contract declares portable preconditions, effects, observations, evidence, and failure classes without a runner command.", - "stage_results": [ - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Typed action contract.", - "outcome": "passed", - "pointer": "/action_contracts/probe-customer-portal-login", - "stage_id": "authored", - "validation_strength": "structural" - }, - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Action refs and evidence bindings validated.", - "outcome": "passed", - "pointer": "/action_contracts/probe-customer-portal-login/effects", - "stage_id": "semantic", - "validation_strength": "semantic" - }, - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Action retained in admitted artifact.", - "outcome": "passed", - "pointer": "/action_contracts/probe-customer-portal-login", - "stage_id": "instantiated", - "validation_strength": "phase-admitted" - }, - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Canonical action address retained.", - "outcome": "passed", - "pointer": "/action_contracts/participant.action-contract.probe-customer-portal-login", - "stage_id": "compiled", - "validation_strength": "compiled" - } - ], - "typed_pointer": "/action_contracts/probe-customer-portal-login" - }, - { - "backend_support": "not-evaluated", - "backend_vocabulary_occurrences": [], - "classification": "directly-expressible", - "completeness_disposition": "implemented", - "concept_id": "participant-observation-boundary", - "rationale": "The observation boundary separately declares visible, hidden, and evidence-only information with transition rules.", - "stage_results": [ - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Typed observation boundary.", - "outcome": "passed", - "pointer": "/observation_boundaries/participant-view", - "stage_id": "authored", - "validation_strength": "structural" - }, - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Information refs and transitions validated.", - "outcome": "passed", - "pointer": "/observation_boundaries/participant-view/view_rules", - "stage_id": "semantic", - "validation_strength": "semantic" - }, - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Boundary retained in admitted artifact.", - "outcome": "passed", - "pointer": "/observation_boundaries/participant-view", - "stage_id": "instantiated", - "validation_strength": "phase-admitted" - }, - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "diagnostic_codes": [], - "note": "Canonical boundary address retained.", - "outcome": "passed", - "pointer": "/observation_boundaries/participant.observation-boundary.participant-view", - "stage_id": "compiled", - "validation_strength": "compiled" - } - ], - "typed_pointer": "/observation_boundaries/participant-view" - }, - { - "backend_support": "not-evaluated", - "backend_vocabulary_occurrences": [], - "classification": "directly-expressible", - "completeness_disposition": "implemented", - "concept_id": "evaluation-measure", - "rationale": "ExperimentTaskModel owns metric construct, unit, direction, aggregation, and evidence requirements outside SDL objectives.", - "stage_results": [ - { - "artifact_path": "contracts/fixtures/experiment-core/experiment-task-v1/valid/reference.json", - "diagnostic_codes": [], - "note": "Closed task contract validated.", - "outcome": "passed", - "pointer": "/evaluation_protocol/metric_definitions/foothold-achieved", - "stage_id": "contract", - "validation_strength": "contract" - } - ], - "typed_pointer": "/evaluation_protocol/metric_definitions/foothold-achieved" - }, - { - "backend_support": "not-evaluated", - "backend_vocabulary_occurrences": [], - "classification": "missing", - "completeness_disposition": "documented-gap", - "concept_id": "participant-tool-affordance", - "rationale": "This preregistered matrix has no tested carrier for participant tool affordances. The retained missing classification records missing coverage evidence, not the absence of current participant-behavior capabilities.", - "stage_results": [ - { - "artifact_path": "docs/explain/sdl/limitations.md", - "diagnostic_codes": [], - "note": "The preregistered carrier slot was not run; metadata does not substitute for a typed coverage test.", - "outcome": "not_run", - "pointer": null, - "stage_id": "authored", - "validation_strength": "not-applicable" - } - ], - "typed_pointer": null - }, - { - "backend_support": "not-evaluated", - "backend_vocabulary_occurrences": [], - "classification": "directly-expressible", - "completeness_disposition": "implemented", - "concept_id": "resource-constrained-topology", - "rationale": "SDL node resources and infrastructure dependencies express portable resource intent without provider resource identifiers.", - "stage_results": [ - { - "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", - "diagnostic_codes": [], - "note": "Typed CPU and memory declaration.", - "outcome": "passed", - "pointer": "/nodes/shipping-portal/resources", - "stage_id": "authored", - "validation_strength": "structural" - }, - { - "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", - "diagnostic_codes": [], - "note": "Resource-bearing topology validated.", - "outcome": "passed", - "pointer": "/infrastructure/shipping-portal", - "stage_id": "semantic", - "validation_strength": "semantic" - }, - { - "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", - "diagnostic_codes": [], - "note": "Constraints retained in admitted artifact.", - "outcome": "passed", - "pointer": "/nodes/shipping-portal/resources", - "stage_id": "instantiated", - "validation_strength": "phase-admitted" - }, - { - "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", - "diagnostic_codes": [], - "note": "Deployment specification retains resource intent.", - "outcome": "passed", - "pointer": "/node_deployments/provision.node.shipping-portal", - "stage_id": "compiled", - "validation_strength": "compiled" - } - ], - "typed_pointer": "/nodes/shipping-portal/resources" - }, - { - "backend_support": "not-evaluated", - "backend_vocabulary_occurrences": [], - "classification": "missing", - "completeness_disposition": "documented-gap", - "concept_id": "formal-constraint-satisfiability", - "rationale": "This coverage matrix did not exercise a solver-backed carrier. The separate formal-semantic-validation release demonstrates its bounded finite-domain profile; that result is not silently imported into this protocol's missing carrier slot.", - "stage_results": [ - { - "artifact_path": "docs/explain/sdl/limitations.md", - "diagnostic_codes": [], - "note": "No coverage-carrier execution was performed here; independent solver evidence does not change this preregistered denominator.", - "outcome": "not_run", - "pointer": null, - "stage_id": "semantic", - "validation_strength": "not-applicable" - } - ], - "typed_pointer": null - }, - { - "backend_support": "profile-bound", - "backend_vocabulary_occurrences": [ - { - "allowed": true, - "artifact_path": "source:vsdl-paper", - "pointer": "source sections 4-5", - "reason": "Legitimate VSDL realization vocabulary, not RAES core SDL structure.", - "term": "OpenStack/Terraform/Packer" - } - ], - "classification": "deliberately-backend-specific", - "completeness_disposition": "external", - "concept_id": "provider-specific-provisioning", - "rationale": "Provider image selection and provisioning engines are realization mechanics and therefore remain outside core SDL.", - "stage_results": [ - { - "artifact_path": "contracts/profiles/backend/orchestration-capable.json", - "diagnostic_codes": [], - "note": "The portable boundary requires backend contracts; it does not standardize a provider engine.", - "outcome": "not_applicable", - "pointer": "/required_contracts", - "stage_id": "realization-disclosure", - "validation_strength": "profile" - } - ], - "typed_pointer": null - }, - { - "backend_support": "profile-bound", - "backend_vocabulary_occurrences": [], - "classification": "profile-or-manifest-constraint", - "completeness_disposition": "implemented", - "concept_id": "apparatus-clock-context", - "rationale": "ExperimentApparatusContextModel records clock authority, time domain, and synchronization as apparatus facts outside scenario meaning.", - "stage_results": [ - { - "artifact_path": "contracts/fixtures/experiment-core/experiment-apparatus-context-v1/valid/reference.json", - "diagnostic_codes": [], - "note": "Closed apparatus context contract validated.", - "outcome": "passed", - "pointer": "/clocks/0", - "stage_id": "contract", - "validation_strength": "contract" - } - ], - "typed_pointer": "/clocks/0" - }, - { - "backend_support": "not-evaluated", - "backend_vocabulary_occurrences": [], - "classification": "missing", - "completeness_disposition": "documented-gap", - "concept_id": "federated-object-event-exchange", - "rationale": "The federated cyber object/event exchange carrier was not exercised by this preregistered matrix. Runtime event internals are not treated as equivalent evidence.", - "stage_results": [ - { - "artifact_path": "docs/explain/sdl/limitations.md", - "diagnostic_codes": [], - "note": "The missing coverage-carrier test is recorded explicitly, without inferring an ecosystem-wide capability absence.", - "outcome": "not_run", - "pointer": null, - "stage_id": "contract", - "validation_strength": "not-applicable" - } - ], - "typed_pointer": null - } - ], - "deviations": [ - { - "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", - "baseline_sha256": "54ba1a60220e27a55da9cd2a407d7d3ab836fa54460d0b0c6cad87c2e744ddbb", - "rationale": "Migrate participant affiliations and explicit objective assignment, retaining organizational intent and portable action-contract declarations without granting execution authority.", - "retest_sha256": "f7a8897beec243e188ee081975006fad32725f469f267db6e75a1e1cf5727032" - }, - { - "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", - "baseline_sha256": "a27c7a64e0c5c618fadaccafdf1a4e71600170a8b77b983190822b5141f00dec", - "rationale": "Migrate participant affiliations and explicit objective assignment, retaining organizational intent and portable action-contract declarations without granting execution authority.", - "retest_sha256": "0d5497ec946b863e6985284ec487dde7d7f6bf710a985be51401ac0e5e79dc4f" - }, - { - "artifact_path": "contracts/fixtures/experiment-core/experiment-task-v1/valid/reference.json", - "baseline_sha256": "21952a752f4e8581a9fc3b872e4bc308150548170d38bcfc83dbbe35ff5e0b9f", - "rationale": "Replay the retained preregistered artifact against the current evidence-provenance validation implementation.", - "retest_sha256": "f3edf713ac6af26bad609136851c6dd434bfb87ce919a2d8c4414c1035deeafc" - }, - { - "artifact_path": "contracts/fixtures/experiment-core/experiment-apparatus-context-v1/valid/reference.json", - "baseline_sha256": "9536d897a09cbc6920e667e4f8f9371e51307aa0b3b5ff3c7de682dd783420ab", - "rationale": "Replay the retained preregistered artifact against the current evidence-provenance validation implementation.", - "retest_sha256": "e6fa559c5e961f0aab448d0f70dead24aa74fa8ba5f20e1b72f88e11473c9299" - }, - { - "artifact_path": "docs/explain/sdl/limitations.md", - "baseline_sha256": "129cf17810aad4c51988bc872e28fe43ae95019a80053c42d800ff7e2b9cc93e", - "rationale": "Correct historical mandatory-profile guidance after issue #1207; retain the preregistered missing-concept classifications and coverage limits.", - "retest_sha256": "489eeab3ce682627682311581eb98af9abb9ff42a437145af266eefb71dc7fc4" - } - ], - "execution_status": "complete", - "implementation_surfaces": [ - { - "content_sha256": "19a6bd28e31df06b77d0a8b56f7177e8e97a1d571ce2df92c114bb4a56f2d6b0", - "path": "implementations/python/packages/raes_contracts", - "surface_id": "contract-models" - }, - { - "content_sha256": "e947f59695e907f5af899a6bc4bde60e629620aa7c4a69a41e074ba335758c7a", - "path": "implementations/python/packages/raes_processor", - "surface_id": "processor-pipeline" - }, - { - "content_sha256": "26449ed7c5f20fb3a8bd098b47ed672d45f7149d06affbd0b81238b4551bd887", - "path": "implementations/python/packages/raes", - "surface_id": "sdl-pipeline" - } - ], - "limitations": [ - "The execution validates the pinned reference implementation and published contracts, not an independent backend.", - "Repository-owned examples are exact execution artifacts but are not themselves the literature-derived request corpus; the protocol's requests and concepts are.", - "No live range, participant, simulator federation, or provider provisioning engine was executed.", - "Missing concepts remain frozen in this snapshot and require separately scoped product work before a later rerun.", - "This capture replays the retained protocol after EXP-732 run, apparatus, measurement-channel, and augmentation-producer provenance validation; it adds no independent backend or universal provenance assurance claim.", - "Materialization attestation is covered by its dedicated regression suite, not a new claim in this preregistered matrix.", - "This capture refreshes the corrected runtime limitations prose for issue #959; the protocol, coverage classifications and implementation source are unchanged.", - "This capture replays open-by-default augmentation scope integrated with the EXP-731 evidence refinements after composition type refinement; it does not evaluate native backend scope enforcement or broaden the preregistered coverage claims.", - "This capture replays the retained protocol after merging ACT-612 participant relationships with open-by-default augmentation scope; it adds no claim of realized participant relationships or native backend scope enforcement.", - "This capture replays issue #1299 partial listener descriptions on the integrated source state; endpoint completeness and backend admission remain outside this protocol's claims.", - "This capture also binds authoring-adapter semantic conformance to the integrated source; adapter transport behavior remains outside this protocol's claims.", - "Reviewed OCI mirror and pre-seed admission is covered by its own regression suites and the development artifact policy gate, not a new claim in this preregistered matrix.", - "This capture binds issue #1297 service-manager identity, native-name, and explicitly selected systemd-state contract changes to the integrated source. It exercises no live service manager and adds no backend-execution claim.", - "This capture replays the retained specification-coverage protocol after API-404 startup reconciliation added an operational recovery-observation contract. It does not evaluate crash recovery, classify provider effects, or broaden EXP-715 experiment-observation claims.", - "This capture binds API-404 single-owner store admission and immutable target/run scope to the integrated source. The retained offline protocol does not exercise process leases, SQLite lifecycle ordering, or crash recovery.", - "This capture binds issue #1015 deterministic mixed and staged trial admission to the integrated source. The retained offline language corpus does not execute mixed runtimes, phase transitions, backend handoff, or scheduler-driven realization.", - "This replay binds issue #1186 offline control-plane maintenance, readiness, and bounded audit code to the integrated source. The retained language corpus does not execute store recovery, HTTP health behavior, or audit redaction.", - "Issue #1187 control-plane crash/profile conformance and HTTP security changes are covered by their dedicated regression suite, not promoted to new claims by this retained corpus.", - "Issue #1189 control-plane profile declarations are covered by their dedicated runtime suite, not promoted to new claims by the retained language corpus.", - "Issue #1016 mixed-runtime coordination is covered by its dedicated runtime suite. The retained language corpus does not execute mixed providers or establish backend-native realization, multi-controller coordination, IFC, or equivalence.", - "Issue #610's reconciliation demonstration harness is covered by its dedicated processor and CLI suite, not promoted to new claims by the retained language corpus.", - "Participant identity, organization ownership, and participant assignment are separated by issue #1338. This retained offline corpus does not establish participant autonomy, execution authority, live backend fidelity, or causal attribution.", - "Issue #1361 execution and recovery requirements are verified by dedicated policy, composition, and admission tests; this retained corpus establishes no live recovery, continuation, or trial-allocation guarantee.", - "The issue #1361 maintainability repair preserves policy semantics and retained corpus outcomes; it establishes no live recovery, continuation, or trial-allocation guarantee.", - "The issue #1361 resource type-hint repair preserves policy semantics and retained corpus outcomes; it establishes no live recovery, continuation, or trial-allocation guarantee.", - "The combined issue #1361 execution-policy and hatchling update preserves retained outcomes and bounded claims; it establishes no live recovery, continuation, or trial-allocation guarantee.", - "Issue #1091 request-boundary admission is verified by its dedicated tests; this retained corpus does not execute the served HTTP adapter or broaden its bounded claims.", - "This combined-source capture re-executes the named SDL, contract and profile artifacts and their passing typed pointers. The inject placement discriminator repair adds no specification coverage claim; runtime dispatch and live backend effects remain outside this corpus. CI independently verifies replay.", - "Issue #1395 adds a separate bounded two-operation crossing model profile. This retained corpus does not establish participant-crossing equivalence or runtime realization; those assurances remain separate.", - "Issue #1479 fetches OCI modules from public registries through the distribution anonymous bearer-token flow; this retained corpus makes no new claim." - ], - "protocol_revision": "1.0.0", - "protocol_sha256": "e97a19e643e94c9e589dca823a63c6ce49d3329fe2a3cb888ab630838ed93125", - "raes_revision": "3d7b88e2b465ffa0c0a4a6b3b8894de8e95ca2b6", - "snapshot_id": "issue-1479-oci-anonymous-token-specification-bee18848d137", - "snapshot_revision": "branch-capture", - "source_state": { - "base_revision": "3d7b88e2b465ffa0c0a4a6b3b8894de8e95ca2b6", - "checkout_state": "clean", - "implementation_digest": "bee18848d1372ba29188de8a8443c494d377824261645f88cf4c2d9353677cf8", - "profile": "python-reference-source/v2" - } -} From b72a138b8e1cb52bd50e92bd1e7ecf4d16584d98 Mon Sep 17 00:00:00 2001 From: Yernat Yestekov <2068106+doublewhy@users.noreply.github.com> Date: Thu, 29 Oct 2026 09:42:46 +0000 Subject: [PATCH 09/11] test: record research captures for issue #1479 on the merged source --- ...5ae027e9f9c4d4b24cdc4b225094caa520847.json | 4 + .../analysis.json | 140 ++++ .../manifest.json | 122 ++++ .../snapshot.json | 653 +++++++++++++++++ ...df1ada75ab934c40579eefd5973a0098c6b3e.json | 4 + .../analysis.json | 93 +++ .../manifest.json | 10 + .../snapshot.json | 688 ++++++++++++++++++ 8 files changed, 1714 insertions(+) create mode 100644 docs/research/formal-semantic-validation/capture-records/capture-1bcc46839134b4a57ebdd77f64a5ae027e9f9c4d4b24cdc4b225094caa520847.json create mode 100644 docs/research/formal-semantic-validation/captures/capture-1bcc46839134b4a57ebdd77f64a5ae027e9f9c4d4b24cdc4b225094caa520847/analysis.json create mode 100644 docs/research/formal-semantic-validation/captures/capture-1bcc46839134b4a57ebdd77f64a5ae027e9f9c4d4b24cdc4b225094caa520847/manifest.json create mode 100644 docs/research/formal-semantic-validation/captures/capture-1bcc46839134b4a57ebdd77f64a5ae027e9f9c4d4b24cdc4b225094caa520847/snapshot.json create mode 100644 docs/research/specification-coverage/capture-records/capture-6afc59f304f1e7367a62e598807df1ada75ab934c40579eefd5973a0098c6b3e.json create mode 100644 docs/research/specification-coverage/captures/capture-6afc59f304f1e7367a62e598807df1ada75ab934c40579eefd5973a0098c6b3e/analysis.json create mode 100644 docs/research/specification-coverage/captures/capture-6afc59f304f1e7367a62e598807df1ada75ab934c40579eefd5973a0098c6b3e/manifest.json create mode 100644 docs/research/specification-coverage/captures/capture-6afc59f304f1e7367a62e598807df1ada75ab934c40579eefd5973a0098c6b3e/snapshot.json diff --git a/docs/research/formal-semantic-validation/capture-records/capture-1bcc46839134b4a57ebdd77f64a5ae027e9f9c4d4b24cdc4b225094caa520847.json b/docs/research/formal-semantic-validation/capture-records/capture-1bcc46839134b4a57ebdd77f64a5ae027e9f9c4d4b24cdc4b225094caa520847.json new file mode 100644 index 0000000000..80a75043b3 --- /dev/null +++ b/docs/research/formal-semantic-validation/capture-records/capture-1bcc46839134b4a57ebdd77f64a5ae027e9f9c4d4b24cdc4b225094caa520847.json @@ -0,0 +1,4 @@ +{ + "capture_path": "docs/research/formal-semantic-validation/captures/capture-1bcc46839134b4a57ebdd77f64a5ae027e9f9c4d4b24cdc4b225094caa520847/manifest.json", + "capture_sha256": "0667c03764b6e59c54b3b2dc652e8a2722972648cf248925d409f93275979fd4" +} diff --git a/docs/research/formal-semantic-validation/captures/capture-1bcc46839134b4a57ebdd77f64a5ae027e9f9c4d4b24cdc4b225094caa520847/analysis.json b/docs/research/formal-semantic-validation/captures/capture-1bcc46839134b4a57ebdd77f64a5ae027e9f9c4d4b24cdc4b225094caa520847/analysis.json new file mode 100644 index 0000000000..71618aca32 --- /dev/null +++ b/docs/research/formal-semantic-validation/captures/capture-1bcc46839134b4a57ebdd77f64a5ae027e9f9c4d4b24cdc4b225094caa520847/analysis.json @@ -0,0 +1,140 @@ +{ + "analysis_id": "issue-1479-oci-anonymous-token-formal-analysis-fc45184b2a54", + "claim": { + "allowed_evidence": [ + "production parser and semantic-validator results", + "canonical compiled digests", + "participant contract regression tests", + "pinned protocol, corpus, and execution snapshot" + ], + "claim_id": "asr-530-formal-semantic-validation-retest", + "disallowed_evidence": [ + "schema success as semantic proof", + "workflow reachability as network or exploit reachability", + "FM labels as gate outcomes", + "attribution as counterfactual proof", + "formal prose or maintainer confidence alone" + ], + "evidence_artifacts": [ + "docs/research/formal-semantic-validation/protocol-v2.json", + "docs/research/formal-semantic-validation/corpus/manifest-v4.json", + "@snapshot", + "docs/research/formal-semantic-validation/evidence/finite-domain-satisfiable-v4.json", + "docs/research/formal-semantic-validation/evidence/finite-domain-unsatisfiable-v4.json", + "docs/research/formal-semantic-validation/evidence/typed-exploit-path-valid-v4.json", + "docs/research/formal-semantic-validation/evidence/typed-exploit-path-invalid-v4.json" + ], + "falsification_protocol": "Replay every retained and new case through its production entrypoint, require complete digest and evidence joins, execute participant fixtures, and derive status from the recorded outcomes.", + "objective_fail_criteria": "A supported negative passes, a positive fails, an observation drifts, a required participant case is missing, or weaker evidence is promoted to solver, exploit-path, runtime-stability, or counterfactual assurance.", + "objective_pass_criteria": "Every claim class has positive and negative cases, all supported cases reproduce the frozen outcome, every participant obligation has passing positive and negative fixtures, and unsupported classes remain untested.", + "statement": "At the recorded source-state digest, the retained RAES controls have the bounded statuses recorded here; historical releases are integrity evidence, not current replay evidence.", + "threats_to_validity": [ + "The issue-specific corpus is intentionally small and does not enumerate every validator invariant.", + "The participant fixtures exercise reference production contracts and tests, not every independent backend realization.", + "The replay gate runs on one Python reference configuration and one pinned RAES revision.", + "Unsupported solver-level classes have protocol cases but no executable observations." + ] + }, + "claim_results": [ + { + "case_count": 2, + "claim_class_id": "schema-validity", + "evidence_status": "demonstrated", + "limitations": [ + "Bounded to the named source/model structural controls." + ], + "matching_case_count": 2, + "participant_obligation_count": 0, + "replayable_case_count": 2, + "unsupported_case_count": 0 + }, + { + "case_count": 4, + "claim_class_id": "semantic-consistency", + "evidence_status": "partial", + "limitations": [ + "Partial coverage of named static semantics and participant obligations, not universal consistency." + ], + "matching_case_count": 4, + "participant_obligation_count": 7, + "replayable_case_count": 4, + "unsupported_case_count": 0 + }, + { + "case_count": 2, + "claim_class_id": "graph-reachability", + "evidence_status": "partial", + "limitations": [ + "Partial workflow control-flow reachability only; not network, service, or exploit reachability." + ], + "matching_case_count": 2, + "participant_obligation_count": 0, + "replayable_case_count": 2, + "unsupported_case_count": 0 + }, + { + "case_count": 4, + "claim_class_id": "constraint-satisfiability", + "evidence_status": "demonstrated", + "limitations": [ + "Demonstrated only for raes-finite-domain-satisfiability-v1 and its pinned solver configuration." + ], + "matching_case_count": 4, + "participant_obligation_count": 0, + "replayable_case_count": 2, + "unsupported_case_count": 2 + }, + { + "case_count": 4, + "claim_class_id": "exploit-path-validity", + "evidence_status": "demonstrated", + "limitations": [ + "Demonstrated only for the admitted snapshot, typed graph, query, semantics, and bounded search profile." + ], + "matching_case_count": 4, + "participant_obligation_count": 0, + "replayable_case_count": 2, + "unsupported_case_count": 2 + }, + { + "case_count": 2, + "claim_class_id": "determinism-stability", + "evidence_status": "partial", + "limitations": [ + "Partial parse-to-compile repeatability only; runtime and backend determinism are untested." + ], + "matching_case_count": 2, + "participant_obligation_count": 0, + "replayable_case_count": 2, + "unsupported_case_count": 0 + }, + { + "case_count": 2, + "claim_class_id": "counterfactual-necessity", + "evidence_status": "untested", + "limitations": [ + "Untested because no governed intervention or ablation entrypoint ran." + ], + "matching_case_count": 2, + "participant_obligation_count": 0, + "replayable_case_count": 0, + "unsupported_case_count": 2 + } + ], + "corpus_revision": "4.0.0", + "evidence_status": "partial", + "execution_id": "issue-1479-oci-anonymous-token-formal-fc45184b2a54", + "generated_at": "2026-10-29T09:42:23.019833+00:00", + "limitations": [ + "Satisfiability is limited to raes-finite-domain-satisfiability-v1 and its exact translation, theory, and Z3 configuration.", + "EXP-719 factorial generation, randomized allocation and participant configuration behavior are covered by their dedicated regressions; this retained corpus adds no treatment or live execution claim.", + "Issue 1549 external-backend compatibility and trial realization are verified by dedicated regressions; this retained corpus adds no independent-backend execution claim.", + "Issue 1520 condition membership is verified by dedicated experiment-authoring regressions. This retained offline corpus adds no ontology, domain completeness, or execution claim.", + "The retained research corpus does not certify native descendant creator attribution, ownership, physical effects or independent observation.", + "API-414 support declarations do not establish native participant tool execution; the retained formal cases keep their existing bounded claims.", + "This retained offline corpus adds no modular control runtime or independent backend conformance claim. Issue 1071 has separate bounded runtime probes.", + "Issue 1629 shared runtime sequencing, Temporal recovery and authored retry behavior have separate targeted tests; this offline corpus adds no live backend or durable workflow assurance." + ], + "plain_language_outcome": "The retained formal cases reproduce their outcomes on the combined source of current dev and issue #1479's anonymous bearer-token flow for OCI module fetches. Bounded claims and unsupported classes are unchanged.", + "protocol_revision": "2.0.0" +} diff --git a/docs/research/formal-semantic-validation/captures/capture-1bcc46839134b4a57ebdd77f64a5ae027e9f9c4d4b24cdc4b225094caa520847/manifest.json b/docs/research/formal-semantic-validation/captures/capture-1bcc46839134b4a57ebdd77f64a5ae027e9f9c4d4b24cdc4b225094caa520847/manifest.json new file mode 100644 index 0000000000..578bbd12f2 --- /dev/null +++ b/docs/research/formal-semantic-validation/captures/capture-1bcc46839134b4a57ebdd77f64a5ae027e9f9c4d4b24cdc4b225094caa520847/manifest.json @@ -0,0 +1,122 @@ +{ + "analysis_path": "docs/research/formal-semantic-validation/captures/capture-1bcc46839134b4a57ebdd77f64a5ae027e9f9c4d4b24cdc4b225094caa520847/analysis.json", + "analysis_sha256": "ffef2b75f244b52a5dfceefd7db780b125b3d75822bbf214fd7777e6e1196735", + "artifacts": [ + { + "artifact_id": "finite-domain-satisfiable-v2-input", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/satisfiable-control.sdl.yaml", + "sha256": "0ca9eaba9dc47171f7a042dc6753faa6c820c65ee966538f9d65fac5342202e8" + }, + { + "artifact_id": "finite-domain-satisfiable-v2-evidence", + "kind": "production-evidence", + "path": "docs/research/formal-semantic-validation/evidence/finite-domain-satisfiable-v4.json", + "sha256": "554202313d678046958b5c028e2de26ff03c74895cfac552677eed74e8153add" + }, + { + "artifact_id": "finite-domain-unsatisfiable-v2-input", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/unsatisfiable-control.sdl.yaml", + "sha256": "cfef56a1f56d5f0db9da195377fd75694bdd0f0b92932fdb8fafcbd3f7baf6c5" + }, + { + "artifact_id": "finite-domain-unsatisfiable-v2-evidence", + "kind": "production-evidence", + "path": "docs/research/formal-semantic-validation/evidence/finite-domain-unsatisfiable-v4.json", + "sha256": "c972725ef64822a75a60380afc11f08eac25b7fe9b091d39b058b3c9f7c8031d" + }, + { + "artifact_id": "typed-exploit-path-valid-v2-input", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/exploit-path-valid-v3.json", + "sha256": "0afe635a63db5b6e6380ac70982fd61d09790745d51a10d670321304121e7c39" + }, + { + "artifact_id": "typed-exploit-path-valid-v2-evidence", + "kind": "production-evidence", + "path": "docs/research/formal-semantic-validation/evidence/typed-exploit-path-valid-v4.json", + "sha256": "1b7f55d04db172da32658187c64a88c13b5f4d565267ce2be7cb86a9d04cb70c" + }, + { + "artifact_id": "typed-exploit-path-invalid-v2-input", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/exploit-path-invalid-v3.json", + "sha256": "0b2293d4a8983515ff05c516be6e6b418a4f3f09e055250a00bf15fda861aab3" + }, + { + "artifact_id": "typed-exploit-path-invalid-v2-evidence", + "kind": "production-evidence", + "path": "docs/research/formal-semantic-validation/evidence/typed-exploit-path-invalid-v4.json", + "sha256": "244f895a64f14c10916ab0533ab462ce80a328021cd6a50c30a4aa59266d5533" + }, + { + "artifact_id": "schema-valid-control-fixture", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/schema-valid.sdl.yaml", + "sha256": "41a9adffdf9f5f2ccc2f887dcf7b15fba3b47c83a1af15f33db872c4a2449d67" + }, + { + "artifact_id": "schema-unknown-field-fixture", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/schema-invalid-unknown-field.sdl.yaml", + "sha256": "51cf62319a86c95a2517995939d1f370573051835e4b55bb6d5beaf049640481" + }, + { + "artifact_id": "semantic-resolved-objective-fixture", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/semantic-valid-participant-identity-v2.sdl.yaml", + "sha256": "75834bdc883e2003e1c473870bdf75700978955bb83095c6bd718ba6bd3908a6" + }, + { + "artifact_id": "semantic-dangling-assertion-fixture", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/semantic-invalid-dangling-ref-participant-identity-v2.sdl.yaml", + "sha256": "1d25bee5f556054e5f0a518df025e4c62e080e1964035e3c1a12e074d88d3a5d" + }, + { + "artifact_id": "semantic-ambiguous-reference-fixture", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/semantic-invalid-ambiguous-ref.sdl.yaml", + "sha256": "653cbd2fd62e220d49fb86f80133884207df5ae6752846345ae3085b93f6e4ed" + }, + { + "artifact_id": "semantic-feature-cycle-fixture", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/semantic-invalid-feature-cycle.sdl.yaml", + "sha256": "e1f66d95a9ad039687aec8cccbc8843b514072ff08e006c1b4ca6aa5cd8d4ed1" + }, + { + "artifact_id": "workflow-reachable-control-fixture", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/workflow-reachable.sdl.yaml", + "sha256": "54c40ceb98ad47247447d737973b2c55e8fb2045e209c7545c4fb20cf42dc3dc" + }, + { + "artifact_id": "workflow-unreachable-step-fixture", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/workflow-unreachable.sdl.yaml", + "sha256": "ef22ef2e260f1a7fd92d286f9b571716436b192ddfd54aea7bdfcfdda4ca52a2" + }, + { + "artifact_id": "compile-repeatability-control-fixture", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/determinism-a.sdl.yaml", + "sha256": "0bc40900d598c1af7a405d798ca19710405e53ced262d8733081abf12edf89fe" + }, + { + "artifact_id": "compile-non-vacuity-control-comparison-fixture", + "kind": "corpus-input", + "path": "docs/research/formal-semantic-validation/corpus/determinism-b.sdl.yaml", + "sha256": "d85338f89f20a45515b12da8640173c1a52e47eb17ca0f4f6b4f8f3306e863a1" + } + ], + "bundle_id": "raes-formal-semantic-validation", + "corpus_path": "docs/research/formal-semantic-validation/corpus/manifest-v4.json", + "corpus_sha256": "c57207af72406aa4f70882b9bbeb7cedcc79cf3854c878a95e3eb1fa59ea7a72", + "protocol_path": "docs/research/formal-semantic-validation/protocol-v2.json", + "protocol_sha256": "abf94093e344bf495dfb04e8b0c5985c0beaab8ebb17a75e15c8674fa81b1a7c", + "revision": "capture-1bcc46839134b4a57ebdd77f64a5ae027e9f9c4d4b24cdc4b225094caa520847", + "snapshot_path": "docs/research/formal-semantic-validation/captures/capture-1bcc46839134b4a57ebdd77f64a5ae027e9f9c4d4b24cdc4b225094caa520847/snapshot.json", + "snapshot_sha256": "aebf5ed315fc4d2dd264927a02dc88fbebab7062a5dd981a0c7190364277eeb2" +} diff --git a/docs/research/formal-semantic-validation/captures/capture-1bcc46839134b4a57ebdd77f64a5ae027e9f9c4d4b24cdc4b225094caa520847/snapshot.json b/docs/research/formal-semantic-validation/captures/capture-1bcc46839134b4a57ebdd77f64a5ae027e9f9c4d4b24cdc4b225094caa520847/snapshot.json new file mode 100644 index 0000000000..97f30d4b8e --- /dev/null +++ b/docs/research/formal-semantic-validation/captures/capture-1bcc46839134b4a57ebdd77f64a5ae027e9f9c4d4b24cdc4b225094caa520847/snapshot.json @@ -0,0 +1,653 @@ +{ + "baseline": { + "execution_id": "issue-1697-prepared-provenance-replay", + "release_path": "docs/research/formal-semantic-validation/captures/capture-037aeaa06af1511d9945eb4107047324070d073e86182377a8bae7ce77a9013d/manifest.json", + "release_revision": "capture-037aeaa06af1511d9945eb4107047324070d073e86182377a8bae7ce77a9013d", + "release_sha256": "08ff56cf88e073ede25cec6f21957418db5b5b3f178d96337a3d6b80f20d6471" + }, + "captured_at": "2026-10-29T09:42:23.019833+00:00", + "commands": [ + { + "argv": [ + "implementations/python/.venv/bin/pytest", + "-q", + "implementations/python/tests/test_sem_208_participant_behavior.py::test_hidden_truth_disclosure_is_separate_from_observable_projection", + "implementations/python/tests/test_sem_208_participant_behavior.py::test_hidden_truth_cannot_be_observed_without_explicit_disclosure_rule", + "implementations/python/tests/test_sem_211_participant_action_semantics.py::test_action_contract_declares_sem_211_classes_and_compiles_them", + "implementations/python/tests/test_sem_211_participant_action_semantics.py::test_action_result_rejects_success_when_preconditions_are_unresolved", + "implementations/python/tests/test_run_308_concurrent_participant_execution.py::test_runtime_snapshot_publishes_joint_action_and_time_context_records", + "implementations/python/tests/test_run_308_concurrent_participant_execution.py::test_joint_action_record_contract_rejects_unordered_conflicting_writes", + "implementations/python/tests/test_participant_runtime_invariants.py::test_order_discipline_accepts_supported_order_claim_strengths", + "implementations/python/tests/test_participant_runtime_invariants.py::test_order_discipline_rejects_wall_clock_causality", + "implementations/python/tests/test_sem_212_participant_attribution_semantics.py::test_attribution_edge_round_trips_on_terminal_observation", + "implementations/python/tests/test_sem_212_participant_attribution_semantics.py::test_timestamp_adjacency_cannot_be_reported_as_strong_causality", + "implementations/python/tests/test_sem_215_participant_outcome_interpretation.py::test_outcome_interpretation_rule_parses_and_compiles_explicit_layers", + "implementations/python/tests/test_sem_215_participant_outcome_interpretation.py::test_local_action_success_does_not_imply_objective_success_without_rule_record", + "implementations/python/tests/test_realization_honesty_conformance.py::test_constructive_envelope_runs_positive_and_negative_honesty_probes", + "implementations/python/tests/test_realization_honesty_conformance.py::test_only_native_live_can_support_native_conformance" + ], + "command_id": "participant-fixtures", + "network": "disabled" + }, + { + "argv": [ + "implementations/python/.venv/bin/raes", + "processor", + "satisfiability", + "docs/research/formal-semantic-validation/corpus/satisfiable-control.sdl.yaml", + "--profile", + "raes-finite-domain-satisfiability-v1" + ], + "command_id": "finite-domain-satisfiable-v2", + "network": "disabled" + }, + { + "argv": [ + "implementations/python/.venv/bin/raes", + "processor", + "satisfiability", + "docs/research/formal-semantic-validation/corpus/unsatisfiable-control.sdl.yaml", + "--profile", + "raes-finite-domain-satisfiability-v1" + ], + "command_id": "finite-domain-unsatisfiable-v2", + "network": "disabled" + }, + { + "argv": [ + "implementations/python/.venv/bin/raes", + "processor", + "exploit-path", + "docs/research/formal-semantic-validation/corpus/exploit-path-valid-v3.json", + "--profile", + "raes-exploit-path-analysis-v1" + ], + "command_id": "typed-exploit-path-valid-v2", + "network": "disabled" + }, + { + "argv": [ + "implementations/python/.venv/bin/raes", + "processor", + "exploit-path", + "docs/research/formal-semantic-validation/corpus/exploit-path-invalid-v3.json", + "--profile", + "raes-exploit-path-analysis-v1" + ], + "command_id": "typed-exploit-path-invalid-v2", + "network": "disabled" + }, + { + "argv": [ + "implementations/python/.venv/bin/python", + "-c", + "import json, sys\nfrom pathlib import Path\nroot = Path.cwd().resolve()\nfor entry in (str(root), str(root / \"implementations\" / \"python\" / \"packages\")):\n if entry not in sys.path:\n sys.path.insert(0, entry)\nfrom tools.formal_semantic_validation._replay import replay_case\ncorpus = json.loads((root / \"docs/research/formal-semantic-validation/corpus/manifest-v4.json\").read_text(encoding=\"utf-8\"))\nskipped = set([\"exploit-path\", \"satisfiability\", \"unsupported\"])\nresults = {}\nfor case in corpus[\"cases\"]:\n if case.get(\"replay_mode\") in skipped:\n continue\n try:\n results[case[\"case_id\"]] = {\"ok\": True, **replay_case(root, case)}\n except Exception as exc:\n results[case[\"case_id\"]] = {\"ok\": False, \"error\": type(exc).__name__ + \": \" + str(exc)[:300]}\nprint(json.dumps(results, sort_keys=True))\n" + ], + "command_id": "retained-case-replay", + "network": "disabled" + } + ], + "configuration_id": "raes-python-reference-offline-v41", + "corpus_revision": "4.0.0", + "deviations": [], + "execution_id": "issue-1479-oci-anonymous-token-formal-fc45184b2a54", + "execution_status": "complete", + "observations": [ + { + "actual_outcome": "accepted", + "analysis_profile": null, + "case_id": "schema-valid-control", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": null, + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/schema-valid.sdl.yaml" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-fc45184b2a54", + "limitations": [ + "A passing minimal source does not establish semantic correctness." + ], + "replayable": true, + "result_digest": "f7d364ef384df8a1526b489501835b635021c860793b5764f91d956710d2250c", + "source_digest": null + }, + { + "actual_outcome": "rejected", + "analysis_profile": null, + "case_id": "schema-unknown-field", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": "SDLParseError", + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/schema-invalid-unknown-field.sdl.yaml" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-fc45184b2a54", + "limitations": [ + "The observation covers one unknown-field defect only." + ], + "replayable": true, + "result_digest": "f55d834b458f8e069e1c69061b4cc0a6d61e0e052bf90c670f2e6a5ad8b5bd98", + "source_digest": null + }, + { + "actual_outcome": "accepted", + "analysis_profile": null, + "case_id": "semantic-resolved-objective", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": null, + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/semantic-valid-participant-identity-v2.sdl.yaml" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-fc45184b2a54", + "limitations": [ + "This is a positive control for one objective-reference slice." + ], + "replayable": true, + "result_digest": "652288785dc09095955ed3649f6407d616fb7c4d4f4188df4ed513ccb7537e0b", + "source_digest": null + }, + { + "actual_outcome": "rejected", + "analysis_profile": null, + "case_id": "semantic-dangling-assertion", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": "SDLValidationError", + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/semantic-invalid-dangling-ref-participant-identity-v2.sdl.yaml" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-fc45184b2a54", + "limitations": [ + "A single dangling reference does not prove complete semantic coverage." + ], + "replayable": true, + "result_digest": "0207cf616b56708ca9b8c4499d3301abe22dbe52162cf8d58d3bec429d9db024", + "source_digest": null + }, + { + "actual_outcome": "rejected", + "analysis_profile": null, + "case_id": "semantic-ambiguous-reference", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": "SDLValidationError", + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/semantic-invalid-ambiguous-ref.sdl.yaml" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-fc45184b2a54", + "limitations": [ + "One namespace collision does not enumerate every ambiguity surface." + ], + "replayable": true, + "result_digest": "9da4a87797d228e0012ab6b30459f4892e41aa6f224a9840be035fee4a2eea73", + "source_digest": null + }, + { + "actual_outcome": "rejected", + "analysis_profile": null, + "case_id": "semantic-feature-cycle", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": "SDLValidationError", + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/semantic-invalid-feature-cycle.sdl.yaml" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-fc45184b2a54", + "limitations": [ + "One static dependency cycle does not establish general constraint satisfiability." + ], + "replayable": true, + "result_digest": "d15dbcd99fb4f20b965d7031b07dd6534576302270399c3fa656d29e7de02b83", + "source_digest": null + }, + { + "actual_outcome": "accepted", + "analysis_profile": null, + "case_id": "workflow-reachable-control", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": null, + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/workflow-reachable.sdl.yaml" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-fc45184b2a54", + "limitations": [ + "The graph is workflow control flow only." + ], + "replayable": true, + "result_digest": "b1b49649b54bd59d4ef357b39cf9158da90f4eae560f8dd756acf97bd0827a06", + "source_digest": null + }, + { + "actual_outcome": "rejected", + "analysis_profile": null, + "case_id": "workflow-unreachable-step", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": "SDLValidationError", + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/workflow-unreachable.sdl.yaml" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-fc45184b2a54", + "limitations": [ + "The result does not establish network, service, participant, or exploit reachability." + ], + "replayable": true, + "result_digest": "bb931d19346ef9193408ae6c85deb4079704378fc5f00dc5f47a2817cff21943", + "source_digest": null + }, + { + "actual_outcome": "unsupported", + "analysis_profile": null, + "case_id": "whole-scenario-satisfiable-request", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": null, + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/decisions/issue-168-formal-semantic-validation-reachability-preflight.md" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-fc45184b2a54", + "limitations": [ + "No governed whole-scenario constraint theory or solver exists." + ], + "replayable": false, + "result_digest": null, + "source_digest": null + }, + { + "actual_outcome": "unsupported", + "analysis_profile": null, + "case_id": "whole-scenario-unsatisfiable-request", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": null, + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/decisions/issue-168-formal-semantic-validation-reachability-preflight.md" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-fc45184b2a54", + "limitations": [ + "Local checks cannot produce a whole-scenario unsat certificate." + ], + "replayable": false, + "result_digest": null, + "source_digest": null + }, + { + "actual_outcome": "unsupported", + "analysis_profile": null, + "case_id": "valid-exploit-path-request", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": null, + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/decisions/issue-168-formal-semantic-validation-reachability-preflight.md" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-fc45184b2a54", + "limitations": [ + "The issue-168 baseline had no canonical typed attack graph or path-query entrypoint." + ], + "replayable": false, + "result_digest": null, + "source_digest": null + }, + { + "actual_outcome": "unsupported", + "analysis_profile": null, + "case_id": "invalid-exploit-path-request", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": null, + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/decisions/issue-168-formal-semantic-validation-reachability-preflight.md" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-fc45184b2a54", + "limitations": [ + "Vulnerability and topology declarations are not an invalid-path proof." + ], + "replayable": false, + "result_digest": null, + "source_digest": null + }, + { + "actual_outcome": "stable", + "analysis_profile": null, + "case_id": "compile-repeatability-control", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": null, + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/determinism-a.sdl.yaml" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-fc45184b2a54", + "limitations": [ + "The witness ends at compiled output." + ], + "replayable": true, + "result_digest": "873d1cfda9621a489a48ce9ef8099cf3b9e4ee541c8da3ddc4bf0ee608854b15", + "source_digest": null + }, + { + "actual_outcome": "distinguishable", + "analysis_profile": null, + "case_id": "compile-non-vacuity-control", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": null, + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/determinism-a.sdl.yaml", + "docs/research/formal-semantic-validation/corpus/determinism-b.sdl.yaml" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-fc45184b2a54", + "limitations": [ + "Distinct digests are a non-vacuity control, not semantic non-equivalence proof." + ], + "replayable": true, + "result_digest": "ed31f35450bdc3358f7c90f97e7323c1b2a6a877965260741b78071be6888aeb", + "source_digest": null + }, + { + "actual_outcome": "unsupported", + "analysis_profile": null, + "case_id": "necessity-witness-request", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": null, + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/decisions/issue-168-formal-semantic-validation-reachability-preflight.md" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-fc45184b2a54", + "limitations": [ + "No governed intervention or ablation protocol exists." + ], + "replayable": false, + "result_digest": null, + "source_digest": null + }, + { + "actual_outcome": "unsupported", + "analysis_profile": null, + "case_id": "non-necessity-control-request", + "configuration_digest": null, + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": null, + "evidence_artifact_path": null, + "evidence_artifact_sha256": null, + "evidence_digest": null, + "evidence_profile": null, + "evidence_refs": [ + "docs/decisions/issue-168-formal-semantic-validation-reachability-preflight.md" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-fc45184b2a54", + "limitations": [ + "Attribution and negative fixtures do not demonstrate non-necessity." + ], + "replayable": false, + "result_digest": null, + "source_digest": null + }, + { + "actual_outcome": "satisfiable", + "analysis_profile": "raes-finite-domain-satisfiability-v1", + "case_id": "finite-domain-satisfiable-v2", + "configuration_digest": "sha256:1204635e17e759e9ad3bd6be2ecb28c6de05c07ead6dfdd15936ed5d3d5b81b2", + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": "scenario-satisfiability-evidence/v1", + "evidence_artifact_path": "docs/research/formal-semantic-validation/evidence/finite-domain-satisfiable-v4.json", + "evidence_artifact_sha256": "554202313d678046958b5c028e2de26ff03c74895cfac552677eed74e8153add", + "evidence_digest": "sha256:23c2cae7d95d4cc83d77ca576e3911477b169ecc311c977cb45490345f633b5a", + "evidence_profile": "scenario-satisfiability-evidence/v1", + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/satisfiable-control.sdl.yaml", + "docs/research/formal-semantic-validation/evidence/finite-domain-satisfiable-v4.json", + "specs/formal/scenario-satisfiability/README.md" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-fc45184b2a54", + "limitations": [ + "Demonstrates only the pinned finite-domain theory, translation, solver profile, and source." + ], + "replayable": true, + "result_digest": "sha256:23c2cae7d95d4cc83d77ca576e3911477b169ecc311c977cb45490345f633b5a", + "source_digest": "sha256:0ca9eaba9dc47171f7a042dc6753faa6c820c65ee966538f9d65fac5342202e8" + }, + { + "actual_outcome": "unsatisfiable", + "analysis_profile": "raes-finite-domain-satisfiability-v1", + "case_id": "finite-domain-unsatisfiable-v2", + "configuration_digest": "sha256:1204635e17e759e9ad3bd6be2ecb28c6de05c07ead6dfdd15936ed5d3d5b81b2", + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": "scenario-satisfiability-evidence/v1", + "evidence_artifact_path": "docs/research/formal-semantic-validation/evidence/finite-domain-unsatisfiable-v4.json", + "evidence_artifact_sha256": "c972725ef64822a75a60380afc11f08eac25b7fe9b091d39b058b3c9f7c8031d", + "evidence_digest": "sha256:317b5cad00aa7f4f7868dca66127611ba19d40ffd86f35815502622814df54c1", + "evidence_profile": "scenario-satisfiability-evidence/v1", + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/unsatisfiable-control.sdl.yaml", + "docs/research/formal-semantic-validation/evidence/finite-domain-unsatisfiable-v4.json", + "specs/formal/scenario-satisfiability/README.md" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-fc45184b2a54", + "limitations": [ + "The subset-minimal core is evidence for the pinned translation and solver, not a proof certificate for arbitrary SDL." + ], + "replayable": true, + "result_digest": "sha256:317b5cad00aa7f4f7868dca66127611ba19d40ffd86f35815502622814df54c1", + "source_digest": "sha256:cfef56a1f56d5f0db9da195377fd75694bdd0f0b92932fdb8fafcbd3f7baf6c5" + }, + { + "actual_outcome": "valid-path", + "analysis_profile": "raes-exploit-path-analysis-v1", + "case_id": "typed-exploit-path-valid-v2", + "configuration_digest": "sha256:7f8876d81feb77d3a3239be2fb8337de8885e2744f8786728ba23e4e6027bc0a", + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": "exploit-path-analysis-evidence/v1", + "evidence_artifact_path": "docs/research/formal-semantic-validation/evidence/typed-exploit-path-valid-v4.json", + "evidence_artifact_sha256": "1b7f55d04db172da32658187c64a88c13b5f4d565267ce2be7cb86a9d04cb70c", + "evidence_digest": "sha256:2d4d1a362751abd9544beb8af7f8c6331d04dac8f4abc315fb261f81fbaf4387", + "evidence_profile": "exploit-path-analysis-evidence/v1", + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/exploit-path-valid-v3.json", + "docs/research/formal-semantic-validation/evidence/typed-exploit-path-valid-v4.json", + "specs/formal/exploit-path-analysis/README.md" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-fc45184b2a54", + "limitations": [ + "The witness is bounded to the admitted snapshot, normalized graph, query, semantics, and search profile; it does not establish backend execution." + ], + "replayable": true, + "result_digest": "sha256:2d4d1a362751abd9544beb8af7f8c6331d04dac8f4abc315fb261f81fbaf4387", + "source_digest": "sha256:0afe635a63db5b6e6380ac70982fd61d09790745d51a10d670321304121e7c39" + }, + { + "actual_outcome": "invalid-path", + "analysis_profile": "raes-exploit-path-analysis-v1", + "case_id": "typed-exploit-path-invalid-v2", + "configuration_digest": "sha256:7f8876d81feb77d3a3239be2fb8337de8885e2744f8786728ba23e4e6027bc0a", + "configuration_id": "raes-python-reference-offline-v41", + "diagnostic_kind": "exploit-path-analysis-evidence/v1", + "evidence_artifact_path": "docs/research/formal-semantic-validation/evidence/typed-exploit-path-invalid-v4.json", + "evidence_artifact_sha256": "244f895a64f14c10916ab0533ab462ce80a328021cd6a50c30a4aa59266d5533", + "evidence_digest": "sha256:1b416bb5a4d29d57c961b769cc9d3af5d9328624e3eebf104d57f39a94c5bb97", + "evidence_profile": "exploit-path-analysis-evidence/v1", + "evidence_refs": [ + "docs/research/formal-semantic-validation/corpus/exploit-path-invalid-v3.json", + "docs/research/formal-semantic-validation/evidence/typed-exploit-path-invalid-v4.json", + "specs/formal/exploit-path-analysis/README.md" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-fc45184b2a54", + "limitations": [ + "Structured rejection proves only that this bounded graph/query cannot reach its goal; it does not establish real-world non-exploitability." + ], + "replayable": true, + "result_digest": "sha256:1b416bb5a4d29d57c961b769cc9d3af5d9328624e3eebf104d57f39a94c5bb97", + "source_digest": "sha256:0b2293d4a8983515ff05c516be6e6b418a4f3f09e055250a00bf15fda861aab3" + } + ], + "participant_observations": [ + { + "evidence_refs": [ + "implementations/python/tests/test_sem_208_participant_behavior.py::test_hidden_truth_disclosure_is_separate_from_observable_projection", + "implementations/python/tests/test_sem_208_participant_behavior.py::test_hidden_truth_cannot_be_observed_without_explicit_disclosure_rule" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-fc45184b2a54", + "limitations": [ + "Covers the reference SDL/contract path, not every backend projection." + ], + "negative_outcome": "passed", + "obligation_id": "hidden-vs-visible-projection", + "positive_outcome": "passed" + }, + { + "evidence_refs": [ + "implementations/python/tests/test_sem_211_participant_action_semantics.py::test_action_contract_declares_sem_211_classes_and_compiles_them", + "implementations/python/tests/test_sem_211_participant_action_semantics.py::test_action_result_rejects_success_when_preconditions_are_unresolved" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-fc45184b2a54", + "limitations": [ + "Covers declared applicability and one unresolved-precondition failure." + ], + "negative_outcome": "passed", + "obligation_id": "fail-closed-action-applicability", + "positive_outcome": "passed" + }, + { + "evidence_refs": [ + "implementations/python/tests/test_run_308_concurrent_participant_execution.py::test_runtime_snapshot_publishes_joint_action_and_time_context_records", + "implementations/python/tests/test_run_308_concurrent_participant_execution.py::test_joint_action_record_contract_rejects_unordered_conflicting_writes" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-fc45184b2a54", + "limitations": [ + "Contract evidence does not prove every backend's live concurrency fidelity." + ], + "negative_outcome": "passed", + "obligation_id": "shared-state-effects", + "positive_outcome": "passed" + }, + { + "evidence_refs": [ + "implementations/python/tests/test_participant_runtime_invariants.py::test_order_discipline_accepts_supported_order_claim_strengths", + "implementations/python/tests/test_participant_runtime_invariants.py::test_order_discipline_rejects_wall_clock_causality" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-fc45184b2a54", + "limitations": [ + "Rejecting timestamp-only causality does not supply counterfactual proof." + ], + "negative_outcome": "passed", + "obligation_id": "ordering-before-causality", + "positive_outcome": "passed" + }, + { + "evidence_refs": [ + "implementations/python/tests/test_sem_212_participant_attribution_semantics.py::test_attribution_edge_round_trips_on_terminal_observation", + "implementations/python/tests/test_sem_212_participant_attribution_semantics.py::test_timestamp_adjacency_cannot_be_reported_as_strong_causality" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-fc45184b2a54", + "limitations": [ + "Attribution labels disclose basis; they do not demonstrate necessity." + ], + "negative_outcome": "passed", + "obligation_id": "evidence-labeled-attribution", + "positive_outcome": "passed" + }, + { + "evidence_refs": [ + "implementations/python/tests/test_sem_215_participant_outcome_interpretation.py::test_outcome_interpretation_rule_parses_and_compiles_explicit_layers", + "implementations/python/tests/test_sem_215_participant_outcome_interpretation.py::test_local_action_success_does_not_imply_objective_success_without_rule_record" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-fc45184b2a54", + "limitations": [ + "The fixtures establish layer separation, not outcome validity in every realization." + ], + "negative_outcome": "passed", + "obligation_id": "participant-local-outcome-separation", + "positive_outcome": "passed" + }, + { + "evidence_refs": [ + "implementations/python/tests/test_realization_honesty_conformance.py::test_constructive_envelope_runs_positive_and_negative_honesty_probes", + "implementations/python/tests/test_realization_honesty_conformance.py::test_only_native_live_can_support_native_conformance" + ], + "execution_id": "issue-1479-oci-anonymous-token-formal-fc45184b2a54", + "limitations": [ + "Reference conformance evidence remains bounded to declared realization profiles." + ], + "negative_outcome": "passed", + "obligation_id": "realization-profile-honesty", + "positive_outcome": "passed" + } + ], + "protocol_revision": "2.0.0", + "raes_revision": "1bde15cbff6ac3dea1811fe34ba8f39588a967d1", + "source_state": { + "base_revision": "1bde15cbff6ac3dea1811fe34ba8f39588a967d1", + "checkout_state": "clean", + "implementation_digest": "fc45184b2a54c697bd56863a0f8ed76286fa5d4d45e540bb602299f7dd94c0fc", + "profile": "python-reference-source/v2" + }, + "versions": { + "python": "3.14.7", + "raes": "9.1.0", + "z3_engine": "4.16.0", + "z3_solver": "4.16.0.0" + } +} diff --git a/docs/research/specification-coverage/capture-records/capture-6afc59f304f1e7367a62e598807df1ada75ab934c40579eefd5973a0098c6b3e.json b/docs/research/specification-coverage/capture-records/capture-6afc59f304f1e7367a62e598807df1ada75ab934c40579eefd5973a0098c6b3e.json new file mode 100644 index 0000000000..c94ddf1590 --- /dev/null +++ b/docs/research/specification-coverage/capture-records/capture-6afc59f304f1e7367a62e598807df1ada75ab934c40579eefd5973a0098c6b3e.json @@ -0,0 +1,4 @@ +{ + "capture_path": "docs/research/specification-coverage/captures/capture-6afc59f304f1e7367a62e598807df1ada75ab934c40579eefd5973a0098c6b3e/manifest.json", + "capture_sha256": "a0fc2780c8534bd0e40a12e40a84e92920c80bcf464bb206c49241d2b386499a" +} diff --git a/docs/research/specification-coverage/captures/capture-6afc59f304f1e7367a62e598807df1ada75ab934c40579eefd5973a0098c6b3e/analysis.json b/docs/research/specification-coverage/captures/capture-6afc59f304f1e7367a62e598807df1ada75ab934c40579eefd5973a0098c6b3e/analysis.json new file mode 100644 index 0000000000..314a195ff7 --- /dev/null +++ b/docs/research/specification-coverage/captures/capture-6afc59f304f1e7367a62e598807df1ada75ab934c40579eefd5973a0098c6b3e/analysis.json @@ -0,0 +1,93 @@ +{ + "analysis_id": "issue-1479-oci-anonymous-token-specification-analysis-fc45184b2a54", + "backend_leakage": [], + "claim": { + "allowed_evidence": [ + "pinned source metadata and bounded paraphrases", + "production parser, semantic, instantiation, admission, compiler, contract, and profile results", + "exact artifact digests and typed pointers", + "documented missing-concept and backend-specific dispositions" + ], + "claim_id": "raes-standardized-configurable-specification-coverage", + "disallowed_evidence": [ + "field-count or schema breadth alone", + "the existing scenario stress corpus as the representative request corpus", + "free-form metadata as typed coverage", + "backend-private interpretation", + "post-hoc removal or repair of falsifying concepts" + ], + "evidence_artifacts": [ + "docs/research/specification-coverage/protocol-v1.json", + "@snapshot", + "docs/research/specification-coverage/analysis-v68.json" + ], + "falsification_protocol": "docs/research/specification-coverage/protocol-v1.json", + "objective_fail_criteria": "A load-bearing concept is missing or lossy, an applicable stage fails, or backend vocabulary is required in core SDL while the result claims success.", + "objective_pass_criteria": "Every load-bearing concept passes at every owning stage, backend-specific mechanics stay outside core SDL, and no requested concept is silently lost.", + "statement": "RAES provides a standardized configurable portable specification surface for the preregistered representative cyber-agent evaluation environment requirements without backend vocabulary in core SDL.", + "threats_to_validity": [ + "The representative corpus contains four source strata and sixteen atomic concepts rather than every cyber-range requirement.", + "The reference processor and repository fixtures are not independent backend implementations.", + "No live range, simulator federation, or participant execution was part of this offline specification-coverage test." + ] + }, + "classification_counts": { + "deliberately-backend-specific": 1, + "directly-expressible": 10, + "missing": 3, + "profile-or-manifest-constraint": 2 + }, + "evidence_status": "partial", + "execution_status": "complete", + "generated_at": "2026-10-29T09:42:23.019833+00:00", + "limitations": [ + "This is bounded specification coverage, not universal range coverage, usability, adoption, backend substitution or behavioral equivalence.", + "The retained protocol does not test recursive realization, plan allocation or live participant configuration.", + "EXP-719 factorial generation, randomized allocation and participant configuration evidence are verified by dedicated regression tests; this retained offline corpus makes no additional treatment, runtime or backend realization claim.", + "Issue 1549 external-backend compatibility and trial realization are verified by dedicated regression tests; this retained offline corpus makes no independent-backend execution claim.", + "Issue 1520 condition membership is verified by dedicated experiment-authoring regressions. This retained offline corpus adds no ontology, domain completeness, or execution claim.", + "This retained corpus does not establish native creator attribution or backend execution conformance for descendant inventory.", + "This retained offline corpus adds no modular control runtime or independent backend conformance claim. Issue 1071 has separate bounded runtime probes.", + "Issue 1629 shared runtime sequencing, Temporal recovery and authored retry behavior have separate targeted tests; this offline corpus adds no live backend or durable workflow assurance." + ], + "load_bearing_results": { + "failed": 0, + "missing": 0, + "passed": 10, + "total": 10 + }, + "plain_language_outcome": "The retained specification matrix reproduces its classifications on the combined source of current dev and issue #1479's anonymous bearer-token flow for OCI module fetches. Bounded claims and untested concepts are unchanged.", + "protocol_revision": "1.0.0", + "request_results": [ + { + "concept_count": 6, + "failed_stage_count": 0, + "missing_count": 0, + "request_id": "survey-representative-range", + "status": "demonstrated" + }, + { + "concept_count": 5, + "failed_stage_count": 1, + "missing_count": 1, + "request_id": "cyborg-participant-evaluation", + "status": "partial" + }, + { + "concept_count": 3, + "failed_stage_count": 1, + "missing_count": 1, + "request_id": "vsdl-configurable-infrastructure", + "status": "partial" + }, + { + "concept_count": 2, + "failed_stage_count": 1, + "missing_count": 1, + "request_id": "cyber-dem-federation", + "status": "partial" + } + ], + "snapshot_id": "issue-1479-oci-anonymous-token-specification-fc45184b2a54", + "snapshot_sha256": "62f77c9d8ec8b650969e9f260e5d68b2b12a23ebf8d516b8f95e0717b245c399" +} diff --git a/docs/research/specification-coverage/captures/capture-6afc59f304f1e7367a62e598807df1ada75ab934c40579eefd5973a0098c6b3e/manifest.json b/docs/research/specification-coverage/captures/capture-6afc59f304f1e7367a62e598807df1ada75ab934c40579eefd5973a0098c6b3e/manifest.json new file mode 100644 index 0000000000..9536130f8b --- /dev/null +++ b/docs/research/specification-coverage/captures/capture-6afc59f304f1e7367a62e598807df1ada75ab934c40579eefd5973a0098c6b3e/manifest.json @@ -0,0 +1,10 @@ +{ + "analysis_path": "docs/research/specification-coverage/captures/capture-6afc59f304f1e7367a62e598807df1ada75ab934c40579eefd5973a0098c6b3e/analysis.json", + "analysis_sha256": "fd4d238df407c913755f9c706b683d3ff7fc795ba939ceb00fa5acf828894d06", + "bundle_id": "raes-standardized-specification-coverage", + "protocol_path": "docs/research/specification-coverage/protocol-v1.json", + "protocol_sha256": "e97a19e643e94c9e589dca823a63c6ce49d3329fe2a3cb888ab630838ed93125", + "revision": "capture-6afc59f304f1e7367a62e598807df1ada75ab934c40579eefd5973a0098c6b3e", + "snapshot_path": "docs/research/specification-coverage/captures/capture-6afc59f304f1e7367a62e598807df1ada75ab934c40579eefd5973a0098c6b3e/snapshot.json", + "snapshot_sha256": "78630620b74bdcc87243dce75d68bf57a9b4ab930cf3842b967eaa53a85f5f57" +} diff --git a/docs/research/specification-coverage/captures/capture-6afc59f304f1e7367a62e598807df1ada75ab934c40579eefd5973a0098c6b3e/snapshot.json b/docs/research/specification-coverage/captures/capture-6afc59f304f1e7367a62e598807df1ada75ab934c40579eefd5973a0098c6b3e/snapshot.json new file mode 100644 index 0000000000..4ffb7cfd5e --- /dev/null +++ b/docs/research/specification-coverage/captures/capture-6afc59f304f1e7367a62e598807df1ada75ab934c40579eefd5973a0098c6b3e/snapshot.json @@ -0,0 +1,688 @@ +{ + "artifacts": [ + { + "artifact_id": "enterprise-participant-sdl", + "kind": "sdl", + "path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "sha256": "f7a8897beec243e188ee081975006fad32725f469f267db6e75a1e1cf5727032", + "validator": "raes parse, semantic, instantiation/admission, and compiler pipeline" + }, + { + "artifact_id": "port-range-sdl", + "kind": "sdl", + "path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "sha256": "0d5497ec946b863e6985284ec487dde7d7f6bf710a985be51401ac0e5e79dc4f", + "validator": "raes parse, semantic, instantiation/admission, and compiler pipeline" + }, + { + "artifact_id": "experiment-task-contract", + "kind": "experiment-task", + "path": "contracts/fixtures/experiment-core/experiment-task-v1/valid/reference.json", + "sha256": "f3edf713ac6af26bad609136851c6dd434bfb87ce919a2d8c4414c1035deeafc", + "validator": "raes_contracts.contracts.ExperimentTaskModel" + }, + { + "artifact_id": "apparatus-context-contract", + "kind": "experiment-apparatus-context", + "path": "contracts/fixtures/experiment-core/experiment-apparatus-context-v1/valid/reference.json", + "sha256": "e6fa559c5e961f0aab448d0f70dead24aa74fa8ba5f20e1b72f88e11473c9299", + "validator": "raes_contracts.contracts.ExperimentApparatusContextModel" + }, + { + "artifact_id": "backend-profile", + "kind": "backend-profile", + "path": "contracts/profiles/backend/orchestration-capable.json", + "sha256": "f70b8505a5c0055416db86c533e2e5bf08b11e5a514f076223b6d6c36215a092", + "validator": "raes_contracts.backend_profiles.BackendProfileModel" + }, + { + "artifact_id": "known-limitations", + "kind": "documentation", + "path": "docs/explain/sdl/limitations.md", + "sha256": "489eeab3ce682627682311581eb98af9abb9ff42a437145af266eefb71dc7fc4", + "validator": "documentation evidence only" + } + ], + "baseline": { + "release_revision": "1.1.0", + "release_sha256": "4020a1d56c7fe2831cec59ea64a12bbda9d38ccd94f93b916dd90f1a28f17fcb" + }, + "captured_at": "2026-10-29T09:42:23.019833+00:00", + "concept_results": [ + { + "backend_support": "not-evaluated", + "backend_vocabulary_occurrences": [], + "classification": "directly-expressible", + "completeness_disposition": "implemented", + "concept_id": "range-topology", + "rationale": "SDL nodes and infrastructure own host, network, link, and dependency meaning; the compiler emits canonical node deployment addresses.", + "stage_results": [ + { + "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "diagnostic_codes": [], + "note": "Fresh production replay confirms this declared typed pointer.", + "outcome": "passed", + "pointer": "/nodes/shipping-portal", + "stage_id": "authored", + "validation_strength": "structural" + }, + { + "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "diagnostic_codes": [], + "note": "Fresh production replay confirms this declared typed pointer.", + "outcome": "passed", + "pointer": "/infrastructure/shipping-portal", + "stage_id": "semantic", + "validation_strength": "semantic" + }, + { + "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "diagnostic_codes": [], + "note": "Fresh production replay confirms this declared typed pointer.", + "outcome": "passed", + "pointer": "/nodes/shipping-portal", + "stage_id": "instantiated", + "validation_strength": "phase-admitted" + }, + { + "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "diagnostic_codes": [], + "note": "Fresh production replay confirms this declared typed pointer.", + "outcome": "passed", + "pointer": "/node_deployments/provision.node.shipping-portal", + "stage_id": "compiled", + "validation_strength": "compiled" + } + ], + "typed_pointer": "/nodes/shipping-portal" + }, + { + "backend_support": "not-evaluated", + "backend_vocabulary_occurrences": [], + "classification": "directly-expressible", + "completeness_disposition": "implemented", + "concept_id": "exercise-roles", + "rationale": "SDL entity roles own exercise responsibility without becoming control-plane identity or authorization.", + "stage_results": [ + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Fresh production replay confirms this declared typed pointer.", + "outcome": "passed", + "pointer": "/entities/enterprise-participant/role", + "stage_id": "authored", + "validation_strength": "structural" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Fresh production replay confirms this declared typed pointer.", + "outcome": "passed", + "pointer": "/entities/enterprise-participant", + "stage_id": "semantic", + "validation_strength": "semantic" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Fresh production replay confirms this declared typed pointer.", + "outcome": "passed", + "pointer": "/entities/enterprise-participant/role", + "stage_id": "instantiated", + "validation_strength": "phase-admitted" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Fresh production replay confirms this declared typed pointer.", + "outcome": "passed", + "pointer": "/entity_specs/enterprise-participant/role", + "stage_id": "compiled", + "validation_strength": "compiled" + } + ], + "typed_pointer": "/entities/enterprise-participant/role" + }, + { + "backend_support": "not-evaluated", + "backend_vocabulary_occurrences": [], + "classification": "directly-expressible", + "completeness_disposition": "implemented", + "concept_id": "evaluation-objectives", + "rationale": "SDL objectives own organization ownership, participant assignment, targets, windows, and assertion-based success; measures remain experiment contracts.", + "stage_results": [ + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Fresh production replay confirms this declared typed pointer.", + "outcome": "passed", + "pointer": "/objectives/demonstrate-handoff", + "stage_id": "authored", + "validation_strength": "structural" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Fresh production replay confirms this declared typed pointer.", + "outcome": "passed", + "pointer": "/objectives/demonstrate-handoff/success", + "stage_id": "semantic", + "validation_strength": "semantic" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Fresh production replay confirms this declared typed pointer.", + "outcome": "passed", + "pointer": "/objectives/demonstrate-handoff", + "stage_id": "instantiated", + "validation_strength": "phase-admitted" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Fresh production replay confirms this declared typed pointer.", + "outcome": "passed", + "pointer": "/objectives/evaluation.objective.demonstrate-handoff", + "stage_id": "compiled", + "validation_strength": "compiled" + } + ], + "typed_pointer": "/objectives/demonstrate-handoff" + }, + { + "backend_support": "not-evaluated", + "backend_vocabulary_occurrences": [], + "classification": "directly-expressible", + "completeness_disposition": "implemented", + "concept_id": "control-workflows", + "rationale": "SDL workflows own the portable control graph and compile to canonical orchestration state contracts.", + "stage_results": [ + { + "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "diagnostic_codes": [], + "note": "Fresh production replay confirms this declared typed pointer.", + "outcome": "passed", + "pointer": "/workflows/yard-recovery", + "stage_id": "authored", + "validation_strength": "structural" + }, + { + "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "diagnostic_codes": [], + "note": "Fresh production replay confirms this declared typed pointer.", + "outcome": "passed", + "pointer": "/workflows/yard-recovery/steps", + "stage_id": "semantic", + "validation_strength": "semantic" + }, + { + "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "diagnostic_codes": [], + "note": "Fresh production replay confirms this declared typed pointer.", + "outcome": "passed", + "pointer": "/workflows/yard-recovery", + "stage_id": "instantiated", + "validation_strength": "phase-admitted" + }, + { + "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "diagnostic_codes": [], + "note": "Fresh production replay confirms this declared typed pointer.", + "outcome": "passed", + "pointer": "/workflows/orchestration.workflow.yard-recovery", + "stage_id": "compiled", + "validation_strength": "compiled" + } + ], + "typed_pointer": "/workflows/yard-recovery" + }, + { + "backend_support": "not-evaluated", + "backend_vocabulary_occurrences": [], + "classification": "directly-expressible", + "completeness_disposition": "implemented", + "concept_id": "authored-evidence-expectations", + "rationale": "SDL evidence requirements own portable capture intent and remain distinct from evidence records and measures.", + "stage_results": [ + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Fresh production replay confirms this declared typed pointer.", + "outcome": "passed", + "pointer": "/evidence_requirements/objective-truth-evidence", + "stage_id": "authored", + "validation_strength": "structural" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Fresh production replay confirms this declared typed pointer.", + "outcome": "passed", + "pointer": "/evidence_requirements/objective-truth-evidence", + "stage_id": "semantic", + "validation_strength": "semantic" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Fresh production replay confirms this declared typed pointer.", + "outcome": "passed", + "pointer": "/evidence_requirements/objective-truth-evidence", + "stage_id": "instantiated", + "validation_strength": "phase-admitted" + } + ], + "typed_pointer": "/evidence_requirements/objective-truth-evidence" + }, + { + "backend_support": "profile-bound", + "backend_vocabulary_occurrences": [], + "classification": "profile-or-manifest-constraint", + "completeness_disposition": "implemented", + "concept_id": "apparatus-selection-constraints", + "rationale": "The experiment task contract binds processor/backend identities, manifest refs, and capabilities outside SDL.", + "stage_results": [ + { + "artifact_path": "contracts/fixtures/experiment-core/experiment-task-v1/valid/reference.json", + "diagnostic_codes": [], + "note": "Fresh production replay confirms this declared typed pointer.", + "outcome": "passed", + "pointer": "/apparatus_constraints/allowed_backend_refs/0", + "stage_id": "contract", + "validation_strength": "contract" + } + ], + "typed_pointer": "/apparatus_constraints/allowed_backend_refs/0" + }, + { + "backend_support": "not-evaluated", + "backend_vocabulary_occurrences": [], + "classification": "directly-expressible", + "completeness_disposition": "implemented", + "concept_id": "participant-agent", + "rationale": "SDL agents own participant entity, knowledge, actions, observation boundaries, and operating scope.", + "stage_results": [ + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Fresh production replay confirms this declared typed pointer.", + "outcome": "passed", + "pointer": "/agents/participant-agent", + "stage_id": "authored", + "validation_strength": "structural" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Fresh production replay confirms this declared typed pointer.", + "outcome": "passed", + "pointer": "/agents/participant-agent/observation_boundaries", + "stage_id": "semantic", + "validation_strength": "semantic" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Fresh production replay confirms this declared typed pointer.", + "outcome": "passed", + "pointer": "/agents/participant-agent", + "stage_id": "instantiated", + "validation_strength": "phase-admitted" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Fresh production replay confirms this declared typed pointer.", + "outcome": "passed", + "pointer": "/agent_specs/participant-agent", + "stage_id": "compiled", + "validation_strength": "compiled" + } + ], + "typed_pointer": "/agents/participant-agent" + }, + { + "backend_support": "not-evaluated", + "backend_vocabulary_occurrences": [], + "classification": "directly-expressible", + "completeness_disposition": "implemented", + "concept_id": "participant-action-contract", + "rationale": "The action contract declares portable preconditions, effects, observations, evidence, and failure classes without a runner command.", + "stage_results": [ + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Fresh production replay confirms this declared typed pointer.", + "outcome": "passed", + "pointer": "/action_contracts/probe-customer-portal-login", + "stage_id": "authored", + "validation_strength": "structural" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Fresh production replay confirms this declared typed pointer.", + "outcome": "passed", + "pointer": "/action_contracts/probe-customer-portal-login/effects", + "stage_id": "semantic", + "validation_strength": "semantic" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Fresh production replay confirms this declared typed pointer.", + "outcome": "passed", + "pointer": "/action_contracts/probe-customer-portal-login", + "stage_id": "instantiated", + "validation_strength": "phase-admitted" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Fresh production replay confirms this declared typed pointer.", + "outcome": "passed", + "pointer": "/action_contracts/participant.action-contract.probe-customer-portal-login", + "stage_id": "compiled", + "validation_strength": "compiled" + } + ], + "typed_pointer": "/action_contracts/probe-customer-portal-login" + }, + { + "backend_support": "not-evaluated", + "backend_vocabulary_occurrences": [], + "classification": "directly-expressible", + "completeness_disposition": "implemented", + "concept_id": "participant-observation-boundary", + "rationale": "The observation boundary separately declares visible, hidden, and evidence-only information with transition rules.", + "stage_results": [ + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Fresh production replay confirms this declared typed pointer.", + "outcome": "passed", + "pointer": "/observation_boundaries/participant-view", + "stage_id": "authored", + "validation_strength": "structural" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Fresh production replay confirms this declared typed pointer.", + "outcome": "passed", + "pointer": "/observation_boundaries/participant-view/view_rules", + "stage_id": "semantic", + "validation_strength": "semantic" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Fresh production replay confirms this declared typed pointer.", + "outcome": "passed", + "pointer": "/observation_boundaries/participant-view", + "stage_id": "instantiated", + "validation_strength": "phase-admitted" + }, + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "diagnostic_codes": [], + "note": "Fresh production replay confirms this declared typed pointer.", + "outcome": "passed", + "pointer": "/observation_boundaries/participant.observation-boundary.participant-view", + "stage_id": "compiled", + "validation_strength": "compiled" + } + ], + "typed_pointer": "/observation_boundaries/participant-view" + }, + { + "backend_support": "not-evaluated", + "backend_vocabulary_occurrences": [], + "classification": "directly-expressible", + "completeness_disposition": "implemented", + "concept_id": "evaluation-measure", + "rationale": "ExperimentTaskModel owns metric construct, unit, direction, aggregation, and evidence requirements outside SDL objectives.", + "stage_results": [ + { + "artifact_path": "contracts/fixtures/experiment-core/experiment-task-v1/valid/reference.json", + "diagnostic_codes": [], + "note": "Fresh production replay confirms this declared typed pointer.", + "outcome": "passed", + "pointer": "/evaluation_protocol/metric_definitions/foothold-achieved", + "stage_id": "contract", + "validation_strength": "contract" + } + ], + "typed_pointer": "/evaluation_protocol/metric_definitions/foothold-achieved" + }, + { + "backend_support": "not-evaluated", + "backend_vocabulary_occurrences": [], + "classification": "missing", + "completeness_disposition": "documented-gap", + "concept_id": "participant-tool-affordance", + "rationale": "This preregistered matrix has no tested carrier for participant tool affordances. The retained missing classification records missing coverage evidence, not the absence of current participant-behavior capabilities.", + "stage_results": [ + { + "artifact_path": "docs/explain/sdl/limitations.md", + "diagnostic_codes": [], + "note": "The preregistered carrier slot was not run; metadata does not substitute for a typed coverage test.", + "outcome": "not_run", + "pointer": null, + "stage_id": "authored", + "validation_strength": "not-applicable" + } + ], + "typed_pointer": null + }, + { + "backend_support": "not-evaluated", + "backend_vocabulary_occurrences": [], + "classification": "directly-expressible", + "completeness_disposition": "implemented", + "concept_id": "resource-constrained-topology", + "rationale": "SDL node resources and infrastructure dependencies express portable resource intent without provider resource identifiers.", + "stage_results": [ + { + "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "diagnostic_codes": [], + "note": "Fresh production replay confirms this declared typed pointer.", + "outcome": "passed", + "pointer": "/nodes/shipping-portal/resources", + "stage_id": "authored", + "validation_strength": "structural" + }, + { + "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "diagnostic_codes": [], + "note": "Fresh production replay confirms this declared typed pointer.", + "outcome": "passed", + "pointer": "/infrastructure/shipping-portal", + "stage_id": "semantic", + "validation_strength": "semantic" + }, + { + "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "diagnostic_codes": [], + "note": "Fresh production replay confirms this declared typed pointer.", + "outcome": "passed", + "pointer": "/nodes/shipping-portal/resources", + "stage_id": "instantiated", + "validation_strength": "phase-admitted" + }, + { + "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "diagnostic_codes": [], + "note": "Fresh production replay confirms this declared typed pointer.", + "outcome": "passed", + "pointer": "/node_deployments/provision.node.shipping-portal", + "stage_id": "compiled", + "validation_strength": "compiled" + } + ], + "typed_pointer": "/nodes/shipping-portal/resources" + }, + { + "backend_support": "not-evaluated", + "backend_vocabulary_occurrences": [], + "classification": "missing", + "completeness_disposition": "documented-gap", + "concept_id": "formal-constraint-satisfiability", + "rationale": "This coverage matrix did not exercise a solver-backed carrier. The separate formal-semantic-validation release demonstrates its bounded finite-domain profile; that result is not silently imported into this protocol's missing carrier slot.", + "stage_results": [ + { + "artifact_path": "docs/explain/sdl/limitations.md", + "diagnostic_codes": [], + "note": "No coverage-carrier execution was performed here; independent solver evidence does not change this preregistered denominator.", + "outcome": "not_run", + "pointer": null, + "stage_id": "semantic", + "validation_strength": "not-applicable" + } + ], + "typed_pointer": null + }, + { + "backend_support": "profile-bound", + "backend_vocabulary_occurrences": [ + { + "allowed": true, + "artifact_path": "source:vsdl-paper", + "pointer": "source sections 4-5", + "reason": "Legitimate VSDL realization vocabulary, not RAES core SDL structure.", + "term": "OpenStack/Terraform/Packer" + } + ], + "classification": "deliberately-backend-specific", + "completeness_disposition": "external", + "concept_id": "provider-specific-provisioning", + "rationale": "Provider image selection and provisioning engines are realization mechanics and therefore remain outside core SDL.", + "stage_results": [ + { + "artifact_path": "contracts/profiles/backend/orchestration-capable.json", + "diagnostic_codes": [], + "note": "The portable boundary requires backend contracts; it does not standardize a provider engine.", + "outcome": "not_applicable", + "pointer": "/required_contracts", + "stage_id": "realization-disclosure", + "validation_strength": "profile" + } + ], + "typed_pointer": null + }, + { + "backend_support": "profile-bound", + "backend_vocabulary_occurrences": [], + "classification": "profile-or-manifest-constraint", + "completeness_disposition": "implemented", + "concept_id": "apparatus-clock-context", + "rationale": "ExperimentApparatusContextModel records clock authority, time domain, and synchronization as apparatus facts outside scenario meaning.", + "stage_results": [ + { + "artifact_path": "contracts/fixtures/experiment-core/experiment-apparatus-context-v1/valid/reference.json", + "diagnostic_codes": [], + "note": "Fresh production replay confirms this declared typed pointer.", + "outcome": "passed", + "pointer": "/clocks/0", + "stage_id": "contract", + "validation_strength": "contract" + } + ], + "typed_pointer": "/clocks/0" + }, + { + "backend_support": "not-evaluated", + "backend_vocabulary_occurrences": [], + "classification": "missing", + "completeness_disposition": "documented-gap", + "concept_id": "federated-object-event-exchange", + "rationale": "The federated cyber object/event exchange carrier was not exercised by this preregistered matrix. Runtime event internals are not treated as equivalent evidence.", + "stage_results": [ + { + "artifact_path": "docs/explain/sdl/limitations.md", + "diagnostic_codes": [], + "note": "The missing coverage-carrier test is recorded explicitly, without inferring an ecosystem-wide capability absence.", + "outcome": "not_run", + "pointer": null, + "stage_id": "contract", + "validation_strength": "not-applicable" + } + ], + "typed_pointer": null + } + ], + "deviations": [ + { + "artifact_path": "examples/scenarios/enterprise-participant-evidence-loop.sdl.yaml", + "baseline_sha256": "54ba1a60220e27a55da9cd2a407d7d3ab836fa54460d0b0c6cad87c2e744ddbb", + "rationale": "Current governed artifact bytes were replayed through their production boundary; historical baseline bytes remain retained.", + "retest_sha256": "f7a8897beec243e188ee081975006fad32725f469f267db6e75a1e1cf5727032" + }, + { + "artifact_path": "examples/scenarios/port-authority-surge-response.sdl.yaml", + "baseline_sha256": "a27c7a64e0c5c618fadaccafdf1a4e71600170a8b77b983190822b5141f00dec", + "rationale": "Current governed artifact bytes were replayed through their production boundary; historical baseline bytes remain retained.", + "retest_sha256": "0d5497ec946b863e6985284ec487dde7d7f6bf710a985be51401ac0e5e79dc4f" + }, + { + "artifact_path": "contracts/fixtures/experiment-core/experiment-task-v1/valid/reference.json", + "baseline_sha256": "21952a752f4e8581a9fc3b872e4bc308150548170d38bcfc83dbbe35ff5e0b9f", + "rationale": "Current governed artifact bytes were replayed through their production boundary; historical baseline bytes remain retained.", + "retest_sha256": "f3edf713ac6af26bad609136851c6dd434bfb87ce919a2d8c4414c1035deeafc" + }, + { + "artifact_path": "contracts/fixtures/experiment-core/experiment-apparatus-context-v1/valid/reference.json", + "baseline_sha256": "9536d897a09cbc6920e667e4f8f9371e51307aa0b3b5ff3c7de682dd783420ab", + "rationale": "Current governed artifact bytes were replayed through their production boundary; historical baseline bytes remain retained.", + "retest_sha256": "e6fa559c5e961f0aab448d0f70dead24aa74fa8ba5f20e1b72f88e11473c9299" + }, + { + "artifact_path": "docs/explain/sdl/limitations.md", + "baseline_sha256": "129cf17810aad4c51988bc872e28fe43ae95019a80053c42d800ff7e2b9cc93e", + "rationale": "Current governed artifact bytes were replayed through their production boundary; historical baseline bytes remain retained.", + "retest_sha256": "489eeab3ce682627682311581eb98af9abb9ff42a437145af266eefb71dc7fc4" + } + ], + "execution_status": "complete", + "implementation_surfaces": [ + { + "content_sha256": "eb8ebd50cc5c949f230f5fe922f15dda22a5ccff320056bd5b9bc1308ecdc593", + "path": "implementations/python/packages/raes_contracts", + "surface_id": "contract-models" + }, + { + "content_sha256": "7be699847c2430f451a406c96fd85211e3556afb36a853dd45fc43ab35fc64a6", + "path": "implementations/python/packages/raes_processor", + "surface_id": "processor-pipeline" + }, + { + "content_sha256": "615acb91e687580e5601045994e506ebe78f8039eb59e908d2b9c8d25fa1d310", + "path": "implementations/python/packages/raes", + "surface_id": "sdl-pipeline" + } + ], + "limitations": [ + "The execution validates the pinned reference implementation and published contracts, not an independent backend.", + "Repository-owned examples are exact execution artifacts; the preregistered requests and concepts remain the coverage corpus.", + "No live range, participant, simulator federation or provider provisioning engine was executed.", + "Missing concepts retain the preregistered classification and bounded claims.", + "EXP-719 factorial generation, randomized allocation and participant configuration evidence are verified by dedicated regression tests; this retained offline corpus makes no additional treatment, runtime or backend realization claim.", + "Issue 1549 external-backend compatibility and trial realization are verified by dedicated regression tests; this retained offline corpus makes no independent-backend execution claim.", + "Issue 1520 condition membership is verified by dedicated experiment-authoring regressions. This retained offline corpus adds no ontology, domain completeness, or execution claim.", + "API-414 declarations and capacity checks have dedicated targeted tests. This offline corpus establishes no native participant tool execution.", + "This retained offline corpus adds no modular control runtime or independent backend conformance claim. Issue 1071 has separate bounded runtime probes.", + "Issue 1629 shared runtime sequencing, Temporal recovery and authored retry behavior have separate targeted tests; this offline corpus adds no live backend or durable workflow assurance." + ], + "protocol_revision": "1.0.0", + "protocol_sha256": "e97a19e643e94c9e589dca823a63c6ce49d3329fe2a3cb888ab630838ed93125", + "raes_revision": "1bde15cbff6ac3dea1811fe34ba8f39588a967d1", + "snapshot_id": "issue-1479-oci-anonymous-token-specification-fc45184b2a54", + "snapshot_revision": "1.0.0", + "source_state": { + "base_revision": "1bde15cbff6ac3dea1811fe34ba8f39588a967d1", + "checkout_state": "clean", + "implementation_digest": "fc45184b2a54c697bd56863a0f8ed76286fa5d4d45e540bb602299f7dd94c0fc", + "profile": "python-reference-source/v2" + } +} From 2fe1d864de3c4266b43ee9947e06c6e6d5f162eb Mon Sep 17 00:00:00 2001 From: Yernat Yestekov <2068106+doublewhy@users.noreply.github.com> Date: Thu, 29 Oct 2026 10:04:45 +0000 Subject: [PATCH 10/11] test: record the runtime mapping capture for the merged source --- .../cases.json | 1 + .../manifest.json | 1 + 2 files changed, 2 insertions(+) create mode 100644 specs/formal/participant-semantics/runtime-mapping/capture-0e6b342e0d43a23d262829641881c33c4a9e525cc52dc5981152e62390245538/cases.json create mode 100644 specs/formal/participant-semantics/runtime-mapping/capture-0e6b342e0d43a23d262829641881c33c4a9e525cc52dc5981152e62390245538/manifest.json diff --git a/specs/formal/participant-semantics/runtime-mapping/capture-0e6b342e0d43a23d262829641881c33c4a9e525cc52dc5981152e62390245538/cases.json b/specs/formal/participant-semantics/runtime-mapping/capture-0e6b342e0d43a23d262829641881c33c4a9e525cc52dc5981152e62390245538/cases.json new file mode 100644 index 0000000000..0b3c99ec07 --- /dev/null +++ b/specs/formal/participant-semantics/runtime-mapping/capture-0e6b342e0d43a23d262829641881c33c4a9e525cc52dc5981152e62390245538/cases.json @@ -0,0 +1 @@ +{"egress/deny":{"backend_calls":0,"backend_conformance":"not-established","classification":"incompatible","configuration":{"control_providers_selected":false,"declared_support":[["participant_boundary_flow_resolution","unsupported"],["participant_declassification","unsupported"],["participant_directed_inject_delivery","unsupported"],["participant_egress_projection","exact"],["participant_final_sink_mediation","unsupported"],["participant_ingress_admission","unsupported"],["participant_intervention","unsupported"],["participant_modular_control","unsupported"],["participant_monitor_topology","unsupported"],["participant_predicate_opacity","unsupported"],["participant_processing_role_trust","unsupported"],["participant_quarantined_processing","unsupported"],["participant_transformation","exact"],["scoped_tool_affordances","unsupported"],["tool_affordances","unsupported"]],"operating_profile":null,"store":"memory","store_capabilities":["store.atomic-claims","store.atomic-terminal","store.audit","store.ephemeral","store.revision-cas","store.scope-bound"]},"crossing_rows_added":2,"cut":"p0","entry_point":"get_participant_status_view","equivalence_result":"not-established","events":[{"coordinates":{},"facts":{},"label":"crossing.request","ordinal":0},{"coordinates":{},"facts":{},"label":"internal.validate","ordinal":1},{"coordinates":{"cut":"p0"},"facts":{},"label":"internal.resolve-policy-cut","ordinal":2},{"coordinates":{"capability":"supported","gate":"permit"},"facts":{"effective_levels":[["participant_egress_projection","exact"],["participant_transformation","exact"]],"gates":{"action_admission":"not-applicable","backend_support":"permit","caller_authorization":"permit","declassification":"not-applicable","marking_authorization":"permit","participant_authority":"permit","target_authorization":"permit","transformation_validity":"permit","visibility":"permit"}},"label":"internal.resolve-capability","ordinal":3},{"coordinates":{"decision":"permit"},"facts":{},"label":"crossing.decision.permit","ordinal":4},{"coordinates":{},"facts":{},"label":"internal.prepare-record","ordinal":5},{"coordinates":{"head":"h1"},"facts":{"crossing_rows":2,"operation_state":"failed"},"label":"internal.atomic-commit","ordinal":6}],"final_sink_enforced":true,"input_class":"plain","issues":["final-outcome-mismatch","incomplete-observation","unmodeled-error"],"observation_gaps":["incomplete-observation"],"observed_error":"PermissionError","operation_outcomes":["failed"],"operation_records_added":1,"runtime_binding":{"audience":"audience:red-operator","controller":"runtime.control-plane.participant-retrieval","episode":"episode-1","participant":"participant.behavior.red-agent","policy_cuts":["participant-policy-cut:red:episode-1:8","participant-policy-cut:red:episode-1:8.p1"],"principal":"operator.red","run_scope":"run:default","target":"stub"},"runtime_realization":"not-established","runtime_safety_issues":[],"snapshot_revisions":[1,2],"states":[{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":null,"last":null,"phase":"idle"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","plain","p0","fresh"],"last":null,"phase":"validating"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","plain","p0","fresh"],"last":null,"phase":"resolving-cut"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","plain","p0","fresh"],"last":null,"phase":"resolving-capability"},{"capability":"supported","cut":"p0","decision":"none","delivery":"none","gate":"permit","head":"h0","intent":["request-0","plain","p0","fresh"],"last":null,"phase":"gating"},{"capability":"supported","cut":"p0","decision":"permit","delivery":"pending","gate":"permit","head":"h0","intent":["request-0","plain","p0","fresh"],"last":null,"phase":"preparing-record"},{"capability":"supported","cut":"p0","decision":"permit","delivery":"pending","gate":"permit","head":"h0","intent":["request-0","plain","p0","fresh"],"last":null,"phase":"committing"},{"capability":"supported","cut":"p0","decision":"permit","delivery":"pending","gate":"permit","head":"h1","intent":["request-0","plain","p0","fresh"],"last":["request-0","p0","permit"],"phase":"committing"}],"unexercised":["enabled-choice-completeness","production-backend","independent-reproduction"],"visible_events":["crossing.request","crossing.decision.permit"]},"egress/permit":{"backend_calls":0,"backend_conformance":"not-established","classification":"observation-gap","configuration":{"control_providers_selected":false,"declared_support":[["participant_boundary_flow_resolution","unsupported"],["participant_declassification","unsupported"],["participant_directed_inject_delivery","unsupported"],["participant_egress_projection","exact"],["participant_final_sink_mediation","unsupported"],["participant_ingress_admission","unsupported"],["participant_intervention","unsupported"],["participant_modular_control","unsupported"],["participant_monitor_topology","unsupported"],["participant_predicate_opacity","unsupported"],["participant_processing_role_trust","unsupported"],["participant_quarantined_processing","unsupported"],["participant_transformation","exact"],["scoped_tool_affordances","unsupported"],["tool_affordances","unsupported"]],"operating_profile":null,"store":"memory","store_capabilities":["store.atomic-claims","store.atomic-terminal","store.audit","store.ephemeral","store.revision-cas","store.scope-bound"]},"crossing_rows_added":2,"cut":"p0","entry_point":"get_participant_status_view","equivalence_result":"not-established","events":[{"coordinates":{},"facts":{},"label":"crossing.request","ordinal":0},{"coordinates":{},"facts":{},"label":"internal.validate","ordinal":1},{"coordinates":{"cut":"p0"},"facts":{},"label":"internal.resolve-policy-cut","ordinal":2},{"coordinates":{"capability":"supported","gate":"permit"},"facts":{"effective_levels":[["participant_egress_projection","exact"],["participant_transformation","exact"]],"gates":{"action_admission":"not-applicable","backend_support":"permit","caller_authorization":"permit","declassification":"not-applicable","marking_authorization":"permit","participant_authority":"permit","target_authorization":"permit","transformation_validity":"permit","visibility":"permit"}},"label":"internal.resolve-capability","ordinal":3},{"coordinates":{"decision":"permit"},"facts":{},"label":"crossing.decision.permit","ordinal":4},{"coordinates":{},"facts":{},"label":"internal.prepare-record","ordinal":5},{"coordinates":{"head":"h1"},"facts":{"crossing_rows":2,"operation_state":"succeeded"},"label":"internal.atomic-commit","ordinal":6}],"final_sink_enforced":true,"input_class":"plain","issues":["incomplete-observation"],"observation_gaps":["incomplete-observation"],"observed_error":null,"operation_outcomes":["succeeded"],"operation_records_added":1,"runtime_binding":{"audience":"audience:red-operator","controller":"runtime.control-plane.participant-retrieval","episode":"episode-1","participant":"participant.behavior.red-agent","policy_cuts":["participant-policy-cut:red:episode-1:8","participant-policy-cut:red:episode-1:8.p1"],"principal":"operator.red","run_scope":"run:default","target":"stub"},"runtime_realization":"not-established","runtime_safety_issues":[],"snapshot_revisions":[1,2],"states":[{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":null,"last":null,"phase":"idle"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","plain","p0","fresh"],"last":null,"phase":"validating"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","plain","p0","fresh"],"last":null,"phase":"resolving-cut"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","plain","p0","fresh"],"last":null,"phase":"resolving-capability"},{"capability":"supported","cut":"p0","decision":"none","delivery":"none","gate":"permit","head":"h0","intent":["request-0","plain","p0","fresh"],"last":null,"phase":"gating"},{"capability":"supported","cut":"p0","decision":"permit","delivery":"pending","gate":"permit","head":"h0","intent":["request-0","plain","p0","fresh"],"last":null,"phase":"preparing-record"},{"capability":"supported","cut":"p0","decision":"permit","delivery":"pending","gate":"permit","head":"h0","intent":["request-0","plain","p0","fresh"],"last":null,"phase":"committing"},{"capability":"supported","cut":"p0","decision":"permit","delivery":"pending","gate":"permit","head":"h1","intent":["request-0","plain","p0","fresh"],"last":["request-0","p0","permit"],"phase":"committing"}],"unexercised":["enabled-choice-completeness","production-backend","independent-reproduction"],"visible_events":["crossing.request","crossing.decision.permit"]},"ingress/backend-failure":{"backend_calls":1,"backend_conformance":"not-established","classification":"incompatible","configuration":{"control_providers_selected":false,"declared_support":[["participant_boundary_flow_resolution","unsupported"],["participant_declassification","unsupported"],["participant_directed_inject_delivery","unsupported"],["participant_egress_projection","unsupported"],["participant_final_sink_mediation","unsupported"],["participant_ingress_admission","exact"],["participant_intervention","unsupported"],["participant_modular_control","unsupported"],["participant_monitor_topology","unsupported"],["participant_predicate_opacity","unsupported"],["participant_processing_role_trust","unsupported"],["participant_quarantined_processing","unsupported"],["participant_transformation","unsupported"],["scoped_tool_affordances","unsupported"],["tool_affordances","unsupported"]],"operating_profile":null,"store":"memory","store_capabilities":["store.atomic-claims","store.atomic-terminal","store.audit","store.ephemeral","store.revision-cas","store.scope-bound"]},"crossing_rows_added":2,"cut":"p0","entry_point":"admit_participant_action","equivalence_result":"not-established","events":[{"coordinates":{},"facts":{},"label":"crossing.request","ordinal":0},{"coordinates":{},"facts":{},"label":"internal.validate","ordinal":1},{"coordinates":{"cut":"p0"},"facts":{},"label":"internal.resolve-policy-cut","ordinal":2},{"coordinates":{"capability":"supported","gate":"permit"},"facts":{"effective_levels":[["participant_ingress_admission","exact"]],"gates":{"action_admission":"permit","backend_support":"permit","caller_authorization":"permit","declassification":"not-applicable","marking_authorization":"permit","participant_authority":"permit","target_authorization":"permit","transformation_validity":"not-applicable","visibility":"not-applicable"}},"label":"internal.resolve-capability","ordinal":3},{"coordinates":{"decision":"permit"},"facts":{},"label":"crossing.decision.permit","ordinal":4},{"coordinates":{},"facts":{},"label":"internal.prepare-record","ordinal":5},{"coordinates":{"head":"h1"},"facts":{"crossing_rows":2,"operation_state":"running"},"label":"internal.atomic-commit","ordinal":6}],"final_sink_enforced":false,"input_class":"plain","issues":["external-application-outside-crossing-model","incomplete-observation"],"observation_gaps":["incomplete-observation"],"observed_error":null,"operation_outcomes":["failed"],"operation_records_added":1,"runtime_binding":{"audience":"audience:red-operator","controller":"participant.behavior.supervisor","episode":"episode-1","participant":"participant.behavior.red-agent","policy_cuts":["participant-policy-cut:red:episode-1:8","participant-policy-cut:red:episode-1:8.p1"],"principal":"operator.red","run_scope":"run:default","target":"stub"},"runtime_realization":"not-established","runtime_safety_issues":[],"snapshot_revisions":[1,3],"states":[{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":null,"last":null,"phase":"idle"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","plain","p0","fresh"],"last":null,"phase":"validating"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","plain","p0","fresh"],"last":null,"phase":"resolving-cut"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","plain","p0","fresh"],"last":null,"phase":"resolving-capability"},{"capability":"supported","cut":"p0","decision":"none","delivery":"none","gate":"permit","head":"h0","intent":["request-0","plain","p0","fresh"],"last":null,"phase":"gating"},{"capability":"supported","cut":"p0","decision":"permit","delivery":"pending","gate":"permit","head":"h0","intent":["request-0","plain","p0","fresh"],"last":null,"phase":"preparing-record"},{"capability":"supported","cut":"p0","decision":"permit","delivery":"pending","gate":"permit","head":"h0","intent":["request-0","plain","p0","fresh"],"last":null,"phase":"committing"},{"capability":"supported","cut":"p0","decision":"permit","delivery":"pending","gate":"permit","head":"h1","intent":["request-0","plain","p0","fresh"],"last":["request-0","p0","permit"],"phase":"committing"}],"unexercised":["enabled-choice-completeness","production-backend","independent-reproduction"],"visible_events":["crossing.request","crossing.decision.permit"]},"ingress/declassify/p0":{"backend_calls":0,"backend_conformance":"not-established","classification":"match","configuration":{"control_providers_selected":false,"declared_support":[["participant_boundary_flow_resolution","unsupported"],["participant_declassification","exact"],["participant_directed_inject_delivery","unsupported"],["participant_egress_projection","unsupported"],["participant_final_sink_mediation","unsupported"],["participant_ingress_admission","exact"],["participant_intervention","unsupported"],["participant_modular_control","unsupported"],["participant_monitor_topology","unsupported"],["participant_predicate_opacity","unsupported"],["participant_processing_role_trust","unsupported"],["participant_quarantined_processing","unsupported"],["participant_transformation","exact"],["scoped_tool_affordances","unsupported"],["tool_affordances","unsupported"]],"operating_profile":null,"store":"memory","store_capabilities":["store.atomic-claims","store.atomic-terminal","store.audit","store.ephemeral","store.revision-cas","store.scope-bound"]},"crossing_rows_added":2,"cut":"p0","entry_point":"admit_participant_action","equivalence_result":"not-established","events":[{"coordinates":{},"facts":{},"label":"crossing.request","ordinal":0},{"coordinates":{},"facts":{},"label":"internal.validate","ordinal":1},{"coordinates":{"cut":"p0"},"facts":{},"label":"internal.resolve-policy-cut","ordinal":2},{"coordinates":{"capability":"supported","gate":"deny"},"facts":{"effective_levels":[["participant_ingress_admission","exact"]],"gates":{"action_admission":"permit","backend_support":"permit","caller_authorization":"permit","declassification":"deny","marking_authorization":"permit","participant_authority":"permit","target_authorization":"permit","transformation_validity":"permit","visibility":"not-applicable"}},"label":"internal.resolve-capability","ordinal":3},{"coordinates":{"decision":"deny"},"facts":{},"label":"crossing.decision.deny","ordinal":4},{"coordinates":{},"facts":{},"label":"internal.prepare-record","ordinal":5},{"coordinates":{"head":"h1"},"facts":{"crossing_rows":2,"operation_state":"failed"},"label":"internal.atomic-commit","ordinal":6}],"final_sink_enforced":false,"input_class":"declassify","issues":[],"observation_gaps":[],"observed_error":null,"operation_outcomes":["failed"],"operation_records_added":1,"runtime_binding":{"audience":"audience:red-operator","controller":"participant.behavior.supervisor","episode":"episode-1","participant":"participant.behavior.red-agent","policy_cuts":["participant-policy-cut:red:episode-1:8","participant-policy-cut:red:episode-1:8.p1"],"principal":"operator.red","run_scope":"run:default","target":"stub"},"runtime_realization":"not-established","runtime_safety_issues":[],"snapshot_revisions":[1,2],"states":[{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":null,"last":null,"phase":"idle"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","declassify","p0","fresh"],"last":null,"phase":"validating"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","declassify","p0","fresh"],"last":null,"phase":"resolving-cut"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","declassify","p0","fresh"],"last":null,"phase":"resolving-capability"},{"capability":"supported","cut":"p0","decision":"none","delivery":"none","gate":"deny","head":"h0","intent":["request-0","declassify","p0","fresh"],"last":null,"phase":"gating"},{"capability":"supported","cut":"p0","decision":"deny","delivery":"withheld","gate":"deny","head":"h0","intent":["request-0","declassify","p0","fresh"],"last":null,"phase":"preparing-record"},{"capability":"supported","cut":"p0","decision":"deny","delivery":"withheld","gate":"deny","head":"h0","intent":["request-0","declassify","p0","fresh"],"last":null,"phase":"committing"},{"capability":"supported","cut":"p0","decision":"deny","delivery":"withheld","gate":"deny","head":"h1","intent":["request-0","declassify","p0","fresh"],"last":["request-0","p0","deny"],"phase":"terminal"}],"unexercised":["enabled-choice-completeness","production-backend","independent-reproduction"],"visible_events":["crossing.request","crossing.decision.deny"]},"ingress/declassify/p1":{"backend_calls":1,"backend_conformance":"not-established","classification":"incompatible","configuration":{"control_providers_selected":false,"declared_support":[["participant_boundary_flow_resolution","unsupported"],["participant_declassification","exact"],["participant_directed_inject_delivery","unsupported"],["participant_egress_projection","unsupported"],["participant_final_sink_mediation","unsupported"],["participant_ingress_admission","exact"],["participant_intervention","unsupported"],["participant_modular_control","unsupported"],["participant_monitor_topology","unsupported"],["participant_predicate_opacity","unsupported"],["participant_processing_role_trust","unsupported"],["participant_quarantined_processing","unsupported"],["participant_transformation","exact"],["scoped_tool_affordances","unsupported"],["tool_affordances","unsupported"]],"operating_profile":null,"store":"memory","store_capabilities":["store.atomic-claims","store.atomic-terminal","store.audit","store.ephemeral","store.revision-cas","store.scope-bound"]},"crossing_rows_added":5,"cut":"p1","entry_point":"admit_participant_action","equivalence_result":"not-established","events":[{"coordinates":{"cut":"p1"},"facts":{},"label":"policy.cut.advance","ordinal":0},{"coordinates":{},"facts":{},"label":"crossing.request","ordinal":1},{"coordinates":{},"facts":{},"label":"internal.validate","ordinal":2},{"coordinates":{"cut":"p1"},"facts":{},"label":"internal.resolve-policy-cut","ordinal":3},{"coordinates":{"capability":"supported","gate":"permit"},"facts":{"effective_levels":[["participant_ingress_admission","exact"]],"gates":{"action_admission":"permit","backend_support":"permit","caller_authorization":"permit","declassification":"permit","marking_authorization":"permit","participant_authority":"permit","target_authorization":"permit","transformation_validity":"permit","visibility":"not-applicable"}},"label":"internal.resolve-capability","ordinal":4},{"coordinates":{"decision":"declassify"},"facts":{},"label":"crossing.decision.permit","ordinal":5},{"coordinates":{},"facts":{},"label":"crossing.declassify","ordinal":6},{"coordinates":{},"facts":{},"label":"crossing.request","ordinal":7},{"coordinates":{"capability":"supported","gate":"permit"},"facts":{"effective_levels":[["participant_ingress_admission","exact"]],"gates":{"action_admission":"permit","backend_support":"permit","caller_authorization":"permit","declassification":"not-applicable","marking_authorization":"permit","participant_authority":"permit","target_authorization":"permit","transformation_validity":"not-applicable","visibility":"not-applicable"}},"label":"internal.resolve-capability","ordinal":8},{"coordinates":{"decision":"permit"},"facts":{},"label":"crossing.decision.permit","ordinal":9},{"coordinates":{},"facts":{},"label":"internal.prepare-record","ordinal":10},{"coordinates":{"head":"h1"},"facts":{"crossing_rows":5,"operation_state":"running"},"label":"internal.atomic-commit","ordinal":11}],"final_sink_enforced":false,"input_class":"declassify","issues":["external-application-outside-crossing-model","incomplete-observation","transition-mismatch"],"observation_gaps":["incomplete-observation"],"observed_error":null,"operation_outcomes":["succeeded"],"operation_records_added":1,"runtime_binding":{"audience":"audience:red-operator","controller":"participant.behavior.supervisor","episode":"episode-1","participant":"participant.behavior.red-agent","policy_cuts":["participant-policy-cut:red:episode-1:8","participant-policy-cut:red:episode-1:8.p1"],"principal":"operator.red","run_scope":"run:default","target":"stub"},"runtime_realization":"not-established","runtime_safety_issues":[],"snapshot_revisions":[1,3],"states":[{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":null,"last":null,"phase":"idle"},{"capability":"unresolved","cut":"p1","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":null,"last":null,"phase":"idle"},{"capability":"unresolved","cut":"p1","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","declassify","p1","fresh"],"last":null,"phase":"validating"},{"capability":"unresolved","cut":"p1","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","declassify","p1","fresh"],"last":null,"phase":"resolving-cut"},{"capability":"unresolved","cut":"p1","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","declassify","p1","fresh"],"last":null,"phase":"resolving-capability"},{"capability":"supported","cut":"p1","decision":"none","delivery":"none","gate":"permit","head":"h0","intent":["request-0","declassify","p1","fresh"],"last":null,"phase":"gating"},{"capability":"supported","cut":"p1","decision":"declassify","delivery":"none","gate":"permit","head":"h0","intent":["request-0","declassify","p1","fresh"],"last":null,"phase":"preparing-record"},{"capability":"supported","cut":"p1","decision":"declassify","delivery":"pending","gate":"permit","head":"h0","intent":["request-0","declassify","p1","fresh"],"last":null,"phase":"preparing-record"}],"unexercised":["enabled-choice-completeness","production-backend","independent-reproduction"],"visible_events":["policy.cut.advance","crossing.request","crossing.decision.permit","crossing.declassify","crossing.request","crossing.decision.permit"]},"ingress/forbidden/p0":{"backend_calls":0,"backend_conformance":"not-established","classification":"match","configuration":{"control_providers_selected":false,"declared_support":[["participant_boundary_flow_resolution","unsupported"],["participant_declassification","exact"],["participant_directed_inject_delivery","unsupported"],["participant_egress_projection","unsupported"],["participant_final_sink_mediation","unsupported"],["participant_ingress_admission","exact"],["participant_intervention","unsupported"],["participant_modular_control","unsupported"],["participant_monitor_topology","unsupported"],["participant_predicate_opacity","unsupported"],["participant_processing_role_trust","unsupported"],["participant_quarantined_processing","unsupported"],["participant_transformation","exact"],["scoped_tool_affordances","unsupported"],["tool_affordances","unsupported"]],"operating_profile":null,"store":"memory","store_capabilities":["store.atomic-claims","store.atomic-terminal","store.audit","store.ephemeral","store.revision-cas","store.scope-bound"]},"crossing_rows_added":2,"cut":"p0","entry_point":"admit_participant_action","equivalence_result":"not-established","events":[{"coordinates":{},"facts":{},"label":"crossing.request","ordinal":0},{"coordinates":{},"facts":{},"label":"internal.validate","ordinal":1},{"coordinates":{"cut":"p0"},"facts":{},"label":"internal.resolve-policy-cut","ordinal":2},{"coordinates":{"capability":"supported","gate":"deny"},"facts":{"effective_levels":[["participant_ingress_admission","exact"]],"gates":{"action_admission":"deny","backend_support":"permit","caller_authorization":"permit","declassification":"not-applicable","marking_authorization":"permit","participant_authority":"permit","target_authorization":"permit","transformation_validity":"not-applicable","visibility":"not-applicable"}},"label":"internal.resolve-capability","ordinal":3},{"coordinates":{"decision":"deny"},"facts":{},"label":"crossing.decision.deny","ordinal":4},{"coordinates":{},"facts":{},"label":"internal.prepare-record","ordinal":5},{"coordinates":{"head":"h1"},"facts":{"crossing_rows":2,"operation_state":"failed"},"label":"internal.atomic-commit","ordinal":6}],"final_sink_enforced":false,"input_class":"forbidden","issues":[],"observation_gaps":[],"observed_error":null,"operation_outcomes":["failed"],"operation_records_added":1,"runtime_binding":{"audience":"audience:red-operator","controller":"participant.behavior.supervisor","episode":"episode-1","participant":"participant.behavior.red-agent","policy_cuts":["participant-policy-cut:red:episode-1:8","participant-policy-cut:red:episode-1:8.p1"],"principal":"operator.red","run_scope":"run:default","target":"stub"},"runtime_realization":"not-established","runtime_safety_issues":[],"snapshot_revisions":[1,2],"states":[{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":null,"last":null,"phase":"idle"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","forbidden","p0","fresh"],"last":null,"phase":"validating"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","forbidden","p0","fresh"],"last":null,"phase":"resolving-cut"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","forbidden","p0","fresh"],"last":null,"phase":"resolving-capability"},{"capability":"supported","cut":"p0","decision":"none","delivery":"none","gate":"deny","head":"h0","intent":["request-0","forbidden","p0","fresh"],"last":null,"phase":"gating"},{"capability":"supported","cut":"p0","decision":"deny","delivery":"withheld","gate":"deny","head":"h0","intent":["request-0","forbidden","p0","fresh"],"last":null,"phase":"preparing-record"},{"capability":"supported","cut":"p0","decision":"deny","delivery":"withheld","gate":"deny","head":"h0","intent":["request-0","forbidden","p0","fresh"],"last":null,"phase":"committing"},{"capability":"supported","cut":"p0","decision":"deny","delivery":"withheld","gate":"deny","head":"h1","intent":["request-0","forbidden","p0","fresh"],"last":["request-0","p0","deny"],"phase":"terminal"}],"unexercised":["enabled-choice-completeness","production-backend","independent-reproduction"],"visible_events":["crossing.request","crossing.decision.deny"]},"ingress/forbidden/p1":{"backend_calls":0,"backend_conformance":"not-established","classification":"match","configuration":{"control_providers_selected":false,"declared_support":[["participant_boundary_flow_resolution","unsupported"],["participant_declassification","exact"],["participant_directed_inject_delivery","unsupported"],["participant_egress_projection","unsupported"],["participant_final_sink_mediation","unsupported"],["participant_ingress_admission","exact"],["participant_intervention","unsupported"],["participant_modular_control","unsupported"],["participant_monitor_topology","unsupported"],["participant_predicate_opacity","unsupported"],["participant_processing_role_trust","unsupported"],["participant_quarantined_processing","unsupported"],["participant_transformation","exact"],["scoped_tool_affordances","unsupported"],["tool_affordances","unsupported"]],"operating_profile":null,"store":"memory","store_capabilities":["store.atomic-claims","store.atomic-terminal","store.audit","store.ephemeral","store.revision-cas","store.scope-bound"]},"crossing_rows_added":2,"cut":"p1","entry_point":"admit_participant_action","equivalence_result":"not-established","events":[{"coordinates":{"cut":"p1"},"facts":{},"label":"policy.cut.advance","ordinal":0},{"coordinates":{},"facts":{},"label":"crossing.request","ordinal":1},{"coordinates":{},"facts":{},"label":"internal.validate","ordinal":2},{"coordinates":{"cut":"p1"},"facts":{},"label":"internal.resolve-policy-cut","ordinal":3},{"coordinates":{"capability":"supported","gate":"deny"},"facts":{"effective_levels":[["participant_ingress_admission","exact"]],"gates":{"action_admission":"deny","backend_support":"permit","caller_authorization":"permit","declassification":"not-applicable","marking_authorization":"permit","participant_authority":"permit","target_authorization":"permit","transformation_validity":"not-applicable","visibility":"not-applicable"}},"label":"internal.resolve-capability","ordinal":4},{"coordinates":{"decision":"deny"},"facts":{},"label":"crossing.decision.deny","ordinal":5},{"coordinates":{},"facts":{},"label":"internal.prepare-record","ordinal":6},{"coordinates":{"head":"h1"},"facts":{"crossing_rows":2,"operation_state":"failed"},"label":"internal.atomic-commit","ordinal":7}],"final_sink_enforced":false,"input_class":"forbidden","issues":[],"observation_gaps":[],"observed_error":null,"operation_outcomes":["failed"],"operation_records_added":1,"runtime_binding":{"audience":"audience:red-operator","controller":"participant.behavior.supervisor","episode":"episode-1","participant":"participant.behavior.red-agent","policy_cuts":["participant-policy-cut:red:episode-1:8","participant-policy-cut:red:episode-1:8.p1"],"principal":"operator.red","run_scope":"run:default","target":"stub"},"runtime_realization":"not-established","runtime_safety_issues":[],"snapshot_revisions":[1,2],"states":[{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":null,"last":null,"phase":"idle"},{"capability":"unresolved","cut":"p1","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":null,"last":null,"phase":"idle"},{"capability":"unresolved","cut":"p1","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","forbidden","p1","fresh"],"last":null,"phase":"validating"},{"capability":"unresolved","cut":"p1","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","forbidden","p1","fresh"],"last":null,"phase":"resolving-cut"},{"capability":"unresolved","cut":"p1","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","forbidden","p1","fresh"],"last":null,"phase":"resolving-capability"},{"capability":"supported","cut":"p1","decision":"none","delivery":"none","gate":"deny","head":"h0","intent":["request-0","forbidden","p1","fresh"],"last":null,"phase":"gating"},{"capability":"supported","cut":"p1","decision":"deny","delivery":"withheld","gate":"deny","head":"h0","intent":["request-0","forbidden","p1","fresh"],"last":null,"phase":"preparing-record"},{"capability":"supported","cut":"p1","decision":"deny","delivery":"withheld","gate":"deny","head":"h0","intent":["request-0","forbidden","p1","fresh"],"last":null,"phase":"committing"},{"capability":"supported","cut":"p1","decision":"deny","delivery":"withheld","gate":"deny","head":"h1","intent":["request-0","forbidden","p1","fresh"],"last":["request-0","p1","deny"],"phase":"terminal"}],"unexercised":["enabled-choice-completeness","production-backend","independent-reproduction"],"visible_events":["policy.cut.advance","crossing.request","crossing.decision.deny"]},"ingress/plain/p0":{"backend_calls":1,"backend_conformance":"not-established","classification":"incompatible","configuration":{"control_providers_selected":false,"declared_support":[["participant_boundary_flow_resolution","unsupported"],["participant_declassification","exact"],["participant_directed_inject_delivery","unsupported"],["participant_egress_projection","unsupported"],["participant_final_sink_mediation","unsupported"],["participant_ingress_admission","exact"],["participant_intervention","unsupported"],["participant_modular_control","unsupported"],["participant_monitor_topology","unsupported"],["participant_predicate_opacity","unsupported"],["participant_processing_role_trust","unsupported"],["participant_quarantined_processing","unsupported"],["participant_transformation","exact"],["scoped_tool_affordances","unsupported"],["tool_affordances","unsupported"]],"operating_profile":null,"store":"memory","store_capabilities":["store.atomic-claims","store.atomic-terminal","store.audit","store.ephemeral","store.revision-cas","store.scope-bound"]},"crossing_rows_added":2,"cut":"p0","entry_point":"admit_participant_action","equivalence_result":"not-established","events":[{"coordinates":{},"facts":{},"label":"crossing.request","ordinal":0},{"coordinates":{},"facts":{},"label":"internal.validate","ordinal":1},{"coordinates":{"cut":"p0"},"facts":{},"label":"internal.resolve-policy-cut","ordinal":2},{"coordinates":{"capability":"supported","gate":"permit"},"facts":{"effective_levels":[["participant_ingress_admission","exact"]],"gates":{"action_admission":"permit","backend_support":"permit","caller_authorization":"permit","declassification":"not-applicable","marking_authorization":"permit","participant_authority":"permit","target_authorization":"permit","transformation_validity":"not-applicable","visibility":"not-applicable"}},"label":"internal.resolve-capability","ordinal":3},{"coordinates":{"decision":"permit"},"facts":{},"label":"crossing.decision.permit","ordinal":4},{"coordinates":{},"facts":{},"label":"internal.prepare-record","ordinal":5},{"coordinates":{"head":"h1"},"facts":{"crossing_rows":2,"operation_state":"running"},"label":"internal.atomic-commit","ordinal":6}],"final_sink_enforced":false,"input_class":"plain","issues":["external-application-outside-crossing-model","incomplete-observation"],"observation_gaps":["incomplete-observation"],"observed_error":null,"operation_outcomes":["succeeded"],"operation_records_added":1,"runtime_binding":{"audience":"audience:red-operator","controller":"participant.behavior.supervisor","episode":"episode-1","participant":"participant.behavior.red-agent","policy_cuts":["participant-policy-cut:red:episode-1:8","participant-policy-cut:red:episode-1:8.p1"],"principal":"operator.red","run_scope":"run:default","target":"stub"},"runtime_realization":"not-established","runtime_safety_issues":[],"snapshot_revisions":[1,3],"states":[{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":null,"last":null,"phase":"idle"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","plain","p0","fresh"],"last":null,"phase":"validating"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","plain","p0","fresh"],"last":null,"phase":"resolving-cut"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","plain","p0","fresh"],"last":null,"phase":"resolving-capability"},{"capability":"supported","cut":"p0","decision":"none","delivery":"none","gate":"permit","head":"h0","intent":["request-0","plain","p0","fresh"],"last":null,"phase":"gating"},{"capability":"supported","cut":"p0","decision":"permit","delivery":"pending","gate":"permit","head":"h0","intent":["request-0","plain","p0","fresh"],"last":null,"phase":"preparing-record"},{"capability":"supported","cut":"p0","decision":"permit","delivery":"pending","gate":"permit","head":"h0","intent":["request-0","plain","p0","fresh"],"last":null,"phase":"committing"},{"capability":"supported","cut":"p0","decision":"permit","delivery":"pending","gate":"permit","head":"h1","intent":["request-0","plain","p0","fresh"],"last":["request-0","p0","permit"],"phase":"committing"}],"unexercised":["enabled-choice-completeness","production-backend","independent-reproduction"],"visible_events":["crossing.request","crossing.decision.permit"]},"ingress/plain/p1":{"backend_calls":1,"backend_conformance":"not-established","classification":"incompatible","configuration":{"control_providers_selected":false,"declared_support":[["participant_boundary_flow_resolution","unsupported"],["participant_declassification","exact"],["participant_directed_inject_delivery","unsupported"],["participant_egress_projection","unsupported"],["participant_final_sink_mediation","unsupported"],["participant_ingress_admission","exact"],["participant_intervention","unsupported"],["participant_modular_control","unsupported"],["participant_monitor_topology","unsupported"],["participant_predicate_opacity","unsupported"],["participant_processing_role_trust","unsupported"],["participant_quarantined_processing","unsupported"],["participant_transformation","exact"],["scoped_tool_affordances","unsupported"],["tool_affordances","unsupported"]],"operating_profile":null,"store":"memory","store_capabilities":["store.atomic-claims","store.atomic-terminal","store.audit","store.ephemeral","store.revision-cas","store.scope-bound"]},"crossing_rows_added":2,"cut":"p1","entry_point":"admit_participant_action","equivalence_result":"not-established","events":[{"coordinates":{"cut":"p1"},"facts":{},"label":"policy.cut.advance","ordinal":0},{"coordinates":{},"facts":{},"label":"crossing.request","ordinal":1},{"coordinates":{},"facts":{},"label":"internal.validate","ordinal":2},{"coordinates":{"cut":"p1"},"facts":{},"label":"internal.resolve-policy-cut","ordinal":3},{"coordinates":{"capability":"supported","gate":"permit"},"facts":{"effective_levels":[["participant_ingress_admission","exact"]],"gates":{"action_admission":"permit","backend_support":"permit","caller_authorization":"permit","declassification":"not-applicable","marking_authorization":"permit","participant_authority":"permit","target_authorization":"permit","transformation_validity":"not-applicable","visibility":"not-applicable"}},"label":"internal.resolve-capability","ordinal":4},{"coordinates":{"decision":"permit"},"facts":{},"label":"crossing.decision.permit","ordinal":5},{"coordinates":{},"facts":{},"label":"internal.prepare-record","ordinal":6},{"coordinates":{"head":"h1"},"facts":{"crossing_rows":2,"operation_state":"running"},"label":"internal.atomic-commit","ordinal":7}],"final_sink_enforced":false,"input_class":"plain","issues":["external-application-outside-crossing-model","incomplete-observation"],"observation_gaps":["incomplete-observation"],"observed_error":null,"operation_outcomes":["succeeded"],"operation_records_added":1,"runtime_binding":{"audience":"audience:red-operator","controller":"participant.behavior.supervisor","episode":"episode-1","participant":"participant.behavior.red-agent","policy_cuts":["participant-policy-cut:red:episode-1:8","participant-policy-cut:red:episode-1:8.p1"],"principal":"operator.red","run_scope":"run:default","target":"stub"},"runtime_realization":"not-established","runtime_safety_issues":[],"snapshot_revisions":[1,3],"states":[{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":null,"last":null,"phase":"idle"},{"capability":"unresolved","cut":"p1","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":null,"last":null,"phase":"idle"},{"capability":"unresolved","cut":"p1","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","plain","p1","fresh"],"last":null,"phase":"validating"},{"capability":"unresolved","cut":"p1","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","plain","p1","fresh"],"last":null,"phase":"resolving-cut"},{"capability":"unresolved","cut":"p1","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","plain","p1","fresh"],"last":null,"phase":"resolving-capability"},{"capability":"supported","cut":"p1","decision":"none","delivery":"none","gate":"permit","head":"h0","intent":["request-0","plain","p1","fresh"],"last":null,"phase":"gating"},{"capability":"supported","cut":"p1","decision":"permit","delivery":"pending","gate":"permit","head":"h0","intent":["request-0","plain","p1","fresh"],"last":null,"phase":"preparing-record"},{"capability":"supported","cut":"p1","decision":"permit","delivery":"pending","gate":"permit","head":"h0","intent":["request-0","plain","p1","fresh"],"last":null,"phase":"committing"},{"capability":"supported","cut":"p1","decision":"permit","delivery":"pending","gate":"permit","head":"h1","intent":["request-0","plain","p1","fresh"],"last":["request-0","p1","permit"],"phase":"committing"}],"unexercised":["enabled-choice-completeness","production-backend","independent-reproduction"],"visible_events":["policy.cut.advance","crossing.request","crossing.decision.permit"]},"ingress/transform/p0":{"backend_calls":1,"backend_conformance":"not-established","classification":"incompatible","configuration":{"control_providers_selected":false,"declared_support":[["participant_boundary_flow_resolution","unsupported"],["participant_declassification","exact"],["participant_directed_inject_delivery","unsupported"],["participant_egress_projection","unsupported"],["participant_final_sink_mediation","unsupported"],["participant_ingress_admission","exact"],["participant_intervention","unsupported"],["participant_modular_control","unsupported"],["participant_monitor_topology","unsupported"],["participant_predicate_opacity","unsupported"],["participant_processing_role_trust","unsupported"],["participant_quarantined_processing","unsupported"],["participant_transformation","exact"],["scoped_tool_affordances","unsupported"],["tool_affordances","unsupported"]],"operating_profile":null,"store":"memory","store_capabilities":["store.atomic-claims","store.atomic-terminal","store.audit","store.ephemeral","store.revision-cas","store.scope-bound"]},"crossing_rows_added":5,"cut":"p0","entry_point":"admit_participant_action","equivalence_result":"not-established","events":[{"coordinates":{},"facts":{},"label":"crossing.request","ordinal":0},{"coordinates":{},"facts":{},"label":"internal.validate","ordinal":1},{"coordinates":{"cut":"p0"},"facts":{},"label":"internal.resolve-policy-cut","ordinal":2},{"coordinates":{"capability":"supported","gate":"permit"},"facts":{"effective_levels":[["participant_ingress_admission","exact"]],"gates":{"action_admission":"permit","backend_support":"permit","caller_authorization":"permit","declassification":"not-applicable","marking_authorization":"permit","participant_authority":"permit","target_authorization":"permit","transformation_validity":"permit","visibility":"not-applicable"}},"label":"internal.resolve-capability","ordinal":3},{"coordinates":{"decision":"transform"},"facts":{},"label":"crossing.decision.permit","ordinal":4},{"coordinates":{},"facts":{},"label":"crossing.transform","ordinal":5},{"coordinates":{},"facts":{},"label":"crossing.request","ordinal":6},{"coordinates":{"capability":"supported","gate":"permit"},"facts":{"effective_levels":[["participant_ingress_admission","exact"]],"gates":{"action_admission":"permit","backend_support":"permit","caller_authorization":"permit","declassification":"not-applicable","marking_authorization":"permit","participant_authority":"permit","target_authorization":"permit","transformation_validity":"not-applicable","visibility":"not-applicable"}},"label":"internal.resolve-capability","ordinal":7},{"coordinates":{"decision":"permit"},"facts":{},"label":"crossing.decision.permit","ordinal":8},{"coordinates":{},"facts":{},"label":"internal.prepare-record","ordinal":9},{"coordinates":{"head":"h1"},"facts":{"crossing_rows":5,"operation_state":"running"},"label":"internal.atomic-commit","ordinal":10}],"final_sink_enforced":false,"input_class":"transform","issues":["external-application-outside-crossing-model","incomplete-observation","transition-mismatch"],"observation_gaps":["incomplete-observation"],"observed_error":null,"operation_outcomes":["succeeded"],"operation_records_added":1,"runtime_binding":{"audience":"audience:red-operator","controller":"participant.behavior.supervisor","episode":"episode-1","participant":"participant.behavior.red-agent","policy_cuts":["participant-policy-cut:red:episode-1:8","participant-policy-cut:red:episode-1:8.p1"],"principal":"operator.red","run_scope":"run:default","target":"stub"},"runtime_realization":"not-established","runtime_safety_issues":[],"snapshot_revisions":[1,3],"states":[{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":null,"last":null,"phase":"idle"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","transform","p0","fresh"],"last":null,"phase":"validating"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","transform","p0","fresh"],"last":null,"phase":"resolving-cut"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","transform","p0","fresh"],"last":null,"phase":"resolving-capability"},{"capability":"supported","cut":"p0","decision":"none","delivery":"none","gate":"permit","head":"h0","intent":["request-0","transform","p0","fresh"],"last":null,"phase":"gating"},{"capability":"supported","cut":"p0","decision":"transform","delivery":"none","gate":"permit","head":"h0","intent":["request-0","transform","p0","fresh"],"last":null,"phase":"preparing-record"},{"capability":"supported","cut":"p0","decision":"transform","delivery":"pending","gate":"permit","head":"h0","intent":["request-0","transform","p0","fresh"],"last":null,"phase":"preparing-record"}],"unexercised":["enabled-choice-completeness","production-backend","independent-reproduction"],"visible_events":["crossing.request","crossing.decision.permit","crossing.transform","crossing.request","crossing.decision.permit"]},"ingress/transform/p1":{"backend_calls":1,"backend_conformance":"not-established","classification":"incompatible","configuration":{"control_providers_selected":false,"declared_support":[["participant_boundary_flow_resolution","unsupported"],["participant_declassification","exact"],["participant_directed_inject_delivery","unsupported"],["participant_egress_projection","unsupported"],["participant_final_sink_mediation","unsupported"],["participant_ingress_admission","exact"],["participant_intervention","unsupported"],["participant_modular_control","unsupported"],["participant_monitor_topology","unsupported"],["participant_predicate_opacity","unsupported"],["participant_processing_role_trust","unsupported"],["participant_quarantined_processing","unsupported"],["participant_transformation","exact"],["scoped_tool_affordances","unsupported"],["tool_affordances","unsupported"]],"operating_profile":null,"store":"memory","store_capabilities":["store.atomic-claims","store.atomic-terminal","store.audit","store.ephemeral","store.revision-cas","store.scope-bound"]},"crossing_rows_added":5,"cut":"p1","entry_point":"admit_participant_action","equivalence_result":"not-established","events":[{"coordinates":{"cut":"p1"},"facts":{},"label":"policy.cut.advance","ordinal":0},{"coordinates":{},"facts":{},"label":"crossing.request","ordinal":1},{"coordinates":{},"facts":{},"label":"internal.validate","ordinal":2},{"coordinates":{"cut":"p1"},"facts":{},"label":"internal.resolve-policy-cut","ordinal":3},{"coordinates":{"capability":"supported","gate":"permit"},"facts":{"effective_levels":[["participant_ingress_admission","exact"]],"gates":{"action_admission":"permit","backend_support":"permit","caller_authorization":"permit","declassification":"not-applicable","marking_authorization":"permit","participant_authority":"permit","target_authorization":"permit","transformation_validity":"permit","visibility":"not-applicable"}},"label":"internal.resolve-capability","ordinal":4},{"coordinates":{"decision":"transform"},"facts":{},"label":"crossing.decision.permit","ordinal":5},{"coordinates":{},"facts":{},"label":"crossing.transform","ordinal":6},{"coordinates":{},"facts":{},"label":"crossing.request","ordinal":7},{"coordinates":{"capability":"supported","gate":"permit"},"facts":{"effective_levels":[["participant_ingress_admission","exact"]],"gates":{"action_admission":"permit","backend_support":"permit","caller_authorization":"permit","declassification":"not-applicable","marking_authorization":"permit","participant_authority":"permit","target_authorization":"permit","transformation_validity":"not-applicable","visibility":"not-applicable"}},"label":"internal.resolve-capability","ordinal":8},{"coordinates":{"decision":"permit"},"facts":{},"label":"crossing.decision.permit","ordinal":9},{"coordinates":{},"facts":{},"label":"internal.prepare-record","ordinal":10},{"coordinates":{"head":"h1"},"facts":{"crossing_rows":5,"operation_state":"running"},"label":"internal.atomic-commit","ordinal":11}],"final_sink_enforced":false,"input_class":"transform","issues":["external-application-outside-crossing-model","incomplete-observation","transition-mismatch"],"observation_gaps":["incomplete-observation"],"observed_error":null,"operation_outcomes":["succeeded"],"operation_records_added":1,"runtime_binding":{"audience":"audience:red-operator","controller":"participant.behavior.supervisor","episode":"episode-1","participant":"participant.behavior.red-agent","policy_cuts":["participant-policy-cut:red:episode-1:8","participant-policy-cut:red:episode-1:8.p1"],"principal":"operator.red","run_scope":"run:default","target":"stub"},"runtime_realization":"not-established","runtime_safety_issues":[],"snapshot_revisions":[1,3],"states":[{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":null,"last":null,"phase":"idle"},{"capability":"unresolved","cut":"p1","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":null,"last":null,"phase":"idle"},{"capability":"unresolved","cut":"p1","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","transform","p1","fresh"],"last":null,"phase":"validating"},{"capability":"unresolved","cut":"p1","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","transform","p1","fresh"],"last":null,"phase":"resolving-cut"},{"capability":"unresolved","cut":"p1","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","transform","p1","fresh"],"last":null,"phase":"resolving-capability"},{"capability":"supported","cut":"p1","decision":"none","delivery":"none","gate":"permit","head":"h0","intent":["request-0","transform","p1","fresh"],"last":null,"phase":"gating"},{"capability":"supported","cut":"p1","decision":"transform","delivery":"none","gate":"permit","head":"h0","intent":["request-0","transform","p1","fresh"],"last":null,"phase":"preparing-record"},{"capability":"supported","cut":"p1","decision":"transform","delivery":"pending","gate":"permit","head":"h0","intent":["request-0","transform","p1","fresh"],"last":null,"phase":"preparing-record"}],"unexercised":["enabled-choice-completeness","production-backend","independent-reproduction"],"visible_events":["policy.cut.advance","crossing.request","crossing.decision.permit","crossing.transform","crossing.request","crossing.decision.permit"]},"ingress/unsupported/p0":{"backend_calls":0,"backend_conformance":"not-established","classification":"match","configuration":{"control_providers_selected":false,"declared_support":[["participant_boundary_flow_resolution","unsupported"],["participant_declassification","unsupported"],["participant_directed_inject_delivery","unsupported"],["participant_egress_projection","unsupported"],["participant_final_sink_mediation","unsupported"],["participant_ingress_admission","unsupported"],["participant_intervention","unsupported"],["participant_modular_control","unsupported"],["participant_monitor_topology","unsupported"],["participant_predicate_opacity","unsupported"],["participant_processing_role_trust","unsupported"],["participant_quarantined_processing","unsupported"],["participant_transformation","unsupported"],["scoped_tool_affordances","unsupported"],["tool_affordances","unsupported"]],"operating_profile":null,"store":"memory","store_capabilities":["store.atomic-claims","store.atomic-terminal","store.audit","store.ephemeral","store.revision-cas","store.scope-bound"]},"crossing_rows_added":2,"cut":"p0","entry_point":"admit_participant_action","equivalence_result":"not-established","events":[{"coordinates":{},"facts":{},"label":"crossing.request","ordinal":0},{"coordinates":{},"facts":{},"label":"internal.validate","ordinal":1},{"coordinates":{"cut":"p0"},"facts":{},"label":"internal.resolve-policy-cut","ordinal":2},{"coordinates":{"capability":"unsupported","gate":"permit"},"facts":{"effective_levels":[["participant_ingress_admission","unsupported"]],"gates":{"action_admission":"permit","backend_support":"unsupported","caller_authorization":"permit","declassification":"not-applicable","marking_authorization":"permit","participant_authority":"permit","target_authorization":"permit","transformation_validity":"not-applicable","visibility":"not-applicable"}},"label":"internal.resolve-capability","ordinal":3},{"coordinates":{"decision":"unsupported"},"facts":{},"label":"crossing.decision.unsupported","ordinal":4},{"coordinates":{},"facts":{},"label":"internal.prepare-record","ordinal":5},{"coordinates":{"head":"h1"},"facts":{"crossing_rows":2,"operation_state":"failed"},"label":"internal.atomic-commit","ordinal":6}],"final_sink_enforced":false,"input_class":"unsupported","issues":[],"observation_gaps":[],"observed_error":null,"operation_outcomes":["failed"],"operation_records_added":1,"runtime_binding":{"audience":"audience:red-operator","controller":"participant.behavior.supervisor","episode":"episode-1","participant":"participant.behavior.red-agent","policy_cuts":["participant-policy-cut:red:episode-1:8","participant-policy-cut:red:episode-1:8.p1"],"principal":"operator.red","run_scope":"run:default","target":"stub"},"runtime_realization":"not-established","runtime_safety_issues":[],"snapshot_revisions":[1,2],"states":[{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":null,"last":null,"phase":"idle"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","unsupported","p0","fresh"],"last":null,"phase":"validating"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","unsupported","p0","fresh"],"last":null,"phase":"resolving-cut"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","unsupported","p0","fresh"],"last":null,"phase":"resolving-capability"},{"capability":"unsupported","cut":"p0","decision":"none","delivery":"none","gate":"permit","head":"h0","intent":["request-0","unsupported","p0","fresh"],"last":null,"phase":"gating"},{"capability":"unsupported","cut":"p0","decision":"unsupported","delivery":"withheld","gate":"permit","head":"h0","intent":["request-0","unsupported","p0","fresh"],"last":null,"phase":"preparing-record"},{"capability":"unsupported","cut":"p0","decision":"unsupported","delivery":"withheld","gate":"permit","head":"h0","intent":["request-0","unsupported","p0","fresh"],"last":null,"phase":"committing"},{"capability":"unsupported","cut":"p0","decision":"unsupported","delivery":"withheld","gate":"permit","head":"h1","intent":["request-0","unsupported","p0","fresh"],"last":["request-0","p0","unsupported"],"phase":"terminal"}],"unexercised":["enabled-choice-completeness","production-backend","independent-reproduction"],"visible_events":["crossing.request","crossing.decision.unsupported"]},"ingress/unsupported/p1":{"backend_calls":0,"backend_conformance":"not-established","classification":"match","configuration":{"control_providers_selected":false,"declared_support":[["participant_boundary_flow_resolution","unsupported"],["participant_declassification","unsupported"],["participant_directed_inject_delivery","unsupported"],["participant_egress_projection","unsupported"],["participant_final_sink_mediation","unsupported"],["participant_ingress_admission","unsupported"],["participant_intervention","unsupported"],["participant_modular_control","unsupported"],["participant_monitor_topology","unsupported"],["participant_predicate_opacity","unsupported"],["participant_processing_role_trust","unsupported"],["participant_quarantined_processing","unsupported"],["participant_transformation","unsupported"],["scoped_tool_affordances","unsupported"],["tool_affordances","unsupported"]],"operating_profile":null,"store":"memory","store_capabilities":["store.atomic-claims","store.atomic-terminal","store.audit","store.ephemeral","store.revision-cas","store.scope-bound"]},"crossing_rows_added":2,"cut":"p1","entry_point":"admit_participant_action","equivalence_result":"not-established","events":[{"coordinates":{"cut":"p1"},"facts":{},"label":"policy.cut.advance","ordinal":0},{"coordinates":{},"facts":{},"label":"crossing.request","ordinal":1},{"coordinates":{},"facts":{},"label":"internal.validate","ordinal":2},{"coordinates":{"cut":"p1"},"facts":{},"label":"internal.resolve-policy-cut","ordinal":3},{"coordinates":{"capability":"unsupported","gate":"permit"},"facts":{"effective_levels":[["participant_ingress_admission","unsupported"]],"gates":{"action_admission":"permit","backend_support":"unsupported","caller_authorization":"permit","declassification":"not-applicable","marking_authorization":"permit","participant_authority":"permit","target_authorization":"permit","transformation_validity":"not-applicable","visibility":"not-applicable"}},"label":"internal.resolve-capability","ordinal":4},{"coordinates":{"decision":"unsupported"},"facts":{},"label":"crossing.decision.unsupported","ordinal":5},{"coordinates":{},"facts":{},"label":"internal.prepare-record","ordinal":6},{"coordinates":{"head":"h1"},"facts":{"crossing_rows":2,"operation_state":"failed"},"label":"internal.atomic-commit","ordinal":7}],"final_sink_enforced":false,"input_class":"unsupported","issues":[],"observation_gaps":[],"observed_error":null,"operation_outcomes":["failed"],"operation_records_added":1,"runtime_binding":{"audience":"audience:red-operator","controller":"participant.behavior.supervisor","episode":"episode-1","participant":"participant.behavior.red-agent","policy_cuts":["participant-policy-cut:red:episode-1:8","participant-policy-cut:red:episode-1:8.p1"],"principal":"operator.red","run_scope":"run:default","target":"stub"},"runtime_realization":"not-established","runtime_safety_issues":[],"snapshot_revisions":[1,2],"states":[{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":null,"last":null,"phase":"idle"},{"capability":"unresolved","cut":"p1","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":null,"last":null,"phase":"idle"},{"capability":"unresolved","cut":"p1","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","unsupported","p1","fresh"],"last":null,"phase":"validating"},{"capability":"unresolved","cut":"p1","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","unsupported","p1","fresh"],"last":null,"phase":"resolving-cut"},{"capability":"unresolved","cut":"p1","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","unsupported","p1","fresh"],"last":null,"phase":"resolving-capability"},{"capability":"unsupported","cut":"p1","decision":"none","delivery":"none","gate":"permit","head":"h0","intent":["request-0","unsupported","p1","fresh"],"last":null,"phase":"gating"},{"capability":"unsupported","cut":"p1","decision":"unsupported","delivery":"withheld","gate":"permit","head":"h0","intent":["request-0","unsupported","p1","fresh"],"last":null,"phase":"preparing-record"},{"capability":"unsupported","cut":"p1","decision":"unsupported","delivery":"withheld","gate":"permit","head":"h0","intent":["request-0","unsupported","p1","fresh"],"last":null,"phase":"committing"},{"capability":"unsupported","cut":"p1","decision":"unsupported","delivery":"withheld","gate":"permit","head":"h1","intent":["request-0","unsupported","p1","fresh"],"last":["request-0","p1","unsupported"],"phase":"terminal"}],"unexercised":["enabled-choice-completeness","production-backend","independent-reproduction"],"visible_events":["policy.cut.advance","crossing.request","crossing.decision.unsupported"]},"provider/owner":{"backend_calls":0,"backend_conformance":"not-established","classification":"incompatible","configuration":{"control_providers_selected":true,"declared_support":[["participant_boundary_flow_resolution","unsupported"],["participant_declassification","unsupported"],["participant_directed_inject_delivery","exact"],["participant_egress_projection","exact"],["participant_final_sink_mediation","unsupported"],["participant_ingress_admission","exact"],["participant_intervention","exact"],["participant_modular_control","exact"],["participant_monitor_topology","unsupported"],["participant_predicate_opacity","unsupported"],["participant_processing_role_trust","unsupported"],["participant_quarantined_processing","unsupported"],["participant_transformation","exact"],["scoped_tool_affordances","unsupported"],["tool_affordances","unsupported"]],"operating_profile":null,"store":"memory","store_capabilities":["store.atomic-claims","store.atomic-terminal","store.audit","store.ephemeral","store.revision-cas","store.scope-bound"]},"crossing_rows_added":2,"cut":"p0","entry_point":"dispatch_participant_control_effects","equivalence_result":"not-established","events":[{"coordinates":{},"facts":{},"label":"crossing.request","ordinal":0},{"coordinates":{},"facts":{},"label":"internal.validate","ordinal":1},{"coordinates":{"cut":"p0"},"facts":{},"label":"internal.resolve-policy-cut","ordinal":2},{"coordinates":{"capability":"supported","gate":"permit"},"facts":{"effective_levels":[["participant_ingress_admission","exact"],["participant_intervention","exact"]],"gates":{"action_admission":"permit","backend_support":"permit","caller_authorization":"permit","declassification":"not-applicable","marking_authorization":"permit","participant_authority":"permit","target_authorization":"permit","transformation_validity":"not-applicable","visibility":"not-applicable"}},"label":"internal.resolve-capability","ordinal":3},{"coordinates":{"decision":"permit"},"facts":{},"label":"crossing.decision.permit","ordinal":4},{"coordinates":{},"facts":{},"label":"internal.prepare-record","ordinal":5},{"coordinates":{"head":"h1"},"facts":{"crossing_rows":2,"operation_state":"succeeded"},"label":"internal.atomic-commit","ordinal":6}],"final_sink_enforced":false,"input_class":"plain","issues":["additional-operation-outside-carrier","control-change-outside-carrier","incomplete-observation","initial-state-unmapped"],"observation_gaps":["incomplete-observation","initial-state-unmapped"],"observed_error":null,"operation_outcomes":["succeeded","succeeded"],"operation_records_added":2,"runtime_binding":{"audience":"audience:red-operator","controller":"participant.behavior.supervisor","episode":"episode-1","participant":"participant.behavior.red-agent","policy_cuts":["participant-policy-cut:red:episode-1:8","participant-policy-cut:red:episode-1:8.p1"],"principal":"operator.red","run_scope":"run:default","target":"stub"},"runtime_realization":"not-established","runtime_safety_issues":[],"snapshot_revisions":[2,4],"states":[],"unexercised":["enabled-choice-completeness","production-backend","independent-reproduction"],"visible_events":["crossing.request","crossing.decision.permit"]},"provider/parent":{"backend_calls":0,"backend_conformance":"not-established","classification":"incompatible","configuration":{"control_providers_selected":true,"declared_support":[["participant_boundary_flow_resolution","unsupported"],["participant_declassification","unsupported"],["participant_directed_inject_delivery","exact"],["participant_egress_projection","exact"],["participant_final_sink_mediation","unsupported"],["participant_ingress_admission","exact"],["participant_intervention","exact"],["participant_modular_control","exact"],["participant_monitor_topology","unsupported"],["participant_predicate_opacity","unsupported"],["participant_processing_role_trust","unsupported"],["participant_quarantined_processing","unsupported"],["participant_transformation","exact"],["scoped_tool_affordances","unsupported"],["tool_affordances","unsupported"]],"operating_profile":null,"store":"memory","store_capabilities":["store.atomic-claims","store.atomic-terminal","store.audit","store.ephemeral","store.revision-cas","store.scope-bound"]},"crossing_rows_added":2,"cut":"p0","entry_point":"admit_participant_action","equivalence_result":"not-established","events":[{"coordinates":{},"facts":{},"label":"crossing.request","ordinal":0},{"coordinates":{},"facts":{},"label":"internal.validate","ordinal":1},{"coordinates":{"cut":"p0"},"facts":{},"label":"internal.resolve-policy-cut","ordinal":2},{"coordinates":{"capability":"supported","gate":"permit"},"facts":{"effective_levels":[["participant_ingress_admission","exact"]],"gates":{"action_admission":"permit","backend_support":"permit","caller_authorization":"permit","declassification":"not-applicable","marking_authorization":"permit","participant_authority":"permit","target_authorization":"permit","transformation_validity":"not-applicable","visibility":"not-applicable"}},"label":"internal.resolve-capability","ordinal":3},{"coordinates":{"decision":"permit"},"facts":{},"label":"crossing.decision.permit","ordinal":4},{"coordinates":{},"facts":{},"label":"internal.prepare-record","ordinal":5},{"coordinates":{"head":"h1"},"facts":{"crossing_rows":2,"operation_state":"failed"},"label":"internal.atomic-commit","ordinal":6}],"final_sink_enforced":false,"input_class":"plain","issues":["final-outcome-mismatch","incomplete-observation"],"observation_gaps":["incomplete-observation"],"observed_error":null,"operation_outcomes":["failed"],"operation_records_added":1,"runtime_binding":{"audience":"audience:red-operator","controller":"participant.behavior.supervisor","episode":"episode-1","participant":"participant.behavior.red-agent","policy_cuts":["participant-policy-cut:red:episode-1:8","participant-policy-cut:red:episode-1:8.p1"],"principal":"operator.red","run_scope":"run:default","target":"stub"},"runtime_realization":"not-established","runtime_safety_issues":[],"snapshot_revisions":[1,2],"states":[{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":null,"last":null,"phase":"idle"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","plain","p0","fresh"],"last":null,"phase":"validating"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","plain","p0","fresh"],"last":null,"phase":"resolving-cut"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","plain","p0","fresh"],"last":null,"phase":"resolving-capability"},{"capability":"supported","cut":"p0","decision":"none","delivery":"none","gate":"permit","head":"h0","intent":["request-0","plain","p0","fresh"],"last":null,"phase":"gating"},{"capability":"supported","cut":"p0","decision":"permit","delivery":"pending","gate":"permit","head":"h0","intent":["request-0","plain","p0","fresh"],"last":null,"phase":"preparing-record"},{"capability":"supported","cut":"p0","decision":"permit","delivery":"pending","gate":"permit","head":"h0","intent":["request-0","plain","p0","fresh"],"last":null,"phase":"committing"},{"capability":"supported","cut":"p0","decision":"permit","delivery":"pending","gate":"permit","head":"h1","intent":["request-0","plain","p0","fresh"],"last":["request-0","p0","permit"],"phase":"committing"}],"unexercised":["enabled-choice-completeness","production-backend","independent-reproduction"],"visible_events":["crossing.request","crossing.decision.permit"]},"replay/changed-input/initial":{"backend_calls":0,"backend_conformance":"not-established","classification":"match","configuration":{"control_providers_selected":false,"declared_support":[["participant_boundary_flow_resolution","unsupported"],["participant_declassification","unsupported"],["participant_directed_inject_delivery","unsupported"],["participant_egress_projection","unsupported"],["participant_final_sink_mediation","unsupported"],["participant_ingress_admission","exact"],["participant_intervention","unsupported"],["participant_modular_control","unsupported"],["participant_monitor_topology","unsupported"],["participant_predicate_opacity","unsupported"],["participant_processing_role_trust","unsupported"],["participant_quarantined_processing","unsupported"],["participant_transformation","unsupported"],["scoped_tool_affordances","unsupported"],["tool_affordances","unsupported"]],"operating_profile":null,"store":"memory","store_capabilities":["store.atomic-claims","store.atomic-terminal","store.audit","store.ephemeral","store.revision-cas","store.scope-bound"]},"crossing_rows_added":2,"cut":"p0","entry_point":"admit_participant_action","equivalence_result":"not-established","events":[{"coordinates":{},"facts":{},"label":"crossing.request","ordinal":0},{"coordinates":{},"facts":{},"label":"internal.validate","ordinal":1},{"coordinates":{"cut":"p0"},"facts":{},"label":"internal.resolve-policy-cut","ordinal":2},{"coordinates":{"capability":"supported","gate":"deny"},"facts":{"effective_levels":[["participant_ingress_admission","exact"]],"gates":{"action_admission":"deny","backend_support":"permit","caller_authorization":"permit","declassification":"not-applicable","marking_authorization":"permit","participant_authority":"permit","target_authorization":"permit","transformation_validity":"not-applicable","visibility":"not-applicable"}},"label":"internal.resolve-capability","ordinal":3},{"coordinates":{"decision":"deny"},"facts":{},"label":"crossing.decision.deny","ordinal":4},{"coordinates":{},"facts":{},"label":"internal.prepare-record","ordinal":5},{"coordinates":{"head":"h1"},"facts":{"crossing_rows":2,"operation_state":"failed"},"label":"internal.atomic-commit","ordinal":6}],"final_sink_enforced":false,"input_class":"forbidden","issues":[],"observation_gaps":[],"observed_error":null,"operation_outcomes":["failed"],"operation_records_added":1,"runtime_binding":{"audience":"audience:red-operator","controller":"participant.behavior.supervisor","episode":"episode-1","participant":"participant.behavior.red-agent","policy_cuts":["participant-policy-cut:red:episode-1:8","participant-policy-cut:red:episode-1:8.p1"],"principal":"operator.red","run_scope":"run:default","target":"stub"},"runtime_realization":"not-established","runtime_safety_issues":[],"snapshot_revisions":[1,2],"states":[{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":null,"last":null,"phase":"idle"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","forbidden","p0","fresh"],"last":null,"phase":"validating"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","forbidden","p0","fresh"],"last":null,"phase":"resolving-cut"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","forbidden","p0","fresh"],"last":null,"phase":"resolving-capability"},{"capability":"supported","cut":"p0","decision":"none","delivery":"none","gate":"deny","head":"h0","intent":["request-0","forbidden","p0","fresh"],"last":null,"phase":"gating"},{"capability":"supported","cut":"p0","decision":"deny","delivery":"withheld","gate":"deny","head":"h0","intent":["request-0","forbidden","p0","fresh"],"last":null,"phase":"preparing-record"},{"capability":"supported","cut":"p0","decision":"deny","delivery":"withheld","gate":"deny","head":"h0","intent":["request-0","forbidden","p0","fresh"],"last":null,"phase":"committing"},{"capability":"supported","cut":"p0","decision":"deny","delivery":"withheld","gate":"deny","head":"h1","intent":["request-0","forbidden","p0","fresh"],"last":["request-0","p0","deny"],"phase":"terminal"}],"unexercised":["enabled-choice-completeness","production-backend","independent-reproduction"],"visible_events":["crossing.request","crossing.decision.deny"]},"replay/changed-input/retry":{"backend_calls":0,"backend_conformance":"not-established","classification":"incompatible","configuration":{"control_providers_selected":false,"declared_support":[["participant_boundary_flow_resolution","unsupported"],["participant_declassification","unsupported"],["participant_directed_inject_delivery","unsupported"],["participant_egress_projection","unsupported"],["participant_final_sink_mediation","unsupported"],["participant_ingress_admission","exact"],["participant_intervention","unsupported"],["participant_modular_control","unsupported"],["participant_monitor_topology","unsupported"],["participant_predicate_opacity","unsupported"],["participant_processing_role_trust","unsupported"],["participant_quarantined_processing","unsupported"],["participant_transformation","unsupported"],["scoped_tool_affordances","unsupported"],["tool_affordances","unsupported"]],"operating_profile":null,"store":"memory","store_capabilities":["store.atomic-claims","store.atomic-terminal","store.audit","store.ephemeral","store.revision-cas","store.scope-bound"]},"crossing_rows_added":0,"cut":"p0","entry_point":"admit_participant_action","equivalence_result":"not-established","events":[{"coordinates":{},"facts":{},"label":"crossing.request","ordinal":0},{"coordinates":{},"facts":{},"label":"internal.validate","ordinal":1},{"coordinates":{"cut":"p0"},"facts":{},"label":"internal.resolve-policy-cut","ordinal":2},{"coordinates":{"capability":"supported","gate":"deny"},"facts":{"effective_levels":[["participant_ingress_admission","exact"]],"gates":{"action_admission":"deny","backend_support":"permit","caller_authorization":"permit","declassification":"not-applicable","marking_authorization":"permit","participant_authority":"permit","target_authorization":"permit","transformation_validity":"not-applicable","visibility":"not-applicable"}},"label":"internal.resolve-capability","ordinal":3},{"coordinates":{"decision":"deny"},"facts":{},"label":"crossing.decision.deny","ordinal":4},{"coordinates":{},"facts":{},"label":"internal.prepare-record","ordinal":5}],"final_sink_enforced":false,"input_class":"forbidden","issues":["transition-mismatch","unmodeled-error"],"observation_gaps":[],"observed_error":"ValueError","operation_outcomes":[],"operation_records_added":0,"runtime_binding":{"audience":"audience:red-operator","controller":"participant.behavior.supervisor","episode":"episode-1","participant":"participant.behavior.red-agent","policy_cuts":["participant-policy-cut:red:episode-1:8","participant-policy-cut:red:episode-1:8.p1"],"principal":"operator.red","run_scope":"run:default","target":"stub"},"runtime_realization":"not-established","runtime_safety_issues":[],"snapshot_revisions":[2,2],"states":[{"capability":"supported","cut":"p0","decision":"deny","delivery":"withheld","gate":"deny","head":"h1","intent":["request-0","forbidden","p0","fresh"],"last":["request-0","p0","deny"],"phase":"terminal"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h1","intent":["request-0","forbidden","p0","same-cut"],"last":["request-0","p0","deny"],"phase":"validating"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h1","intent":["request-0","forbidden","p0","same-cut"],"last":["request-0","p0","deny"],"phase":"resolving-cut"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h1","intent":["request-0","forbidden","p0","same-cut"],"last":["request-0","p0","deny"],"phase":"resolving-capability"},{"capability":"supported","cut":"p0","decision":"none","delivery":"none","gate":"deny","head":"h1","intent":["request-0","forbidden","p0","same-cut"],"last":["request-0","p0","deny"],"phase":"gating"},{"capability":"supported","cut":"p0","decision":"deny","delivery":"withheld","gate":"deny","head":"h1","intent":["request-0","forbidden","p0","same-cut"],"last":["request-0","p0","deny"],"phase":"terminal"}],"unexercised":["enabled-choice-completeness","production-backend","independent-reproduction"],"visible_events":["crossing.request","crossing.decision.deny"]},"replay/later-cut/initial":{"backend_calls":0,"backend_conformance":"not-established","classification":"match","configuration":{"control_providers_selected":false,"declared_support":[["participant_boundary_flow_resolution","unsupported"],["participant_declassification","unsupported"],["participant_directed_inject_delivery","unsupported"],["participant_egress_projection","unsupported"],["participant_final_sink_mediation","unsupported"],["participant_ingress_admission","exact"],["participant_intervention","unsupported"],["participant_modular_control","unsupported"],["participant_monitor_topology","unsupported"],["participant_predicate_opacity","unsupported"],["participant_processing_role_trust","unsupported"],["participant_quarantined_processing","unsupported"],["participant_transformation","unsupported"],["scoped_tool_affordances","unsupported"],["tool_affordances","unsupported"]],"operating_profile":null,"store":"memory","store_capabilities":["store.atomic-claims","store.atomic-terminal","store.audit","store.ephemeral","store.revision-cas","store.scope-bound"]},"crossing_rows_added":2,"cut":"p0","entry_point":"admit_participant_action","equivalence_result":"not-established","events":[{"coordinates":{},"facts":{},"label":"crossing.request","ordinal":0},{"coordinates":{},"facts":{},"label":"internal.validate","ordinal":1},{"coordinates":{"cut":"p0"},"facts":{},"label":"internal.resolve-policy-cut","ordinal":2},{"coordinates":{"capability":"supported","gate":"deny"},"facts":{"effective_levels":[["participant_ingress_admission","exact"]],"gates":{"action_admission":"deny","backend_support":"permit","caller_authorization":"permit","declassification":"not-applicable","marking_authorization":"permit","participant_authority":"permit","target_authorization":"permit","transformation_validity":"not-applicable","visibility":"not-applicable"}},"label":"internal.resolve-capability","ordinal":3},{"coordinates":{"decision":"deny"},"facts":{},"label":"crossing.decision.deny","ordinal":4},{"coordinates":{},"facts":{},"label":"internal.prepare-record","ordinal":5},{"coordinates":{"head":"h1"},"facts":{"crossing_rows":2,"operation_state":"failed"},"label":"internal.atomic-commit","ordinal":6}],"final_sink_enforced":false,"input_class":"forbidden","issues":[],"observation_gaps":[],"observed_error":null,"operation_outcomes":["failed"],"operation_records_added":1,"runtime_binding":{"audience":"audience:red-operator","controller":"participant.behavior.supervisor","episode":"episode-1","participant":"participant.behavior.red-agent","policy_cuts":["participant-policy-cut:red:episode-1:8","participant-policy-cut:red:episode-1:8.p1"],"principal":"operator.red","run_scope":"run:default","target":"stub"},"runtime_realization":"not-established","runtime_safety_issues":[],"snapshot_revisions":[1,2],"states":[{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":null,"last":null,"phase":"idle"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","forbidden","p0","fresh"],"last":null,"phase":"validating"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","forbidden","p0","fresh"],"last":null,"phase":"resolving-cut"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","forbidden","p0","fresh"],"last":null,"phase":"resolving-capability"},{"capability":"supported","cut":"p0","decision":"none","delivery":"none","gate":"deny","head":"h0","intent":["request-0","forbidden","p0","fresh"],"last":null,"phase":"gating"},{"capability":"supported","cut":"p0","decision":"deny","delivery":"withheld","gate":"deny","head":"h0","intent":["request-0","forbidden","p0","fresh"],"last":null,"phase":"preparing-record"},{"capability":"supported","cut":"p0","decision":"deny","delivery":"withheld","gate":"deny","head":"h0","intent":["request-0","forbidden","p0","fresh"],"last":null,"phase":"committing"},{"capability":"supported","cut":"p0","decision":"deny","delivery":"withheld","gate":"deny","head":"h1","intent":["request-0","forbidden","p0","fresh"],"last":["request-0","p0","deny"],"phase":"terminal"}],"unexercised":["enabled-choice-completeness","production-backend","independent-reproduction"],"visible_events":["crossing.request","crossing.decision.deny"]},"replay/later-cut/retry":{"backend_calls":0,"backend_conformance":"not-established","classification":"incompatible","configuration":{"control_providers_selected":false,"declared_support":[["participant_boundary_flow_resolution","unsupported"],["participant_declassification","unsupported"],["participant_directed_inject_delivery","unsupported"],["participant_egress_projection","unsupported"],["participant_final_sink_mediation","unsupported"],["participant_ingress_admission","exact"],["participant_intervention","unsupported"],["participant_modular_control","unsupported"],["participant_monitor_topology","unsupported"],["participant_predicate_opacity","unsupported"],["participant_processing_role_trust","unsupported"],["participant_quarantined_processing","unsupported"],["participant_transformation","unsupported"],["scoped_tool_affordances","unsupported"],["tool_affordances","unsupported"]],"operating_profile":null,"store":"memory","store_capabilities":["store.atomic-claims","store.atomic-terminal","store.audit","store.ephemeral","store.revision-cas","store.scope-bound"]},"crossing_rows_added":0,"cut":"p1","entry_point":"admit_participant_action","equivalence_result":"not-established","events":[{"coordinates":{"cut":"p1"},"facts":{},"label":"policy.cut.advance","ordinal":0},{"coordinates":{},"facts":{},"label":"crossing.request","ordinal":1},{"coordinates":{},"facts":{},"label":"internal.validate","ordinal":2},{"coordinates":{"cut":"p1"},"facts":{},"label":"internal.resolve-policy-cut","ordinal":3},{"coordinates":{"capability":"supported","gate":"deny"},"facts":{"effective_levels":[["participant_ingress_admission","exact"]],"gates":{"action_admission":"deny","backend_support":"permit","caller_authorization":"permit","declassification":"not-applicable","marking_authorization":"permit","participant_authority":"permit","target_authorization":"permit","transformation_validity":"not-applicable","visibility":"not-applicable"}},"label":"internal.resolve-capability","ordinal":4},{"coordinates":{"decision":"deny"},"facts":{},"label":"crossing.decision.deny","ordinal":5},{"coordinates":{},"facts":{},"label":"internal.prepare-record","ordinal":6}],"final_sink_enforced":false,"input_class":"forbidden","issues":["incomplete-observation","transition-mismatch","unmodeled-error"],"observation_gaps":["incomplete-observation"],"observed_error":"ValueError","operation_outcomes":[],"operation_records_added":0,"runtime_binding":{"audience":"audience:red-operator","controller":"participant.behavior.supervisor","episode":"episode-1","participant":"participant.behavior.red-agent","policy_cuts":["participant-policy-cut:red:episode-1:8","participant-policy-cut:red:episode-1:8.p1"],"principal":"operator.red","run_scope":"run:default","target":"stub"},"runtime_realization":"not-established","runtime_safety_issues":[],"snapshot_revisions":[2,2],"states":[{"capability":"supported","cut":"p0","decision":"deny","delivery":"withheld","gate":"deny","head":"h1","intent":["request-0","forbidden","p0","fresh"],"last":["request-0","p0","deny"],"phase":"terminal"},{"capability":"supported","cut":"p1","decision":"deny","delivery":"withheld","gate":"deny","head":"h1","intent":["request-0","forbidden","p0","fresh"],"last":["request-0","p0","deny"],"phase":"terminal"},{"capability":"unresolved","cut":"p1","decision":"none","delivery":"none","gate":"unresolved","head":"h1","intent":["request-0","forbidden","p0","later-cut"],"last":["request-0","p0","deny"],"phase":"validating"},{"capability":"unresolved","cut":"p1","decision":"none","delivery":"none","gate":"unresolved","head":"h1","intent":["request-0","forbidden","p0","later-cut"],"last":["request-0","p0","deny"],"phase":"resolving-cut"}],"unexercised":["enabled-choice-completeness","production-backend","independent-reproduction"],"visible_events":["policy.cut.advance","crossing.request","crossing.decision.deny"]},"replay/same-cut/initial":{"backend_calls":0,"backend_conformance":"not-established","classification":"match","configuration":{"control_providers_selected":false,"declared_support":[["participant_boundary_flow_resolution","unsupported"],["participant_declassification","unsupported"],["participant_directed_inject_delivery","unsupported"],["participant_egress_projection","unsupported"],["participant_final_sink_mediation","unsupported"],["participant_ingress_admission","exact"],["participant_intervention","unsupported"],["participant_modular_control","unsupported"],["participant_monitor_topology","unsupported"],["participant_predicate_opacity","unsupported"],["participant_processing_role_trust","unsupported"],["participant_quarantined_processing","unsupported"],["participant_transformation","unsupported"],["scoped_tool_affordances","unsupported"],["tool_affordances","unsupported"]],"operating_profile":null,"store":"memory","store_capabilities":["store.atomic-claims","store.atomic-terminal","store.audit","store.ephemeral","store.revision-cas","store.scope-bound"]},"crossing_rows_added":2,"cut":"p0","entry_point":"admit_participant_action","equivalence_result":"not-established","events":[{"coordinates":{},"facts":{},"label":"crossing.request","ordinal":0},{"coordinates":{},"facts":{},"label":"internal.validate","ordinal":1},{"coordinates":{"cut":"p0"},"facts":{},"label":"internal.resolve-policy-cut","ordinal":2},{"coordinates":{"capability":"supported","gate":"deny"},"facts":{"effective_levels":[["participant_ingress_admission","exact"]],"gates":{"action_admission":"deny","backend_support":"permit","caller_authorization":"permit","declassification":"not-applicable","marking_authorization":"permit","participant_authority":"permit","target_authorization":"permit","transformation_validity":"not-applicable","visibility":"not-applicable"}},"label":"internal.resolve-capability","ordinal":3},{"coordinates":{"decision":"deny"},"facts":{},"label":"crossing.decision.deny","ordinal":4},{"coordinates":{},"facts":{},"label":"internal.prepare-record","ordinal":5},{"coordinates":{"head":"h1"},"facts":{"crossing_rows":2,"operation_state":"failed"},"label":"internal.atomic-commit","ordinal":6}],"final_sink_enforced":false,"input_class":"forbidden","issues":[],"observation_gaps":[],"observed_error":null,"operation_outcomes":["failed"],"operation_records_added":1,"runtime_binding":{"audience":"audience:red-operator","controller":"participant.behavior.supervisor","episode":"episode-1","participant":"participant.behavior.red-agent","policy_cuts":["participant-policy-cut:red:episode-1:8","participant-policy-cut:red:episode-1:8.p1"],"principal":"operator.red","run_scope":"run:default","target":"stub"},"runtime_realization":"not-established","runtime_safety_issues":[],"snapshot_revisions":[1,2],"states":[{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":null,"last":null,"phase":"idle"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","forbidden","p0","fresh"],"last":null,"phase":"validating"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","forbidden","p0","fresh"],"last":null,"phase":"resolving-cut"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","forbidden","p0","fresh"],"last":null,"phase":"resolving-capability"},{"capability":"supported","cut":"p0","decision":"none","delivery":"none","gate":"deny","head":"h0","intent":["request-0","forbidden","p0","fresh"],"last":null,"phase":"gating"},{"capability":"supported","cut":"p0","decision":"deny","delivery":"withheld","gate":"deny","head":"h0","intent":["request-0","forbidden","p0","fresh"],"last":null,"phase":"preparing-record"},{"capability":"supported","cut":"p0","decision":"deny","delivery":"withheld","gate":"deny","head":"h0","intent":["request-0","forbidden","p0","fresh"],"last":null,"phase":"committing"},{"capability":"supported","cut":"p0","decision":"deny","delivery":"withheld","gate":"deny","head":"h1","intent":["request-0","forbidden","p0","fresh"],"last":["request-0","p0","deny"],"phase":"terminal"}],"unexercised":["enabled-choice-completeness","production-backend","independent-reproduction"],"visible_events":["crossing.request","crossing.decision.deny"]},"replay/same-cut/retry":{"backend_calls":0,"backend_conformance":"not-established","classification":"incompatible","configuration":{"control_providers_selected":false,"declared_support":[["participant_boundary_flow_resolution","unsupported"],["participant_declassification","unsupported"],["participant_directed_inject_delivery","unsupported"],["participant_egress_projection","unsupported"],["participant_final_sink_mediation","unsupported"],["participant_ingress_admission","exact"],["participant_intervention","unsupported"],["participant_modular_control","unsupported"],["participant_monitor_topology","unsupported"],["participant_predicate_opacity","unsupported"],["participant_processing_role_trust","unsupported"],["participant_quarantined_processing","unsupported"],["participant_transformation","unsupported"],["scoped_tool_affordances","unsupported"],["tool_affordances","unsupported"]],"operating_profile":null,"store":"memory","store_capabilities":["store.atomic-claims","store.atomic-terminal","store.audit","store.ephemeral","store.revision-cas","store.scope-bound"]},"crossing_rows_added":0,"cut":"p0","entry_point":"admit_participant_action","equivalence_result":"not-established","events":[{"coordinates":{},"facts":{},"label":"crossing.request","ordinal":0},{"coordinates":{},"facts":{},"label":"internal.validate","ordinal":1},{"coordinates":{"cut":"p0"},"facts":{},"label":"internal.resolve-policy-cut","ordinal":2},{"coordinates":{"capability":"supported","gate":"deny"},"facts":{"effective_levels":[["participant_ingress_admission","exact"]],"gates":{"action_admission":"deny","backend_support":"permit","caller_authorization":"permit","declassification":"not-applicable","marking_authorization":"permit","participant_authority":"permit","target_authorization":"permit","transformation_validity":"not-applicable","visibility":"not-applicable"}},"label":"internal.resolve-capability","ordinal":3},{"coordinates":{"decision":"deny"},"facts":{},"label":"crossing.decision.deny","ordinal":4},{"coordinates":{},"facts":{},"label":"internal.prepare-record","ordinal":5}],"final_sink_enforced":false,"input_class":"forbidden","issues":["transition-mismatch"],"observation_gaps":[],"observed_error":null,"operation_outcomes":[],"operation_records_added":0,"runtime_binding":{"audience":"audience:red-operator","controller":"participant.behavior.supervisor","episode":"episode-1","participant":"participant.behavior.red-agent","policy_cuts":["participant-policy-cut:red:episode-1:8","participant-policy-cut:red:episode-1:8.p1"],"principal":"operator.red","run_scope":"run:default","target":"stub"},"runtime_realization":"not-established","runtime_safety_issues":[],"snapshot_revisions":[2,2],"states":[{"capability":"supported","cut":"p0","decision":"deny","delivery":"withheld","gate":"deny","head":"h1","intent":["request-0","forbidden","p0","fresh"],"last":["request-0","p0","deny"],"phase":"terminal"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h1","intent":["request-0","forbidden","p0","same-cut"],"last":["request-0","p0","deny"],"phase":"validating"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h1","intent":["request-0","forbidden","p0","same-cut"],"last":["request-0","p0","deny"],"phase":"resolving-cut"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h1","intent":["request-0","forbidden","p0","same-cut"],"last":["request-0","p0","deny"],"phase":"resolving-capability"},{"capability":"supported","cut":"p0","decision":"none","delivery":"none","gate":"deny","head":"h1","intent":["request-0","forbidden","p0","same-cut"],"last":["request-0","p0","deny"],"phase":"gating"},{"capability":"supported","cut":"p0","decision":"deny","delivery":"withheld","gate":"deny","head":"h1","intent":["request-0","forbidden","p0","same-cut"],"last":["request-0","p0","deny"],"phase":"terminal"}],"unexercised":["enabled-choice-completeness","production-backend","independent-reproduction"],"visible_events":["crossing.request","crossing.decision.deny"]},"v2/missing-identity":{"backend_calls":0,"backend_conformance":"not-established","classification":"incompatible","configuration":{"control_providers_selected":false,"declared_support":[["participant_boundary_flow_resolution","unsupported"],["participant_declassification","unsupported"],["participant_directed_inject_delivery","unsupported"],["participant_egress_projection","unsupported"],["participant_final_sink_mediation","unsupported"],["participant_ingress_admission","exact"],["participant_intervention","unsupported"],["participant_modular_control","unsupported"],["participant_monitor_topology","unsupported"],["participant_predicate_opacity","unsupported"],["participant_processing_role_trust","unsupported"],["participant_quarantined_processing","unsupported"],["participant_transformation","unsupported"],["scoped_tool_affordances","unsupported"],["tool_affordances","unsupported"]],"operating_profile":null,"store":"memory","store_capabilities":["store.atomic-claims","store.atomic-terminal","store.audit","store.ephemeral","store.revision-cas","store.scope-bound"]},"crossing_rows_added":0,"cut":"p0","entry_point":"admit_participant_decision_surface_selection_v2","equivalence_result":"not-established","events":[],"final_sink_enforced":false,"input_class":"plain","issues":["incomplete-observation","unmodeled-error"],"observation_gaps":["incomplete-observation"],"observed_error":"PermissionError","operation_outcomes":[],"operation_records_added":0,"runtime_binding":{"audience":"audience:red-operator","controller":"participant.behavior.supervisor","episode":"episode-1","participant":"participant.behavior.red-agent","policy_cuts":["participant-policy-cut:red:episode-1:8","participant-policy-cut:red:episode-1:8.p1"],"principal":"operator.red","run_scope":"run:default","target":"stub"},"runtime_realization":"not-established","runtime_safety_issues":[],"snapshot_revisions":[1,1],"states":[{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":null,"last":null,"phase":"idle"}],"unexercised":["enabled-choice-completeness","production-backend","independent-reproduction"],"visible_events":[]},"v2/stale-epoch":{"backend_calls":0,"backend_conformance":"not-established","classification":"observation-gap","configuration":{"control_providers_selected":false,"declared_support":[["participant_boundary_flow_resolution","unsupported"],["participant_declassification","unsupported"],["participant_directed_inject_delivery","unsupported"],["participant_egress_projection","unsupported"],["participant_final_sink_mediation","unsupported"],["participant_ingress_admission","exact"],["participant_intervention","unsupported"],["participant_modular_control","unsupported"],["participant_monitor_topology","unsupported"],["participant_predicate_opacity","unsupported"],["participant_processing_role_trust","unsupported"],["participant_quarantined_processing","unsupported"],["participant_transformation","unsupported"],["scoped_tool_affordances","unsupported"],["tool_affordances","unsupported"]],"operating_profile":null,"store":"memory","store_capabilities":["store.atomic-claims","store.atomic-terminal","store.audit","store.ephemeral","store.revision-cas","store.scope-bound"]},"crossing_rows_added":0,"cut":"p0","entry_point":"admit_participant_decision_surface_selection_v2","equivalence_result":"not-established","events":[],"final_sink_enforced":false,"input_class":"plain","issues":["incomplete-observation"],"observation_gaps":["incomplete-observation"],"observed_error":null,"operation_outcomes":[],"operation_records_added":0,"runtime_binding":{"audience":"audience:red-operator","controller":"participant.behavior.supervisor","episode":"episode-1","participant":"participant.behavior.red-agent","policy_cuts":["participant-policy-cut:red:episode-1:8","participant-policy-cut:red:episode-1:8.p1"],"principal":"operator.red","run_scope":"run:default","target":"stub"},"runtime_realization":"not-established","runtime_safety_issues":[],"snapshot_revisions":[1,1],"states":[{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":null,"last":null,"phase":"idle"}],"unexercised":["enabled-choice-completeness","production-backend","independent-reproduction"],"visible_events":[]},"v2/valid":{"backend_calls":1,"backend_conformance":"not-established","classification":"incompatible","configuration":{"control_providers_selected":false,"declared_support":[["participant_boundary_flow_resolution","unsupported"],["participant_declassification","unsupported"],["participant_directed_inject_delivery","unsupported"],["participant_egress_projection","unsupported"],["participant_final_sink_mediation","unsupported"],["participant_ingress_admission","exact"],["participant_intervention","unsupported"],["participant_modular_control","unsupported"],["participant_monitor_topology","unsupported"],["participant_predicate_opacity","unsupported"],["participant_processing_role_trust","unsupported"],["participant_quarantined_processing","unsupported"],["participant_transformation","unsupported"],["scoped_tool_affordances","unsupported"],["tool_affordances","unsupported"]],"operating_profile":null,"store":"memory","store_capabilities":["store.atomic-claims","store.atomic-terminal","store.audit","store.ephemeral","store.revision-cas","store.scope-bound"]},"crossing_rows_added":2,"cut":"p0","entry_point":"admit_participant_decision_surface_selection_v2","equivalence_result":"not-established","events":[{"coordinates":{},"facts":{},"label":"crossing.request","ordinal":0},{"coordinates":{},"facts":{},"label":"internal.validate","ordinal":1},{"coordinates":{"cut":"p0"},"facts":{},"label":"internal.resolve-policy-cut","ordinal":2},{"coordinates":{"capability":"supported","gate":"permit"},"facts":{"effective_levels":[["participant_ingress_admission","exact"]],"gates":{"action_admission":"permit","backend_support":"permit","caller_authorization":"permit","declassification":"not-applicable","marking_authorization":"permit","participant_authority":"permit","target_authorization":"permit","transformation_validity":"not-applicable","visibility":"not-applicable"}},"label":"internal.resolve-capability","ordinal":3},{"coordinates":{"decision":"permit"},"facts":{},"label":"crossing.decision.permit","ordinal":4},{"coordinates":{},"facts":{},"label":"internal.prepare-record","ordinal":5},{"coordinates":{"head":"h1"},"facts":{"crossing_rows":2,"operation_state":"running"},"label":"internal.atomic-commit","ordinal":6}],"final_sink_enforced":false,"input_class":"plain","issues":["external-application-outside-crossing-model","incomplete-observation"],"observation_gaps":["incomplete-observation"],"observed_error":null,"operation_outcomes":["succeeded"],"operation_records_added":1,"runtime_binding":{"audience":"audience:red-operator","controller":"participant.behavior.supervisor","episode":"episode-1","participant":"participant.behavior.red-agent","policy_cuts":["participant-policy-cut:red:episode-1:8","participant-policy-cut:red:episode-1:8.p1"],"principal":"operator.red","run_scope":"run:default","target":"stub"},"runtime_realization":"not-established","runtime_safety_issues":[],"snapshot_revisions":[1,3],"states":[{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":null,"last":null,"phase":"idle"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","plain","p0","fresh"],"last":null,"phase":"validating"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","plain","p0","fresh"],"last":null,"phase":"resolving-cut"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","plain","p0","fresh"],"last":null,"phase":"resolving-capability"},{"capability":"supported","cut":"p0","decision":"none","delivery":"none","gate":"permit","head":"h0","intent":["request-0","plain","p0","fresh"],"last":null,"phase":"gating"},{"capability":"supported","cut":"p0","decision":"permit","delivery":"pending","gate":"permit","head":"h0","intent":["request-0","plain","p0","fresh"],"last":null,"phase":"preparing-record"},{"capability":"supported","cut":"p0","decision":"permit","delivery":"pending","gate":"permit","head":"h0","intent":["request-0","plain","p0","fresh"],"last":null,"phase":"committing"},{"capability":"supported","cut":"p0","decision":"permit","delivery":"pending","gate":"permit","head":"h1","intent":["request-0","plain","p0","fresh"],"last":["request-0","p0","permit"],"phase":"committing"}],"unexercised":["enabled-choice-completeness","production-backend","independent-reproduction"],"visible_events":["crossing.request","crossing.decision.permit"]},"v2/wrong-participant":{"backend_calls":0,"backend_conformance":"not-established","classification":"incompatible","configuration":{"control_providers_selected":false,"declared_support":[["participant_boundary_flow_resolution","unsupported"],["participant_declassification","unsupported"],["participant_directed_inject_delivery","unsupported"],["participant_egress_projection","unsupported"],["participant_final_sink_mediation","unsupported"],["participant_ingress_admission","exact"],["participant_intervention","unsupported"],["participant_modular_control","unsupported"],["participant_monitor_topology","unsupported"],["participant_predicate_opacity","unsupported"],["participant_processing_role_trust","unsupported"],["participant_quarantined_processing","unsupported"],["participant_transformation","unsupported"],["scoped_tool_affordances","unsupported"],["tool_affordances","unsupported"]],"operating_profile":null,"store":"memory","store_capabilities":["store.atomic-claims","store.atomic-terminal","store.audit","store.ephemeral","store.revision-cas","store.scope-bound"]},"crossing_rows_added":0,"cut":"p0","entry_point":"admit_participant_decision_surface_selection_v2","equivalence_result":"not-established","events":[{"coordinates":{},"facts":{},"label":"crossing.request","ordinal":0}],"final_sink_enforced":false,"input_class":"plain","issues":["identity-context-mismatch","incomplete-observation","unmodeled-error"],"observation_gaps":["incomplete-observation"],"observed_error":"PermissionError","operation_outcomes":[],"operation_records_added":0,"runtime_binding":{"audience":"audience:red-operator","controller":"participant.behavior.supervisor","episode":"episode-1","participant":"participant.behavior.red-agent","policy_cuts":["participant-policy-cut:red:episode-1:8","participant-policy-cut:red:episode-1:8.p1"],"principal":"operator.red","run_scope":"run:default","target":"stub"},"runtime_realization":"not-established","runtime_safety_issues":[],"snapshot_revisions":[1,1],"states":[{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":null,"last":null,"phase":"idle"},{"capability":"unresolved","cut":"p0","decision":"none","delivery":"none","gate":"unresolved","head":"h0","intent":["request-0","plain","p0","fresh"],"last":null,"phase":"validating"}],"unexercised":["enabled-choice-completeness","production-backend","independent-reproduction"],"visible_events":["crossing.request"]}} diff --git a/specs/formal/participant-semantics/runtime-mapping/capture-0e6b342e0d43a23d262829641881c33c4a9e525cc52dc5981152e62390245538/manifest.json b/specs/formal/participant-semantics/runtime-mapping/capture-0e6b342e0d43a23d262829641881c33c4a9e525cc52dc5981152e62390245538/manifest.json new file mode 100644 index 0000000000..dca0f021bd --- /dev/null +++ b/specs/formal/participant-semantics/runtime-mapping/capture-0e6b342e0d43a23d262829641881c33c4a9e525cc52dc5981152e62390245538/manifest.json @@ -0,0 +1 @@ +{"artifact_digests":{"cases.json":"sha256:79550a0cf88c0ac7594ece77c341a7f6684ad8ada579a43b2303b27e6fb6dae2"},"backend_conformance":"not-established","case_count":25,"case_counts":{"incompatible":15,"match":8,"observation-gap":2},"equivalence_result":"not-established","historical_source_drift":["implementations/formal/participant_crossing/__main__.py","implementations/formal/participant_crossing/aut.py","implementations/formal/participant_crossing/export.py","implementations/formal/participant_crossing/ingress.py","implementations/python/packages/raes_contracts/_behavioral_profile_loader.py","implementations/python/packages/raes_contracts/_canonical.py","implementations/python/packages/raes_contracts/_participant_crossing_profile.py","implementations/python/packages/raes_contracts/behavioral_relation_profiles.py","implementations/python/packages/raes_contracts/contracts/participant_crossing_validation.py","implementations/python/packages/raes_runtime/control_plane_store.py","implementations/python/packages/raes_runtime/participant_crossing_boundary.py","implementations/python/packages/raes_runtime/participant_crossing_egress.py","implementations/python/packages/raes_runtime/participant_crossing_mediation.py","implementations/python/packages/raes_runtime/participant_crossing_records.py","implementations/python/uv.lock"],"limitations":["Selected public Python calls with synthetic local policy/providers and a stub backend.","A case match compares witnessed states and transitions; it proves no enabled-choice completeness.","Legacy API-423 cases explicitly disable the final sink; egress cases explicitly enable it.","Unprofiled fixtures claim no P0/P1/P2/P3 conformance, HTTP authentication or process-loss recovery.","No bisimulation, independent reproduction, whole-runtime, timing, probability or concurrency claim.","Additional operations, transformed ingress revalidation, errors and absent observations remain explicit."],"model":"api-423-run-319-crossing-kernel@rev2","model_artifact_digests":{"specs/formal/participant-semantics/crossing-models/rev2/abstract.aut":"sha256:5891bbc5b3da53c7345f383da7f935ee9f8f0e4dd56b50c6edc132bbbd33964b","specs/formal/participant-semantics/crossing-models/rev2/abstract.json":"sha256:8a5804e83b674b2099206b113101e2a45e60d7f08996af099dfe685e494173e3","specs/formal/participant-semantics/crossing-models/rev2/concrete.aut":"sha256:8d8ca9681c2893abf048a0988aa5efc76c22e1fe148c4c75be78780e9be09b39","specs/formal/participant-semantics/crossing-models/rev2/concrete.json":"sha256:108384d53dadb8aff695d9591c6fa8908af753bee14d56ed37d4c5c382203691","specs/formal/participant-semantics/crossing-models/rev2/manifest.json":"sha256:81feed351df647e65161a925b3804beee2c2dad8fdd5fc473fa5c4a816814e8f"},"profile":"participant-crossing-dpbb-finite-v1@rev2","projection":"participant-crossing-projection@rev1","runtime_realization":"not-established","schema":"participant-crossing-runtime-mapping/v1","source_digests":{".ground-control.yaml":"sha256:d0310fda7659a7b3ebd4834727adb1d20c5a522ef90ad13b13c51ce1d0763928","contracts/concept-authority/atlas-tactics-source-v1.json":"sha256:04ad740b60ebe4581644776c4314e318e37d6b40ab165cdb896ef537033ac2de","contracts/concept-authority/attack-enterprise-tactics-source-v1.json":"sha256:4438bd586874650390c483966efc6ecf8b72f79f5b588e14d0959c173139b60e","contracts/concept-authority/behavioral-relations-v1.json":"sha256:580f781fad84fa74777dbf5b99b9f41605a1dd2ba8f74762732bb2844bf1b52b","contracts/concept-authority/concept-families-v1.json":"sha256:cc49229cfa3c711b75aee317edf0ef0b39e0f9188a53d90376cd4c85c987bb7a","contracts/concept-authority/controlled-vocabularies-v1.json":"sha256:cb1a8faf28638e177bcb79ef43043ebf74aacb5cf6fd54f53f7b9a49761ccfc2","contracts/concept-authority/fipa-communicative-acts-source-v1.json":"sha256:648c572a926a2cbd4c9e84008f29fff48aea60f5afd7de1ddbe186758805441d","contracts/concept-authority/history/behavioral-relations-v1-rev10.json":"sha256:18999258bf2f0b23a3754d1f7d81dd437ff8b74181b99ab2afe3eaa92fbdd5aa","contracts/concept-authority/history/behavioral-relations-v1-rev11.json":"sha256:7f3ecc9b63cdac3e5bcbfd0583ef4a9f6b6aebcd7d043dad9c74d0c811c2b9cc","contracts/concept-authority/history/behavioral-relations-v1-rev12.json":"sha256:847f4920c6d896429f03cb0ddb2c530efa7a7fdbb5716459767d0507dfafea06","contracts/concept-authority/history/behavioral-relations-v1-rev8.json":"sha256:f8f37918921082954eb87400fd191e8402bf550c30dbf69d0bab571ee4b79d58","contracts/concept-authority/history/behavioral-relations-v1-rev9.json":"sha256:ec893a8464f6ddba89e5848c40dccc864ae555f95996d736dbc8f12d56afb971","contracts/concept-authority/nist-csf-defensive-categories-source-v1.json":"sha256:39b4d621070674707d129980b97e3c35acf8815eea6ea69da10dbf3618c70d02","contracts/concept-authority/reference-models-v1.json":"sha256:170c28bfa130b66eb0b969a6bc2f1ddc1238152d8966422a6ba7a394d086e929","contracts/concept-authority/uco-alignment-v1.json":"sha256:4a480321d0f3ed4157bb10f62699fba436ca57b164c7a7d7b6812de3476963b8","contracts/concept-authority/w3c-activitystreams-activity-types-source-v1.json":"sha256:0e3be78efd1bd471a13b6ded48e982545390376550d5d94a2aa15ac45701787a","contracts/fixtures/artifact-requirements/artifact-requirement-v1/invalid/constrained-without-domain.json":"sha256:58166f867cc88323b5b36f72301a7cf93232f246ba875fc82ebcc870960d616d","contracts/fixtures/artifact-requirements/artifact-requirement-v1/invalid/dangling-materialization-input.json":"sha256:779b1585327e98fc070eb150e5fe4137f8e142b8797cd0f09186365479926b66","contracts/fixtures/artifact-requirements/artifact-requirement-v1/invalid/exact-selector-mismatch.json":"sha256:aa5e2242274e10c616f21dd7e0d9e0f5d2dbd75e3ba99789c9fe43fade79c0e8","contracts/fixtures/artifact-requirements/artifact-requirement-v1/invalid/exact-with-fallback.json":"sha256:fba7470c367cacba5a84ca8f2716701c075d7a810fd98c1b68b830b5128be3ff","contracts/fixtures/artifact-requirements/artifact-requirement-v1/invalid/missing-artifact-requirement.json":"sha256:889b1d8f400715cbd4467bc0252e6bd3c9b36071404c44a35d3bcff5db4ae11b","contracts/fixtures/artifact-requirements/artifact-requirement-v1/invalid/open-with-candidate.json":"sha256:fef1e43f9f395fc99033eae11df8d2a4a16f7c2e3952d6ecdd7bd29daaf8513d","contracts/fixtures/artifact-requirements/artifact-requirement-v1/invalid/open-with-constraint.json":"sha256:ced657d937b1a267d83e408bf6b3b6271d5904a7c152f50cd065f857f5d0b04c","contracts/fixtures/artifact-requirements/artifact-requirement-v1/invalid/open-with-materialization.json":"sha256:45f434fa51476bd133f4051cd5c0084cdb93f82b9094d44f652cbbaac3a2d090","contracts/fixtures/artifact-requirements/artifact-requirement-v1/invalid/ungoverned-mechanism.json":"sha256:05ed2a1ce508abe3ec5ee2be6e548507623d6d28d7176923a8ece87c374b8599","contracts/fixtures/artifact-requirements/artifact-requirement-v1/invalid/unknown-field.json":"sha256:9298616f9bf6614f9a3bc99048468a116962cc76c9f3b8ce9e0ac63d300e554f","contracts/fixtures/artifact-requirements/artifact-requirement-v1/valid/constrained-materialization.json":"sha256:3072121c624f28a0092c4d516cff096017d4c75cce63e7595ddeaebb199a221b","contracts/fixtures/artifact-requirements/artifact-requirement-v1/valid/exact-artifact.json":"sha256:0f2d071d39009d9799bb6add34b4368e2eb30d67e18aa2aa3d6a8844777c8fe5","contracts/fixtures/artifact-transformations-v1/cases/canonicalize-portable-contract.json":"sha256:77d7c540166e511dd877e2c0f0de0413248bc8407ffbe85c66238586323fd6df","contracts/fixtures/artifact-transformations-v1/cases/refuse-collision.json":"sha256:f97ff10a26cf0a955902ae5b70484ef4446dbdd03d7c59b8b25183f6f4e5ae58","contracts/fixtures/artifact-transformations-v1/cases/remove-with-explicit-loss.json":"sha256:37b4e0f2155daf3e63710a6db54577d73b5193803d7ad9a0b4000cb6611b9216","contracts/fixtures/artifact-transformations-v1/cases/rename-composed-reference.json":"sha256:db28ed06c93e6f3238bd688a1bc7b7345fea85f1d83f9ad380f47376eeb4a2a2","contracts/fixtures/artifact-transformations-v1/cases/rename-references.json":"sha256:62217382c8921acd0d52b67350c9070d28e5234c05abaa0c08911bf3927b5c03","contracts/fixtures/artifact-transformations-v1/sources/collision.sdl.yaml":"sha256:bdbfecf178c9cde8adaf0c68481ce91b060e72f3b58325c77fa8e5fd4c6825e4","contracts/fixtures/artifact-transformations-v1/sources/references.sdl.yaml":"sha256:461805fcedb435695d20a79e53bfa3b09b7309aca6612ba9648e559484f43adc","contracts/fixtures/artifact-transformations/artifact-transformation-report-v1/invalid/success-without-target.json":"sha256:4e087ca3152e3f9d17514e3d893370b2b562da8b74b25bf7fabc53dd1ca1598f","contracts/fixtures/artifact-transformations/artifact-transformation-report-v1/valid/canonical-identity.json":"sha256:fe57873c722e6957ce29ff9d037ece9f984e69824b9746e60c7a99eeba41f813","contracts/fixtures/asset-trust/reusable-asset-trust-policy-v1/invalid/authenticity-without-threshold.json":"sha256:d48e7e3590abbc4a3b8edebbea72a3f15417ba9435dde874d8248a1930606430","contracts/fixtures/asset-trust/reusable-asset-trust-policy-v1/invalid/duplicate-evidence-class.json":"sha256:6d82afe53c68acf54cd51ca378951de8971cb114fb688f3ffb56d89e1d7167b9","contracts/fixtures/asset-trust/reusable-asset-trust-policy-v1/invalid/missing-family.json":"sha256:8f13e5d2aa966880dcffa303947a2e32f06632ead1da910cbc9ee5e97c849cc3","contracts/fixtures/asset-trust/reusable-asset-trust-policy-v1/invalid/missing-integrity.json":"sha256:2efc1dd691966097068d665e1cb5941fb3e5f49b728c366ca73257d9eb56cc9f","contracts/fixtures/asset-trust/reusable-asset-trust-policy-v1/invalid/secret-bearing.json":"sha256:10580ea9792339c7621d2e323db89ef18435ced9d7a6ae9a544f8ee8b6ff4f76","contracts/fixtures/asset-trust/reusable-asset-trust-policy-v1/invalid/unknown-family.json":"sha256:d1fe9fd57ae7a9d89395aa5fb9e92b49c212af1f3bc7a6ac68f02f9640e1e170","contracts/fixtures/asset-trust/reusable-asset-trust-policy-v1/invalid/vocabulary-missing-governance-source.json":"sha256:62049152eae7621eb137f0254a65f3f61089f8ffc7b96dc02c7cec1e00c7c1c1","contracts/fixtures/asset-trust/reusable-asset-trust-policy-v1/valid/reference.json":"sha256:393085df520699a43bc6b9916e4e18a23b213ca6ddc9904d5b7eb2a6193a99ab","contracts/fixtures/associated-artifacts/associated-artifact-manifest-v1/invalid/exact-descriptor-alias.json":"sha256:5c136ab17893c70b2fe19a1ff0a3c1de60b46afa24e613e048b64241998310ad","contracts/fixtures/associated-artifacts/associated-artifact-manifest-v1/invalid/keyed-id-mismatch.json":"sha256:490c9ffbd51ac3b40038ebe697c46d2ce3a4406df6d021a234a6c5118a9a05bb","contracts/fixtures/associated-artifacts/associated-artifact-manifest-v1/invalid/scope-parent-mismatch.json":"sha256:929c6160b1a21a6a5ee055bd85faee5676985902ad003714bd0c4214f22a1518","contracts/fixtures/associated-artifacts/associated-artifact-manifest-v1/invalid/secret-bearing-uri.json":"sha256:08d6ec554680e2da922f28b79082aedd4eb6dbcfd60fde0291cc7fe4b335e5a5","contracts/fixtures/associated-artifacts/associated-artifact-manifest-v1/invalid/unknown-extra.json":"sha256:809f3b9f00f3b15ee5b326033e7de4644544a1d3d7572f964e294287fb9fbae2","contracts/fixtures/associated-artifacts/associated-artifact-manifest-v1/valid/apparatus-context.json":"sha256:adbaa34f98f0f9fafbcebfbc22fe3923bfb90ea5a42b11a3a47e2ea7aaa7532d","contracts/fixtures/associated-artifacts/associated-artifact-manifest-v1/valid/authoring-input.json":"sha256:1bafa8d960fe47126b0405b50b82406e5c49566fc2d19d60de27ad11c777ef46","contracts/fixtures/associated-artifacts/associated-artifact-manifest-v1/valid/run.json":"sha256:7e17c4547c1517be90ee18d10f99a3b667d871cdb03f9b8f68c6133c38b1f44d","contracts/fixtures/associated-artifacts/associated-artifact-manifest-v1/valid/scenario-snapshot.json":"sha256:9156697217f3ff18336737b065d7d29ea66957f7bb194090284f9756e6966a65","contracts/fixtures/associated-artifacts/associated-artifact-manifest-v1/valid/scenario.json":"sha256:7b964dbc671f769ff2cb11abc47bd1d69dde9e6d7b3f8092f7b715cb540a3b99","contracts/fixtures/associated-artifacts/associated-artifact-manifest-v1/valid/study.json":"sha256:a0e3545b1dcd86dacf91e284ca7669c8a3e1f08baf87936fd357002498a95be1","contracts/fixtures/associated-artifacts/associated-artifact-manifest-v1/valid/task.json":"sha256:e287718d29928f2b6759671162cb580737da65426be9d643b9817cc73886aa4c","contracts/fixtures/authoring-adapters-v1/cases/declaration-difference.json":"sha256:36a0c9e18566c0dae636c7d1b2c97178be342544d80c156a7f8482af09aa7580","contracts/fixtures/authoring-adapters-v1/cases/duplicate-key.json":"sha256:0b61cbd6b57493e43a756cac53eb4b568b0e450f3f938dcee3181a72aaf8000b","contracts/fixtures/authoring-adapters-v1/cases/editorial-difference.json":"sha256:9ffd55426f4435e1be416c1e567cea04febad1bd42beada0a0cf7f434461b99f","contracts/fixtures/authoring-adapters-v1/cases/rename-collision.json":"sha256:28dca375fccfc4a6d62d941a23b2257a97410cd139aef9ef417f1f7d1aa275aa","contracts/fixtures/authoring-adapters-v1/cases/rename-invalid-source.json":"sha256:93ea66ee4ad36ddc4723c266bbaec9508a8a3753489ee93832fe330c3f6e8ccb","contracts/fixtures/authoring-adapters-v1/cases/rename-node.json":"sha256:b0c7ec54f66b66475445de91a9aea56c9f377520ac20ba0feb4ee6d1b5b2de12","contracts/fixtures/authoring-adapters-v1/cases/strict-source.json":"sha256:ae0836bf30ce9f1c0e0ad3cc987108ce866dd87720475ad68086267a7cb135ee","contracts/fixtures/authoring-adapters/authoring-adapter-comparison-v1/invalid/unknown-field.json":"sha256:c0e714c8a4ce4e2e1c60af181e5c8f247c574ce7ab0b9548736d174253919fe4","contracts/fixtures/authoring-adapters/authoring-adapter-comparison-v1/valid/reference.json":"sha256:2a4de25609c6ca1722e80721c4db8c6b08e7b430e3824fcb11857d3db7b6f006","contracts/fixtures/authoring-adapters/authoring-adapter-profile-v1/invalid/unknown-field.json":"sha256:69caa88cf6a7648cbf7746738b655972d488a12ca91dad669f5ef1f7b4f0f2db","contracts/fixtures/authoring-adapters/authoring-adapter-profile-v1/valid/reference.json":"sha256:a9521868b0f9b381e1468da3f1a2bf02b0c834f414e6036059e7b3ffbdd86cab","contracts/fixtures/authoring-adapters/authoring-adapter-vector-v1/invalid/unknown-field.json":"sha256:85caa6cb2042ebf9f4f6e9f5c07eb6db64a4dd0ad30667415baaf8a471b951d4","contracts/fixtures/authoring-adapters/authoring-adapter-vector-v1/valid/reference.json":"sha256:2c88d1448de198d55a311c5e4e810e232f80605c0a77bbcf2c1e2ad4deb7b7bf","contracts/fixtures/backend-manifest/backend-manifest-v2/invalid/duplicate-binding-scope.json":"sha256:37b149f59984c9ed4c479737b647841d4d97f43ade6845b2cb88d5a744894ec8","contracts/fixtures/backend-manifest/backend-manifest-v2/invalid/duplicate-operation-guarantees.json":"sha256:32f97eb19681e71973685bbc6c6661031c5d0fa02f0151f45aa44d96a6d9ea70","contracts/fixtures/backend-manifest/backend-manifest-v2/invalid/empty-compatibility.json":"sha256:e198c6d4622178d2b14c4f666aff36547d002ea2621b228997340029b4f5638c","contracts/fixtures/backend-manifest/backend-manifest-v2/invalid/feature-support-duplicate-feature.json":"sha256:e27140a1e2a57982e2cb06a8a196307531c542985cc68a5bb3255b9157bc9e6a","contracts/fixtures/backend-manifest/backend-manifest-v2/invalid/feature-support-missing-disclosure.json":"sha256:79fb5b19aa6bb7de4a6db35c57b5d1b4b4413e1951237796fbabb3340f736e90","contracts/fixtures/backend-manifest/backend-manifest-v2/invalid/feature-support-unguarded-feature-term.json":"sha256:ce8c0c20ebde2bfda30997bcfe96c8e88c836ab11bf0ee29e3963e59e6e92015","contracts/fixtures/backend-manifest/backend-manifest-v2/invalid/feature-support-unsupported-declared-feature.json":"sha256:0fb19327586a39412b644b998b34025a5cec48a64b70053769568504d1edb156","contracts/fixtures/backend-manifest/backend-manifest-v2/invalid/hollow-provisioner.json":"sha256:576821202cec5fe7ec5c3d7e81df7136f3c18befe1cdece10968dc27c128de86","contracts/fixtures/backend-manifest/backend-manifest-v2/invalid/hollow-realization-support.json":"sha256:d4501e1b8e776afe2326038de5c05d26b4433d20ad1772ecae6c3552693bf7a5","contracts/fixtures/backend-manifest/backend-manifest-v2/invalid/invalid-binding-family.json":"sha256:8a9db70ce322876ffff8e3fba0aa08164fbd62f181552c93c12f430fa3f31b95","contracts/fixtures/backend-manifest/backend-manifest-v2/invalid/malformed-compatibility.json":"sha256:aa8ccef87cb1c41238cc56fd5195ba870d2b1ae2ae99440e88b721f0176bcb6b","contracts/fixtures/backend-manifest/backend-manifest-v2/invalid/malformed-realization-support.json":"sha256:b8c178cd73c4a89678ba9ec318b96ab18eb1ef56000754f87e84cdb6a6b0fb85","contracts/fixtures/backend-manifest/backend-manifest-v2/invalid/missing-concept-bindings.json":"sha256:ef10c71b00edaf696febd60bbb05ca2883033caa4a162820032d30b3c63b7522","contracts/fixtures/backend-manifest/backend-manifest-v2/invalid/missing-version.json":"sha256:90eb04ecde075ae48c8b187e3136a22bfebad961b6fb9bdd256751ece8cda790","contracts/fixtures/backend-manifest/backend-manifest-v2/invalid/non-backend-contract-version.json":"sha256:2bccb2711edd7398f14e99b1066977337dfa7f73966a2dd0217469fff3ed176d","contracts/fixtures/backend-manifest/backend-manifest-v2/invalid/non-processor-compatibility-surface.json":"sha256:d0cdebf61823792e198720a35618391624ae40fb606f4f20c752b3912437643c","contracts/fixtures/backend-manifest/backend-manifest-v2/invalid/operation-supervision-without-contracts.json":"sha256:c4b78981954ad5121b7b37999818e54a937b9b47d6e0402eb6812aef985c77b9","contracts/fixtures/backend-manifest/backend-manifest-v2/invalid/unknown-workflow-feature.json":"sha256:6040403f04705ae6572a80a8899c7012b30d1d3394fccd389cee9e4359459876","contracts/fixtures/backend-manifest/backend-manifest-v2/invalid/unknown-workflow-state-predicate.json":"sha256:7cc3bc9dd67788d1951c767673d3e167a70723fc70b9d5a65ce783f4eff4dad7","contracts/fixtures/backend-manifest/backend-manifest-v2/valid/feature-support-bounded.json":"sha256:75b7bcb0535af7492472e6e43ed43d2aca293db59cd3ff8edac709d44e9ab0d0","contracts/fixtures/backend-manifest/backend-manifest-v2/valid/operation-supervision.json":"sha256:716730cb9212e37b7f7c3e6bd1ddfccd28500db91bd395b0b04ed83bd784e130","contracts/fixtures/backend-manifest/backend-manifest-v2/valid/stub.json":"sha256:76ad1f7de87f270bff053aca22e69a5cf7f058fe175081dcfebe6c9a38f01da3","contracts/fixtures/candidate-synthesis/sdl-candidate-synthesis-input-v1/invalid/ambiguous-ordering.json":"sha256:c3efdc35521db605f492d2bcff99a974ad1fb9729ee3b8acc48765d88c684fcf","contracts/fixtures/candidate-synthesis/sdl-candidate-synthesis-input-v1/invalid/missing-native-semantics.json":"sha256:d1949b3c68a1d592c37f3082141dc630170e08957a3105c867e3f8df2fc3e43b","contracts/fixtures/candidate-synthesis/sdl-candidate-synthesis-input-v1/invalid/non-reproducible-transformation.json":"sha256:4ae5f70640e17eb1d20984fb09a3f0f0aa418eb5cf66bd7d69776f95859e8949","contracts/fixtures/candidate-synthesis/sdl-candidate-synthesis-input-v1/invalid/stale-input.json":"sha256:ad0d0938c1c26f3521247cab776096ad53c00bd7830451abe0ffd5db75a58da3","contracts/fixtures/candidate-synthesis/sdl-candidate-synthesis-input-v1/invalid/unresolved-parameterization.json":"sha256:72a5b870114b625be98cae934968a08141b119c4ee7efd7363d2a88ec7542fe0","contracts/fixtures/candidate-synthesis/sdl-candidate-synthesis-input-v1/invalid/unsupported-relation.json":"sha256:bce1bcb436aacb157562e91c531c7b3f6892fbc2caca125a096c9f39b5b31ab8","contracts/fixtures/candidate-synthesis/sdl-candidate-synthesis-input-v1/valid/attack-enterprise.json":"sha256:c2ac01377355376465eac35c5d4f18f4121308795d7d5621480cabeeaa6e0f43","contracts/fixtures/candidate-synthesis/sdl-candidate-synthesis-input-v1/valid/nist-csf.json":"sha256:5f6c2f4adb8fbf32aaef142ecb3a635f19c6c482311b922c6b1ef2672aec692d","contracts/fixtures/candidate-synthesis/sdl-candidate-synthesis-record-v1/valid/attack-enterprise.json":"sha256:0ecc7b10c44471bc300822039c47c3824b7612b273f02a438d94bc4f0d1bcec5","contracts/fixtures/candidate-synthesis/sdl-candidate-synthesis-record-v1/valid/nist-csf.json":"sha256:17cbc87785f899160f7d2e5d431e5a917f23392eb7572e2f794ced067ca06694","contracts/fixtures/concept-authority/behavioral-relations-v1/invalid/missing-taxonomy-id.json":"sha256:6c984676ab9b1e3a401378c78319090fcf6705e56caf4cc7ea361e8ab5b01213","contracts/fixtures/concept-authority/behavioral-relations-v1/valid/reference.json":"sha256:580f781fad84fa74777dbf5b99b9f41605a1dd2ba8f74762732bb2844bf1b52b","contracts/fixtures/concept-authority/concept-families-v1/invalid/empty-families.json":"sha256:246c6374a5513fbbef82e0993ecef402f3ebb95291c77476b5689dff459d4d63","contracts/fixtures/concept-authority/concept-families-v1/invalid/empty-title.json":"sha256:2a34f5c520da0499b5cbaf1439e25dec487e39391953d849ef6e923ced2c2952","contracts/fixtures/concept-authority/concept-families-v1/invalid/missing-authority-reference.json":"sha256:a705dd3e35a6faf6e5238eb9b940e997bac65788aa8348f421752e17f6ede954","contracts/fixtures/concept-authority/concept-families-v1/invalid/missing-authority.json":"sha256:8dd0ba9169e3d6db0185de8676e6100dbba5c31c4b1394c66cd660f611635a82","contracts/fixtures/concept-authority/concept-families-v1/invalid/missing-provenance.json":"sha256:cd63c6c69a96b8736b7ca670b9fa2a44d0303796dcdeed2d405dfd22562673bc","contracts/fixtures/concept-authority/concept-families-v1/invalid/native-missing-extension-scope.json":"sha256:821a49d2d43b52a5a780dc59eaf74bcc5c6f33ec6d17283c771ad9fa2b94c7f7","contracts/fixtures/concept-authority/concept-families-v1/invalid/native-missing-non-ambiguity-constraints.json":"sha256:7b6ad0cde13af5ff6156957b6710d4e96f99818721d3cf94a75ff935ef64a2ef","contracts/fixtures/concept-authority/concept-families-v1/invalid/native-missing-relation-rules.json":"sha256:a74e0c918dfe2cc33be2e22846198a2ec35c676c49603d4dc157d11329cfadc6","contracts/fixtures/concept-authority/concept-families-v1/invalid/native-with-authority.json":"sha256:4190ff5f560507fca372d5686229c785812bc8a01374f3e70564f2672fdd2663","contracts/fixtures/concept-authority/concept-families-v1/valid/reference.json":"sha256:0f618b1dc55992e8e5503c08d6e2232cc32a09ddc303c618be9dff892170b8b6","contracts/fixtures/concept-authority/controlled-vocabularies-v1/invalid/closed-vocabulary-with-extension-pattern.json":"sha256:230f6209b453aab8def99c052493100cee071dbf6080211eefa2e3f266202ac3","contracts/fixtures/concept-authority/controlled-vocabularies-v1/invalid/governed-extension-missing-pattern.json":"sha256:9b584915bc4a50b5b79e167b48cb12c7097a963e0dd3b9f99a27975c8c3df4d9","contracts/fixtures/concept-authority/controlled-vocabularies-v1/invalid/unknown-governed-scope.json":"sha256:cc1a7d9e68e50b3502f224018696aea085852f48e97d26febc0a706acd5f83d6","contracts/fixtures/concept-authority/controlled-vocabularies-v1/valid/reference.json":"sha256:42565f65d328f61550c86a475d23f036baabc9d4e71cb0883dc0985d873d79d3","contracts/fixtures/concept-authority/external-concept-bindings-v1/context/autonomous-behavior-subject.sdl.yaml":"sha256:dab33c31c9202875d218833f39bd9e468a7f4604557a254ef584d442d91c3ab3","contracts/fixtures/concept-authority/external-concept-bindings-v1/context/subject.sdl.yaml":"sha256:fdb7d6ae1174f157b9c1ee074190684556c89fc9b9dbe12f3fc46a02888d8826","contracts/fixtures/concept-authority/external-concept-bindings-v1/invalid/ambiguous-subject.json":"sha256:4593e755f9532df9eddb8aa09fd3a8105978051c6752b1cb001f145bfe8ff332","contracts/fixtures/concept-authority/external-concept-bindings-v1/invalid/impermissible-participant-disclosure.json":"sha256:51fd87846b1bbe74b552dfb33eeb75e3dd3aee7ef4c952456b34c0db0fce57bd","contracts/fixtures/concept-authority/external-concept-bindings-v1/invalid/missing-provenance.json":"sha256:94e040b65bffec66d453e3ace2a0eb6ee5b377885ceb5e9d2d945493505aa3ce","contracts/fixtures/concept-authority/external-concept-bindings-v1/invalid/stale-scheme-revision.json":"sha256:d034bea3a8402d6f8c7b5eb7787a91e0516e39ec20f99c892ef582afa4db27c8","contracts/fixtures/concept-authority/external-concept-bindings-v1/invalid/unknown-relationship.json":"sha256:87d728d645a8f5334af68825dccd9601538a5c9f9940a98828a4fd1f23062f16","contracts/fixtures/concept-authority/external-concept-bindings-v1/valid/activitystreams-behavior.json":"sha256:34ce59982dca754173e86e9024125aa60111b7beb6f2bdee36957a947deb2512","contracts/fixtures/concept-authority/external-concept-bindings-v1/valid/attack-enterprise.json":"sha256:cecea9ca22696ddbbb1d91c3ae9f36a26203fd71a67273ce95c3ce4dd44ba76d","contracts/fixtures/concept-authority/external-concept-bindings-v1/valid/fipa-behavior.json":"sha256:e93bcef552fd453b3dafc6c5cc84513446112e1151677060d4a1d541d9804b7a","contracts/fixtures/concept-authority/external-concept-bindings-v1/valid/nist-csf.json":"sha256:9e7fcf011f93387d659f7908d69cc46068c7ca52e08567fc2dc6b7f8a9348cc0","contracts/fixtures/concept-authority/reference-models-v1/invalid/instance-path-mismatch.json":"sha256:2272c68dd396231d807d53590bb1d88b5f6f53b405e0f8c4de8330d270c7e0ad","contracts/fixtures/concept-authority/reference-models-v1/invalid/missing-key-field.json":"sha256:ea53a5bbfb7c1382dde9ab138a92d556479842f46f500ec8f469c1990aaa3469","contracts/fixtures/concept-authority/reference-models-v1/invalid/schema-pointer-not-found.json":"sha256:e42c0e605d5975d7e1738af15506b022aff10257685207c81ed15e76cd1df44a","contracts/fixtures/concept-authority/reference-models-v1/invalid/unknown-concept-family.json":"sha256:400a07a7c836490cfad585379be3162c14678dc14ef1cbc181f9cac4dad2f226","contracts/fixtures/concept-authority/reference-models-v1/invalid/unknown-contract-id.json":"sha256:2739d217ac072ef2d990a9a890c6786bdc35cf51a023a44bc266682e6654938e","contracts/fixtures/concept-authority/reference-models-v1/valid/reference.json":"sha256:170c28bfa130b66eb0b969a6bc2f1ddc1238152d8966422a6ba7a394d086e929","contracts/fixtures/concept-authority/semantic-projection-report-v1/invalid/evidence-free-verification.json":"sha256:4e9ddb1b7b3d1b63f16776b43a21226e26a81078e3f8a7d2578f187bf5735599","contracts/fixtures/concept-authority/semantic-projection-report-v1/invalid/implicit-denominator.json":"sha256:c352fdd707edf692234febca2e58dc097236ccfd37de1990d3f2cbef93c8bfdc","contracts/fixtures/concept-authority/semantic-projection-report-v1/invalid/missing-scheme-revision.json":"sha256:eb1c831f4f41cf12243e5867ff6634fab5d53979db9ae04fdf41931f61a59eb9","contracts/fixtures/concept-authority/semantic-projection-report-v1/invalid/unknown-predicate.json":"sha256:b1efee655f5bbef754b43425396ca5b181ad9aeb602415b003e8d5d9f849b32a","contracts/fixtures/concept-authority/semantic-projection-report-v1/valid/declared-attack-enterprise.json":"sha256:eaabca69077e494e048cd99b0b59e3a40a40199a072b0e75ad39f9a26d1ebeaf","contracts/fixtures/concept-authority/uco-alignment-v1/invalid/adapted-without-divergence.json":"sha256:f2ffa0e689573a47bfffd26f28ce7ebb9ddc73841eed8458887512e91e8cf092","contracts/fixtures/concept-authority/uco-alignment-v1/invalid/empty-divergence.json":"sha256:da6798eca1cfad845a91ec1e0684c27364fae6069589039eb94377843ca88126","contracts/fixtures/concept-authority/uco-alignment-v1/invalid/iri-mismatch.json":"sha256:c66f8b8747d9019cf40b7ce238bd463b9f01fea0774b2d96b73ba538d45f2e80","contracts/fixtures/concept-authority/uco-alignment-v1/invalid/missing-family.json":"sha256:3c99a05315ee2d343698961a624ab9dc7036a6a27a78f6b46652fcdb94041e72","contracts/fixtures/concept-authority/uco-alignment-v1/invalid/native-family.json":"sha256:08017c781a8df7682507b4f74feeb050adbebaba16dbc7233addf2a458f3d645","contracts/fixtures/concept-authority/uco-alignment-v1/invalid/provenance-mismatch.json":"sha256:e07f9078507611be4a07b48cf410f0254ac50f4fb7f25416bd510bd54873d157","contracts/fixtures/concept-authority/uco-alignment-v1/invalid/unknown-family.json":"sha256:4e2e353dcd3ecf2ba44859efd1b58d6caae6e9d94cf423d85000d323499c52cc","contracts/fixtures/concept-authority/uco-alignment-v1/valid/reference.json":"sha256:4a480321d0f3ed4157bb10f62699fba436ca57b164c7a7d7b6812de3476963b8","contracts/fixtures/control-plane/backend-operation-capabilities-v1/valid/mixed-bridge.json":"sha256:b2b75b1196f637c85df7aff09d27d59b1a912afb1928f237713526d3ca79ddaf","contracts/fixtures/control-plane/backend-operation-capabilities-v1/valid/mixed-transfer.json":"sha256:0a4ffe1ec570c44acb2f7e1ec65be509e846539c0650ee7959ca048ba94fc2ae","contracts/fixtures/control-plane/backend-operation-capabilities-v1/valid/provider.json":"sha256:d0ffc37fe417866e8c77679777fb2b9cf354b01b114b6d188a2d6c4a35947dee","contracts/fixtures/control-plane/backend-operation-control-v1/valid/cancel-race-01.json":"sha256:6ff0f38d9a023f4e1596518e74327ad346b5ab1bfceb0637057321d9b06e2672","contracts/fixtures/control-plane/backend-operation-control-v1/valid/partial-cancel-01.json":"sha256:6ff0f38d9a023f4e1596518e74327ad346b5ab1bfceb0637057321d9b06e2672","contracts/fixtures/control-plane/backend-operation-control-v1/valid/uncertain-01.json":"sha256:d63206fa1c8fc9f1a6c36d11fc9a6a5c3bf3cefb141d4a2f9bb136c45e2c7b7e","contracts/fixtures/control-plane/backend-operation-request-v1/valid/accepted.json":"sha256:4865d5a780c1748109e6175beeefd429d120fe6584a1e2068792629436fdcbc6","contracts/fixtures/control-plane/backend-operation-request-v1/valid/cancel-race.json":"sha256:4865d5a780c1748109e6175beeefd429d120fe6584a1e2068792629436fdcbc6","contracts/fixtures/control-plane/backend-operation-request-v1/valid/duplicate.json":"sha256:4865d5a780c1748109e6175beeefd429d120fe6584a1e2068792629436fdcbc6","contracts/fixtures/control-plane/backend-operation-request-v1/valid/inject-handover.json":"sha256:a37cdd0a7ff564264fc88b1cfc8588d2e7282c49b03923c567f7f8054c3a7df1","contracts/fixtures/control-plane/backend-operation-request-v1/valid/inject-release.json":"sha256:9fce09d8022f37fc53d75c0372adbb1f17285c5abf4e8b31f016363420a84153","contracts/fixtures/control-plane/backend-operation-request-v1/valid/mixed-edge-partial.json":"sha256:c42244d741411b9a63796c2913fccf51bbd8c765fb1f341112fe3fd83f2a16fd","contracts/fixtures/control-plane/backend-operation-request-v1/valid/mixed-edge-refused.json":"sha256:d84cc2c183bbab580c4275a0defe419ab0b7e5ea1d569ca8b26a9d4af1506a04","contracts/fixtures/control-plane/backend-operation-request-v1/valid/mixed-edge-time-refused.json":"sha256:63bb3196c322be4d75cb909e53ddd1a9982b94ab770b6c989840bc5cfa95b8ec","contracts/fixtures/control-plane/backend-operation-request-v1/valid/mixed-edge.json":"sha256:75f74fa32fb52ebeb0cc66cfb7025f08d64067281ad434f6c6d54ae27aea32c0","contracts/fixtures/control-plane/backend-operation-request-v1/valid/mixed-handoff-stale.json":"sha256:0094e58e30829facf9f20985f698bdfad02d770816aa2d83d46c1365c7ae8167","contracts/fixtures/control-plane/backend-operation-request-v1/valid/mixed-handoff.json":"sha256:366827a366c829692a2cde811a280bf742af36f8283e88b8425c65262005db70","contracts/fixtures/control-plane/backend-operation-request-v1/valid/partial-cancel.json":"sha256:4865d5a780c1748109e6175beeefd429d120fe6584a1e2068792629436fdcbc6","contracts/fixtures/control-plane/backend-operation-request-v1/valid/refused.json":"sha256:4865d5a780c1748109e6175beeefd429d120fe6584a1e2068792629436fdcbc6","contracts/fixtures/control-plane/backend-operation-request-v1/valid/uncertain.json":"sha256:4865d5a780c1748109e6175beeefd429d120fe6584a1e2068792629436fdcbc6","contracts/fixtures/control-plane/backend-operation-response-v1/valid/accepted-01.json":"sha256:c2ec24b7392d229ca96a343e48d77b1a2de20274917826b275c81df41347e50b","contracts/fixtures/control-plane/backend-operation-response-v1/valid/accepted-02.json":"sha256:51e39a1d97a1585dfc52ff94bd30d22da4835d406f681f4b627cb11f1d7a2804","contracts/fixtures/control-plane/backend-operation-response-v1/valid/accepted-03.json":"sha256:5e7e085e2ae2dc70b69a63f31b6037789a1fe51a4d6f980058f5c2f09d1fd005","contracts/fixtures/control-plane/backend-operation-response-v1/valid/accepted-04.json":"sha256:90ca79c9400b28e903ac5febf6295ed43f8e30ebb7a96bfe077e57cd194115c1","contracts/fixtures/control-plane/backend-operation-response-v1/valid/cancel-race-01.json":"sha256:038447245ab2b65c2658de8556ed6a31f9c6be72ed59c60cb36e75558a436220","contracts/fixtures/control-plane/backend-operation-response-v1/valid/cancel-race-02.json":"sha256:892bbf5b6de411a06a000708aacf15a3a19c735b6e83a7ad2bc3d2381e96c6c6","contracts/fixtures/control-plane/backend-operation-response-v1/valid/cancel-race-03.json":"sha256:480fa5fdd52991654aa4ccf115281cf6b7f7a97cf497bb78325029cdd3d26fc5","contracts/fixtures/control-plane/backend-operation-response-v1/valid/duplicate-01.json":"sha256:038447245ab2b65c2658de8556ed6a31f9c6be72ed59c60cb36e75558a436220","contracts/fixtures/control-plane/backend-operation-response-v1/valid/duplicate-02.json":"sha256:038447245ab2b65c2658de8556ed6a31f9c6be72ed59c60cb36e75558a436220","contracts/fixtures/control-plane/backend-operation-response-v1/valid/mixed-edge-01.json":"sha256:053adfdf263caad1c95f49e70c2454711e73f8cad45c0d28baf6106fb12ab715","contracts/fixtures/control-plane/backend-operation-response-v1/valid/mixed-edge-02.json":"sha256:e94db361d04bffae0548fefda18dc2b3645beb9ceab465e41140f3ee2729556c","contracts/fixtures/control-plane/backend-operation-response-v1/valid/mixed-edge-03.json":"sha256:3f3b6879b5b805724d969e3cb45be35dc57965430f63ae5fa5b86a88c21e5ad1","contracts/fixtures/control-plane/backend-operation-response-v1/valid/mixed-edge-partial-01.json":"sha256:539192459036784baa88544be43436d3bc9ae3b28267fe5adb04416f6586e817","contracts/fixtures/control-plane/backend-operation-response-v1/valid/mixed-edge-partial-02.json":"sha256:5c6437b8878135802a5f97b1e783d6539f07f7b8a4e07706b415fe6bdb44add6","contracts/fixtures/control-plane/backend-operation-response-v1/valid/mixed-edge-refused-01.json":"sha256:acfdf000caa02ff31a2244393400fa8260cc8d70eb10dd280f6d4bfd17fc273e","contracts/fixtures/control-plane/backend-operation-response-v1/valid/mixed-edge-time-refused-01.json":"sha256:8ef85c4c1734a7c649c3371bee1dbd255c76d2b9ad416c2e2b82090e51194644","contracts/fixtures/control-plane/backend-operation-response-v1/valid/mixed-edge-time-refused-02.json":"sha256:e0874b75d5518458a06aa8b5e0ec2f7a1684e478a85437b0ac776b2fc5e625ae","contracts/fixtures/control-plane/backend-operation-response-v1/valid/mixed-handoff-01.json":"sha256:9e63e32d242c25bfa673507079afd6cf6f8cb5bed65d25da94609d88ace05ff7","contracts/fixtures/control-plane/backend-operation-response-v1/valid/mixed-handoff-02.json":"sha256:b013b9b7112455193c896a01ad0d496b369bae940749f8868d134ec5efbb5509","contracts/fixtures/control-plane/backend-operation-response-v1/valid/mixed-handoff-stale-01.json":"sha256:2ef8812ff375ca8a53e1af06f658459e430c41d3dc2007158e157ed56b702656","contracts/fixtures/control-plane/backend-operation-response-v1/valid/mixed-handoff-stale-02.json":"sha256:85480361379ef2ac13518965f3ae494820489f84c1ab07ca16c6f25d6362a442","contracts/fixtures/control-plane/backend-operation-response-v1/valid/partial-cancel-01.json":"sha256:038447245ab2b65c2658de8556ed6a31f9c6be72ed59c60cb36e75558a436220","contracts/fixtures/control-plane/backend-operation-response-v1/valid/partial-cancel-02.json":"sha256:892bbf5b6de411a06a000708aacf15a3a19c735b6e83a7ad2bc3d2381e96c6c6","contracts/fixtures/control-plane/backend-operation-response-v1/valid/partial-cancel-03.json":"sha256:9d438a5557658c225d093cdb938d02e4b1e2c259979d0972711ccf220f2bd7a3","contracts/fixtures/control-plane/backend-operation-response-v1/valid/refused-01.json":"sha256:60c26a77318660e0107b669c13e52174cafd0c0e0cd470852f92ca1cb4574e2e","contracts/fixtures/control-plane/backend-operation-response-v1/valid/uncertain-01.json":"sha256:038447245ab2b65c2658de8556ed6a31f9c6be72ed59c60cb36e75558a436220","contracts/fixtures/control-plane/backend-operation-response-v1/valid/uncertain-02.json":"sha256:e238cf4fb948d9f57a91fecaa13b611b716f4bd71e6b174d6af1101126b431ac","contracts/fixtures/control-plane/backend-operation-response-v1/valid/uncertain-03.json":"sha256:7ef94ba0a7527197832b6ec09c8625682d9df7589f1fd438c6741819cedd3413","contracts/fixtures/control-plane/batch-execution-receipt-v1/invalid/bad-trial-outcome.json":"sha256:49d0b89402330cfba17ede990d84c5aab9d1acda2739370587be757c4f408124","contracts/fixtures/control-plane/batch-execution-receipt-v1/invalid/missing-cleanup-receipt-ref.json":"sha256:37f724b613f164ce456ab7b66bafc25673f5de456d05d3379117bfa4e36ab09a","contracts/fixtures/control-plane/batch-execution-receipt-v1/invalid/parallel-missing-proof.json":"sha256:4a84b53462e832447fa045aa3394a6fc6140a25a2659571dd10adc9d266d3b61","contracts/fixtures/control-plane/batch-execution-receipt-v1/invalid/unknown-field.json":"sha256:a6d640ab28fa290896404aea611c341975d306632827c1b8f9b19267a7c86606","contracts/fixtures/control-plane/batch-execution-receipt-v1/invalid/unknown-scheduling-policy.json":"sha256:ee7501745b88a3be5e3f4cb15d5b97505db9d0bd47985d3ae1f630339796cba9","contracts/fixtures/control-plane/batch-execution-receipt-v1/valid/bounded-parallel.json":"sha256:1574a3f48ddbb2370a8f10c94ade09a9ad3ebb7c8210c6d09322420a3a3e124e","contracts/fixtures/control-plane/batch-execution-receipt-v1/valid/serial.json":"sha256:f879b5cc8c5d0206d82ff41a08edab5d4391a4bc237c407fa8cf58c8fdaa78f1","contracts/fixtures/control-plane/evaluation-history-event-stream-v1/invalid/not-a-list.json":"sha256:3930db1c2284e8fb8061eb307f46d1efab51316c9c765349e21576bfdefa6b7a","contracts/fixtures/control-plane/evaluation-history-event-stream-v1/valid/ready.json":"sha256:5bcb107c4bf155f09cea769011395f58ab4f3ba6184ad87a827b9af021c8b287","contracts/fixtures/control-plane/evaluation-result-envelope-v1/invalid/missing-status.json":"sha256:d3d0b8721cc5cd41b2f89f2ca61cd489131a12ca6165679f126553d4267d1bf3","contracts/fixtures/control-plane/evaluation-result-envelope-v1/valid/ready.json":"sha256:a1cac4ca2daae9fc0a9df1b0c475263d0489bf0208f5706c0427db308aa35c82","contracts/fixtures/control-plane/inject-occurrence-correlation-v1/context-invalid/foreign-outcome.json":"sha256:6a592c7902da440874bf4f92f5d11b149295ba85485441bc1275f6be8842c8f2","contracts/fixtures/control-plane/inject-occurrence-correlation-v1/context-invalid/request-as-occurrence.json":"sha256:3ab6e5d2581decc9b539e24898fb68d9db6b3366b8a06e2194a5b768f0573bc6","contracts/fixtures/control-plane/inject-occurrence-correlation-v1/invalid/participant-address.json":"sha256:271f20d479c04f320f79d84af0abe144b1e9b029ce9184e9af4ce9d2dee5d544","contracts/fixtures/control-plane/inject-occurrence-correlation-v1/valid/participant-free-environment.json":"sha256:bf9294e3552e4c311277703921267e95b863de6151c9f01c327f26e07b50646a","contracts/fixtures/control-plane/inject-occurrence-outcome-v1/context-invalid/acceptance-as-settlement.json":"sha256:4db2653b07e0ae36a6c591572cad3c1b5a1ed755d6fc8bccfd6190f77a722699","contracts/fixtures/control-plane/inject-occurrence-outcome-v1/context-invalid/applied-without-readback.json":"sha256:5f1966ef4df4656f23408f269486c05132843f71f239fc0938e873ae8697a9a4","contracts/fixtures/control-plane/inject-occurrence-outcome-v1/context-invalid/successful-no-op.json":"sha256:5b012a20ffc2a6189ed32a96bf901a387c4ab3d53004fe6c961c38f39a2d799a","contracts/fixtures/control-plane/inject-occurrence-outcome-v1/context-invalid/unproven-refusal.json":"sha256:f3065ec75d3bff010acc25a08345751ec15c9b59e2a5cb6075028106559b0a72","contracts/fixtures/control-plane/inject-occurrence-outcome-v1/invalid/no-binding.json":"sha256:f1ad20103d2a017851ab261266f763e16abfd58020d17b8a22676d2c178ea7ee","contracts/fixtures/control-plane/inject-occurrence-outcome-v1/invalid/participant-delivery.json":"sha256:2c6c578a2a1ee658c319d3855bdb0ef4ae72e74eaa28721d459f0a2cc4f01fe5","contracts/fixtures/control-plane/inject-occurrence-outcome-v1/valid/indeterminate.json":"sha256:89815e6ef43e163f4cdeae82582aaee86d0d4faacf221b6fff5bc38bfddb407c","contracts/fixtures/control-plane/inject-occurrence-outcome-v1/valid/known-partial.json":"sha256:050f4837e2ca660856845e40d6bc94b5829efe4f43b6ba8bd395e1ed4a73c794","contracts/fixtures/control-plane/inject-occurrence-outcome-v1/valid/participant-free-environment.json":"sha256:608b4f1016e7c5867b76286be18f55d114b0683ff413a72753e80f7bccba70d3","contracts/fixtures/control-plane/inject-occurrence-outcome-v1/valid/refused.json":"sha256:bf495836469b0b169933de89e5b69936a4da25aac1ed21eb237377aff79ef6e5","contracts/fixtures/control-plane/inject-occurrence-outcome-v1/valid/unceased-effect.json":"sha256:a86050c748a374d4b62f5c26d12bd3862ccdb72e209cd123750f33909f42f8bb","contracts/fixtures/control-plane/inject-occurrence-v1/context-invalid/provisioning-kind.json":"sha256:73a3acb4f58f3692bd26001ef605808edcaaa93449bfd8fc59d9767d605dbc82","contracts/fixtures/control-plane/inject-occurrence-v1/context-invalid/rebased-order.json":"sha256:d7f7f03364213f78cefa1e74ed345fa93ab6b778834fdb387c9cac4e321747e0","contracts/fixtures/control-plane/inject-occurrence-v1/context-invalid/shared-identity.json":"sha256:3a4b84f254646a9e3f0fd0437d81da8c88c7a63f17246a954c2029250896ddf3","contracts/fixtures/control-plane/inject-occurrence-v1/invalid/missing-admission.json":"sha256:a87765c9925f0361be6ca301b873819b29fb929dcdfa4d9d5a6b53d034833635","contracts/fixtures/control-plane/inject-occurrence-v1/invalid/missing-event-kind.json":"sha256:b70c903d771e7d4c315ccff61111d2eaf2a5e0c7e3e37fdd4afe3feba8fc6437","contracts/fixtures/control-plane/inject-occurrence-v1/invalid/missing-independent-kind.json":"sha256:2695c84e2c8363f78b2800b4e3850ad173041a7b864ce0e134034f7bb49b9190","contracts/fixtures/control-plane/inject-occurrence-v1/invalid/missing-schedule-kind.json":"sha256:36a55ab96f211b084de18065f73215f5975ffda618123f81dab4b2e0bb01b5a1","contracts/fixtures/control-plane/inject-occurrence-v1/valid/participant-free-environment.json":"sha256:ddd8dd385ae900f844baa324a874e81dd63c9db61ecc469d7661fca1456a6ba4","contracts/fixtures/control-plane/inject-occurrence-v1/valid/scheduled-fan-out.json":"sha256:37094dce7c6ebca7749c1f414833bd6794c79411481d8905eddda28f9e56ecee","contracts/fixtures/control-plane/inject-trigger-request-v1/context-invalid/ambiguous-instance.json":"sha256:4e105064d9b2612837d7e16a14d88160b097634551077f1aa1e671daca47eab0","contracts/fixtures/control-plane/inject-trigger-request-v1/context-invalid/event-as-inject.json":"sha256:eafacc29ab3dc55accdf42d24bda94441bbf5e6cbdad728ad6e0c7b465f00c26","contracts/fixtures/control-plane/inject-trigger-request-v1/context-invalid/foreign-binding.json":"sha256:3e390d59303a11388a9ef1848ffb19c05dc8c414158f11d957f018563227a4f5","contracts/fixtures/control-plane/inject-trigger-request-v1/context-invalid/namespaced-binding.json":"sha256:5f4845cc60373962a910fad05d9ef92e025e7b2c6f8cb3c1c3a016d58b47776e","contracts/fixtures/control-plane/inject-trigger-request-v1/invalid/missing-event-kind.json":"sha256:df72ddee87cbfce3035e2fc1306dfa768666049177b163273ce4d40b96fa2f4b","contracts/fixtures/control-plane/inject-trigger-request-v1/invalid/missing-independent-kind.json":"sha256:9f921ae3fb97f0a36dfb48dda618c134aef3ae1c9cba5d2a3867ac5bc55bf271","contracts/fixtures/control-plane/inject-trigger-request-v1/invalid/missing-schedule-kind.json":"sha256:1693f3fd1209652dd222400da202218b2950529878c066ba1cf26b7f32fd144c","contracts/fixtures/control-plane/inject-trigger-request-v1/invalid/no-binding.json":"sha256:789761b4b533f957b285ca0fc390d50b0963f2839733261e9c44bfe332f8a369","contracts/fixtures/control-plane/inject-trigger-request-v1/invalid/participant-binding.json":"sha256:2dd2ef943ebc957d6f790d59edd43ec106bf8fb81da965478defd05a7858cea6","contracts/fixtures/control-plane/inject-trigger-request-v1/invalid/untyped-payload.json":"sha256:777461eec3b06d23edfd009874b00e3c2f447f5d8c8485b0f630c2299a5b6b17","contracts/fixtures/control-plane/inject-trigger-request-v1/valid/independent-binding.json":"sha256:6e127543f8683c4d6183e7777e288252700896db77ecf5f12952d6ab81ae626d","contracts/fixtures/control-plane/inject-trigger-request-v1/valid/participant-free-environment.json":"sha256:73d88332ceb82b36a340f3004984e493965a4e149d8d578b0a7ae6d8103a3057","contracts/fixtures/control-plane/inject-trigger-request-v1/valid/scheduled-fan-out.json":"sha256:039f555fcebec248255e1bd24aea738c02bcde927d6bef36033baaec07a7a34f","contracts/fixtures/control-plane/mixed-backend-execution-binding-v1/context-invalid/foreign-bridge.json":"sha256:27073fcbc57dac23f2e264375317cc16ece9235d9311950f1aac7b89ec990b4a","contracts/fixtures/control-plane/mixed-backend-execution-binding-v1/invalid/bridge-as-reader.json":"sha256:49db2b11d9e100b9f1d2cbb0a94a2a8455a9b4d144bd8696a3a262dd8e516d5f","contracts/fixtures/control-plane/mixed-backend-execution-binding-v1/invalid/changed-subject.json":"sha256:62aa80d54942b12d1b173af234e1a835e31db6ead632feb605af1b6dcdc69c87","contracts/fixtures/control-plane/mixed-backend-execution-binding-v1/invalid/open-metadata.json":"sha256:8909dc9ed50be1916782946fc8ad9f06ffa3e00065251f74100888ca92fd6689","contracts/fixtures/control-plane/mixed-backend-execution-binding-v1/invalid/transfer-as-owner-reader.json":"sha256:52b858433c0cdd57bd2f5e7bdd947b6a761beff9e31c0ce3906aaf5a60028921","contracts/fixtures/control-plane/mixed-backend-execution-binding-v1/invalid/ungoverned-order.json":"sha256:23fe38aa8ac6d40cac428b21e36fdb390aa6d5b4fbc00c24994130e13c460722","contracts/fixtures/control-plane/mixed-backend-execution-binding-v1/valid/mixed-edge.json":"sha256:16aaec837ccf338135f37e913b67f0cd9ebdb52f03e85359467a7391f193f6b6","contracts/fixtures/control-plane/mixed-backend-execution-binding-v1/valid/mixed-handoff.json":"sha256:2b8007468187c830d05d10db9c969a0fb83cbd0f50142ac8ca93352ddeb11a75","contracts/fixtures/control-plane/mixed-backend-stage-report-v1/context-invalid/foreign-invocation.json":"sha256:2977394d182871f1514c961aed70ff04e7a7d800d46306d5fd2866eb919554ed","contracts/fixtures/control-plane/mixed-backend-stage-report-v1/invalid/failed-without-cessation.json":"sha256:90e69c28bebc7b7c5da494dafea14b121f70880464cfc0158e7215ac837b325a","contracts/fixtures/control-plane/mixed-backend-stage-report-v1/invalid/observation-without-evidence.json":"sha256:499e7937acb7e088232b085532a034fc6d68c81f88b80ba427fbfb5b652f6d74","contracts/fixtures/control-plane/mixed-backend-stage-report-v1/invalid/untagged-stage.json":"sha256:06c5f6468d03c83de4abec40cba37886cedbae43f1e2ae5f758dba8f6d9b7dd9","contracts/fixtures/control-plane/mixed-backend-stage-report-v1/valid/mixed-edge-01.json":"sha256:a1fe438c88f40cb0720ff3c1213661eacc189a35b03faa872bb4cfeda39cf48c","contracts/fixtures/control-plane/mixed-backend-stage-report-v1/valid/mixed-edge-02.json":"sha256:a4483d820d3f2726ef864cd240269dacbaa03c882db757fe5a32b51cd7e70056","contracts/fixtures/control-plane/mixed-backend-stage-report-v1/valid/mixed-edge-03.json":"sha256:3ee03b78e31484117bbd995fb3381a30513d65b51dbb0d7e82102c703e8d53be","contracts/fixtures/control-plane/mixed-backend-stage-report-v1/valid/mixed-edge-04.json":"sha256:69444b7d914f51b25ffa60901acaa53bffea8d7d094f1af318629efd0a5474bb","contracts/fixtures/control-plane/mixed-backend-stage-report-v1/valid/mixed-edge-partial-01.json":"sha256:adc007ffa23bedf1094839e7d8741068dcf0e60d979ed2a94c65fd0442612cc8","contracts/fixtures/control-plane/mixed-backend-stage-report-v1/valid/mixed-edge-partial-02.json":"sha256:c7a4f37272614b94545f9fd2a1455f85a9da4999734364966b673937f60879d6","contracts/fixtures/control-plane/mixed-backend-stage-report-v1/valid/mixed-edge-time-refused-01.json":"sha256:c5cdaf9238b8f6983ed090934946b5dd17559bd881981bad0d940792b002a27a","contracts/fixtures/control-plane/mixed-backend-stage-report-v1/valid/mixed-handoff-01.json":"sha256:99b6e03bf240b314511d10890e8b643a9dc1277a74d2e70b46b77e61b4ab419e","contracts/fixtures/control-plane/mixed-backend-stage-report-v1/valid/mixed-handoff-02.json":"sha256:6d9068a8f0932a03a601b775217322c6d019cf07a4b404fb7850a824172c0732","contracts/fixtures/control-plane/mixed-backend-stage-report-v1/valid/mixed-handoff-03.json":"sha256:e670d002f9638e228b70630b9cfa9cfcbeaf838466c1078cb0b8463f96491a3c","contracts/fixtures/control-plane/mixed-backend-stage-report-v1/valid/mixed-handoff-stale-01.json":"sha256:3c8d6ce49e3fc4684afbdc626a124e654a8e7d17453ad2c58478d06673d9adad","contracts/fixtures/control-plane/mixed-backend-stage-report-v1/valid/mixed-handoff-stale-02.json":"sha256:7c594c533d7f22efd71bdbca6c1944086e1b349af1cdff4623c1a3fde4aa2668","contracts/fixtures/control-plane/mixed-backend-stage-report-v1/valid/mixed-handoff-stale-03.json":"sha256:d2e942f7e74fd4e8a7ef36f86e1907aad96346262ca8f5faa833e665e5a9e2b7","contracts/fixtures/control-plane/observation-demand-v1/invalid/policy-empty-rule.json":"sha256:738a3b4d21f7743b192245ca95daf6095cb13dc5a3b679af92e8df18d7d7da44","contracts/fixtures/control-plane/observation-demand-v1/invalid/unbounded-exhaustive.json":"sha256:2058bf46c0e6546963f8e17bb9f6d4940f2b5a42575979cf637d9832d6d78400","contracts/fixtures/control-plane/observation-demand-v1/valid/mixed-scopes.json":"sha256:1f9cae0fb8a676ba3372ce4490cb4d6ba2c7ee7d2cfcd80b8061869c8681d0fd","contracts/fixtures/control-plane/operation-receipt-v1/invalid/missing-context.json":"sha256:368731cd72de5ea1a0c585485670375fdb6f9d10bf605c5f46276247fe7a5ccd","contracts/fixtures/control-plane/operation-receipt-v1/invalid/missing-id.json":"sha256:2538947cf9ed3f958f3bc4dc30bf925f99fc7181b7c35c3e8babcad341ed179b","contracts/fixtures/control-plane/operation-receipt-v1/valid/accepted.json":"sha256:d4d54bf4aea7fe3dedcafdaa735577298fc62ba6fc4e5edd4e2dc9d02e35e695","contracts/fixtures/control-plane/operation-receipt-v1/valid/indeterminate-resolution.json":"sha256:8c593e9b35da8c7783b3953788d5d020218a4094c56dcc6059efded79cab6ac6","contracts/fixtures/control-plane/operation-status-v1/invalid/duplicate-terminal-diagnostic.json":"sha256:21fd8947eafdf9ed224593924effd4f476bdfd7e7d93d96b52f7e294f307e26a","contracts/fixtures/control-plane/operation-status-v1/invalid/missing-terminal-diagnostic.json":"sha256:8c7aec3a72835c37f3d5bc9f81a33342b1ba14206d9191d6a4ad4b2778741f89","contracts/fixtures/control-plane/operation-status-v1/invalid/unknown-extra.json":"sha256:5a1911e51d4a2689cbf84f54b226b6c4b880fd5901d02f7e08b5c6dbcd5b867e","contracts/fixtures/control-plane/operation-status-v1/invalid/unknown-state.json":"sha256:afe8261ecb1a4dc5b24604f8ed196463f66d78d9aa41d242b546482f45d7c457","contracts/fixtures/control-plane/operation-status-v1/valid/indeterminate-resolution.json":"sha256:bfece07ba9a406cf50253cce9dd9f863a89e714cae2cf8dcc4078e34b4bb369a","contracts/fixtures/control-plane/operation-status-v1/valid/indeterminate.json":"sha256:8cb6fc9c28b9f67a3e6c9dbe440e9cdb10c6c8ca29940cba6d1e45c50f1a91b7","contracts/fixtures/control-plane/operation-status-v1/valid/succeeded.json":"sha256:4d0506684c18e379a09a3b91fb7881fc9daba8fcda1ee6d1104e7d6f0e0e897d","contracts/fixtures/control-plane/participant-behavior-history-event-stream-v1/invalid/unknown-extra.json":"sha256:5d797052772d66d60363a9aaf2d4009c161907dae5d6a129b4dd250725ded1b3","contracts/fixtures/control-plane/participant-behavior-history-event-stream-v1/valid/terminal-observation.json":"sha256:d1a2e6de54aa13b77dc5ccb6473b9130f9f18302fb12e69c06123bd753f07dd3","contracts/fixtures/control-plane/participant-context-view-v1/invalid/audience-neutral-scope.json":"sha256:3965be8ac01bccce9f0056116724f06dce2d52d0cc32faa810da21fd6def96dd","contracts/fixtures/control-plane/participant-context-view-v1/invalid/empty-derived-from-refs.json":"sha256:98839e2f746413dba82c639d751e8ef17da24447356dca2f1033539d223ce835","contracts/fixtures/control-plane/participant-context-view-v1/invalid/future-state-source-layer.json":"sha256:b52ee4fad934a9c013d43087c1efa3ee5057c33ee0e11c2fea2b7e37653a9dc7","contracts/fixtures/control-plane/participant-context-view-v1/invalid/global-runtime-state-source.json":"sha256:c9ba5f3172e56c20c36a2d34765367ad9529e0f909c1b3d33f4fab603d0641a6","contracts/fixtures/control-plane/participant-context-view-v1/invalid/missing-bounded-staleness-basis.json":"sha256:4f6cc548797bf3bc42138020802a061d97c44feb66c96c68e8c97bd847a24d0b","contracts/fixtures/control-plane/participant-context-view-v1/invalid/missing-weakened-comparability-disclosure.json":"sha256:0be1c763813e812cfa0e49dde2d0aab309e45f84db1e057d3fbb49b9e0f14034","contracts/fixtures/control-plane/participant-context-view-v1/invalid/sem216-archival-evidence-participant-visible.json":"sha256:411fe0405aa73498708c04057a737f1c0b86e7567f71d9570f186b32efc99ede","contracts/fixtures/control-plane/participant-context-view-v1/invalid/sem216-backend-observability-as-observation.json":"sha256:822700451646863548b74100d4d4d56d170084b636a1322611fe5d3a78fb27d1","contracts/fixtures/control-plane/participant-context-view-v1/invalid/sem216-hidden-adjudication-in-evaluation-output.json":"sha256:bc959276a66575bc56c9e5735e5db85c011296e5facfaf96ba6aec7c24cab44d","contracts/fixtures/control-plane/participant-context-view-v1/valid/control-context-asset.json":"sha256:37e74cc8684ae2daf224453ab4d5ea5e2a375c9d6645295836f7819738b2e3a7","contracts/fixtures/control-plane/participant-context-view-v1/valid/network-posture-context.json":"sha256:2f2ed584c4f73f7ee72159303231aec4f100473151d1b0b2e707451ebf8c8669","contracts/fixtures/control-plane/participant-context-view-v1/valid/sem216-mediated-evidence-view.json":"sha256:bd317ec20eaf792caaefd3e5e35fd63c01be432a30ea5305120391c9d9d784b3","contracts/fixtures/control-plane/participant-decision-surface-v1/invalid/presentation-as-outcome.json":"sha256:f25fbc3b810ca76534e14dbb4408c105781f8677aa5e43eacc1f4ee827105e9b","contracts/fixtures/control-plane/participant-decision-surface-v1/invalid/undisclosed-form-loss.json":"sha256:70b375a65dd96fa15d399939bae4f3855e2a255ba56e6f01bfbb7587a2068009","contracts/fixtures/control-plane/participant-decision-surface-v1/valid/human-candidate.json":"sha256:285dd74412ccf4e114a58e40d3b136e435c3b47b7bc141470be131da75f9ab7c","contracts/fixtures/control-plane/participant-decision-surface-v1/valid/llm-open.json":"sha256:7c1adcba448a231a53f1bff75aa55ab3031d845cff375b3224c48e1e154611dd","contracts/fixtures/control-plane/participant-decision-surface-v1/valid/rl-candidate.json":"sha256:ec798cb88c38d15765e993a025d4c631712980b51ea9bcb3d2a77b549f52dc1e","contracts/fixtures/control-plane/participant-decision-surface-v1/valid/script-form.json":"sha256:5966453ec58654e65d3538eb51a38bbe8d04eafcfa0be97ec7b72227eac86ca2","contracts/fixtures/control-plane/participant-decision-surface-v2/invalid/delivered-without-delivery.json":"sha256:ec6dcd1bff1b2d283edb609eff84acf5fe53ece6466674f7ced5429a2ce27121","contracts/fixtures/control-plane/participant-decision-surface-v2/invalid/episode-local-without-reset-authority.json":"sha256:535089864044d5bb0967be04099f129ef581978660edeba2e001b8eba25a203b","contracts/fixtures/control-plane/participant-decision-surface-v2/invalid/legacy-observation-order.json":"sha256:43ff62fce93b1e19daf686c8a8641413195e00cd735a2d65357034724f83c245","contracts/fixtures/control-plane/participant-decision-surface-v2/valid/delivered-initial.json":"sha256:52121ce02361cd68e1569b33896a0e07a471dc5708967deefddbe05e6feaaef8","contracts/fixtures/control-plane/participant-decision-surface-v2/valid/projected-initial.json":"sha256:5eed850f92317d50f55aeb45fa9f5ae77f0fb8976789ab89be3bf20e3b9c9a77","contracts/fixtures/control-plane/participant-episode-history-event-stream-v1/invalid/unknown-extra.json":"sha256:8ee82c7ff9e9e39d397e823feca640d78bda6a2ff4f6571cc1b0fd6d5d27dc38","contracts/fixtures/control-plane/participant-episode-history-event-stream-v1/valid/initialized-then-completed.json":"sha256:4bdfcdbc923f16d98ff6d56016214becc580e0aed9b1bbf650d12518e8ef5ade","contracts/fixtures/control-plane/participant-episode-state-envelope-v1/invalid/unknown-extra.json":"sha256:fbc97be9d3f4023f47d9a566d39c8f489830cb5405090e3e93ba2c43d1ccbaf9","contracts/fixtures/control-plane/participant-episode-state-envelope-v1/valid/initialized.json":"sha256:b357a7ea4cb7427253574e001856485efde874267c02a81c93b923672bfb8180","contracts/fixtures/control-plane/participant-history-view-v1/invalid/behavior-event-restates-scope.json":"sha256:5fe5a65074abfa2fc120416eb95fa06a3c3cdfaee524a06bacf4fb46dac52a98","contracts/fixtures/control-plane/participant-history-view-v1/invalid/episode-event-restates-scope.json":"sha256:b8915524b57d341772246d4ac7d2dbd91243842eae28a1dbc233dbb378bf6d9e","contracts/fixtures/control-plane/participant-history-view-v1/invalid/truncated-without-basis.json":"sha256:ff24b7dc8e8916fd2447006b826c47f5ca273534224f32f79f39b989f1d2133a","contracts/fixtures/control-plane/participant-history-view-v1/valid/truncated-history.json":"sha256:b82c4bf465b51c81ba1fcda5b5958e6c57c4ebca35742b70630dcceca044e1a3","contracts/fixtures/control-plane/participant-inject-application-v1/invalid/coordinate-mismatch.json":"sha256:4abaee7c3070b129b0b07b3c03e2e8bc856f1f436cda285afc778c23b800baf3","contracts/fixtures/control-plane/participant-inject-application-v1/invalid/unknown-field.json":"sha256:593f7139cf4377881d96ee175c701c30acbc9957b3731286165527761a0b7207","contracts/fixtures/control-plane/participant-inject-application-v1/valid/basic.json":"sha256:c852dbb507e5e7417ea6fcc4b697dcd634fd4354da01acd4632d35a6edac200a","contracts/fixtures/control-plane/participant-inject-delivery-receipt-v1/context-invalid/coordinate-mismatch.json":"sha256:7277c49cd5c414f97498fab9b36bb35b17f3ffec9635cb1b651ed52728d0b478","contracts/fixtures/control-plane/participant-inject-delivery-receipt-v1/invalid/unknown-field.json":"sha256:8deb56150cccda9d4c8d6e454aa51730f73074aafa82df1563630e9b277cf182","contracts/fixtures/control-plane/participant-inject-delivery-receipt-v1/valid/basic.json":"sha256:13c370e7d8a041507fcbaff5628b57102017ad663cbf7ab434132b1bd2e34d19","contracts/fixtures/control-plane/participant-inject-delivery-v1/context-invalid/coordinate-mismatch.json":"sha256:892e739ab1136442a7d2c2c421866ea9a8a480f6fbf219e8158a37df44b5984b","contracts/fixtures/control-plane/participant-inject-delivery-v1/invalid/unknown-field.json":"sha256:e9c103118334615e75ccc136547c7d62c57a84c4c800b7b162eeef9170abf0ce","contracts/fixtures/control-plane/participant-inject-delivery-v1/valid/basic.json":"sha256:a21cb5ea714c2c33e92fa14ec37bcfecc15b8f89f1769382292cee965181dd8d","contracts/fixtures/control-plane/participant-status-view-v1/invalid/episode-state-restates-scope.json":"sha256:2c6325fe6e43105e7cf190a38ab9619e1eb1774151a8d6f572d3b4a31380ce36","contracts/fixtures/control-plane/participant-status-view-v1/invalid/missing-source-snapshot-ref.json":"sha256:b1532d37a7c14c7662b7e8ee3e11f797ba968881eee18f71b602877b551f4cd6","contracts/fixtures/control-plane/participant-status-view-v1/valid/running-episode.json":"sha256:36b1e6b77c191b585a6a8c88dd6ff90d1eebd9efcc93dcf99725402aa2df5078","contracts/fixtures/control-plane/proposition-truth-result-v1/invalid/decided-without-evidence.json":"sha256:db45733fb15984d8d8e348b5e542c71fe0aaeedeab6d302d86f6e702dda0d8ef","contracts/fixtures/control-plane/proposition-truth-result-v1/valid/ambiguous-conflicting.json":"sha256:1bd8fd0206b16551a757a5dac3eb9b780f5d3edc8dd992ea2bfd7dfae2b4f4c6","contracts/fixtures/control-plane/proposition-truth-result-v1/valid/equivalent-range-b.json":"sha256:2b1ae5cd49e28a8e1301a5d39e8302eb262f387e70c754904a7bc42f8a8bad0e","contracts/fixtures/control-plane/proposition-truth-result-v1/valid/negative-observed.json":"sha256:d33d3d18bc23934a3759f0e89c637b93764b65b703606196e172c7dedd206a34","contracts/fixtures/control-plane/proposition-truth-result-v1/valid/positive-observed.json":"sha256:986beeeccaf0b1f680cd426978baeaed21391143e7d902138351318e3792e589","contracts/fixtures/control-plane/proposition-truth-result-v1/valid/unsupported.json":"sha256:a1f16d17986a625d72fbd40856739079f4a69cd27d844d5f64218aef002227e5","contracts/fixtures/control-plane/scheduler-isolation-proof-v1/invalid/incomplete-parallel-proof.json":"sha256:34bc2ac9d23e409dcaa2fc819d6c57ee77f0dc81e9867f6906231cc7f1e07412","contracts/fixtures/control-plane/scheduler-isolation-proof-v1/invalid/missing-secret-scope.json":"sha256:595d2ee7aebdfa82638d306f240e46edabf843cd92e1a93da68d704b9cb3f3c3","contracts/fixtures/control-plane/scheduler-isolation-proof-v1/valid/bounded-parallel.json":"sha256:baf1c4441cf4ee2d53c3b60cd08ae4f1d163c42b283669e38abe198f1d93ca62","contracts/fixtures/control-plane/scheduler-isolation-proof-v1/valid/serial.json":"sha256:43042198cc983f50bea2761861df023d20c64c75f96a0c940e02491a5c348d7c","contracts/fixtures/control-plane/trial-cleanup-receipt-v1/invalid/unsupported-clean-claim.json":"sha256:5f8ee87e45c8b9d56e04382ba717de38649a150a138b3ddbd8848225dcd94ac7","contracts/fixtures/control-plane/trial-cleanup-receipt-v1/invalid/unverified-clean-claim.json":"sha256:c18f0f90e3e05ea02d23124e2835097511c2f76126b6e87aa36f408f8f03497a","contracts/fixtures/control-plane/trial-cleanup-receipt-v1/valid/abort-cleanup-failed.json":"sha256:9c61f221cd8d1ac49541a7dc83a19647f104648b763f8f2958a439a70e708f97","contracts/fixtures/control-plane/trial-cleanup-receipt-v1/valid/abort.json":"sha256:728beddc7d590f1651f8315fedc916f77621a8cc76889ced14f8ea6a6c0bb34a","contracts/fixtures/control-plane/trial-cleanup-receipt-v1/valid/cancellation-cleanup-unverified.json":"sha256:df4abfdfd1a6c79ea722ff3cf08b6456d32151f85947e1974358938f0f5c4c8e","contracts/fixtures/control-plane/trial-cleanup-receipt-v1/valid/cancellation.json":"sha256:b49ad2af2a6491b8208781255d2543202789f1c49f8382c8696019659b103bc4","contracts/fixtures/control-plane/trial-cleanup-receipt-v1/valid/partial-cleanup.json":"sha256:f063d082d2efcbf82b048534d8127e3d82012f7d0a0fd9974e2b68a9d893a581","contracts/fixtures/control-plane/trial-cleanup-receipt-v1/valid/primary-failure-cleanup-succeeded.json":"sha256:5ab0648ded9e5af655b81ab285d46a067fc3b9b904c2c8bf89e001002775d7cd","contracts/fixtures/control-plane/trial-cleanup-receipt-v1/valid/required-cleanup-failed.json":"sha256:9ee2a35c41b7f32f0892341cac5a819ce57275e648163102d6ce773926793baf","contracts/fixtures/control-plane/trial-cleanup-receipt-v1/valid/success-cleanup-failed.json":"sha256:1d3e777982e0784442109b0d0f00e142dabf53850ff37c9b68073e3d65e0d1b9","contracts/fixtures/control-plane/trial-cleanup-receipt-v1/valid/success.json":"sha256:da63a5819ca3869d3534694e0a5523d39a14135d90d0175330e65fd663b87019","contracts/fixtures/control-plane/trial-cleanup-receipt-v1/valid/timeout-cleanup-unsupported.json":"sha256:d3ee988567621adbe1176843952f3f3cf0e0751cda1a9bc8701c272174cd162c","contracts/fixtures/control-plane/trial-cleanup-receipt-v1/valid/timeout.json":"sha256:d0c1b2215835bf40ee6c970d236606de2a6d68effbaa41f198c40bc9b66c9e7e","contracts/fixtures/control-plane/workflow-cancellation-request-v1/invalid/unknown-field.json":"sha256:dad4881ac5c7f32a9254f4bf0550f5169b4c1b784a61a0ccbe571fadff48d420","contracts/fixtures/control-plane/workflow-cancellation-request-v1/valid/operator-cancel.json":"sha256:10e25c37a56b2092c7ff78734b53a6100bfa9d2f7cc001013c892276c32555f6","contracts/fixtures/control-plane/workflow-cancellation-request-v1/valid/run-scoped.json":"sha256:2fe5507bd58ab30eaf6cf907b4d3d784f055fed493f43a0b8aa1aed95604d55a","contracts/fixtures/control-plane/workflow-history-event-stream-v1/invalid/missing-timestamp.json":"sha256:3f789468fe5e90c05e64a34c60baacb22c2ab585c7ec2d5bace0671cfa311ffb","contracts/fixtures/control-plane/workflow-history-event-stream-v1/valid/started.json":"sha256:6249f87ce06d5233fe21341dec43bfbbd4353523ffaeda8c1c9ceed303faba4e","contracts/fixtures/control-plane/workflow-result-envelope-v1/invalid/pending-with-outcome.json":"sha256:c660593321bc915a7d861f6783fb4a502a0ab4c0bf992b4ec81274aa42ad4e13","contracts/fixtures/control-plane/workflow-result-envelope-v1/valid/running.json":"sha256:d51ebb6de68798180ef74b1d93bf51acc9784bf3f0fc8f0a4820de2c51e7be27","contracts/fixtures/experiment-core/adaptive-difficulty/boundary.json":"sha256:7191c19618aa78341198b1fc1841fb4c9f85d87191e7d93d0fc19299c36900b1","contracts/fixtures/experiment-core/adaptive-difficulty/policy-violation.json":"sha256:43267209b92ea5dab3ffee4ceab9222dd610c900916d16c39529ab3ba4c98a14","contracts/fixtures/experiment-core/adaptive-difficulty/policy.json":"sha256:68aa29ffe3ed9091b63f6435b391c85c4b4e22cb32f11b88251b83051621e9a2","contracts/fixtures/experiment-core/adaptive-difficulty/positive.json":"sha256:283e55fc86ed610809dc1999961853e22c24ad6f8854817b6fbb0ce5bee9a6ee","contracts/fixtures/experiment-core/adaptive-difficulty/unsupported.json":"sha256:d5da968d50176b90f95f584b3d78d183b4415fd5bdb4bff0477608f8f6cd456d","contracts/fixtures/experiment-core/experiment-apparatus-context-v1/invalid/empty-components.json":"sha256:4141656c33483dee6d40236ec93fb5e508fe16b10b0fe99c2b8902c52fdc0151","contracts/fixtures/experiment-core/experiment-apparatus-context-v1/invalid/selected-manifest-is-run.json":"sha256:5644b2d667c3314d0ee88376b74798395843e9932e6e7f280dd6cbf97379c032","contracts/fixtures/experiment-core/experiment-apparatus-context-v1/valid/reference.json":"sha256:e6fa559c5e961f0aab448d0f70dead24aa74fa8ba5f20e1b72f88e11473c9299","contracts/fixtures/experiment-core/experiment-authoring-input-v1/context-invalid/factorial-unknown-level.json":"sha256:958c71cfc8e9da9631b6b69a9cb3565990d35a0773ff84a2748ccb8aa1c77720","contracts/fixtures/experiment-core/experiment-authoring-input-v1/context-invalid/typed-factorial-duplicate-point.json":"sha256:c3465ce5833da671a6ff206ad956538343375ad514f5a733710eb11d27c8f4f3","contracts/fixtures/experiment-core/experiment-authoring-input-v1/context-invalid/typed-factorial-source-level.json":"sha256:222896ae54f75ae68e2ac2e669f17342180e68b64d60e2be55abc9ca153bd9f2","contracts/fixtures/experiment-core/experiment-authoring-input-v1/context-invalid/undeclared-condition-factor.json":"sha256:44760e94397b95056294d07c2db9e59c8dfbfaabdb3377f5f3e02af682086013","contracts/fixtures/experiment-core/experiment-authoring-input-v1/context-invalid/undeclared-condition-level.json":"sha256:cf2e32afbfed2262a81b91fbeb64b57c003390830846138a0f71d463f9833cb9","contracts/fixtures/experiment-core/experiment-authoring-input-v1/invalid/coverage-selection-unsupported.json":"sha256:cf76e48c4e2d4190b55c92789462f43ce3952817f6973f95d7f29cd5b9d81691","contracts/fixtures/experiment-core/experiment-authoring-input-v1/invalid/enumerate-selection-unbounded.json":"sha256:9052cc6adae0d30b94a6a2d2a50d3e4b3fdfc816953e21c5f9fc4d642925baa0","contracts/fixtures/experiment-core/experiment-authoring-input-v1/invalid/fixed-selection-missing-outcome.json":"sha256:9157b4113d3cd8beb7352e57cc13e049da7a1edb73cb96ec9fab62f09571b4a2","contracts/fixtures/experiment-core/experiment-authoring-input-v1/invalid/product-selection-single-dimension.json":"sha256:b2fe9097d0aedb23ae5812902413cbad752c7e8225ccc6d7a522ec37dbba4d15","contracts/fixtures/experiment-core/experiment-authoring-input-v1/invalid/replacement-coerced-limit.json":"sha256:2d6f743f11815a03eba3e1364a357b23c10bc8787fc853d4176eda904b1f2776","contracts/fixtures/experiment-core/experiment-authoring-input-v1/invalid/replacement-duplicate-triggers.json":"sha256:73c1bcd6adfc5220cda43bfce86751b6daf09b5f6633a2cbf6f24efb3d21df01","contracts/fixtures/experiment-core/experiment-authoring-input-v1/invalid/replacement-empty-triggers.json":"sha256:85bf3ae57cf8dfacc53f10e8af726858f6bc86d06a324a0ab08c856e9e56487f","contracts/fixtures/experiment-core/experiment-authoring-input-v1/invalid/run-plan-both-allocation-and-count.json":"sha256:62568c35c69fdd6d3b9a6c4f59727ac5bab4003f9f2cc978ee6ab733c93b5559","contracts/fixtures/experiment-core/experiment-authoring-input-v1/invalid/run-plan-neither-allocation-nor-count.json":"sha256:c8f4c5769115a2e26aacad5b3d306f4d3a971b03d690e5b70d4022513745d8f8","contracts/fixtures/experiment-core/experiment-authoring-input-v1/invalid/sample-selection-weighted.json":"sha256:191a3f45e8d7ab8280f3d958f52ccd571d8455dc8dd5a1caa8a71f75d0139b58","contracts/fixtures/experiment-core/experiment-authoring-input-v1/invalid/sample-selection-without-replacement.json":"sha256:606de589ab0a4c9c225c6ecd05c78378ea2c0a092f91e0186355cc7ef9eb26bb","contracts/fixtures/experiment-core/experiment-authoring-input-v1/invalid/stratified-selection-empty-outcomes.json":"sha256:15d96ccc2fd36ea70ead1afb8510032955c047a6efc5befec2d50bf807c557d8","contracts/fixtures/experiment-core/experiment-authoring-input-v1/invalid/typed-factorial-scalarized-member.json":"sha256:99b36f862841b775ff3ce1ed58da75c496f2d38b971c2214ff7beb92e18a8fad","contracts/fixtures/experiment-core/experiment-authoring-input-v1/valid/bounded-replacement.json":"sha256:af60deea90cd4326b33bdf76b5ac57ea86b0e46dee75759204e846c8acd83ab4","contracts/fixtures/experiment-core/experiment-authoring-input-v1/valid/enumerate-selection.json":"sha256:78a31eb16c49ef037a1f32c774ee7f50a9059cd9f7f086f2ea5d5e6f4922c0f0","contracts/fixtures/experiment-core/experiment-authoring-input-v1/valid/factorial.json":"sha256:2fe070446e4c267e58327d8f4ce61cb698a60b9881dc9e1c4845f0b366aa7f04","contracts/fixtures/experiment-core/experiment-authoring-input-v1/valid/fixed-selection.json":"sha256:e9ee14a26b118ed1a3ff222babe677bbf34968ce442d381f70bb9d166188357c","contracts/fixtures/experiment-core/experiment-authoring-input-v1/valid/no-replacement.json":"sha256:155a429ad8f3ee239c9e2434aa82ac0642504869893ec85e9bc531a61034bba2","contracts/fixtures/experiment-core/experiment-authoring-input-v1/valid/product-selection.json":"sha256:9d3407be136dca3805bfafbb6828c1f0ca1d0809353f5bd1b353c5a8c640181c","contracts/fixtures/experiment-core/experiment-authoring-input-v1/valid/reference.json":"sha256:337b742c028e82e4b2d881ada32a8e8003e562da80947b88e1c94558ed6d9956","contracts/fixtures/experiment-core/experiment-authoring-input-v1/valid/sample-selection.json":"sha256:b62f0252051e7399c8a977876b96ca7dae00629532e16e4e38d338b0ea6f7433","contracts/fixtures/experiment-core/experiment-authoring-input-v1/valid/stratified-selection.json":"sha256:725c821c5bba89135e705266d1181a70fabf0b0c8b18d36a9b4846cee0bb484b","contracts/fixtures/experiment-core/experiment-authoring-input-v1/valid/typed-factorial-selection-only.json":"sha256:29e11677f7536c22d69add61a4b52096426457760597279a2e63b7c84ca74b4f","contracts/fixtures/experiment-core/experiment-authoring-input-v1/valid/typed-factorial.json":"sha256:cf79196fb76c31460bf1fba8763ddce16b60c4355497619125a73f75c7641a9b","contracts/fixtures/experiment-core/experiment-binding-descriptors-v1/invalid/duplicate-canonical-target.json":"sha256:a370ad162315615a1281789d81b39a84a9e3020f10688d8ffbed123ff73f9a0c","contracts/fixtures/experiment-core/experiment-binding-descriptors-v1/valid/reference.json":"sha256:358304e9b58e40211dfd8c62764924fad67013933251c413697018b6884a047e","contracts/fixtures/experiment-core/experiment-capture-spec-v1/invalid/missing-capture-requirements.json":"sha256:b378c89f4e91f8a24027bb75620588e25756ded8b4d612b64e16d0e38abb530d","contracts/fixtures/experiment-core/experiment-capture-spec-v1/invalid/under-specified-capture-window.json":"sha256:d9c0cdd68abdbbe720b1c8ea27b8831d7c7f2bf630dfd8a76d223d6d851be5af","contracts/fixtures/experiment-core/experiment-capture-spec-v1/valid/reference.json":"sha256:b161b35e10eb8988214d89396023b364c3a2f256d626f84fa31a714a5a93cc75","contracts/fixtures/experiment-core/experiment-derived-measure-v1/invalid/invalid-generated-at.json":"sha256:3e2004022b15301679e69dbb568e4a63cc649282e29178b5efdb7a001c8b98fa","contracts/fixtures/experiment-core/experiment-derived-measure-v1/invalid/missing-source-evidence.json":"sha256:30bb17108ac62cc49086ffce8bae5cb431c01ee928a6ddf6f149623cc5d2a6dd","contracts/fixtures/experiment-core/experiment-derived-measure-v1/invalid/non-reported-with-value.json":"sha256:6ea00a1f0ddd25f080f95ba7efabf8bc575527f465002c7dd45c557a95c778d5","contracts/fixtures/experiment-core/experiment-derived-measure-v1/invalid/reported-without-value.json":"sha256:ed69cac3b6f2d3ec5b7666ee4614a02b3cbb9b31586f630444062b745f390cc6","contracts/fixtures/experiment-core/experiment-derived-measure-v1/valid/reference.json":"sha256:24e610c8b1ba84e0521d416fd603047c31253d831b9312fca2f15c750846cef5","contracts/fixtures/experiment-core/experiment-derived-measure-v1/valid/vulnerability-severity-summary.json":"sha256:14aa432aee2f86d4faeafcf7890c725abc88b20d3824b302403883eae7e1a6bb","contracts/fixtures/experiment-core/experiment-evidence-record-v1/invalid/content-uri-without-checksum.json":"sha256:e9f8c5082eaebe78ae2fdd0def64c0a559841dbbbb8ed0da8872f09cee410a88","contracts/fixtures/experiment-core/experiment-evidence-record-v1/invalid/empty-source-refs.json":"sha256:e0d020bfb7af30ba86aa9deeb9a3f90647c0e56c2ae2922761aaaf0d723396f7","contracts/fixtures/experiment-core/experiment-evidence-record-v1/invalid/invalid-captured-at.json":"sha256:77cba4b686b210d0ea7d4ff0e83599fffefb84940d22e25fcb7580aeb23309d9","contracts/fixtures/experiment-core/experiment-evidence-record-v1/invalid/missing-raw-content.json":"sha256:37d51774b0a153063f4d77903ec75976efb6670b92401c3cdce95f346175b188","contracts/fixtures/experiment-core/experiment-evidence-record-v1/invalid/sem216-analysis-output-as-evidence.json":"sha256:6c86da9172fa9a83337127e546db729b6c42ffa99cccc8bd4c53f1e58a11ecc6","contracts/fixtures/experiment-core/experiment-evidence-record-v1/invalid/sem216-withheld-without-loss-disclosure.json":"sha256:d3e46c3ba477f0e3b356817439c26c9e4fef4baf91d207a80f7144e4d544e29d","contracts/fixtures/experiment-core/experiment-evidence-record-v1/invalid/sem224-capture-record-without-requirement-ref.json":"sha256:3ff89aa428f1b0d9315e81428f31dc5524dc8c93f913aace7a1373a48a67c0fb","contracts/fixtures/experiment-core/experiment-evidence-record-v1/invalid/withheld-description-value.json":"sha256:89a98491b63d0ca5d842288baeb8e9a2ddec66833d4b054bf408871838ecd121","contracts/fixtures/experiment-core/experiment-evidence-record-v1/valid/docker-network-endpoint-observation.json":"sha256:cf2485c923ecedc32219107ad35b612b464dcef46caa6a58955cef3c5a0b85a6","contracts/fixtures/experiment-core/experiment-evidence-record-v1/valid/partial-description.json":"sha256:553d6205c46719ce06442e86d127bc82512b765751faf7fc9ab2e4de4ab98b6b","contracts/fixtures/experiment-core/experiment-evidence-record-v1/valid/reference.json":"sha256:d1bbe05227a609f85c9ad9688319d9e1bef06efca22a8543a655d76e85a35cc8","contracts/fixtures/experiment-core/experiment-evidence-record-v1/valid/runtime-health-observation.json":"sha256:9315cb95072e7fbf2f555c2ee9dd6b9468cc4a7b4bb30e4233016735b610f08a","contracts/fixtures/experiment-core/experiment-evidence-record-v1/valid/scanner-vulnerability-observation.json":"sha256:203e205f065f842d15e1982ec4192f857a46a5e9a347bb27caeab8f9e6e6fdcf","contracts/fixtures/experiment-core/experiment-run-v1/context-invalid/typed-treatment-duplicate-point.json":"sha256:8ab30e8e5a4cb52f603ed9db04fec746499f863620d28efe3331ec632959a7dc","contracts/fixtures/experiment-core/experiment-run-v1/invalid/augmentation-comparability-without-observer-effect.json":"sha256:91cc6ac55fd9dbe1b2a5b82ea6c06717b6fa3b8f26e384200a9c696ab5348ace","contracts/fixtures/experiment-core/experiment-run-v1/invalid/augmentation-environment-without-effect.json":"sha256:16f82fd3908249ddff012dbc8885c9cdc3123e51cd4be01238d5747038570cf9","contracts/fixtures/experiment-core/experiment-run-v1/invalid/augmentation-participant-without-markings.json":"sha256:8c69c8c57297ecef93e8d714b954fd1d42b434dd96f3816c0f76e953068b9096","contracts/fixtures/experiment-core/experiment-run-v1/invalid/augmentation-purpose-without-evidence.json":"sha256:5f14cda646d18847a0a6d5450c92a3a2117ee1cff662d86e13053b48c9a75364","contracts/fixtures/experiment-core/experiment-run-v1/invalid/augmentation-without-affected-refs.json":"sha256:7657f756001a1fe15587738152ce0d1f71c970b39d2260d980cf3b892586d1e2","contracts/fixtures/experiment-core/experiment-run-v1/invalid/augmentation-without-portable-carrier.json":"sha256:abb2d42b416a66cb467692d1634a9c0997a741a3a696ace9d39f45d71b07feca","contracts/fixtures/experiment-core/experiment-run-v1/invalid/invalidated-without-details.json":"sha256:9ad75acb27d7f4296779a5d165571d4efe5340739d1408f546a80d4119ef2331","contracts/fixtures/experiment-core/experiment-run-v1/invalid/realized-form-authority-mismatch.json":"sha256:fb33c183ad0d90ec7f467ce959b858f2dccdc3cd73ac11ff3406a172ddc32622","contracts/fixtures/experiment-core/experiment-run-v1/invalid/realized-form-missing-target.json":"sha256:a96cd50b4b8307240c6a3bb52b42caccf082034cc0ca0a3cf6ff25c9d0cbeaff","contracts/fixtures/experiment-core/experiment-run-v1/invalid/realized-form-processor-authority-mismatch.json":"sha256:1781a4b10728c5c75c9bb96d25f28a075bcd0c391e2972853901c147bd611977","contracts/fixtures/experiment-core/experiment-run-v1/invalid/traceability-empty-capture-specs.json":"sha256:ce9c8b2eb238731a62e3c70d5533034fa28abb341d60b97ebee2c66b5b55458b","contracts/fixtures/experiment-core/experiment-run-v1/invalid/typed-treatment-scalarized-member.json":"sha256:d6a7f61ead0edfb976e2ae42d22b92bf49c12349169c8ce943f565c28a2ee792","contracts/fixtures/experiment-core/experiment-run-v1/valid/augmentation-classifications.json":"sha256:58b79cfc2567e1d77ecba75fb7cc6eab94fe183bb7d78e283c581ed34777c033","contracts/fixtures/experiment-core/experiment-run-v1/valid/reference.json":"sha256:211316cefa82cd6b4bb917294da9476520ba00155d0046ae0904656c33ca8aee","contracts/fixtures/experiment-core/experiment-run-v1/valid/typed-treatment.json":"sha256:c06b72d1ed7f6653a03e64b0ac4af52da3cfbfebdfa2ba5dfa80e2b3d2d7c6e6","contracts/fixtures/experiment-core/experiment-study-v1/context-invalid/typed-treatment-source-level.json":"sha256:94b185d4a3c42f19a4176b2dab17fe42818b69f867a7a0047c008e89abe91bfa","contracts/fixtures/experiment-core/experiment-study-v1/invalid/empty-membership.json":"sha256:7f1430f3d1deec51f1e432dfaf1c5f2f23d5fa2025f62b9824e434a4a245b4c8","contracts/fixtures/experiment-core/experiment-study-v1/invalid/typed-treatment-scalarized-member.json":"sha256:974c731f097cd77911636cddd6c4bb293f2c49081106808fdfd7fc2e33162fe1","contracts/fixtures/experiment-core/experiment-study-v1/valid/reference.json":"sha256:7b4c9ead6395eec1eab0bdc6dbc3553a6f71438d711ef252d598e4f632cd1068","contracts/fixtures/experiment-core/experiment-study-v1/valid/required-bindings.json":"sha256:acf246ac975e21ff01c8e285a8df988f42d3fc9815704eec6c552ce13bfc9903","contracts/fixtures/experiment-core/experiment-study-v1/valid/typed-treatment.json":"sha256:275cddeb6d13fa7717be3bd6f4940b95b75a9f4d3d61ed2948a0592ba70ce5a3","contracts/fixtures/experiment-core/experiment-task-v1/invalid/scenario-ref-is-run.json":"sha256:2fc27115e8b13d41448f9deda9de88325063a505036f3caa8e7738019314772c","contracts/fixtures/experiment-core/experiment-task-v1/valid/reference.json":"sha256:f3edf713ac6af26bad609136851c6dd434bfb87ce919a2d8c4414c1035deeafc","contracts/fixtures/experiment-core/materialization-archive-record-v1/invalid/wrong-phase.json":"sha256:3ba3ac0cab18caf3d83889b2e66eacd78c9d080cf4ed73baee70b76c9d0478d3","contracts/fixtures/experiment-core/materialization-archive-record-v1/valid/reference.json":"sha256:6d33aed2c55e8134cbadb716954ec1d9d34521d09b15112ee5bd51251be44334","contracts/fixtures/exploit-path-analysis/exploit-path-analysis-evidence-v1/invalid/cross-outcome-payload.json":"sha256:103ff4bd92e06230182e6a74f9ff41a22f60f06fa3a7f0741dd246e1cdb01260","contracts/fixtures/exploit-path-analysis/exploit-path-analysis-evidence-v1/valid/valid-path.json":"sha256:1b7f55d04db172da32658187c64a88c13b5f4d565267ce2be7cb86a9d04cb70c","contracts/fixtures/formal-analysis/participant-opacity-analysis-evidence-v1/invalid/universal-bounded-claim.json":"sha256:129503f018ac6212908d35477c8b4b278aaf969897d7d62f8cd4460617fc0470","contracts/fixtures/formal-analysis/participant-opacity-analysis-evidence-v1/valid/bounded-counterexample.json":"sha256:b5aaf9d1294f0b104772572aa5ee213ed4e456ce244e7b628b1ef1ca9f415912","contracts/fixtures/formal-analysis/participant-opacity-analysis-input-v1/invalid/count-mismatch.json":"sha256:1610e51cfb604f17cffe43d08b85cf6eef6b19f5e4e16dabcfc333a2896833b5","contracts/fixtures/formal-analysis/participant-opacity-analysis-input-v1/valid/opaque-pair.json":"sha256:3d6df63e488dc28771154afa9b90529452db8020a9af4b212a8c327481496589","contracts/fixtures/formal-analysis/participant-opacity-model-check-evidence-v1/invalid/incomplete-positive-result.json":"sha256:fb806c4c451d9626ee2f581f223c9791f9f2517441ebbacdb08856f5902cb2cb","contracts/fixtures/formal-analysis/participant-opacity-model-check-evidence-v1/valid/opaque-transition-model.json":"sha256:074a5a57b445426a37209bcc928a0dd1ba72a6b6709f3524aaef0e7b1bb692f7","contracts/fixtures/formal-analysis/participant-opacity-model-check-input-v1/invalid/count-mismatch.json":"sha256:4f578f665de916c100f4a8ec06e788e051c9f283110faa290e1dd05919ba5c33","contracts/fixtures/formal-analysis/participant-opacity-model-check-input-v1/valid/opaque-transition-model.json":"sha256:fc5cc63e8f403cdeb7773647b152bd5919061c283ba50089aff635d632db9b26","contracts/fixtures/participant-implementation-configuration/participant-configuration-result-v1/invalid/digest-mismatch.json":"sha256:0d2debf3060399352b8f1c2d740bb7a5f2afb28fef771c874b77b67b740097bc","contracts/fixtures/participant-implementation-configuration/participant-configuration-result-v1/valid/reference.json":"sha256:88f7bee0370ea8da9f8a77dd3cb14f18c4a2f3af2fec7a509b0607674afb45db","contracts/fixtures/participant-implementation-manifest/participant-implementation-manifest-v1/invalid/empty-compatibility.json":"sha256:9ab91a86caa50ed8c04feddc2f74d7ae2fc982d6577a821cb58f2144144559c0","contracts/fixtures/participant-implementation-manifest/participant-implementation-manifest-v1/invalid/unknown-contract.json":"sha256:a32ac2e39ccb1415932090a43a8609ede99312271844e6a88eecfcbb54d3987f","contracts/fixtures/participant-implementation-manifest/participant-implementation-manifest-v1/valid/participant-control-legacy.json":"sha256:53d49bd0a00d4a6d543ec1a350ab9da6d2f6a2333b51d61932a6c0a3faea989b","contracts/fixtures/participant-implementation-manifest/participant-implementation-manifest-v1/valid/reference.json":"sha256:8d5bfcf9e62b497b85d9e6ccac0c014243475825fac49a488859ac96c34d2543","contracts/fixtures/participant-implementation-provenance/participant-implementation-provenance-v1/invalid/duplicate-participant-address.json":"sha256:2f762d8a94b66ec4bcafc7f1fe403fdbd4c7ee8db459338c1eb4c00a7998cd6c","contracts/fixtures/participant-implementation-provenance/participant-implementation-provenance-v1/invalid/empty-exposure-policy.json":"sha256:2b13ac04fde5807028cce1a2b49fc57ae20b6b785d014054712238549bc04afe","contracts/fixtures/participant-implementation-provenance/participant-implementation-provenance-v1/valid/reference.json":"sha256:1763e1f928e0f6a6c45c3daf10252fd1c15e808b31729cb21f760989653b081d","contracts/fixtures/participant-runtime/participant-control-context-asset-v1/invalid/no-applicability.json":"sha256:5cb309a11e27cd8667db7544b28ab388e35f4ebff4e9b771dbafe1457af73c26","contracts/fixtures/participant-runtime/participant-control-context-asset-v1/invalid/private-content.json":"sha256:9392f6393854abbe8af96bd81da8ed23bbb6b020b8bc28993abee53670585a98","contracts/fixtures/participant-runtime/participant-control-context-asset-v1/invalid/unknown-kind.json":"sha256:5d7676d2c0effdbc60bd1e5ed2085c658920f5cb532ba7a500ac65d4ba0cc9dd","contracts/fixtures/participant-runtime/participant-control-context-asset-v1/valid/directive.json":"sha256:70adbf4354326a44683bc5f1cb576c570f180757d08a3ab690ae83a69b26f37b","contracts/fixtures/participant-runtime/participant-control-context-asset-v1/valid/guidance.json":"sha256:a37ba05d8825388fa896e4b53036a3c98244724e9f1146e1ce39c2cfdf22befd","contracts/fixtures/participant-runtime/participant-control-context-asset-v1/valid/instruction.json":"sha256:a774253a7c7a6668a02c8899f1b21234caaf0b2507c9a8f093ed464f3cbce05d","contracts/fixtures/participant-runtime/participant-control-context-asset-v1/valid/policy.json":"sha256:743e35c169b9187b5da8aafff3ef18d42e3c4234e0011e2b1e15375147cf76b6","contracts/fixtures/participant-runtime/participant-control-context-change-v1/invalid/replacement-without-successor.json":"sha256:8013d984576b1c10d44439530173391b24f0c327d3d14bfa4d200bcb3cd6855d","contracts/fixtures/participant-runtime/participant-control-context-change-v1/invalid/same-version-successor.json":"sha256:b1c6949ee3f0a95d0f07f5c7af26b4d57a7017ff54761660a83c65f63a1822e5","contracts/fixtures/participant-runtime/participant-control-context-change-v1/valid/publish.json":"sha256:f34d8530411bc9848efaedf39efa1d72c6395e5ddf546640c6f86bd6d9eab7c9","contracts/fixtures/participant-runtime/participant-control-context-change-v1/valid/replace.json":"sha256:e669821845541ffda84ea579e2a8db7fd153150f45530d7697d2261fe0c8edee","contracts/fixtures/participant-runtime/participant-control-context-change-v1/valid/withdraw.json":"sha256:bd6bbaccb05528989180fee76e0f302f1d53bc30c437c43df8b4a384525b3b60","contracts/fixtures/participant-runtime/participant-control-context-record-v1/invalid/delivered-without-occurrence.json":"sha256:472af45d1bd7ebe72001d8ef8d93a43299d2fe9fd885a9526b9d5d3f53a7d74b","contracts/fixtures/participant-runtime/participant-control-context-record-v1/invalid/selection-claims-delivery.json":"sha256:7b9199889b81e20a39bbe980ce11c5f9202b83208e8249e6afcbbaf5a1445945","contracts/fixtures/participant-runtime/participant-control-context-record-v1/invalid/withheld-discloses-item.json":"sha256:43d91c1bc1dfcbf48772d19ad82df06db99cbd2eb1232f5d6e6b625f055d29c7","contracts/fixtures/participant-runtime/participant-control-context-record-v1/valid/delivered.json":"sha256:2214b61630fef05508b884dd4a2a46568a71bb29b9c63c1ca16abc01a8251d7d","contracts/fixtures/participant-runtime/participant-control-context-record-v1/valid/disclosed.json":"sha256:4e6559c5ef4b89764fbcfe762287c0d2b7435b2b44337791181ea0b221cddf08","contracts/fixtures/participant-runtime/participant-control-context-record-v1/valid/mid-episode-revision.json":"sha256:ca1d75dfdbda1911d3bf742d8f353baed939cec5241a0f99ed3e3470cec5f3a9","contracts/fixtures/participant-runtime/participant-control-context-record-v1/valid/selected-blue.json":"sha256:bfb70e372cfedc7c12f146478839ba74c0a0e8d5ec149984b4ac5827c19dd203","contracts/fixtures/participant-runtime/participant-control-context-record-v1/valid/selected-red.json":"sha256:1fb4d54540628ceb19e72f2dd68f084ddf97223c6a82e7c693dee01b299d8f7b","contracts/fixtures/participant-runtime/participant-control-context-record-v1/valid/withheld.json":"sha256:3020e52dee2e8c0cbfd1b16393d57a146086e09a2e0481658c73f1a2fbe45500","contracts/fixtures/participant-runtime/participant-control-evaluation-v1/context-invalid/dishonest.json":"sha256:cfa87ccc6fe4bfdc43c947b581054d83caad0a68f56c1b88324628c265a0c7f0","contracts/fixtures/participant-runtime/participant-control-evaluation-v1/context-invalid/stale.json":"sha256:ce9186aa7748864c7d6f2dfee3a655c79eef7672df49fcbd7ecc89f235f0bee9","contracts/fixtures/participant-runtime/participant-control-evaluation-v1/invalid/executable-selector.json":"sha256:d46114bb5e8d4abb058ec1ab9756854e8a59df4c4685038069b2a16c4c720136","contracts/fixtures/participant-runtime/participant-control-evaluation-v1/valid/conflict.json":"sha256:cf450c394ff60722460a85440e8776449a41a9176ba56a5d01764be20e6c239b","contracts/fixtures/participant-runtime/participant-control-evaluation-v1/valid/downgrade.json":"sha256:c59b7ea645abe2718ff8e5c6e42532743aee03f2562ad2c453736f6eec0899f2","contracts/fixtures/participant-runtime/participant-control-evaluation-v1/valid/exhausted-replay.json":"sha256:7336781aadd04c44bb63343bb3344ccfbdb1783e3979954b97c2dcac88db1edc","contracts/fixtures/participant-runtime/participant-control-evaluation-v1/valid/teaching-inject.json":"sha256:63f1ea17245dfca8c98056a03835af9efef795bf480cf3e7f07f21eccbddaec0","contracts/fixtures/participant-runtime/participant-control-evaluation-v2/context-invalid/missing-obligation.json":"sha256:2dd311d6c47df0b834d3f8d3e06ae121778bbae977eeaed1d23eb83ceb7cc172","contracts/fixtures/participant-runtime/participant-control-evaluation-v2/invalid/unknown-field.json":"sha256:42c6616594cba5c212534194940cfb098f3e74f4c5205376c0ed1aba49c2223c","contracts/fixtures/participant-runtime/participant-control-evaluation-v2/valid/dependency-chain.json":"sha256:3eca3533a23e7e8a0e535e74e1d22fbf735966b643e40fbc16f4902fb426f7db","contracts/fixtures/participant-runtime/participant-control-evaluation-v2/valid/later-phase-denial.json":"sha256:0c8e21daa61127281262aa5de0c1c38c513dc3260255c7792526bc8651cff880","contracts/fixtures/participant-runtime/participant-control-evaluation-v2/valid/optional-failure.json":"sha256:5f5d79bad4a371a4a243c38a7257e7b39c63260abb3cd5f9d3c96c950197977d","contracts/fixtures/participant-runtime/participant-control-evaluation-v2/valid/owner-flow.json":"sha256:4557e2b6c4b5ca668c60936f4eb7cfd2f09d07211c6b3f0c68f85f5e0d56c499","contracts/fixtures/participant-runtime/participant-control-occurrence-v1/invalid/payload-smuggling.json":"sha256:fff39913e1ad0555ebfe61095d5630544f3294fd672a22fcb36ca0fd07592d3d","contracts/fixtures/participant-runtime/participant-control-occurrence-v1/valid/proposal.json":"sha256:4e00a604e0eb4b28023f5025631a43d37c063b19a42d2730466b90fd22cb4c54","contracts/fixtures/participant-runtime/participant-control-occurrence-v2/invalid/accepted-without-validity-bounds.json":"sha256:3c29f9f8375d32a1c01c7aee1e695ff6beaed0c5f1ac3d298822274b5febf9f8","contracts/fixtures/participant-runtime/participant-control-occurrence-v2/invalid/rejected-asserting-validity.json":"sha256:3b4399f49305391f8cea82bb1a0ba365de03bda21689c5727cab5ad970a9bfb0","contracts/fixtures/participant-runtime/participant-control-occurrence-v2/valid/accepted-handoff.json":"sha256:3ac8aac684626628959ce7ea4766a997850895f496261409cb878feed15d3a01","contracts/fixtures/participant-runtime/participant-control-occurrence-v2/valid/rejected-stale-state.json":"sha256:95804e6eb0fe71c5b19ca5237d9f0e990d842c6d39a81002ba6edd3c245b285f","contracts/fixtures/participant-runtime/participant-control-selection-v1/invalid/executable-selector.json":"sha256:4d6dc6d17cf360fe27e5b121599244e9bab495fee8bb788eb66dffd39a959968","contracts/fixtures/participant-runtime/participant-control-selection-v1/valid/teaching-inject.json":"sha256:e9177adfa6adc7c5ae8b766eb9abec812c6c716b650e702eccb3f8e583bf498b","contracts/fixtures/participant-runtime/participant-control-selection-v2/context-invalid/owner-missing-promise.json":"sha256:ee8c7901e443db9cd3d529d818bb6717e128b1b39bb3645f749492d0d2e7cdc3","contracts/fixtures/participant-runtime/participant-control-selection-v2/valid/disjoint-sinks.json":"sha256:df7ae1578a66e49f9db700dbc45c8d5528e808e740ddc57000d97f52669d0c52","contracts/fixtures/participant-runtime/participant-control-selection-v2/valid/owner-flow.json":"sha256:6685389d94d17d89122660b7be1e3b6a5e8ada8e984feda4e6f4e392a2d54df7","contracts/fixtures/participant-runtime/participant-control-teaching-profile-v1/invalid/teaching.json":"sha256:7dfe135385288fb7d525ac652f21d3dd8b1fd8681303d9cbe081956bedf6432f","contracts/fixtures/participant-runtime/participant-control-teaching-profile-v1/valid/teaching.json":"sha256:9340e1b714f7125901c97744b18c40315fa85eedcb535c50ca151d31da2f0000","contracts/fixtures/participant-runtime/participant-crossing-occurrence-v1/invalid/policy-bag.json":"sha256:e05bda4f74993304e3ece8594b468868b4a8eaa9f1fb71a9388fc80734593647","contracts/fixtures/participant-runtime/participant-crossing-occurrence-v1/valid/request.json":"sha256:be28814aeead8305164d3e15f993a2a103c5bb1c18b947b07b2ead832be7486e","contracts/fixtures/participant-runtime/participant-execution-binding-v1/invalid/duplicate-target-address.json":"sha256:4914be377efccffb6db744c796233e9dc4a576304d9aaa51aac77b9aaea0f44c","contracts/fixtures/participant-runtime/participant-execution-binding-v1/invalid/unbounded-in-flight.json":"sha256:121c07696a52a12acf324269ba2c7306598f0e5966e624500aeb51beb56e62ee","contracts/fixtures/participant-runtime/participant-execution-binding-v1/valid/reference.json":"sha256:4ef4c0f728ef491f52505c2dca13c6fe136480cbdb1e82bf3c81eacff2a90b13","contracts/fixtures/participant-runtime/participant-execution-control-v1/invalid/drain-without-timeout.json":"sha256:942bfb4cc84783612c419fe0e03af837a26c8c83a725414438b0b16db49281cd","contracts/fixtures/participant-runtime/participant-execution-control-v1/invalid/unknown-action.json":"sha256:afc9307871d61588c9b8ab831b22553e61e0bf8cbb91c8fc041d66b0ba5f4758","contracts/fixtures/participant-runtime/participant-execution-control-v1/valid/drain-with-timeout.json":"sha256:a29c55d1cb78ce56f564aedf6eebf26d0e72fb5c0b9c738be98ea6afa20dac5e","contracts/fixtures/participant-runtime/participant-execution-control-v1/valid/start.json":"sha256:bde191a8618ca94eaa9bd48880496af7dfb09e24596104d8f572e597b7a27535","contracts/fixtures/participant-runtime/participant-execution-service-state-v1/invalid/admitting-while-paused.json":"sha256:f2c13b242405a08531c85c88473702e88c43a19281181e46228b4a085dbe9276","contracts/fixtures/participant-runtime/participant-execution-service-state-v1/invalid/capacity-overcommitted.json":"sha256:2811eec023817997021064af48db1e1d8b7ec0a39707bde4dc0cd69aee1bb520","contracts/fixtures/participant-runtime/participant-execution-service-state-v1/invalid/observed-generation-ahead-of-generation.json":"sha256:eda305ad05e3f6e7066ed285e494505891c4c1acf3f135b86cf1c6d8a45e684d","contracts/fixtures/participant-runtime/participant-execution-service-state-v1/valid/quiescent-after-drain.json":"sha256:13ab7d0c8b667ad5932b49872dd67d94332fdcca1db83a7a946a7d00077c7fcb","contracts/fixtures/participant-runtime/participant-execution-service-state-v1/valid/running-ready.json":"sha256:c16d9250a470c1f911f4ac69f7931db288de1169d51adaabd3631555ab2e02a2","contracts/fixtures/participant-runtime/participant-flow-control-relation-v1/invalid/open-payload-bag.json":"sha256:2aa14a83d578ff7297f328809da63487846c0fab79297088da705740e963eb3d","contracts/fixtures/participant-runtime/participant-flow-control-relation-v1/valid/conservative-release-chain.json":"sha256:20f2d8048d2a411245d77b50ee000f23e6f5813c0403a8d56e8179ed3249d293","contracts/fixtures/participant-runtime/participant-information-state-record-v1/invalid/strong-without-profile.json":"sha256:c642e0d154689bf10087b101cb7c037b5e86a91e0c45db41d358cab800ead0be","contracts/fixtures/participant-runtime/participant-information-state-record-v1/valid/history-consistent-cut.json":"sha256:112ae20feebcfdcebf86a50dd3533db92fb1d322e9b263a9e2e164032ccbe5e3","contracts/fixtures/participant-runtime/participant-joint-action-record-v1/invalid/implicit-last-writer-wins.json":"sha256:d1714d24e88902b2687ca7f3c1df2f0dd914f54317061d8e6c57fe878e8ffce9","contracts/fixtures/participant-runtime/participant-joint-action-record-v1/valid/serialized-red-blue-shared-state.json":"sha256:60e0fb4d7b816c8aa6e6d08f42dc1964451ac96fa5537248c550e79dd5a8b7c2","contracts/fixtures/participant-runtime/participant-lifecycle-event-v1/invalid/unknown-phase.json":"sha256:57184ec6e0922afab539baa5c7f64802504ae4a03cb6a2300c611e8460374a96","contracts/fixtures/participant-runtime/participant-lifecycle-event-v1/valid/opaque-llm-execution-attempt.json":"sha256:a81cb192bfaedb49375cf73a0c97db79fd56c195dfe8e514a2d5f1dbcb644f89","contracts/fixtures/participant-runtime/participant-lifecycle-event-v1/valid/opaque-llm-selection.json":"sha256:10cf84a8ac995fe7201876bdd8f6d5f2d07174f2fc413892b4e473915342596f","contracts/fixtures/participant-runtime/participant-observation-envelope-v1/invalid/missing-visibility-projection.json":"sha256:87c88f6265c9d9e1f21d0ac738f92782910715372aaa5eabab5d7990b42bcc58","contracts/fixtures/participant-runtime/participant-observation-envelope-v1/valid/rl-observation-only.json":"sha256:7676972d31a5aaf73c4ae11f9a9807244ba65be27defa9baa708b1212d5d7659","contracts/fixtures/participant-runtime/participant-outcome-report-v1/invalid/empty-outcome-sources.json":"sha256:71ca3b835264a95cb4883ea95b17a3479187c265b38ae603a0964dd178ec25c2","contracts/fixtures/participant-runtime/participant-outcome-report-v1/invalid/empty-state-relationships.json":"sha256:e5aea45777d3d41b594db405c5599224307f6807021a9b55daa6c68396dcae97","contracts/fixtures/participant-runtime/participant-outcome-report-v1/invalid/inline-score-field.json":"sha256:efd83de01600388e844a072ee3e3d1fa6f545a173955397d96bf74decb47de37","contracts/fixtures/participant-runtime/participant-outcome-report-v1/valid/exfiltration-outcome.json":"sha256:07330151889ab20da20e9501bbf047e017deb9c08d9dec7410b4fbbe9780c14e","contracts/fixtures/participant-runtime/participant-outcome-report-v2/invalid/missing-participant.json":"sha256:baeb2ebe83c277d8da810558f42a96502e18ec611b4fd8ecc923c254c065270d","contracts/fixtures/participant-runtime/participant-outcome-report-v2/invalid/reward-field.json":"sha256:18e08d2b2a42a901decc20410336cc860fa23fe8f9c5010d8a3fa9e02b1fd0d2","contracts/fixtures/participant-runtime/participant-outcome-report-v2/invalid/unsupported-version.json":"sha256:f5d6d26f8fbd5a4d9c92617d266078371776d2f2d3cb2bcc88b7fc0f3cecd482","contracts/fixtures/participant-runtime/participant-outcome-report-v2/valid/attained-task.json":"sha256:11c486994432132174ae337e8a1b4e7ce98b0df8721bf3b725239533ced6539c","contracts/fixtures/participant-runtime/participant-outcome-report-v2/valid/not-attained.json":"sha256:02a42a3cedd4a2210c0a4d35a9e27d0bb9e332a4b488a1bf41f360f31466aedb","contracts/fixtures/participant-runtime/participant-outcome-report-v2/valid/unknown-after-success.json":"sha256:f6493da8ac0fc8a98aec8f8267ca55a62272eacd8d06949f349c9dd5cb09279b","contracts/fixtures/participant-runtime/participant-resource-budget-event-v1/valid/token-commit-event.json":"sha256:75d2c8b09ef8866b35bfd5de725cca519b3c090864064eef84b1be85e4b9e1df","contracts/fixtures/participant-runtime/participant-resource-budget-policy-v1/valid/complete-resource-vector.json":"sha256:9ab5f7b72d5e9a3353b85b550a63ec6cd70ed69db8c270aa882e9a11afc51619","contracts/fixtures/participant-runtime/participant-resource-budget-state-v1/valid/token-budget-state.json":"sha256:67ff2a5e81d02f5703e6cf53f261be08ff65ba9fa2bc167ff57dd61834d4fa5d","contracts/fixtures/participant-runtime/participant-resource-pool-capacity-v1/valid/configured-inference-pool.json":"sha256:f511c255b0ed770350920615e510edb47f4c050333f7919c074af6519f152d81","contracts/fixtures/participant-runtime/participant-shared-state-record-v1/invalid/unknown-access-kind.json":"sha256:8298105e2196323c989074e8c40a0fa60993e3df725fb2b5668606b872f16fb0","contracts/fixtures/participant-runtime/participant-shared-state-record-v1/valid/serialized-service-state-commit.json":"sha256:72fcadd0811df299c38111132321c027cd221bf60a03c2fffbc7eb3b27ad1499","contracts/fixtures/participant-runtime/participant-time-management-context-v1/invalid/timestamp-only-exact.json":"sha256:7b0da2ff407cea15b56b7e6de9fd4a9e239fd705f3d559de51baa300effe3e62","contracts/fixtures/participant-runtime/participant-time-management-context-v1/valid/backend-serialized-logical-clock.json":"sha256:de3f34a57f28cbf6f1c60be3ecdbd2a26b4ef66b7b68b77ebb4d3f06d29247b6","contracts/fixtures/participant-runtime/runtime-fact-binding-plane-v1/invalid/additional-property.json":"sha256:efbe1215c246da4d04c0d49b57b0b1d8a2ad65693d61133e2256129d49c137f8","contracts/fixtures/participant-runtime/runtime-fact-binding-plane-v1/valid/cross-backend-portable.json":"sha256:bc0f46adee9815a31a376de3b1562f0019f78069b15183480ee033256cd49e72","contracts/fixtures/participant-runtime/runtime-fact-binding-plane-v1/valid/failure-dispositions.json":"sha256:2e95a4fcbb6b1b750d0fd771957de1923dd98bec622b56c4d9fc628c2f9f3a46","contracts/fixtures/participant-runtime/runtime-fact-binding-plane-v1/valid/observation-to-action.json":"sha256:051fbb24758941cbf0998f61b0789a29536f52a76fd26ebbaee29df69df55fe8","contracts/fixtures/participant-runtime/runtime-fact-binding-plane-v1/valid/secret-reference.json":"sha256:4f1e3467ac6fb5d6af525d21fae095b1c9ac918325433c8a5f4e411c15ff8fe5","contracts/fixtures/plans/admitted-trial-plan-v1/context-invalid/altered-allocation.json":"sha256:30790117e031037bc1f1b34512b30be6a66e1f23ac707ae541d75b0218692de2","contracts/fixtures/plans/admitted-trial-plan-v1/context-invalid/typed-treatment-wrong-family-pin.json":"sha256:30ff5e653da50d271c1cb1979441f134c4ebbeeab26b12d9062184b68e56e857","contracts/fixtures/plans/admitted-trial-plan-v1/invalid/bad-admission-stage.json":"sha256:7ee5d6f89a4f05eea6019a70022c747b60024785f3974c0311959cf840a2e658","contracts/fixtures/plans/admitted-trial-plan-v1/invalid/empty-entries.json":"sha256:829f3aa5a949ffd6f386d305b7bd5259ec71bfc143c389865a47cb237311e15b","contracts/fixtures/plans/admitted-trial-plan-v1/invalid/missing-plan-digest.json":"sha256:3129e2b4050a4704aed48e43f1f11dfe4842a620bb896c16186e3e63d40ad34c","contracts/fixtures/plans/admitted-trial-plan-v1/invalid/unknown-field.json":"sha256:6c050ef08ec6f35fbe73ddf47afe3082ef4358513a859bde74f0cb4912cb2a78","contracts/fixtures/plans/admitted-trial-plan-v1/invalid/unknown-treatment-profile.json":"sha256:e33ebce74aa7d7cba491b5ef9eac4731c39187164c8dc678582e9bcef408122c","contracts/fixtures/plans/admitted-trial-plan-v1/invalid/unsupported-profile.json":"sha256:0ebf75f85845bec933b3ac3fff61b2def6c17ebde39dcbf5d0d5650ee461485c","contracts/fixtures/plans/admitted-trial-plan-v1/valid/factorial-randomized.json":"sha256:e7ca61e55526fbe1d9e69b49c4f87a39b0c71921054f11d6b9c73fa46cabeb83","contracts/fixtures/plans/admitted-trial-plan-v1/valid/minimal.json":"sha256:bf592e8dc928ffb2936acbb36fa90bf961045d6f0459493d4bd5bca27d92b5da","contracts/fixtures/plans/admitted-trial-plan-v1/valid/parallel-isolated.json":"sha256:da26f002c830f2e3755fe614f23d9ec678fc58c125d32743ad0122c40239ae6f","contracts/fixtures/plans/admitted-trial-plan-v1/valid/typed-treatment.json":"sha256:c76f52dd2c8c05140cf2166f47536591dc626a1e155a122086eebfeddd528ab1","contracts/fixtures/plans/backend-augmentation-scope-v1/invalid/partial-coverage.json":"sha256:82888ba82eb7c4831c7caaa77eb53dda56f32f1600688b73867c33664a1ffe1c","contracts/fixtures/plans/backend-augmentation-scope-v1/valid/reference.json":"sha256:e7959cc1c72f430236ff8f9913143326c8906e93565be9ce28e325c14963ac89","contracts/fixtures/plans/backend-materialization-attestation-v1/invalid/wrong-phase.json":"sha256:37d718a44787fc12ea9696e178c543de01a25539669e65c90d76fc0b31e60acc","contracts/fixtures/plans/backend-materialization-attestation-v1/valid/reference.json":"sha256:d949caedec52a9f9dbd4f05e8ae0983f0acf71039c26b8add72cb19d679eb014","contracts/fixtures/plans/backend-realization-preparation-v1/invalid/foreign-domain-operation.json":"sha256:c439d661556803c0a203f6c069e985f126acf61e6d20a7fa252e6f3672572eea","contracts/fixtures/plans/backend-realization-preparation-v1/valid/selected-database-service.json":"sha256:99749debf6e0d318f653218c3037105a6fb9a9c0be84f3d645485b42d3206bdf","contracts/fixtures/plans/backend-runtime-descendants-v1/invalid/reference.json":"sha256:f55e6dde4d889ea2b048844e758ece5cc448c63243b62fd385fbb49d4810a9f4","contracts/fixtures/plans/backend-runtime-descendants-v1/valid/reference.json":"sha256:1afb80843ce67db3877dae6b20ae0d618f2856098d9a2ad328d186c71c051dfe","contracts/fixtures/plans/evaluation-plan-v1/invalid/unknown-extra.json":"sha256:7453cbbd187471b47deddace3f558cbba69c2d7e6263c622efc1e2b3f3d18f2a","contracts/fixtures/plans/evaluation-plan-v1/valid/minimal.json":"sha256:d2bceef6e9d3c44369e6d95d04bf2449feb9d8c0ae83c24ddc3b8c6adeee4af3","contracts/fixtures/plans/mixed-participant-composition-profile-v1/invalid/alternative-fallback-pool.json":"sha256:5311b83faf28695541b4aa199b287b2444fc84975cee4632671705b4bbc32bc5","contracts/fixtures/plans/mixed-participant-composition-profile-v1/invalid/duplicate-apparatus-identity.json":"sha256:82c42ba41f67fe66e61fbbc16fc9b5e7b64847ba4acdfa202e08928fb14b88c8","contracts/fixtures/plans/mixed-participant-composition-profile-v1/invalid/open-metadata.json":"sha256:e958657f3d164ee01162902b4878d730c0ac3bc229abfc95f75b0f1cddb40866","contracts/fixtures/plans/mixed-participant-composition-profile-v1/invalid/simultaneous-single-form.json":"sha256:16f24389aba3f696f826db9d61be900dd6b51112ae4d37b2afc987d818eafd8a","contracts/fixtures/plans/mixed-participant-composition-profile-v1/invalid/staged-unadmitted-member.json":"sha256:a0544f780bab61731ba0f364caf4cecc92837587c435c05d5556e7f41f73be19","contracts/fixtures/plans/mixed-participant-composition-profile-v1/invalid/unknown-revision.json":"sha256:79130387062a89f229e4d8241648a53df4ca53625a84e3a3a33a2559da330324","contracts/fixtures/plans/mixed-participant-composition-profile-v1/valid/alternative.json":"sha256:af1375decf2827e4a6631914c2c5f7d6ddf9481a46d88a07951d6af26f708790","contracts/fixtures/plans/mixed-participant-composition-profile-v1/valid/simultaneous-mixed.json":"sha256:7f79fab8edf64cea629ed0de2a730f5693438c6bbd04d93a88df9e61343fcc81","contracts/fixtures/plans/mixed-participant-composition-profile-v1/valid/staged.json":"sha256:bd39bd3897af89b1261aa773bb6a2cfda66f4e0dc7176edbcbc51ce9471768ce","contracts/fixtures/plans/orchestration-plan-v1/invalid/unknown-extra.json":"sha256:7453cbbd187471b47deddace3f558cbba69c2d7e6263c622efc1e2b3f3d18f2a","contracts/fixtures/plans/orchestration-plan-v1/valid/minimal.json":"sha256:d2bceef6e9d3c44369e6d95d04bf2449feb9d8c0ae83c24ddc3b8c6adeee4af3","contracts/fixtures/plans/plan-realization-profiles-v1/invalid/unsupported-declaration-shape.json":"sha256:4badc94930f808437406ce2d341ac28323f2965d1c3316bab32ea1e1f49ab13f","contracts/fixtures/plans/plan-realization-profiles-v1/valid/resource-label-authority.json":"sha256:cc938afe06a028ae3a8fd16f3e2e2a9fdfe412ad76ef8be2d357fcffe52184c5","contracts/fixtures/plans/provisioning-plan-v1/invalid/unknown-extra.json":"sha256:70eef9aeb425033aceb8b5c6e5e3de4c710bddbcd887b372c0573b2ebd991b6a","contracts/fixtures/plans/provisioning-plan-v1/valid/minimal.json":"sha256:0863f7e8b889ecac6921f241a7ec17c5499d265404a0f16dfbe62a1d79f797d3","contracts/fixtures/plans/trial-cleanup-plan-v1/invalid/missing-run-id.json":"sha256:04040ced37bdd430caa03c8d66e3bd4406153fd2a5cdd9a7c1ea694f44daa4ff","contracts/fixtures/plans/trial-cleanup-plan-v1/valid/fresh-range.json":"sha256:a4d44d248955a364316a201d96d0c49d108ba0de4a9ce6bb691bd18e6aa2bed5","contracts/fixtures/plans/trial-cleanup-plan-v1/valid/retry-with-reset.json":"sha256:3f4d409fb273f18c099a6891bf0c61173eb2208a484e06d7f28a02d50e334b29","contracts/fixtures/plans/trial-compiler-mixed-composition-v1/identity-vectors.json":"sha256:398fd7f8ce988188e2cdc851117e72441dfa50eafad64ef6e14e0a8379296d6c","contracts/fixtures/plans/trial-compiler-replacement-v1/identity-vectors.json":"sha256:fb53370067ae7b55deef5d9720debb1cfc043f5ecbbc9594d601e495712539a7","contracts/fixtures/plans/trial-compiler-v1/identity-vectors.json":"sha256:5f7e8989447db6fda35cf4bfaf8b0470c88c1fe0bce34976ee87e8f7e8faabe3","contracts/fixtures/processor-manifest/processor-manifest-v2/invalid/empty-compatibility.json":"sha256:39b18c5ec05975b3eea12a3b4c61dfae04745bf70507cd8c0cf5998f53c38326","contracts/fixtures/processor-manifest/processor-manifest-v2/invalid/hollow-capabilities.json":"sha256:6f531a17b3ad37858e9164f43417dccf1b96a7b21b9dd9938677fa457f0f2d12","contracts/fixtures/processor-manifest/processor-manifest-v2/invalid/hollow-realization-support.json":"sha256:dd76c95e2564b3135d4fd86c5a456c399e195e00c98172b881b8c6f6aa27a922","contracts/fixtures/processor-manifest/processor-manifest-v2/invalid/malformed-realization-support.json":"sha256:fa777cf4ed41e38d3995f93dd7aa4783d6d395544307541da6a39de5c34b46ab","contracts/fixtures/processor-manifest/processor-manifest-v2/invalid/missing-concept-bindings.json":"sha256:c02bb661659c00aa7d46b745c2355d41b98eedc954ab00a800b572f83048b8b7","contracts/fixtures/processor-manifest/processor-manifest-v2/invalid/non-backend-compatibility-surface.json":"sha256:de90e32f526053a0ec66835264e0aa0ce2a7caec3796047acc92befedabfff33","contracts/fixtures/processor-manifest/processor-manifest-v2/invalid/non-processor-contract-version.json":"sha256:6e8fe98783a0ef1eb56a5dbc9de39035114203002ccee56473378d5467771661","contracts/fixtures/processor-manifest/processor-manifest-v2/invalid/unknown-feature.json":"sha256:fa1ed8e2f6720326397612524b274536a3cdfde61d8b59db71a9f621eb2a0e3b","contracts/fixtures/processor-manifest/processor-manifest-v2/invalid/unknown-sdl-version.json":"sha256:a1bc8b776c4d1bb21b17dd1886cf33f02871ba76c53d1a3d9a586d0b14c58126","contracts/fixtures/processor-manifest/processor-manifest-v2/valid/reference.json":"sha256:bfc18cd94611afc1864e1179018e9afb14f9963bf9ea62b3803db2f6f156e8eb","contracts/fixtures/profiles/behavioral-relation-profile-v1/invalid/incomplete-crossing-domain.json":"sha256:9e7e015e70670112b98dbbf9f317f53fae035e2521ac9065c47eea81a48883ac","contracts/fixtures/profiles/behavioral-relation-profile-v1/invalid/multi-operation-truncated-heads.json":"sha256:786aa6809959dd2810ed1557f46693adff6184349e51e5c503f427079ea9ea0c","contracts/fixtures/profiles/behavioral-relation-profile-v1/invalid/multi-operation-wrong-projection.json":"sha256:0f7c3f6beeee785835c4cfe0ef647923702e70d4ec66d7fc4b8b48d6e4ce096d","contracts/fixtures/profiles/behavioral-relation-profile-v1/invalid/observable-absence-without-opportunity.json":"sha256:c8c3150dfbcf9b732c44235090528677caaad5f1ad865793db49b59f5ba39c5e","contracts/fixtures/profiles/behavioral-relation-profile-v1/invalid/overlapping-crossing-labels.json":"sha256:a440579be3af6f7a5bc5ee3742d36812abd7506e1f690d94980d57405f7ca575","contracts/fixtures/profiles/behavioral-relation-profile-v1/invalid/shared-crossing-authority.json":"sha256:550e0e8d465ebb6088fe4dcf1b231f7b8372012af41e9668dbc5a657e472d9ce","contracts/fixtures/profiles/behavioral-relation-profile-v1/valid/multi-operation-crossing.json":"sha256:2d53aafc05060342defcccf7e8dd1bd2c8746fa84840de2a40425754cb5ed583","contracts/fixtures/profiles/behavioral-relation-profile-v1/valid/participant-crossing.json":"sha256:47c02f085aa6952333f75512c9eb7ffc5f7b7982ba49ee0dba4c5a3c32857db4","contracts/fixtures/profiles/behavioral-relation-profile-v1/valid/participant-opacity-baseline.json":"sha256:1c7761db8f76e7a8e89db7448df215a367ceedb20beb58643f4bdbb99f95bbd9","contracts/fixtures/profiles/behavioral-relation-profile-v1/valid/participant-opacity-runtime-reference.json":"sha256:ef644f5fb99b28886f4f40d63a7d7cff524602e23d374c888b03a3523c52ff9b","contracts/fixtures/profiles/behavioral-relation-profile-v1/valid/participant-opacity-theorem.json":"sha256:646a227f3cda814c666a1463c01e9a52c9dc1a89ec811f728da010ee938113bb","contracts/fixtures/profiles/domain-profile-admission-policy-v1/invalid/unknown-operation.json":"sha256:a1560affa771ee9c0530cb322fb3101a731d3e7b4e130ee641aac5e5a35e5bba","contracts/fixtures/profiles/domain-profile-admission-policy-v1/valid/reference.json":"sha256:4020d96301cb574cfaf874ac2411ac635bec7d7ca30e97bcfb844c86fdb2b8a7","contracts/fixtures/profiles/domain-profile-binding-v1/invalid/observed-without-evidence.json":"sha256:e2d972302a05c7c272dd8c3ae067c8ea8809a62a855c4a5367330d1d71d7938a","contracts/fixtures/profiles/domain-profile-binding-v1/invalid/unknown-use.json":"sha256:fe597f44e2990314b5831232546856e6765830f3aee1147ca028966964bb3cd0","contracts/fixtures/profiles/domain-profile-binding-v1/valid/reference.json":"sha256:3aa9500624708179c103b4907ad3b207a67c940d1f17336e337e8bdf9a76b951","contracts/fixtures/profiles/domain-profile-definition-v1/invalid/missing-coordinate.json":"sha256:0f86726837ac204a6766f1dac869f4211965c65b5ce4c1a96ddf764dd4bc652f","contracts/fixtures/profiles/domain-profile-definition-v1/valid/reference.json":"sha256:972ed481422002a0a6b77ee702092a9163cf5fab54406086fd057adbae3498fa","contracts/fixtures/profiles/domain-profile-resolution-context-v1/invalid/unbounded-limits.json":"sha256:21cff9ab168c2d835d45fe31aa1fb5208836f2aa07880af9b65a855bfb667774","contracts/fixtures/profiles/domain-profile-resolution-context-v1/valid/reference.json":"sha256:a93c7469be8ad794a1716caaa5b8696ba9f06efbc8f8434b91d8151f68cbd5f2","contracts/fixtures/profiles/domain-profile-support-declaration-v1/invalid/structural-without-dialects.json":"sha256:4e46aac027e313bb19278eb89f631c571d73b3172aac406982243ab477701fa2","contracts/fixtures/profiles/domain-profile-support-declaration-v1/invalid/unknown-operation.json":"sha256:12dec8153ed0db2acbe6ada2af4181562678eef59d326c5ae1590e63322ca130","contracts/fixtures/profiles/domain-profile-support-declaration-v1/valid/reference.json":"sha256:fbd70a5561a95aae8f38237505d135c266ae22bc29566a11bd2d31d95ffef96b","contracts/fixtures/profiles/participant-boundary-flow-policy-v1/invalid/open-policy-expression.json":"sha256:36d071ecb0bd0be44a5ec4f50b2004cbc62f0383637ff516123585d858061d46","contracts/fixtures/profiles/participant-boundary-flow-policy-v1/valid/reference.json":"sha256:0791a092b5e4e0004aa9e2098870e74f7f47125c5efd3a51d2fb046a7ebba6c3","contracts/fixtures/profiles/participant-information-reconstruction-profile-v1/invalid/executable-dispatch.json":"sha256:a7c069736d890237a6f43786aab019ea62f86c620a07097bdfecf112fb7b5566","contracts/fixtures/profiles/participant-information-reconstruction-profile-v1/valid/occurrence-prefix-evidence-v1.json":"sha256:99d6351ee45447b13e94aa7a506d49cb3fe7bb02e22e00c911bc94d5e3527001","contracts/fixtures/profiles/participant-owner-flow-policy-v1/invalid/reference.json":"sha256:00b45447f878000797517d31bd6b3c53ed57906e8688cc38c058bd686d85a134","contracts/fixtures/profiles/participant-owner-flow-policy-v1/valid/reference.json":"sha256:527e5fe3b90332c80fb1ecfddd9e860fe0a06354d82afbedae4be5720a537663","contracts/fixtures/profiles/random-stream-profile-v1/invalid/bad-profile-id-pattern.json":"sha256:27fda01935092f884848b7f798b1f4da2428eb57e162a569f570fd9864f249fe","contracts/fixtures/profiles/random-stream-profile-v1/invalid/empty-transforms.json":"sha256:8d7ea638f6d2c2a008deb81839fc9a452aacc43b28a00275cba92a3d8aff17c4","contracts/fixtures/profiles/random-stream-profile-v1/invalid/missing-generator.json":"sha256:605b58f76c702b1e940b6574d1e7d162f98a329096db88ecd8701f1931ca3694","contracts/fixtures/profiles/random-stream-profile-v1/invalid/transform-key-mismatch.json":"sha256:0329ffffc5a600cb3b22cecf3a48d672c142a60fdd1945baa96dd88ef4cc1d58","contracts/fixtures/profiles/random-stream-profile-v1/invalid/unknown-field.json":"sha256:29d88b59d90d0c1e3f38b04a9f474543e1568f63a7c3d1683fac553a8f7e25dd","contracts/fixtures/profiles/random-stream-profile-v1/valid/blake3-xof-participant-v1.json":"sha256:fa9c4dc98a3a9d5019b308ed117eefad105bdc52fde8eae11d67dd471ec461be","contracts/fixtures/profiles/random-stream-profile-v1/valid/blake3-xof-v1.json":"sha256:6c1c0dd010ab629d375f6200854ad1e5de5d715b91e0179366f9a5d3bca66b18","contracts/fixtures/profiles/scientific-completeness-assessment-v1/invalid/external-without-binding.json":"sha256:75881e8379ae1396571f4917fae5d87ec487359752099219d4d86b9cefed78d9","contracts/fixtures/profiles/scientific-completeness-assessment-v1/valid/minimal.json":"sha256:81c65a7ad64bf0701962654944c5559a71a5a72c2128778ae83f754e77edb9de","contracts/fixtures/profiles/scientific-completeness-taxonomy-v1/invalid/missing-disposition.json":"sha256:45bcaa2fcd9d945b3d5ee9a78d4d4434a1a87da2dda6b01b87b25650f7f7a641","contracts/fixtures/profiles/scientific-completeness-taxonomy-v1/valid/minimal.json":"sha256:aae59c689824153855367b206f3e74598cf62a4e59cdb8151f02d9ff492f43b6","contracts/fixtures/profiles/validation-basis-disclosure-v1/invalid/missing-required-gate.json":"sha256:fda7f09551979db2e8b86c5fd13d54971566120268129de6204215594011bbdf","contracts/fixtures/profiles/validation-basis-disclosure-v1/invalid/run-missing-ref-version.json":"sha256:4fb61643ef4e007490755533e029da5852c5a84c0cc246e513e765ed327c722c","contracts/fixtures/profiles/validation-basis-disclosure-v1/invalid/scenario-snapshot-missing-digest.json":"sha256:99b3f72c5906a4e2cf226216589e1482bfcdbf9ec7b8d5a2efdd0c310d34823b","contracts/fixtures/profiles/validation-basis-disclosure-v1/invalid/unknown-profile.json":"sha256:587a2c949df1c5eb0175b8d11213bd3b6d079d969dedfffeebd5c45e2fb79df4","contracts/fixtures/profiles/validation-basis-disclosure-v1/valid/evidence-backed-run.json":"sha256:a3c1f17f282e305affa6bf9e6a2fd3e19556fa189cc184e15d8b9b58d30b6ae5","contracts/fixtures/profiles/validation-basis-disclosure-v1/valid/scenario-snapshot.json":"sha256:9dcdbf3914bdb7ae10bdaf81fb3c4925cde80424bf1a83c63ab97a9b36cbb265","contracts/fixtures/profiles/validation-basis-disclosure-v1/valid/structural-scenario.json":"sha256:d5fff67b1bc3a01158443ad468009741052db7355f5fc600c4dde557eb413375","contracts/fixtures/profiles/validation-profile-catalog-v1/invalid/dangling-reference.json":"sha256:2d443b588e6a2de4c5cf69389d5c14db04bccacc172d74a8e0e82fa5d1faf236","contracts/fixtures/profiles/validation-profile-catalog-v1/valid/minimal.json":"sha256:f1db977e7beb834865e2287d8998141cb389130f23a8135d073078e162d67414","contracts/fixtures/provenance/sdl-lineage-ledger-v1/invalid/unpinned-git-source.json":"sha256:88bfb9dac3dac9bf6885623948d4a71b50929ce296c43d597d13c2986c67b5c5","contracts/fixtures/provenance/sdl-lineage-ledger-v1/valid/minimal.json":"sha256:28dad1560dde74f7464b845359c8ffcc023c1df6968ff76acd1bf391fd5ad26b","contracts/fixtures/random-stream-vectors/blake3-xof-participant-v1/participant-occurrence-bounded-draw.json":"sha256:f17582080e822cc18066d6b5ef79be4d5ed5bf77bc273bfae26a3050b36a1baa","contracts/fixtures/random-stream-vectors/blake3-xof-v1/basic-address-and-block.json":"sha256:ed60d867bc688ab30a876e2c50cc6d89a179b39ab7ffb4c4469abc43cbd43975","contracts/fixtures/random-stream-vectors/blake3-xof-v1/bounded-integer-basic-draw.json":"sha256:8feb590d6695f14f534acb8324fbdb6e0ce470e8d998a7fc85f1ca652e343282","contracts/fixtures/random-stream-vectors/blake3-xof-v1/bounded-integer-boundary-single-value.json":"sha256:2a28dd1605597990a26126e6b2ddd8345a5b3bb1d71581795a98e02d040e104c","contracts/fixtures/random-stream-vectors/blake3-xof-v1/bounded-integer-exhaustion.json":"sha256:63ac7637305a2adabb0ecaf532920ee557c1e7eafad2f496aacf5ea6a890d53e","contracts/fixtures/random-stream-vectors/blake3-xof-v1/bounded-integer-rejection-then-accept.json":"sha256:31cacc2f2a3518184e809cbda72672b32cf6e3956e07e76f7aee715814f3de23","contracts/fixtures/random-stream-vectors/blake3-xof-v1/zero-heavy-seed-and-address.json":"sha256:e2c695a61609794e730ab346c5f7cfecdd41d8b0f59a837ac2ef8a321f79c595","contracts/fixtures/realization-constraints/recursive-realization-constraint-v1/invalid/unnamed-closed-universe.json":"sha256:193235a16e89bd099409287f799f75deaa70baf7f2a4daefafa43c458894a1c0","contracts/fixtures/realization-constraints/recursive-realization-constraint-v1/valid/nested-open.json":"sha256:426e172db909d89e9dd43801e466bd6a9de7253c648e9fe058316abb5c18840d","contracts/fixtures/realization-envelope/realization-envelope-v1/invalid/missing-digest.json":"sha256:e2a1b408e481c54b035b1d5b0faa40f3d317352ad8427dfacb8c5abfd8a1ed38","contracts/fixtures/realization-envelope/realization-envelope-v1/valid/generic.json":"sha256:e71b710d2ee25eb866b21492898899e1db1ae058ea69f0d803892b8ed756bcc3","contracts/fixtures/satisfiability/scenario-satisfiability-evidence-v1/invalid/cross-outcome-payload.json":"sha256:2d54ecb4a7be4fa43f559504a87337a09165d0b78d2d566a9a8f45a918440689","contracts/fixtures/satisfiability/scenario-satisfiability-evidence-v1/valid/unsupported-target.json":"sha256:fd702d8e818074bc2da88597917a3543c6e23d1beb0f5b6b6eeebf7c0fb04982","contracts/fixtures/sdl/instantiated-scenario-snapshot-v1/invalid/wrong-profile.json":"sha256:c6ccdbf625f8f022ff5aa12d6926d65748af25fd88709bdd892d165917b67234","contracts/fixtures/sdl/instantiated-scenario-snapshot-v1/valid/minimal.json":"sha256:09621f7d3bd2be8848e14df34b80dae37e064b7dbde72c1777866c90d6ed8cb5","contracts/fixtures/sdl/instantiated-scenario-v1/invalid/imports-empty.json":"sha256:d6b6a4226051e443a20167518d7a1e8295e42b6795583c6727dcc1419fd5b33f","contracts/fixtures/sdl/instantiated-scenario-v1/invalid/missing-provenance.json":"sha256:7ddccdd4ae62ba345124cd500d424fe81567ca0436509bab657b0c83c895b2b9","contracts/fixtures/sdl/instantiated-scenario-v1/invalid/module-null.json":"sha256:4245c612f2199e869af8083fdcd249ec6460d64b85864e84f4ce7de8341f493c","contracts/fixtures/sdl/instantiated-scenario-v1/invalid/unresolved-variable.json":"sha256:e62dd75da9ad87c57454a4a13ffa6dbce99749f120ec600a019587b0c49c4465","contracts/fixtures/sdl/instantiated-scenario-v1/invalid/variables-empty.json":"sha256:bac83b7e6b444c6d1306e11b2a54b727015bef9205b96256edf6a73e4056026f","contracts/fixtures/sdl/instantiated-scenario-v1/valid/minimal.json":"sha256:727531b76a5aac93e33ad62195d03764542e9eef34e87ed261b82632564f325d","contracts/fixtures/sdl/instantiated-scenario-v1/valid/selected-runtime-parameter.json":"sha256:d6ef1fc79bd71b1016ad63f857f212f15a1680bcc3d0d562786ab3586d69e93e","contracts/fixtures/sdl/materialized-scenario-v1/invalid/wrong-phase.json":"sha256:0158c256895a5c44def1613e11f359445ada2373ca1e71f52d8120578dd1fe31","contracts/fixtures/sdl/materialized-scenario-v1/valid/reference.json":"sha256:6a4030238df4fa4e7e62c8fd7191de794f16cba55204db1a01fe38bd4cb7cc54","contracts/fixtures/sdl/mixed-control-v1/invalid/mixed-control-operator-impersonation.yaml":"sha256:24e7df1eb3f4b5ddfeb44c08449821af7c9bae32a690ce503593b32d87011abf","contracts/fixtures/sdl/mixed-control-v1/valid/mixed-control-participant.yaml":"sha256:2d6be574c7871ac40a15001db602ab11629d6ed8561dbe5383501e95b3a93767","contracts/fixtures/sdl/participant-inject-delivery-v1/invalid/environment-only-leakage.yaml":"sha256:d1bdc768736d6817a008809658c0cf7406b7544af2208d4aee281d5036e2fd18","contracts/fixtures/sdl/participant-inject-delivery-v1/valid/participant-directed.yaml":"sha256:88a83f75b0fecd4a4d85b30c249c28b3ab5984b6707656a124f19eac3a5effef","contracts/fixtures/sdl/participant-relationships-v1/invalid/entity-endpoint.yaml":"sha256:ca92b6fce277cb328290dfeca691d2ef8253d46dce64a47c3b07b67381b114dc","contracts/fixtures/sdl/participant-relationships-v1/valid/abstract-relations.yaml":"sha256:f3cf1f9bb6a964de45fc1324faae437471e3d2ba14c3232713d3162f92003a93","contracts/fixtures/sdl/runtime-package-repository-v1/invalid/unpinned-key.yaml":"sha256:d9bf1ae94d25b6db9cf75a4874e50fbe58aaf6c87b520c1e01d53f9a47c83284","contracts/fixtures/sdl/runtime-package-repository-v1/valid/wazuh.yaml":"sha256:56fd670d994057fc4908e35395faf70e3f425fbe50c3a011576dbefa8b8c2558","contracts/fixtures/sdl/scenario-instantiation-request-v1/invalid/non-canonical-parameter-name.json":"sha256:f7f45519ece3b7d98d102ae22770ce211526ba653186de1b83365fb6e997f85b","contracts/fixtures/sdl/scenario-instantiation-request-v1/valid/minimal.json":"sha256:9dcbadcfea88bede5054370d30902aa4ddd1e8a535e3e558ecf4a0cff84d0b82","contracts/fixtures/sdl/scenario-instantiation-request-v1/valid/parameterized.json":"sha256:fee5b89c11f8eacdcee2734ede9e5b140757ea3b1dd146010db7ec4a49ca957c","contracts/fixtures/sdl/sdl-semantic-migration-context-v1/invalid/implicit-adoption.json":"sha256:a510711acf672c7e90e0a9a16fb2cf3d6aee06745857e3cd2e51052f98897716","contracts/fixtures/sdl/sdl-semantic-migration-context-v1/valid/explicit-adoption.json":"sha256:7c995e7f10dd5cd42d5d7b3028e9cdde8491a9f13562d73569fb86b14fce682a","contracts/fixtures/sdl/sdl-yaml-v1/invalid/alias-cycle.yaml":"sha256:ef0af768b766d45144ef989ae0b51b1f1ba5831328f7c59c435c095979dd0b5c","contracts/fixtures/sdl/sdl-yaml-v1/invalid/directive.yaml":"sha256:a45c79b9c161e133b97a55949a9c0e4a97e6cdacf57479841ca4332030ac173c","contracts/fixtures/sdl/sdl-yaml-v1/invalid/duplicate-field.yaml":"sha256:a4f1922eee529656b804f3f0d389906847eb5fe5275feefa06c67101f4a2f226","contracts/fixtures/sdl/sdl-yaml-v1/invalid/explicit-tag.yaml":"sha256:11cde9b1294ca76ed8af9fd9f641b869abe420824646da96272c7c3434685a56","contracts/fixtures/sdl/sdl-yaml-v1/invalid/merge-conflict.yaml":"sha256:93d836005348e831500182f66cfc0f57c34bbf8bd95cb5729f83e5106844dbb7","contracts/fixtures/sdl/sdl-yaml-v1/invalid/multiple-documents.yaml":"sha256:d82db1bece6c1929d8266459ad2323ea541f0d2433021c44c6bdb62c2cad5342","contracts/fixtures/sdl/sdl-yaml-v1/invalid/non-string-key.yaml":"sha256:6eee87ffbab8a253eb9ff5eb208796c151fc3e7cb10eec6f9ae1ccea2fa5c215","contracts/fixtures/sdl/sdl-yaml-v1/invalid/noncanonical-field.yaml":"sha256:f8b251e31db299e49f45ab020351a96b5549040b4fb7f85fc6d700a186e421bf","contracts/fixtures/sdl/sdl-yaml-v1/invalid/nonfinite.yaml":"sha256:5cf7f4fe310e3da46ce842629df7ec00d1715b60a9670ea89f79dfebf80ea15f","contracts/fixtures/sdl/sdl-yaml-v1/migration/field-alias.yaml":"sha256:4f947cd7efd5cba4836d06609c4acc3148a0df4c01ad24bc712627e37f24a17a","contracts/fixtures/sdl/sdl-yaml-v1/migration/merge-key.yaml":"sha256:f586fd21961fce86c468c68156ac20e877705b835719f9d166adf52efd144217","contracts/fixtures/sdl/sdl-yaml-v1/valid/anchors.yaml":"sha256:09655b74461a8a421121085c3d927e1b37ea6fc9c113d9b70a3b3b5d7895c900","contracts/fixtures/sdl/sdl-yaml-v1/valid/core-scalars.yaml":"sha256:398f42b002b27d85195b750ea73e57f3ce520fcd6b79e267f2c4752e251a34d4","contracts/fixtures/sdl/sdl-yaml-v1/valid/migration/participant-control-legacy-before.yaml":"sha256:0ca8aaab2a483a9a678816540b975dcc74fbfe446923d0c642bd17c801597480","contracts/fixtures/sdl/sdl-yaml-v1/valid/migration/participant-control-opt-in-after.yaml":"sha256:0ca8aaab2a483a9a678816540b975dcc74fbfe446923d0c642bd17c801597480","contracts/fixtures/sdl/sdl-yaml-v1/valid/minimal.yaml":"sha256:31aa0831f834b2eefc94c83e7fad67a02991571f95809e17364c0463c7d23d43","contracts/fixtures/sdl/sdl-yaml-v1/valid/observability-native-no-demand.yaml":"sha256:9e541184d9dcd003db1c42ee8384aaef2dcd8810d908ead7b5d3ccd983fe26f5","contracts/fixtures/sdl/sdl-yaml-v1/valid/observability-selected-demand.yaml":"sha256:4e0507e382050b6720e111b878ff4c233f7f7d1fa5da6604ca14ce6953b5bede","contracts/fixtures/sdl/variation-points-v1/canonical/absent.yaml":"sha256:aa405292dc7ece76b5020c7b140489c4fa3a7c60102f6a2508ff2c1e221ea04e","contracts/fixtures/sdl/variation-points-v1/canonical/empty.yaml":"sha256:43eb7514b410d4d94615cc67019afd86eeb5bd008cf3aad27de5f193cc9394bf","contracts/fixtures/sdl/variation-points-v1/composition/module.yaml":"sha256:d2d1dbf60479004f1725f9e8027654948eb919be6f136b76a527107e9b0901ed","contracts/fixtures/sdl/variation-points-v1/composition/root.yaml":"sha256:0f283b5251b257408d4ba75b991b5530815736d10bf801551b2b01b80796af04","contracts/fixtures/sdl/variation-points-v1/invalid/dangling-candidate.yaml":"sha256:5ef7502ac5933703d6f52ab317fff93ba1aeaa68d79d4e3c49ee86813b622d03","contracts/fixtures/sdl/variation-points-v1/valid/family.yaml":"sha256:5e955d06d65fc050eed44de332feb051618c813e3459d65458fec4b13626b482","contracts/fixtures/sdl/variation-points-v1/valid/node-inventory.yaml":"sha256:3cc2cbed579f8f003c7eb67647b26767e7c95a6f33fe9c24639f9b66cd1894f0","contracts/fixtures/semantic-comparison/semantic-comparison-request-v1/invalid/filesystem-path-coordinate.json":"sha256:0b74a9b5900ae4cfb7a8d70217ec3ec092a2a250b7f3a73f91fa6e1571e08875","contracts/fixtures/semantic-comparison/semantic-comparison-request-v1/valid/evidence-specification.json":"sha256:c4513d637a6814f32daa95f41a88908892be391d55339d7ccc56afd538e027c7","contracts/fixtures/semantic-comparison/semantic-comparison-request-v1/valid/external-concept-bindings.json":"sha256:9ef640f9e79919276ea6400cb9b9b3ea405a4f17b55c6feb4148eea28b850757","contracts/fixtures/semantic-comparison/semantic-comparison-request-v1/valid/module.json":"sha256:0f769583f81e59128bdddab7bc76bab7239e6d5b9279625d1cd19ccad92f26ac","contracts/fixtures/semantic-comparison/semantic-comparison-request-v1/valid/run.json":"sha256:4e42efe9aeb3d9ad2be8cf9fa79dc55b05453c22a8c3c07506f8984e4e1d8254","contracts/fixtures/semantic-comparison/semantic-comparison-request-v1/valid/scenario.json":"sha256:fda914331c743289b7d87675fd132bda23dd822973c99af9d0386a165002e47f","contracts/fixtures/semantic-comparison/semantic-comparison-request-v1/valid/study.json":"sha256:921a26b78330f7ac55644db5dc45874734f1624637ac09b8a6b079b7098fc749","contracts/fixtures/semantic-comparison/semantic-comparison-request-v1/valid/task.json":"sha256:df6843e355373eb3e6fc1c124f7d287330591a234f7cb7410fa8ff40fe7776b8","contracts/fixtures/semantic-comparison/semantic-comparison-result-v1/invalid/path-without-edges.json":"sha256:69f2c280c389a7c0ff5340ccf5e11b0c7e353465c933c874b352e159e10e6c68","contracts/fixtures/semantic-comparison/semantic-comparison-result-v1/valid/changed-with-impact.json":"sha256:18a5007b45ea0ca81b710828472bebb8f2c1d537c828a614ffdd0e4a0f9728a9","contracts/fixtures/semantic-profile/semantic-profile-v1/invalid/authoring-binding-scope-not-governed.json":"sha256:f0e3011e3c031eae45fb06007c99c08b685183ffb8d76747be2413f906986339","contracts/fixtures/semantic-profile/semantic-profile-v1/invalid/binding-family-not-declared.json":"sha256:395abc81280fd43461a59b4484f8c555be34111d94bcef6a0f1d376740e68bfe","contracts/fixtures/semantic-profile/semantic-profile-v1/invalid/duplicate-required-contracts.json":"sha256:ff3781150ced67f5ce3f73826aff5e0129a655bee68bf0e1b152379f91f6bb83","contracts/fixtures/semantic-profile/semantic-profile-v1/invalid/missing-concept-catalog-version.json":"sha256:76cd5e6bcef584606938911f218dbbacb4fe8f0349478b289524b13e33f10140","contracts/fixtures/semantic-profile/semantic-profile-v1/invalid/processing-binding-scope-not-governed.json":"sha256:737854341629ef9f82d93d303f57994fd26a50a9dc695f036b84b56feabbed68","contracts/fixtures/semantic-profile/semantic-profile-v1/invalid/unknown-contract.json":"sha256:df223316e09555bfc301f20a927cbd03b0f6eaf68d3bf86271053f145a05dc86","contracts/fixtures/semantic-profile/semantic-profile-v1/valid/reference-stack-v1.json":"sha256:91ccd35eba0e7abb102e80ff14afdabf8fc071887c824c02984d564c1eab3925","contracts/fixtures/snapshots/runtime-snapshot-v1/invalid/realization-observation-missing-strength.json":"sha256:21c45952a6f2a43b318751a4bafcb901e0dd6d232128f0a63f4d28576d056a5f","contracts/fixtures/snapshots/runtime-snapshot-v1/invalid/realization-provenance-missing-provenance.json":"sha256:6d95dc6285acec60bb266257585c4fc359b92fb9caff7a253cdd63b631bd866c","contracts/fixtures/snapshots/runtime-snapshot-v1/invalid/workflow-extra-step.json":"sha256:efae8d28b68796a6b20e317030ea23001efc1d77dfaccb3d42f20798ae13ea7c","contracts/fixtures/snapshots/runtime-snapshot-v1/migration/participant-control-legacy-before.json":"sha256:1ea0c9114b6fb849eff32a7ba33c705390bc193431ba6fcb81827777ceb3690a","contracts/fixtures/snapshots/runtime-snapshot-v1/migration/participant-control-opt-in-after.json":"sha256:7d345a2c8cec6cbaab0a4680ae4eb443d8ad4bfdd313ce40f0009250563b022f","contracts/fixtures/snapshots/runtime-snapshot-v1/valid/realization-provenance.json":"sha256:411eddfa24978b045e5333762b67848367dbc888e26e3b8be06888b0c3cd37c6","contracts/fixtures/snapshots/runtime-snapshot-v1/valid/reference.json":"sha256:c8052da2a38f63606def39a85c27b4151a93b3e4e5bf7403b4387308df79d003","contracts/fixtures/time/realized-time-model-v1/invalid/missing-apparatus-binding.json":"sha256:2b7867d6d8bce864971ba1837a73dc850b83df206595d736031fdda92d3db552","contracts/fixtures/time/realized-time-model-v1/valid/reference.json":"sha256:4d2829157faf585badbdc749cdaf73cce24429d7cfbd5504b7c73d86dfca9c33","contracts/fixtures/time/time-model-v1/invalid/dangling-clock-domain.json":"sha256:792f8e0bb61d696760c6764efab58aea39ff43867805b97bf0234e2ecbdbf371","contracts/fixtures/time/time-model-v1/valid/reference.json":"sha256:6726e95fff1edb789836c0e202fc018ac7d9a9ee32a4676ea8ae0c6744d22b91","contracts/fixtures/time/time-runtime-state-v1/invalid/noncontiguous-history.json":"sha256:cef5f9e496dcee9eb4bd36b6614b836c79843ab3c33347ac891b31abf48b82ac","contracts/fixtures/time/time-runtime-state-v1/valid/reference.json":"sha256:2aa339ce6bef162ab841f35de20e446dfd667514a47320b13fa24934bbb6ba5a","contracts/profiles/authoring-adapters/reference-v1.json":"sha256:a9521868b0f9b381e1468da3f1a2bf02b0c834f414e6036059e7b3ffbdd86cab","contracts/profiles/backend/full-remote-control-plane.json":"sha256:6ec2635602906479603519c937e4cbd06edf775d43e8e74e61c9c0231d6b8cd5","contracts/profiles/backend/observability-evidence.json":"sha256:4c69d7692460f2d53ff370a0ab6c62d493882f7d44f733b4abba7020c5c6f4bc","contracts/profiles/backend/operation-supervision.json":"sha256:31bed4813d90a0637d63a8f8422077130854f2506793b47fa9ffe40f094ebdf6","contracts/profiles/backend/orchestration-capable.json":"sha256:f70b8505a5c0055416db86c533e2e5bf08b11e5a514f076223b6d6c36215a092","contracts/profiles/backend/orchestration-evaluation.json":"sha256:9e7a64ace38b22af52bd46216c3f99562cf706c3cc2de3f77b0bd1fc11a7548b","contracts/profiles/backend/provisioning-only.json":"sha256:7a5f8aaaead793da8ead1ebc74b616cc278d502670bea3f6ef6cbb35e1a6cf03","contracts/profiles/behavioral-relation/history/participant-opacity-baseline-v1-sem-231-rev2.json":"sha256:4b6a38cee8d8a80742f03db0e8ef808f505782e18efe315a1439a549faaceace","contracts/profiles/behavioral-relation/history/participant-opacity-runtime-reference-v1-sem-231-runtime-rev1.json":"sha256:ef644f5fb99b28886f4f40d63a7d7cff524602e23d374c888b03a3523c52ff9b","contracts/profiles/behavioral-relation/participant-crossing-dpbb-finite-v1.json":"sha256:47c02f085aa6952333f75512c9eb7ffc5f7b7982ba49ee0dba4c5a3c32857db4","contracts/profiles/behavioral-relation/participant-crossing-multi-operation-dpbb-finite-v1.json":"sha256:2d53aafc05060342defcccf7e8dd1bd2c8746fa84840de2a40425754cb5ed583","contracts/profiles/behavioral-relation/participant-opacity-baseline-v1.json":"sha256:d8bbe6edfaa19f6390b9aad63ff7b00eb0c988d4dfae2c1ad9566ff46b903b71","contracts/profiles/behavioral-relation/participant-opacity-runtime-reference-v1.json":"sha256:a8728ff7e9cd77ebf1ecb944266ccc6a97a6be7ca73c427cb6429db9cb56e9f2","contracts/profiles/behavioral-relation/participant-opacity-theorem-v1.json":"sha256:646a227f3cda814c666a1463c01e9a52c9dc1a89ec811f728da010ee938113bb","contracts/profiles/candidate-synthesis/concept-nodes-v1.json":"sha256:c5a8df92882c78d57182b81e0e4208bc37335e49db243a600b77f7e0bf8b34e9","contracts/profiles/participant-boundary-flow-policy/participant-boundary-flow-policy-v1.json":"sha256:0791a092b5e4e0004aa9e2098870e74f7f47125c5efd3a51d2fb046a7ebba6c3","contracts/profiles/participant-boundary-flow-policy/participant-owner-flow-policy-v1.json":"sha256:527e5fe3b90332c80fb1ecfddd9e860fe0a06354d82afbedae4be5720a537663","contracts/profiles/participant-control/teaching-influence-rev1.json":"sha256:9340e1b714f7125901c97744b18c40315fa85eedcb535c50ca151d31da2f0000","contracts/profiles/participant-information-reconstruction/occurrence-prefix-evidence-v1.json":"sha256:f0f1bc32c42e270c66384a8c8eff377b5555285e36a796ce2bf8e2aa5a2e80df","contracts/profiles/random-stream/blake3-xof-participant-v1.json":"sha256:fa9c4dc98a3a9d5019b308ed117eefad105bdc52fde8eae11d67dd471ec461be","contracts/profiles/random-stream/blake3-xof-v1.json":"sha256:6c1c0dd010ab629d375f6200854ad1e5de5d715b91e0179366f9a5d3bca66b18","contracts/profiles/scientific-completeness/delivery-assessment-2026-07-12.json":"sha256:cf059e8d77f6ed1d1e702c30e90d113abedef5e7454670afae1483e58d026521","contracts/profiles/scientific-completeness/scientific-scenario-completeness-rev1.json":"sha256:c184e266a904093b658d8fd93d1a4245bb955604b38808328304bc4d4a81c894","contracts/profiles/semantic-comparison/reference-v1.json":"sha256:ff05abea4b817c2327e6d54cdee90682c76b6cc3ca2ddae4dea8e3b302dc4424","contracts/profiles/semantic-comparison/reference-v2.json":"sha256:356766abcc5c21652313f2536804908cb39cb0e3684247a5c603393dd31d2ad9","contracts/profiles/semantic/reference-stack-v1.json":"sha256:91ccd35eba0e7abb102e80ff14afdabf8fc071887c824c02984d564c1eab3925","contracts/profiles/validation/validation-profile-catalog-v1.json":"sha256:286201ec94c4de992a90c898e59da48c017df380d056f37bd3edf20ee1b02835","contracts/provenance/sdl-lineage-ledger-v1.json":"sha256:5f1731f1ddde34108d0d253a2363a85fac19b36d4f0797c866cd60b44d71b939","contracts/provenance/sdl-lineage-ledger-v2.json":"sha256:a59d7daa699690786c7857551fce552c66b4ed79739bccfce13c3584240e0885","contracts/realization-envelopes/libvirt-qemu/generic-v1.json":"sha256:e71b710d2ee25eb866b21492898899e1db1ae058ea69f0d803892b8ed756bcc3","contracts/realization-envelopes/libvirt-qemu/guest-certified-appliance-v1.json":"sha256:ad4aacd91ad0ebb5093726938be07274a6e9fa28b61bf850d4b3e9d866bbed98","contracts/realization-envelopes/libvirt-qemu/techvault-appliance-v1.json":"sha256:0e316253108bb64a4ab1ded4726eec38f9671c06c0c26b65ad5b954a4fcc0000","contracts/realization-envelopes/reference-emulation/in-process-v1.json":"sha256:6b6b2d637e2ffad70e480ae2e825c23d7f6ae930c9e0eaaeb29219a8e26ab90b","contracts/realization-envelopes/reference-emulation/oci-container-v1.json":"sha256:1d3aa97a25b4e7301694313ff807d0e4e885058f5e839a86c832edbe7de146e0","contracts/schema-publication-manifest.json":"sha256:bf9abb74764f8d4ebc3cc543c39bafbd882d4289f79f0114e345ae0da6b88ffd","contracts/schema-publication/entries/admitted-trial-plan-v1.json":"sha256:af978bb101349e9cb4d24e404baf0ecdd5627707e3632008d0844fa139d3f2d7","contracts/schema-publication/entries/artifact-requirement-v1.json":"sha256:4c3a3bfdac32bfd7921393ce5ac383191eb20235a6c0ee76e8381f286001099c","contracts/schema-publication/entries/artifact-transformation-report-v1.json":"sha256:126c2cb1bb23caa3711832f0db221a56939b4cf7667d19a21e5bf96eab29ee7e","contracts/schema-publication/entries/associated-artifact-manifest-v1.json":"sha256:64c0680a926f74df20114f1bb0fa4b00cb40b097e39e0d8d34a724ada835b1e7","contracts/schema-publication/entries/atlas-tactics-source-v1.json":"sha256:fc8ad9e7990385153aaa209f6e71a07f3aaffdbf75399f6de06b86315b195fbb","contracts/schema-publication/entries/attack-enterprise-tactics-source-v1.json":"sha256:792834b288977094e0f5f544c9ecdf1f08a8a180ce74a422407a992b84e81fca","contracts/schema-publication/entries/authoring-adapter-comparison-v1.json":"sha256:0767d14fac1eb0f5b8431f3c964b6bf79be3d2bf1cb8bdc0224e216f8944425d","contracts/schema-publication/entries/authoring-adapter-profile-v1.json":"sha256:5615cf80cf41c5671b80d6cd799e35fe29cdc59429cc02a118d5bd49807c243b","contracts/schema-publication/entries/authoring-adapter-vector-v1.json":"sha256:5b045b149ec6e866c2929bd804809a49a8e5d651986396d65e51405704848ab3","contracts/schema-publication/entries/backend-augmentation-scope-v1.json":"sha256:abb7921d5818eac43ac256f63f54f011bbd377e9b7c99bab68fe07efdb6b6579","contracts/schema-publication/entries/backend-manifest-v2.json":"sha256:b52b3175502a3a0ffcbe3b16da0f6285dff67b817f425a875191d370e84320d0","contracts/schema-publication/entries/backend-materialization-attestation-v1.json":"sha256:e834b9527600af2c7a9c82c98538ea566797fc342437f2802625cc39a241bb83","contracts/schema-publication/entries/backend-operation-capabilities-v1.json":"sha256:4f77ff39eef3ed369427f91feaa1ad176d9539b8029d27532dd8e7b7f5997bad","contracts/schema-publication/entries/backend-operation-control-v1.json":"sha256:c64575b05c27a94eb917030d3d05ff87acec8775fa77195c574714751976f0c1","contracts/schema-publication/entries/backend-operation-request-v1.json":"sha256:69633fbc3bec2baa449232fab37987f140382ad329c39e884ba936c02b88d3a5","contracts/schema-publication/entries/backend-operation-response-v1.json":"sha256:08fb74fcaa63a8f9c6c02cba5b6bcb1498e4283a61e4c9068dd904a98fe20c74","contracts/schema-publication/entries/backend-profile-v1.json":"sha256:c097f4c9438a110f6ed997da2889195573add1dc826d872a78d1b25e9e9cc458","contracts/schema-publication/entries/backend-realization-preparation-v1.json":"sha256:c197ecf57ca1f59afea114b953d17d24ed1f3308c0958190ffb1fe169a272a31","contracts/schema-publication/entries/backend-runtime-descendants-v1.json":"sha256:f87ec2462a2b948f31ca77689ec96fe24e82ffa84af0aff9ea58e4bab9c8242b","contracts/schema-publication/entries/batch-execution-receipt-v1.json":"sha256:d5d86208fe7b9947a5a487f9a2952ca4bf14b323988e40e254e386a675dff5ae","contracts/schema-publication/entries/behavioral-relation-profile-v1.json":"sha256:8dcfb822921734481825fc058fa583f453fa09506b09c324dad70a7be5023bda","contracts/schema-publication/entries/behavioral-relations-v1.json":"sha256:b86c3428c3c7bde54003f956179cbfed60fa7eadf6dadca9820b25defe47b52b","contracts/schema-publication/entries/concept-families-v1.json":"sha256:a2919b3abf1c4fa3d1984a2b0207373f33ca434a75dc8b07b3d0388639a68673","contracts/schema-publication/entries/controlled-vocabularies-v1.json":"sha256:03d46a971275961cecaeff4ca23aef38f02fa53353e956e33f0a1c4cc5a52595","contracts/schema-publication/entries/domain-profile-admission-policy-v1.json":"sha256:5c726e9a321c9efb913674f04e6ffc236f04b731ee6421501bf7c358feba332e","contracts/schema-publication/entries/domain-profile-binding-v1.json":"sha256:57c741a9e8737c4f5f327f283c3f7ad20902772f32e8b9594dba0bfa05a176d4","contracts/schema-publication/entries/domain-profile-definition-v1.json":"sha256:1bd7ff67cf6c0cf45cec4fb2670878e9b340f57ee789a862d14c08f44ccf0c99","contracts/schema-publication/entries/domain-profile-resolution-context-v1.json":"sha256:3a91485030221068035ba265aef2f9577c9f9f998e4af22b32543b725a050227","contracts/schema-publication/entries/domain-profile-support-declaration-v1.json":"sha256:249376ea2d7f9a081669ed409328e5cae6960ab2a0ad15294ddbcfb0e950c6fa","contracts/schema-publication/entries/evaluation-history-event-stream-v1.json":"sha256:71fdd19c3e0e04f13590697398a54329c3a2e00940df6ffa24485e337e9d6f11","contracts/schema-publication/entries/evaluation-plan-v1.json":"sha256:38a01ae48f301487d1081fab053ac20db026f46caf060acd7e796dc2f409eac3","contracts/schema-publication/entries/evaluation-result-envelope-v1.json":"sha256:5a89854982512f510b5d982671424fa69f3fadc1129015281f3df9c57f2134fb","contracts/schema-publication/entries/experiment-apparatus-context-v1.json":"sha256:afbd713fb0f6f102ab6c1df77671cee0a6c24dcc02dfb8a8a42f54ad4e7327d3","contracts/schema-publication/entries/experiment-authoring-input-v1.json":"sha256:57313040b786598f80caf4a3bdbb963cc440702c530509e8f814946679435041","contracts/schema-publication/entries/experiment-binding-descriptors-v1.json":"sha256:950d0918c5e6503dcaf2f6b1e37fe8e21bd21c02060781110a799564af603933","contracts/schema-publication/entries/experiment-capture-spec-v1.json":"sha256:f338b4aa2fa36ce338c93cab22881d2074147db0845e2463308d24b566752957","contracts/schema-publication/entries/experiment-derived-measure-v1.json":"sha256:1f3f133e78e2099648b3fb0f937cc43c796f765654b74eb63b4368d301fc9745","contracts/schema-publication/entries/experiment-evidence-record-v1.json":"sha256:0e4dfb5f5f0698981a76999b0eaffd2ba062ee9139c10448933712e5bd9e104c","contracts/schema-publication/entries/experiment-run-v1.json":"sha256:f69288bf90a5d83437dcb42a35efe6a4bb0c8cb76ad6310dac5805b0e5260558","contracts/schema-publication/entries/experiment-study-v1.json":"sha256:408d98a0df0ef601fad14455636298c3da2b32cd927ba8e0a177ab4367970ac5","contracts/schema-publication/entries/experiment-task-v1.json":"sha256:ecd3b5513a076ec5c9d9a554d0e2afd6492549bc3b3888bb2650850c6fc3dddb","contracts/schema-publication/entries/exploit-path-analysis-evidence-v1.json":"sha256:3d233337b3331a1f6c252c21f2aeed8d107e8d1e9a66d3fd9e019157765d757f","contracts/schema-publication/entries/external-concept-bindings-v1.json":"sha256:26bdb70b7cfddfd7c75b99d95e9a5667c675a829e063635907f70737823f503d","contracts/schema-publication/entries/fipa-communicative-acts-source-v1.json":"sha256:d07fd19ba54d552b8a3a62126a2a696477eac8572d928f92304283a86a26ca3f","contracts/schema-publication/entries/inject-occurrence-correlation-v1.json":"sha256:815fd9a6e4e0b680da6e1b695c48ca801a9cca35c895b76f4edb1455dd7a88bb","contracts/schema-publication/entries/inject-occurrence-outcome-v1.json":"sha256:176e6561d92837b95590e729cb39266830109c7ccd2ebb7a67a65bb974d7718b","contracts/schema-publication/entries/inject-occurrence-v1.json":"sha256:1cd5e29bc7bc19c2216edd757d3c6313fff16dfc2a7a39f2c53f12263df55000","contracts/schema-publication/entries/inject-trigger-request-v1.json":"sha256:16f50be3d7d1b18b46136164b6d70590db09cc498205df3dfabec5395289129e","contracts/schema-publication/entries/instantiated-scenario-snapshot-v1.json":"sha256:197accde46f23eea250ab826efa4d99dd73fd376bdf468d472e2c2c1eb7764ac","contracts/schema-publication/entries/instantiated-scenario-v1.json":"sha256:674e93f6eeab969d079416e5c16d590e6490ab59f0760ec8d3a08e12bc3da857","contracts/schema-publication/entries/materialization-archive-record-v1.json":"sha256:4c5175698b5a8924702fbe0cbe4024fe99e38422340b13e3c82c1e922cd5483b","contracts/schema-publication/entries/materialized-scenario-v1.json":"sha256:4d2a9e1795403dec7e926a32943a5f5c4ecd75b7aec424db6c3ed1affc514f22","contracts/schema-publication/entries/mixed-backend-execution-binding-v1.json":"sha256:f14ffec2ce1ce2114c54ebcd5987ce7617390f93356b2afb50bd14ba9b3bfc2b","contracts/schema-publication/entries/mixed-backend-stage-report-v1.json":"sha256:9cfddf215981621b2cb30ad1b8f69f738ab7c9c895f7f1f807e6a7903f2bdae6","contracts/schema-publication/entries/mixed-participant-composition-profile-v1.json":"sha256:c969f8fb9cf7392cebc3adedfe33a4228c3f7eb49a3211cd60f064a4f70e9bce","contracts/schema-publication/entries/nist-csf-defensive-categories-source-v1.json":"sha256:edb2429d0cc9f9341f41942c8805faaefe5f0e7a5810fa2de090ed43ba43038f","contracts/schema-publication/entries/observation-demand-v1.json":"sha256:d8fbcfa34f75339181115272ca19c620a12f03807e776265f0d56b8b3be7f61d","contracts/schema-publication/entries/operation-receipt-v1.json":"sha256:48d39f3cee9cedd7c3fa6b5196c43c71da1097df684a4467f2c8141a8e5395cf","contracts/schema-publication/entries/operation-status-v1.json":"sha256:a6bab6f54bcaa3fbc7bdca439ba547e37e10b2177abfac25865ba5cde52ac4a6","contracts/schema-publication/entries/orchestration-plan-v1.json":"sha256:b0d29486c877966bca035876a1c2544d48224fdab69141b45d7a47410c8dc60f","contracts/schema-publication/entries/participant-behavior-history-event-stream-v1.json":"sha256:b8fe97e03f9befcbc9afcf945dec34b007c5fe11c6184b35cd744ce4f58b2405","contracts/schema-publication/entries/participant-boundary-flow-policy-v1.json":"sha256:879ad3d1b73c7cfa1634972cc5a0a6353d5d78e480a1319911298d0d3681331f","contracts/schema-publication/entries/participant-configuration-result-v1.json":"sha256:d58d30f28a9ebeddc93e171189a65cf0fb79298c157466c8412502280f524e2f","contracts/schema-publication/entries/participant-context-view-v1.json":"sha256:a3689b5b91246721d34d22ee23fec82e7c39e06246dcc129fb235b5411f85cb5","contracts/schema-publication/entries/participant-control-context-asset-v1.json":"sha256:dff07087bd8ba22a0c141eab16addb9da55c1d9485fa0f87beadea5ea0c271bc","contracts/schema-publication/entries/participant-control-context-change-v1.json":"sha256:67c56f0badf58b734c0df90be25f68130a81a207abb89e8fd01313043fd6b1fc","contracts/schema-publication/entries/participant-control-context-record-v1.json":"sha256:607031b5dfb4a14b60b4d19b0a98a6ff27ed9dbde9d5b7eebb4b966e34475f16","contracts/schema-publication/entries/participant-control-evaluation-v1.json":"sha256:1ad1cc2c1fb4f76aa61791b0272a617aa0ed504ebf3a2369bd40ef3fb46eebb7","contracts/schema-publication/entries/participant-control-evaluation-v2.json":"sha256:178987fbb3fd3e1a436f585373b4746aa18630cbe1787c8d53a29a0bf6f1058c","contracts/schema-publication/entries/participant-control-occurrence-v1.json":"sha256:dde057125687d502f055dfb01aa38ffb2f22794531b3cf2bc678781b8f782056","contracts/schema-publication/entries/participant-control-occurrence-v2.json":"sha256:69a6b513b62bf28dd6c231f5b830f0178fdf636e083fda1ba184d4dbbb06534d","contracts/schema-publication/entries/participant-control-selection-v1.json":"sha256:c586b294c862e5ec1ec299baf93c42dd805cb46772aa51523800407f14f81969","contracts/schema-publication/entries/participant-control-selection-v2.json":"sha256:74a6a84b4d57d1424e9621576b98dd2593424045aeea81cbc8eb13496ae9141f","contracts/schema-publication/entries/participant-control-teaching-profile-v1.json":"sha256:663c24e3e93edf6907180bed2268e5feec402d832859b731fd90601714c4f404","contracts/schema-publication/entries/participant-crossing-occurrence-v1.json":"sha256:80fa7695219bd20b7e796feabdaa40f639ce951a95aeb8f9b31e14fcb3f0f20a","contracts/schema-publication/entries/participant-decision-surface-v1.json":"sha256:d3a124d2770db46a3bc4be40268349f14092170ad345b72d6d0c45a300d8fe1d","contracts/schema-publication/entries/participant-decision-surface-v2.json":"sha256:3e028ee67fe85c26945663941f766835e7e7f9441bfdbbe2f83f939af2effaba","contracts/schema-publication/entries/participant-episode-history-event-stream-v1.json":"sha256:bd29fa7e0cde756acd07021c76247a9b9d39a5dd89262a8e617f74e1aab4ffa9","contracts/schema-publication/entries/participant-episode-state-envelope-v1.json":"sha256:3e7eb5fa879fa23d917e714f230a56f3ebe6ac941de8237b00bb46a6fe69439b","contracts/schema-publication/entries/participant-execution-binding-v1.json":"sha256:820577743d493af5bb95b243a6f793a1e45bded0547d24c1bcf18bbc89c214aa","contracts/schema-publication/entries/participant-execution-control-v1.json":"sha256:7919ed81e316a8230d3a0aa6d1787c9392addeced1943f981a1c9ab8f1489499","contracts/schema-publication/entries/participant-execution-service-state-v1.json":"sha256:3dd86deb35c609bac7cdf7687d2b65649e21cd8e0817d285eeed2a1c0b65115a","contracts/schema-publication/entries/participant-flow-control-relation-v1.json":"sha256:e21f6700efb9794b07bf3d9ac0a668d5bfe3a49ad309f4700a03e05707795fdc","contracts/schema-publication/entries/participant-history-view-v1.json":"sha256:277fdac42197ca6d0e4bf8dc459809ebc99dc417c83e6b85a3420bbdcf24f629","contracts/schema-publication/entries/participant-implementation-manifest-v1.json":"sha256:52e82e92f8f29d273dabeac1fd424c53d1d99c0c609e6088af26a1be515ea100","contracts/schema-publication/entries/participant-implementation-provenance-v1.json":"sha256:a2bf06af6366c54016dcc32b6006a47e95bdc6900cee5ce3c102c720134979f3","contracts/schema-publication/entries/participant-information-reconstruction-profile-v1.json":"sha256:3fc45e48b8c18c35d3ec43d4cb60df7a1689890c695016a308288dcde24718fb","contracts/schema-publication/entries/participant-information-state-record-v1.json":"sha256:666b92b7a735db3c0db16d403d6721c7428ac89815c5e96daa363fcf9666ead5","contracts/schema-publication/entries/participant-inject-application-v1.json":"sha256:2471922687449a7f6adc628e6a38f978eb0a8209c2b303d6b7bdc33f22979ced","contracts/schema-publication/entries/participant-inject-delivery-receipt-v1.json":"sha256:6025080e1ab40343a39d356b3af42d57dbb5d403db41b9574f5bc3594fdf188b","contracts/schema-publication/entries/participant-inject-delivery-v1.json":"sha256:45f9af0c11429cc0f532b70240fc13325f8c7ec4a3810d6f429d7189c773c904","contracts/schema-publication/entries/participant-joint-action-record-v1.json":"sha256:81553f8afb17b456274ad5e19ebbd3c8412c463f6831c6c40fca9a91f75e4131","contracts/schema-publication/entries/participant-lifecycle-event-v1.json":"sha256:b039810541fb40490d7622175ad873902d2fd01e62f9439a813d8df4d5783807","contracts/schema-publication/entries/participant-observation-envelope-v1.json":"sha256:cf473a6e14c44142833a534c4354eeaacf3c8595e311b6e7011b2c6a9e587521","contracts/schema-publication/entries/participant-opacity-analysis-evidence-v1.json":"sha256:ae3dc97cc645cebad089d36603f3d1f78ef51ff9d242a80c8581e8b2403dc722","contracts/schema-publication/entries/participant-opacity-analysis-input-v1.json":"sha256:42268d2c3d3a01d39266c8d9beb6275611d685ae10c95c49b18ae9e6ac643991","contracts/schema-publication/entries/participant-opacity-model-check-evidence-v1.json":"sha256:114d85a5e405868b6990c02ccc7399195f740d1081aa50224088ce7850eb0a6d","contracts/schema-publication/entries/participant-opacity-model-check-input-v1.json":"sha256:d71ac6964452e6564ec248a060d07e79b5b80628482b29fa5e5fa0e2a986f88f","contracts/schema-publication/entries/participant-outcome-report-v1.json":"sha256:7506563f4b9920461d40f1bf806c76b535967a9f100792dcd78638b61920cdc7","contracts/schema-publication/entries/participant-outcome-report-v2.json":"sha256:0852338a4b882fcbba72c9623842373e577f0845c3fe36754095b943ffb69add","contracts/schema-publication/entries/participant-owner-flow-policy-v1.json":"sha256:53b4f9b2c74ba361ddfcf30aa3c792ed9437010a02101c9cfd33ff9e7d96aac8","contracts/schema-publication/entries/participant-resource-budget-event-v1.json":"sha256:92389f4ae793c8a4a8ed53fd228b455b06271a965020fba2b029a97101258616","contracts/schema-publication/entries/participant-resource-budget-policy-v1.json":"sha256:a6ba2240798b85c9d4f6ab0dac804262e5348b085d7b2b61416a08fec2fe1f90","contracts/schema-publication/entries/participant-resource-budget-state-v1.json":"sha256:cdc22fb057020b3b30425b4ee9726364108ecd7bd0217aae23afcc02b839dc9a","contracts/schema-publication/entries/participant-resource-pool-capacity-v1.json":"sha256:b568f7ca8f13ba94a18eabe53318f580f56bfd7e86359a1d2bbf47516d82e058","contracts/schema-publication/entries/participant-shared-state-record-v1.json":"sha256:956465d34f8d0dcb05309370762baf918016138522551523c4e121ed000a3a31","contracts/schema-publication/entries/participant-status-view-v1.json":"sha256:8616c3c9cc4d3745c50098bfdbfa8be8922cfb55a3eed67f69ec95b50563b2fd","contracts/schema-publication/entries/participant-time-management-context-v1.json":"sha256:65a9b6237938f5bebd9026d2da6f71ea0318339632a85dcec41ba0845d2fc380","contracts/schema-publication/entries/plan-realization-profiles-v1.json":"sha256:0816f88b42cb0828c266a7b9319da435d8548c5713f3769c075696ff17acef47","contracts/schema-publication/entries/processor-manifest-v2.json":"sha256:ba5869219664f809cd21d5991445c13ce01083870d7d8df56816993b3e7b2a6e","contracts/schema-publication/entries/proposition-truth-result-v1.json":"sha256:e4eb4a0ef6149a272c6d8ee960d3aba27fd01a2f8ba26b0c098e19eb3e59a729","contracts/schema-publication/entries/provisioning-plan-v1.json":"sha256:14220dd38d3d12cafea12433210299b666bc72e35e9d02ae5866a25f19f2b555","contracts/schema-publication/entries/raes-semantic-invariants-v1.json":"sha256:55f345328e8a28c5b513aa1d8a9666ed8a4cb96d110a4678f817a1e8ea3a2cd6","contracts/schema-publication/entries/random-stream-profile-v1.json":"sha256:b00a485dd0c449479fef978aff94951648de537bc5482f90ecf618330bbdf696","contracts/schema-publication/entries/random-stream-vector-v1.json":"sha256:fd5db977ffbb992a03d42ba2fa43cffce49125907fc1beab9a377b06e5498848","contracts/schema-publication/entries/realization-envelope-v1.json":"sha256:9c8869c728c37c5e60f8e87c71c31b1c776dc76f5f92de3aae10a1dcd03e4522","contracts/schema-publication/entries/realized-time-model-v1.json":"sha256:3d1d9bcaec1de7350489edb94bb7d4fdc0c846e8532bd02227be30a29210933f","contracts/schema-publication/entries/recursive-realization-constraint-v1.json":"sha256:5423bb39a3ae47d0aa786042a452c778422497833bb3dcf1f9ea86a94e75ee48","contracts/schema-publication/entries/reference-models-v1.json":"sha256:6f54401952858c89c0b0f1ff3e7f7d94324ae985221290ac9cb3c9e8ca714193","contracts/schema-publication/entries/reusable-asset-trust-policy-v1.json":"sha256:5aebbecd83abe1dbc9c90cc59269555e8b3973e1fbbc56e805d06585733caebb","contracts/schema-publication/entries/runtime-fact-binding-plane-v1.json":"sha256:225b0916bce5853cc22d286476fd8b2d00f03dd4e1b707aee4929a8cd63a891a","contracts/schema-publication/entries/runtime-snapshot-v1.json":"sha256:5d05a55cf4e04c73745ba48923f6b507cc7ceeb0d5fda8aeb48065a26449d2bd","contracts/schema-publication/entries/scenario-instantiation-request-v1.json":"sha256:c8197d654b52c88e669bed6afbe10cbf2a6c2e1707870207234953ec72d6b88f","contracts/schema-publication/entries/scenario-satisfiability-evidence-v1.json":"sha256:24854446f7da5f5b0fee89e38e7d269bc81cfc54926ae2e9fd36b88d50427bc9","contracts/schema-publication/entries/scheduler-isolation-proof-v1.json":"sha256:94871e39b54455fd8e279ca6031679610b4cdfa1917756c59a2744afe721d50f","contracts/schema-publication/entries/scientific-completeness-assessment-v1.json":"sha256:490a7b837e1428be1b5d435bc67545e742343f050d89ce5d2ac879f473cef26a","contracts/schema-publication/entries/scientific-completeness-taxonomy-v1.json":"sha256:408e706b6bf077104d0659b6479f464639670532c493e748d0640d84774af0aa","contracts/schema-publication/entries/sdl-authoring-input-v1.json":"sha256:78df8b2458dd052d32a48660cab2348962a1d64ce4926dfb131c564219d9d5bc","contracts/schema-publication/entries/sdl-candidate-synthesis-input-v1.json":"sha256:27fb29384e2d5e5e0c48365999542e00e80688462669c5a53af23fe2c4170254","contracts/schema-publication/entries/sdl-candidate-synthesis-profile-v1.json":"sha256:a9b217b49b31c30a35851988641e0a568f383713e76367de51b53944755638c8","contracts/schema-publication/entries/sdl-candidate-synthesis-record-v1.json":"sha256:5bc5fbf27e3c8cd32f125471ffdc01c3f0f960a612e285dba943e733ada88996","contracts/schema-publication/entries/sdl-lineage-ledger-v1.json":"sha256:ff20b89375a7fbc00513156d366e3c69aa04bea822acc37420b113eddabbc9cf","contracts/schema-publication/entries/sdl-semantic-migration-context-v1.json":"sha256:8c2cf2d4ef097ca4fee98529a89980592c63d6dfeb04f5aca1b47d30be3db844","contracts/schema-publication/entries/semantic-comparison-request-v1.json":"sha256:db959c624054830b677d7e709abfe27ef4528c8a8c1ea23e5caa95f945f52cdd","contracts/schema-publication/entries/semantic-comparison-result-v1.json":"sha256:b4573e4dcf4eedeaa7d6928a93ed5fda8854c4d5ac633e3e984c980727e02082","contracts/schema-publication/entries/semantic-profile-v1.json":"sha256:8a41c4b8479dcb3e9ca0efb1dd64c870ff0b4b2a2539380b1acc5127e2c0a011","contracts/schema-publication/entries/semantic-projection-report-v1.json":"sha256:6b1a48907a465c1aa40bb0b188845ffa62a3e8ce364fbc75de97ddfb57c9f492","contracts/schema-publication/entries/time-model-v1.json":"sha256:518b9eb7bdbe66bda073917601cd5956d141e72703d594813307b3b971f2d21e","contracts/schema-publication/entries/time-runtime-state-v1.json":"sha256:4f9a4ff73e91e2a2684c814eea68cddef9648fbde7cd3a2623eae91ed609f414","contracts/schema-publication/entries/trial-cleanup-plan-v1.json":"sha256:5268e5d25801ee159577b9e9f19f4991d6702d6a8b27cc06ed291cff3b09bcc9","contracts/schema-publication/entries/trial-cleanup-receipt-v1.json":"sha256:0037d347d2010cd21eff9f352d334bcdd30e6b5226e4a9bac680961df1df68a3","contracts/schema-publication/entries/uco-alignment-v1.json":"sha256:7b9e5c2b37fab78134b538e304e26d588e7b22e7244b2c90099ed8120b3ce9d3","contracts/schema-publication/entries/validation-basis-disclosure-v1.json":"sha256:d423a97336e9039a689ad63e0a07fea70b139d9b8a5a19c2d7f50230c33cf77a","contracts/schema-publication/entries/validation-profile-catalog-v1.json":"sha256:f299686bcd744eeffe257adffce6e4b89113fd97408640770be40e8c71e11c9c","contracts/schema-publication/entries/w3c-activitystreams-activity-types-source-v1.json":"sha256:098b47bf0a798ff10dc60d6540b78b2248be089778359f399561c75686a662b3","contracts/schema-publication/entries/workflow-cancellation-request-v1.json":"sha256:7c050fb97f7c62898dc52f18af71950ed622c226df211021ba84e7f5874e5d8f","contracts/schema-publication/entries/workflow-history-event-stream-v1.json":"sha256:f9ddb59826a64410fea4b36bc6b6008f2809567d6a54ed8c14985f1cef47cc49","contracts/schema-publication/entries/workflow-result-envelope-v1.json":"sha256:48c737007b43778e469e84b10aa25be49dc47497c67c06f547cc1fec08c655b6","contracts/schemas/artifact-requirements/artifact-requirement-v1.json":"sha256:0c32d4940a1eda855e58f1053ea734dc72fea91b3d54eb3cc83b9af99bb5f771","contracts/schemas/artifact-transformations/artifact-transformation-report-v1.json":"sha256:a4859c3c0ddfb0125ece97a3bce392c7d6ea0c5af8269477edcb3d484d084691","contracts/schemas/asset-trust/reusable-asset-trust-policy-v1.json":"sha256:0255ffbe60a685d9a7d340db31330e023f98fb667c37af44ce441fe90eeba2da","contracts/schemas/associated-artifacts/associated-artifact-manifest-v1.json":"sha256:6af54561be2e3dcf1f29f73905c41220d866af747bb142dd4eab3e340b51414e","contracts/schemas/authoring-adapters/authoring-adapter-comparison-v1.json":"sha256:5392048d78173ec6ad58b8b865434b3f88495905b4f71b496952d40347236b5e","contracts/schemas/authoring-adapters/authoring-adapter-profile-v1.json":"sha256:16be670b2649e0cfce2fa7d4d5d4ffc2426781a389cb05286b25d5cf23ab7942","contracts/schemas/authoring-adapters/authoring-adapter-vector-v1.json":"sha256:393c81076f14ff4bee7bd86639eb55d37ae40ede531267611f81c6d41c036335","contracts/schemas/backend-manifest/backend-manifest-v2.json":"sha256:3881998c0fc37081d73b552249ebf26601c71bf9fa8e0e3a3faa263d5d3b2683","contracts/schemas/candidate-synthesis/sdl-candidate-synthesis-input-v1.json":"sha256:0c785fc0e23fd2c592c9ebb757318fa8a10039e96c5ca5a934cf38f459995dfb","contracts/schemas/candidate-synthesis/sdl-candidate-synthesis-profile-v1.json":"sha256:c8a445e61a6b8d6e20215ffe4b0311556fbfdc2f098c3ac31492509f043eb26f","contracts/schemas/candidate-synthesis/sdl-candidate-synthesis-record-v1.json":"sha256:92b761cd131f633f8926b74c12dadc245e99cd687e913e5d52d6df9f4afe44a6","contracts/schemas/concept-authority/atlas-tactics-source-v1.json":"sha256:15262896f548e3b1f500be6132a225b26711c31d52ed931b821148425ec918ff","contracts/schemas/concept-authority/attack-enterprise-tactics-source-v1.json":"sha256:ce1a42b5f70f9929a134eafa786f048d6f7f07dc3ff47e4fbeccbfd8b3f00d0b","contracts/schemas/concept-authority/behavioral-relations-v1.json":"sha256:c5430e82488e3f4356b5b13973512254183ec9ae31ff2ea82febe0ac49476260","contracts/schemas/concept-authority/concept-families-v1.json":"sha256:6333365aa1cbd21ff57f42ae109bfd01abf5863927552235d671cf13812fd902","contracts/schemas/concept-authority/controlled-vocabularies-v1.json":"sha256:31d6b345bd37ec4ef999556723358d5b34732d10a518e77c7849887d6c673240","contracts/schemas/concept-authority/external-concept-bindings-v1.json":"sha256:ea897768581996d1e870f73011049e6269616994c4fc87b7708a8604ee953dcb","contracts/schemas/concept-authority/fipa-communicative-acts-source-v1.json":"sha256:f5c592d6c40e29db3176e7aff7b753a9346482edecabb875c6d3d04e5ae7ad5c","contracts/schemas/concept-authority/nist-csf-defensive-categories-source-v1.json":"sha256:5334e59a81079122f68df2983a684de38033d333f2944859f83b1a875da0825a","contracts/schemas/concept-authority/reference-models-v1.json":"sha256:e880b422a6fedbe2355772df3e6522ec532a65afb4ea6a8449bfef8dfe7dccb5","contracts/schemas/concept-authority/semantic-projection-report-v1.json":"sha256:f21eae7e5c8fb1241dd38abc0d462d9ded158f74aa7bedbd4bf5a3b514a219f7","contracts/schemas/concept-authority/uco-alignment-v1.json":"sha256:103b9f9d8ad2f87f5b2a9a525cb122b2973a037bc1716001d286169b0f0617c7","contracts/schemas/concept-authority/w3c-activitystreams-activity-types-source-v1.json":"sha256:3fd62271e7a73fc01e2e8e0ba7b7595b1b8bc035c7620729f1e7933acbde64f3","contracts/schemas/control-plane/backend-operation-capabilities-v1.json":"sha256:098e5de7ad9be6cd2d4c09c0ff092ce132a4a0bf994d01d09583557088222d91","contracts/schemas/control-plane/backend-operation-control-v1.json":"sha256:4223fa7a2feea4bc0a7d3fa9d0865fadee681aab765b4c50250f296cf5f04366","contracts/schemas/control-plane/backend-operation-request-v1.json":"sha256:4cb34743a58c53b609d6a1ad66ddefbe9b6a3f92d66c65684e58c25ba372f93f","contracts/schemas/control-plane/backend-operation-response-v1.json":"sha256:6330117ee4ee28225468e7c5b7b09b06461f5aa45a95b6ca63d2988ef3d56239","contracts/schemas/control-plane/batch-execution-receipt-v1.json":"sha256:63211695fbaccd49e4eaf57f6892d6ab8025a37f2ab7ca44f91af6566a485b2e","contracts/schemas/control-plane/evaluation-history-event-stream-v1.json":"sha256:5ce410057f18bf90ff3428f5b1094d5376fbfeec99e0043dcbbb368b7d7567a6","contracts/schemas/control-plane/evaluation-result-envelope-v1.json":"sha256:0a0896d47175362c17ef17446ded10cef52d54e319d19fa525d7d5e08c5253b3","contracts/schemas/control-plane/inject-occurrence-correlation-v1.json":"sha256:a959aea3f9c3d1e7a05ea2e1cbef7208d5fd67c74171904138a771b8c88bf444","contracts/schemas/control-plane/inject-occurrence-outcome-v1.json":"sha256:fe4abfdca26bb2caeb7c3d85c93298e35691121a13a005d47dd46c8b2a0fdd35","contracts/schemas/control-plane/inject-occurrence-v1.json":"sha256:b1dc09bad86a3f8a81df2ac4ec25130cb3cc6ab65987da9c42daa557705495b0","contracts/schemas/control-plane/inject-trigger-request-v1.json":"sha256:1d8ace098425edf41d096c728d3dd520e4fb48d357af33e1459eb6c6cf6f0a49","contracts/schemas/control-plane/mixed-backend-execution-binding-v1.json":"sha256:c9a25d05e6a9987266ee7a16a22a1dcc29e940077d959e36e02ae10a11290318","contracts/schemas/control-plane/mixed-backend-stage-report-v1.json":"sha256:0a22b986550436624b6702203970c81a28f2522fb5121375215c544f583a43f5","contracts/schemas/control-plane/observation-demand-v1.json":"sha256:07fa75d05c0a36e632d4dbf9e03df703b9f84ea68c2888d7321784ab9cd8ba6d","contracts/schemas/control-plane/operation-receipt-v1.json":"sha256:4feae9797cfd5ea3b532c8961ee05ab517056dbcd3f844e3493d6a0245c1a8a9","contracts/schemas/control-plane/operation-status-v1.json":"sha256:09af6616525b08667ff0e972f0a175999a769b5e95e849b5fbc7b8a2246fbbac","contracts/schemas/control-plane/participant-behavior-history-event-stream-v1.json":"sha256:3828e6d20289b8b36426748780df47bedcef4ab8d0516e3cd9e8154d0537b874","contracts/schemas/control-plane/participant-context-view-v1.json":"sha256:841b1d2e773fe1f2ba372352e7f6aa9466b60eb25b305be7295ab9249fbc384d","contracts/schemas/control-plane/participant-decision-surface-v1.json":"sha256:8a949ad1c4e2dede407a5ae725aab7ee7b0a065a4f660c81dd827b8290b581a5","contracts/schemas/control-plane/participant-decision-surface-v2.json":"sha256:9490946649c4ceada123502aa73509eefe9192d1f6222436d34022bc52ab58d5","contracts/schemas/control-plane/participant-episode-history-event-stream-v1.json":"sha256:56b53c9d600d4848c8cb76f9153eb0c59aed4ccaed5cc3631fb3115b113d051e","contracts/schemas/control-plane/participant-episode-state-envelope-v1.json":"sha256:b06ebea5ab2d7f789410d0a24bb3c5acede43f7cfa26a49eda39925e7ab26aee","contracts/schemas/control-plane/participant-history-view-v1.json":"sha256:a64a4d478193641d23a93693b5739efe61a5f30605dd7911eda274e668e55540","contracts/schemas/control-plane/participant-inject-application-v1.json":"sha256:6da00f3eabf6a310081da15c589a74e2edc562873270137b8f5b6897589fc019","contracts/schemas/control-plane/participant-inject-delivery-receipt-v1.json":"sha256:b7d41bce95a2712f46007b78116e438a58c760a0e9bd1cd7c080065b48bb1772","contracts/schemas/control-plane/participant-inject-delivery-v1.json":"sha256:e8cd86dc92a9efef50c5a03e4958f0a061213df54436a277be4929bb4ad91058","contracts/schemas/control-plane/participant-status-view-v1.json":"sha256:e5a336f5df05f71e832d2c903ae3ee4db181809debd6d5de7a328c16b9ea9135","contracts/schemas/control-plane/proposition-truth-result-v1.json":"sha256:4c53eaa80106575390572e5e7fcf7084bd7a19a135bb2f0d89417c403c1ea944","contracts/schemas/control-plane/scheduler-isolation-proof-v1.json":"sha256:eee44392f318526e9dd57f66041549e179bcbb69e17676a1a6af73e3e2c775c3","contracts/schemas/control-plane/trial-cleanup-receipt-v1.json":"sha256:039c2da98243e3ac5bd257ef07a6dd97f77dbf3ba828617325971e27d3df6ffd","contracts/schemas/control-plane/workflow-cancellation-request-v1.json":"sha256:fbb91f3f2f735834ecec83efd84409fbfc958f0a430794ac07399d688e450a39","contracts/schemas/control-plane/workflow-history-event-stream-v1.json":"sha256:10b742d0c67e85f11eb18d1d052802d306cae9d87329313560bb2ede1eed8a14","contracts/schemas/control-plane/workflow-result-envelope-v1.json":"sha256:5bf887c7c61035e91f4b8ada38a60ccac9602f0d3188ca97a072a9e88b2dbeba","contracts/schemas/experiment-core/experiment-apparatus-context-v1.json":"sha256:e4794204741522550b19b473a527dca9f229403954809022a3efaa7396b9ed4b","contracts/schemas/experiment-core/experiment-authoring-input-v1.json":"sha256:a6c36382f4b1fd25282047c736a44eef141f3ecf6ca73b25824e207e19562284","contracts/schemas/experiment-core/experiment-binding-descriptors-v1.json":"sha256:7c0056dc6d82bfa603682f482fc997cb7aa9c34864417be4f43eed47757f6195","contracts/schemas/experiment-core/experiment-capture-spec-v1.json":"sha256:e0ab0006a5fc3f32c72f919a14d7d9abe3cc658e1a99f2308b06a3e83216ee4e","contracts/schemas/experiment-core/experiment-derived-measure-v1.json":"sha256:12374614a96c39a4f09f02c7d5d59d4a83c24d437bcc257aaaae70f73d4c3690","contracts/schemas/experiment-core/experiment-evidence-record-v1.json":"sha256:3ee9d830c024fa9ef05af5a2362867656829e09ae5fd6d3cfa4b69ea615e5b66","contracts/schemas/experiment-core/experiment-run-v1.json":"sha256:ff843475159f9d5ce1f7ff7ecfaf8516dc9481bcbdf707ad46a72ff17006e46d","contracts/schemas/experiment-core/experiment-study-v1.json":"sha256:5784e4a6d1e11a0b2f9508735d2dbe62ed702c117c0a1c096c6ebfa6e07fb409","contracts/schemas/experiment-core/experiment-task-v1.json":"sha256:153b386c65aa96d80e867e4052a3b4e0e1e5f31fdd7a50ca2c8fbe2fb1e76854","contracts/schemas/experiment-core/materialization-archive-record-v1.json":"sha256:64a4dbf3347a7d2294941a534b2e5cacf65f7162dd79a74f955438c086243dcf","contracts/schemas/exploit-path-analysis/exploit-path-analysis-evidence-v1.json":"sha256:5815e7e95fb864c80d29b59979e34ef5c9cb39328a66a62953cc5c9eb2bce394","contracts/schemas/formal-analysis/participant-opacity-analysis-evidence-v1.json":"sha256:fef0c9cd1465cec3a1b0be06113d9b59f097ace35d4b9884bfd2dbdddbbd7263","contracts/schemas/formal-analysis/participant-opacity-analysis-input-v1.json":"sha256:00695d0dd9c8bb8ac8a43b9717548dc085b92f94d06c953490d757b270b5f8f2","contracts/schemas/formal-analysis/participant-opacity-model-check-evidence-v1.json":"sha256:8978f08d49849a6564404465e134393cc73486529029b728db61da00b87e7368","contracts/schemas/formal-analysis/participant-opacity-model-check-input-v1.json":"sha256:ac07f698bdd1b98bf4af77f8e4e62bf913e532f906e046ec0878c7f55b28e5c0","contracts/schemas/participant-implementation-configuration/participant-configuration-result-v1.json":"sha256:2ed083df061ae2d3c44e941fcdd0ccb67268de6e32f50a5a4e1c204309d5bd74","contracts/schemas/participant-implementation-manifest/participant-implementation-manifest-v1.json":"sha256:ec1a51b3e1277743f20b2a917e23d6edb7b384a8fb7c5981d44753aaa89fcee8","contracts/schemas/participant-implementation-provenance/participant-implementation-provenance-v1.json":"sha256:9e9c855ae220963624a019cb12b6e10011994e576e5d4d274aa7b69495312e72","contracts/schemas/participant-runtime/participant-control-context-asset-v1.json":"sha256:239c015de5e42270ccedd9017b4f7fe0140f8f090fecbf63e38dff9e13de3c6b","contracts/schemas/participant-runtime/participant-control-context-change-v1.json":"sha256:161f7f59f4a24cb759516dfca799323658be2285197fd60cf8b2915a94c5ffb4","contracts/schemas/participant-runtime/participant-control-context-record-v1.json":"sha256:21c60ce293e30001446c3fde3db8899e52022a7f83653da9896e1ace07f5de78","contracts/schemas/participant-runtime/participant-control-evaluation-v1.json":"sha256:076a3c3043b77e4cdb16e90a28a0f756053f73feaee6ba9e36aee7b753e31fd0","contracts/schemas/participant-runtime/participant-control-evaluation-v2.json":"sha256:cf55ebb74ab7de6e51d20560ba7241a4267f27243834431d9a0683f1a4f50e29","contracts/schemas/participant-runtime/participant-control-occurrence-v1.json":"sha256:ba8eec010aa89c7bab2e76ae6db5dcc892b948f71c6e8311b7e18eedeffc6483","contracts/schemas/participant-runtime/participant-control-occurrence-v2.json":"sha256:1b88f04f11161656464d681dc6e9839feed017803a49b9bae1e86a6cf6de010a","contracts/schemas/participant-runtime/participant-control-selection-v1.json":"sha256:00596d7c9a21af0887eba3d623ad62508d39baa089d4e3dd3344fae4b154ba6d","contracts/schemas/participant-runtime/participant-control-selection-v2.json":"sha256:68834031487a44a64e180e1cda960511ffb82438f539c297203fcb4de46c34e2","contracts/schemas/participant-runtime/participant-control-teaching-profile-v1.json":"sha256:811b1e9213e9a0abe6f4c644e1913a913c7929925b50fc59ef3a41d94defca40","contracts/schemas/participant-runtime/participant-crossing-occurrence-v1.json":"sha256:d67ce8f96e0f4b069cbaba698c74491d24de6148516ae900731fd01205d2fdeb","contracts/schemas/participant-runtime/participant-execution-binding-v1.json":"sha256:92f99244817ee1ff3cce729c68bbf33d3547cc68c38b48ee34481dc233ae8c45","contracts/schemas/participant-runtime/participant-execution-control-v1.json":"sha256:1e362cf2cd92fb3465bca586aa4085b15f7b32c8a672875e7b6c14f1edd77b18","contracts/schemas/participant-runtime/participant-execution-service-state-v1.json":"sha256:f337ee379fded34353e2d26e20a9363e717ada328fbbfaad5840aa6d5a6ebe8b","contracts/schemas/participant-runtime/participant-flow-control-relation-v1.json":"sha256:cc47475d30e42ae933d6207f7d12899f5819e706366e83689f8a739048c82d56","contracts/schemas/participant-runtime/participant-information-state-record-v1.json":"sha256:041653edc8e98e293003d28af31f3ee5b5148d1e090492784b1f9f1d862bbc59","contracts/schemas/participant-runtime/participant-joint-action-record-v1.json":"sha256:64f17167efe90e91d4ce9bad9db8844e4e1c32ca4ee6e39820458c1f299ede10","contracts/schemas/participant-runtime/participant-lifecycle-event-v1.json":"sha256:15ddbcacb53ee6851a8fa697b761abdb01a11b83727cce069a3a9aca65bab28d","contracts/schemas/participant-runtime/participant-observation-envelope-v1.json":"sha256:bdd0736560f6288c3b23e806bd79055b7108592f21790c4e4a092b2b9e7e64c3","contracts/schemas/participant-runtime/participant-outcome-report-v1.json":"sha256:e67763fee445a217ebbf33f6bf438815c61f1b63108580e6b1f63e1a26b8e07a","contracts/schemas/participant-runtime/participant-outcome-report-v2.json":"sha256:20ad39fd485f4786a9189fafb5ccb3249b2c21bba6c7cf633fabd52424416de6","contracts/schemas/participant-runtime/participant-resource-budget-event-v1.json":"sha256:e0829034ff121bfd8fd9fb94bb06add48129af70210730bcfcd5597d661966c4","contracts/schemas/participant-runtime/participant-resource-budget-policy-v1.json":"sha256:3d31d3a249c31ffde4ffe57629a36212e74a8a95a581a5127e4ad7c094f30cef","contracts/schemas/participant-runtime/participant-resource-budget-state-v1.json":"sha256:dcbc23a5e6bf86c32c1cccd2fb1599610085793d2afc06987e701264720eebc7","contracts/schemas/participant-runtime/participant-resource-pool-capacity-v1.json":"sha256:59baf2eb6b882889ff0338b700ec1210d42a86b9cc43fc1ad13fc4a7b89d13af","contracts/schemas/participant-runtime/participant-shared-state-record-v1.json":"sha256:dd949fa624bc154c0b8e0d4b25e50166a2d237a09ccc958e477ae8d52fb145b4","contracts/schemas/participant-runtime/participant-time-management-context-v1.json":"sha256:01d7770a12fd622a2ff8bd3459f094de3e6358cbcd93210cacb91a0ed7cbd542","contracts/schemas/participant-runtime/runtime-fact-binding-plane-v1.json":"sha256:c10d784f163c27b016e9bafa14cf93d3b1a37e914cd515f33d9a5874c6ead7b0","contracts/schemas/plans/admitted-trial-plan-v1.json":"sha256:f178df5c8a2e4229f1dd555c6638d34a9792c64146e71847a2067672bac58574","contracts/schemas/plans/backend-augmentation-scope-v1.json":"sha256:d796270c3ca61d5211ce202a1baffbc6685bd5ec075af672ac7aa7dffdb83cd0","contracts/schemas/plans/backend-materialization-attestation-v1.json":"sha256:a69d8116966e08c126963e72feeb12d26207ada02adcc8a43eb2bb47d765d3d1","contracts/schemas/plans/backend-realization-preparation-v1.json":"sha256:406943571a6403028d5783e59aaeca22723bacce8b70d5311bb0a1396e7234fc","contracts/schemas/plans/backend-runtime-descendants-v1.json":"sha256:5c1846c022a0aa453d42439c742a5c8ee0f85c17a9084233f0069cf646445748","contracts/schemas/plans/evaluation-plan-v1.json":"sha256:eadcbae80c749519d35fb3a214f9d720fa281c33af0ddfdd711fe6b80dfce407","contracts/schemas/plans/mixed-participant-composition-profile-v1.json":"sha256:ba807ae3535acf4c148c7a8a99bfadec88806a937a947309bea47e335afb7973","contracts/schemas/plans/orchestration-plan-v1.json":"sha256:457220ef944c9de12a7c3aff7ffa44c087c2344d3df1df26e0938b6b6ef300f3","contracts/schemas/plans/plan-realization-profiles-v1.json":"sha256:c16761bda12b82830e686e110e5f811a3a6aeb446ebb895249eac95c6fed7de8","contracts/schemas/plans/provisioning-plan-v1.json":"sha256:55971447ff45bad5b8fe783f705c9ce4155c8a4e6fe0b366746930604e57cce6","contracts/schemas/plans/trial-cleanup-plan-v1.json":"sha256:f654f87a8023f93e1607ed2a29bd5fe89d98d90255dcc528824aaaf29bce5ef7","contracts/schemas/processor-manifest/processor-manifest-v2.json":"sha256:3b437d2609b8070aac72d501c318fceed7d93553b6e502f2afd5ed2988c8b501","contracts/schemas/profiles/backend-profile-v1.json":"sha256:282406678b5199e2510d68f422fcc74cc74a3f3d01023bcc0bf62f3c1ca9aa5b","contracts/schemas/profiles/behavioral-relation-profile-v1.json":"sha256:7753324c47fe7ffa77d62f51a3113a96eec3973a0d095cc11a0152b25d0e401a","contracts/schemas/profiles/domain-profile-admission-policy-v1.json":"sha256:fdff042775b553be0a25f8d0feb7d7ad6cd36c559c9268a215e08f4b1ec76cb2","contracts/schemas/profiles/domain-profile-binding-v1.json":"sha256:e0fe771820ebbb47165e421b13808b22fbc9cad9f620a1944ea741ab8fdfa33a","contracts/schemas/profiles/domain-profile-definition-v1.json":"sha256:0ae301c11597b4903327be77d7891d9e1c08f03db9b90bcb0be6712b7bbd0ec9","contracts/schemas/profiles/domain-profile-resolution-context-v1.json":"sha256:b8de93a7959a05b13fb00c05ef0156f292399c9c74406a79248a87a196dcf77a","contracts/schemas/profiles/domain-profile-support-declaration-v1.json":"sha256:bbd2d1a7eef310748c0daceb7dfc14e2aefb23f9372c47dd85c44e03a7c6601e","contracts/schemas/profiles/participant-boundary-flow-policy-v1.json":"sha256:249a95c722a3f54ecf343a913dcacc384a73fcbe36027f879ea091336504058b","contracts/schemas/profiles/participant-information-reconstruction-profile-v1.json":"sha256:5f4d9fcde1a14f1a4e8ca2ff0d2e18105bf94f9120cf74f94abb7c43cd903c18","contracts/schemas/profiles/participant-owner-flow-policy-v1.json":"sha256:1d7014f64256d47d6813283ad205f082e9149cc16c36c335314f5ac6ad5d6cd9","contracts/schemas/profiles/raes-semantic-invariants-v1.json":"sha256:72bdd4a23084f31b291d14016ea77acc2b930e279fc5f45782ea926641996ecd","contracts/schemas/profiles/random-stream-profile-v1.json":"sha256:8dae93ec45a4a3b4dd95160c41070107c2cb3159669ba0d393fd6ede41e0efcd","contracts/schemas/profiles/random-stream-vector-v1.json":"sha256:6056f089fc067d4a268ca26327a395078a9c8e1ce339a8ee7a8cc949453bbfb1","contracts/schemas/profiles/scientific-completeness-assessment-v1.json":"sha256:49ac4bea63181a4c09d9af74d1ef3e2434ad23b1df67dca85042e42d608a3118","contracts/schemas/profiles/scientific-completeness-taxonomy-v1.json":"sha256:09cf3e5dfeb7ab0914c12c996a2900428f0060a43a53214772c8c8004e73d910","contracts/schemas/profiles/semantic-profile-v1.json":"sha256:c219180f19cb1b080d44384c706f78f271601c7129316f925c1c5bd0dc666930","contracts/schemas/profiles/validation-basis-disclosure-v1.json":"sha256:28f1e2ec6098bf22c4f676cb71e364e364b9426743251eff8c2d7af13226952d","contracts/schemas/profiles/validation-profile-catalog-v1.json":"sha256:84c38d758d5a0c8f0d151792910079161874f0686a4e8fea03d175b0b88a0d38","contracts/schemas/provenance/sdl-lineage-ledger-v1.json":"sha256:6fdc8ecf62c9893cfea87d421cfe5d340e349cea524526f7c925b466bad8609b","contracts/schemas/realization-constraints/recursive-realization-constraint-v1.json":"sha256:1fd1bb896639bc66e4231d35d7a7665b5023b98a03f3526aea243e91986b8faa","contracts/schemas/realization-envelope/realization-envelope-v1.json":"sha256:dbd1ac6c12ab6423a6a48176f789faab1f79f479f7afb974c02f41b21dc3527a","contracts/schemas/satisfiability/scenario-satisfiability-evidence-v1.json":"sha256:46ba3bf5915e7e9b1524c749d16d5a3765ed98c218d52aa22914dfdf93503fce","contracts/schemas/sdl/instantiated-scenario-snapshot-v1.json":"sha256:142b80c4b49d86e1279b786536324d59331b60d5213c47924a76026bd539f317","contracts/schemas/sdl/instantiated-scenario-v1.json":"sha256:6e3352f0fd2dd788a31b5ae3a16c2c880923c6565856e793dd0b552b96485185","contracts/schemas/sdl/materialized-scenario-v1.json":"sha256:7816d9b357cdc44d8587bb70124c8ccdfc409ff9f3702b98095a0d55ae77e355","contracts/schemas/sdl/scenario-instantiation-request-v1.json":"sha256:f19b6da4504a8c7ee606b987926bed39fe7bb71ef488f37eed33712c751fe306","contracts/schemas/sdl/sdl-authoring-input-v1.json":"sha256:cfe0339a43cf8e2030fd0abca81d352f8fc01872dcce2dadacfd5e5210398a40","contracts/schemas/sdl/sdl-semantic-migration-context-v1.json":"sha256:91ad1bf7c899b5ded4e5a7ecf11d2093b9febb460fb365ce37aabbaf8b3f4216","contracts/schemas/semantic-comparison/semantic-comparison-request-v1.json":"sha256:ec8b4ec11b6ff632d6500f839463d529329ea6ca9d7f70ed8963abf7cbdddde3","contracts/schemas/semantic-comparison/semantic-comparison-result-v1.json":"sha256:dbdd4014ae869ea600165ee642fc52783101de1446fd6eabb8eb3eb36bcb3ef2","contracts/schemas/snapshots/runtime-snapshot-v1.json":"sha256:1f8d6357d4927a98eed7ea62654fd272eb4d3a549122d6177feb9f0295100b69","contracts/schemas/time/realized-time-model-v1.json":"sha256:e0cc49ea4892d98496b2584d391bed3925c11322608f620095ef5de73eec4e8d","contracts/schemas/time/time-model-v1.json":"sha256:132acd5af118e01356922de66974a9de5d2d1e3c7c54d0221e573669d041e5ae","contracts/schemas/time/time-runtime-state-v1.json":"sha256:862042656b6c01c6bfefd6856ddcd7c37b472d0489489064781aa1ae7d51e7fa","docs/governance/requirement-scopes/972.json":"sha256:0fe690427a52398bbea28e435e801781d07af819d732a53083a3f64a328f3c79","implementations/formal/participant_crossing/__init__.py":"sha256:f51f0d2c6683d45c41da9712da916ccd8df86a96eff4e97d9274a1ee55a96fba","implementations/formal/participant_crossing/__main__.py":"sha256:50e4cff061086b085a26a165b0b240565b9b14263b2d413e2115cc1747ced323","implementations/formal/participant_crossing/abstract.py":"sha256:efbd1672a1687a21930625a1a16177b450d037f5bddf2047cb17832bf9d26531","implementations/formal/participant_crossing/aut.py":"sha256:2f0966548044e4bf6c30f5f1f80173e428ff0551ec546323012181707dd9dd52","implementations/formal/participant_crossing/concrete.py":"sha256:9d2e3c716e76b20b956d0a5d5d49a3533022663a04b6ad5baa318f2e3bd5b3b5","implementations/formal/participant_crossing/export.py":"sha256:c42601830bea1fe979b6d80d12032c44cfc2b2a922ba76ed937f0289c2abe4c8","implementations/formal/participant_crossing/graph.py":"sha256:18d6846bebb31bda0ecacd3e64a4c86c17309b9734d3ea9ed87c4fab7b07a37d","implementations/formal/participant_crossing/ingress.py":"sha256:c9ab4c65edb541c8d030212e4f4392b2327c19033f71a0378ee45af468758a5f","implementations/formal/participant_crossing/multi_abstract.py":"sha256:ea7856a7f2ebee7057e5012c956caff0d4d4b62b913039ef477c11eb5a3136b0","implementations/formal/participant_crossing/multi_concrete.py":"sha256:8c33ddb7c803936c9a701e7e4197bad697a3729a0ef6851861e8bed0c1602678","implementations/formal/participant_crossing/multi_export.py":"sha256:a4254b9f686e0cac6965219d7db237f5903f1efc9860e11d65824771d09f5997","implementations/formal/participant_crossing/runtime_mapping.py":"sha256:f47e29eae425fbefb079ad20a4a05a0b4d207db578d41e57f2244a1eaaeaa697","implementations/formal/participant_crossing/runtime_mapping_export.py":"sha256:d47031be5dcbd52bddafac9701739a90f02e2c4a953e0ad11649b9a4d04e8471","implementations/formal/participant_crossing/runtime_mapping_integrity.py":"sha256:1907ce19d8418efa1469e0353fa3b235ec7e1a96bde62037a67d2e01474bb6dd","implementations/python/packages/raes/__init__.py":"sha256:87c7ae40b7c1f63f458153a4f8f2e4ca49e27fdd2069c3b9bbc555288b693cfc","implementations/python/packages/raes/_base.py":"sha256:53c7738fd8f70339c8f7b624d5a815614f4b8f88ceb3ce8c284050437b49209c","implementations/python/packages/raes/_behavior_authoring.py":"sha256:6933551424f96852d783cdf003b6725ff47722c2064b8bd5fe1e5a942abf3b1f","implementations/python/packages/raes/_capability_binding_normalization.py":"sha256:7349277b5f9ddf482107662f9fbbf5f5f02f478d27e7270d19e76f1c9693cb03","implementations/python/packages/raes/_capability_constraints.py":"sha256:bac895e9620656ad5e798fee1fca84030df88ff933c3fb61584f9666106416b0","implementations/python/packages/raes/_classification_guard.py":"sha256:1b772f3e2c09e1a82b845ae79149a1e7b4492e81f4f4ff240025c30229794cd6","implementations/python/packages/raes/_composition_budget.py":"sha256:c1997d15e45f74ef34743d5a5729ebf06f2576f7b8c91ef62d5a9d27ff441e3f","implementations/python/packages/raes/_composition_provenance.py":"sha256:c81132ac1342741d29470e4dabc8d6ac078c55159d4034a81b3423afbd02e2ad","implementations/python/packages/raes/_declaration_adders.py":"sha256:b40a181a461e4e20b4806801e48db62c76c7ea38fd906db0c2f85092ca638d5f","implementations/python/packages/raes/_declaration_index.py":"sha256:8d6d486c5395d8321ddb0408fc9de24567da21c18647428a020ea78c6f16ccfe","implementations/python/packages/raes/_declaration_sources.py":"sha256:dd112d2873bff52fc0ac4cc5ced45ff96fb782af1b2f22fdf9163ef241e07a9f","implementations/python/packages/raes/_declarations.py":"sha256:70d12fa338ca97c849d6a07b04a3789a4f2a2e49b99d22c5b9280739a9994cb8","implementations/python/packages/raes/_errors.py":"sha256:e5ab87131fb43f49d69be3962850d6b7d58d1298365dadb951974cb0f7138ce6","implementations/python/packages/raes/_identifiers.py":"sha256:441635fed8fcfbf95f075b3fb57a65b547d8b50293b839104806e5d6e1a7671c","implementations/python/packages/raes/_incremental_reuse.py":"sha256:f3ba9266c1779c9044c029a835a9013527af1f0a5ec1afd18b0a4470e7d79f58","implementations/python/packages/raes/_language_context.py":"sha256:ef83b58af8fc21c963f92a0461f9d3d7fd6c4ac02c3fee3168694f57a199b8e9","implementations/python/packages/raes/_language_definitions.py":"sha256:8dd65b8756f2479571d77354e7cae284ccd77c9c6be2a3e219423f52783e7a4c","implementations/python/packages/raes/_language_diagnostics.py":"sha256:d782c66a1f106d7f5aec88e18c9a35cb0f76ff406bc433a13d216f1dbd573dfe","implementations/python/packages/raes/_language_edit.py":"sha256:7c42f25bd7e8498fbb16607a1e57941002e0a66018821b280509ad8e4f7dbcd2","implementations/python/packages/raes/_language_metadata.py":"sha256:a7304b8f576efe3e71c7445593eed6a9d1fcd8a0992f514118cc30ccfad9a220","implementations/python/packages/raes/_language_references.py":"sha256:737556a68a05ddd67a47196a3d3ce43f0e28e0d0d76e93148bac479ca6112953","implementations/python/packages/raes/_language_relationship_candidates.py":"sha256:6e416a62ef90e18228c116a7dde9aeb134cdefec0b0019838864096c6f5eb791","implementations/python/packages/raes/_language_structural_variation.py":"sha256:a3c9964c55874e828d468eadadff4af717dadbd0ada9d0096a99836e36c240df","implementations/python/packages/raes/_legacy_classification_source.py":"sha256:4aa16e3e12bccf749871b9be3907d30656a76f94229ec445b94ed0cb04d813fb","implementations/python/packages/raes/_legacy_node_migration.py":"sha256:f2dd9fe12784648eeef022ef6943a79fd5210ccd39a852da155845cefd5b98cc","implementations/python/packages/raes/_legacy_snapshot_classifications.py":"sha256:d5ae149244b155a4993fba3d044800c1b904bc4ed9bb5a344c7efa35aea77fcc","implementations/python/packages/raes/_mapping_key_analyzer.py":"sha256:964c34a76c672df05aad49c6977ca5030c3139b3678815c688be85742a9ec66c","implementations/python/packages/raes/_mapping_scopes.py":"sha256:098898473965e123562f11cc62ad20c5be94ba65b04f2c23035d1c6d09cd4c04","implementations/python/packages/raes/_model_diagnostics.py":"sha256:d1771a3e7b651bf7b475d71cd4b0eb1c7f095a5416037f4414a29cd85a2f1902","implementations/python/packages/raes/_module_declarations.py":"sha256:59799bd1e3432778398e193c40e2f6902190ae1e2bdac9a52ca19e9e3123430a","implementations/python/packages/raes/_module_runtime_aliases.py":"sha256:24cb825c8b378f2e3493e218b7e2aace4bf2ea09bd5336cffde7e1d15b2c16a4","implementations/python/packages/raes/_module_symbols.py":"sha256:14dd610c53c76463b5cd3e29e974222ffc108062af3350b77e2ac4bf028375f3","implementations/python/packages/raes/_operating_scope_index.py":"sha256:5f6378d59a4c4919db752dbcce6c0622244f12827577f1a8530cba9784a8d19e","implementations/python/packages/raes/_phase_base.py":"sha256:40963ca16c69b94e876862ea2eaa1b1a2dbaa67c404b61dce000154ce458edd1","implementations/python/packages/raes/_realization_envelope_domains.py":"sha256:7ba512aaea4bba81df2b47c92cf824f8604f00ef0c8b7e456d7c90e977c4a6d2","implementations/python/packages/raes/_realization_envelope_engine.py":"sha256:13df70697bdae6e6b03a5352933f01b7323415e4db0d7c8677c7b2c73b9be2ec","implementations/python/packages/raes/_realization_envelope_probe_payloads.py":"sha256:012cef0ea657551c8e24fec3f47b98efcd05dc29a677a42b2ba28355f81ddc04","implementations/python/packages/raes/_realization_envelope_projection.py":"sha256:16e4f248199d27861c2a4cf73d3f3a287b5705587413b51f16f300f34bf8b4a7","implementations/python/packages/raes/_reference_targetability.py":"sha256:f8bc6c5a0cdb6753518925a439abf85c7cc565bc1f001e67db981fbf626d12cf","implementations/python/packages/raes/_relationship_endpoint_policy.py":"sha256:6aac456973f7ec7baabe031b9fef3b47eade6ae58a90702c4bb043b11c9dacea","implementations/python/packages/raes/_runtime_datastore_support.py":"sha256:8f79058cce66a98504a7a08c4358d8f38b8d889df4b05859fb4ada08075d8438","implementations/python/packages/raes/_runtime_service_families.py":"sha256:338ff4ee0457a5bea57a3d071a5386851c518cc09a2338b719e9d1697778ffbe","implementations/python/packages/raes/_runtime_service_family_registry.py":"sha256:debd647fbd6e5d8e7184c8ab8dc44f8e5e54ff56ec3afcee9dedccdcc264f401","implementations/python/packages/raes/_scenario_instantiation.py":"sha256:fea76c7087029a41d1665da6b51b02540d0ef06977d5a8c4852360e13bdebc4a","implementations/python/packages/raes/_selection_provenance.py":"sha256:f482973cc90f88d83e27b84159904e268b4f170630c3b37de2af6191dd7ad3ac","implementations/python/packages/raes/_semantic_migration_decisions.py":"sha256:9103697c9f96331254690ef47334306576e8f94b112411d9bf78408322df3e0f","implementations/python/packages/raes/_source.py":"sha256:9b85d85b0d4cdd11f01b3e9390c53bf544bd326ad20aa9c0b0388869fb317405","implementations/python/packages/raes/_source_identifier_paths.py":"sha256:4b285c430cde6b5f2d52acc8586a644027834e2ef6b323aed930a71ccb452040","implementations/python/packages/raes/_source_profile.py":"sha256:488f2137a4418ce1ac4b1f8011e70a4e9566ceb65e5f593ec19f1bddf8c3e418","implementations/python/packages/raes/_source_validation.py":"sha256:c9b53e58df2e36a408ca6632912ce22f757eea0e1f5e399b9a2ef2173ab86d8d","implementations/python/packages/raes/_stateful_resource_references.py":"sha256:36194e69ddf388a9a0b4abb6fa4a1aaff53540e364875b7aa70f6c5a01796d04","implementations/python/packages/raes/_transformation_bindings.py":"sha256:59b3b659a625d883eafa9e0a4953271e0800b6cb05df1fd874cd83d65f383a1a","implementations/python/packages/raes/_transformation_portable.py":"sha256:6c96846e8c88b2de5b921bbb9a09f78e64bd1c68d98a9f108c8d8476cf638239","implementations/python/packages/raes/_transformation_remove.py":"sha256:0db3c317f2a14a1852fcbd402f4caa41cc48f8b3af2d4b0a3e4b5f62b4e4303b","implementations/python/packages/raes/_transformation_rename.py":"sha256:c7f7285dd88dd3a9c85ff024ce0e27534f480256d7a41bedcd33be7e32254bca","implementations/python/packages/raes/_transformation_support.py":"sha256:c157acdafa036688fa49447b5db1bda984aa51ffa285841fb4715a13fc5acb2a","implementations/python/packages/raes/_transformation_types.py":"sha256:98cd74447a8a335fc6687abf2ce95f35edf55b870b92a0263d8a9d03cf5e624d","implementations/python/packages/raes/_version.py":"sha256:34dbea5eb905bc8ede6a20a82a4bcbf7a884f8c5a3d58e265b146ebd14a9b4d5","implementations/python/packages/raes/_yaml_loader.py":"sha256:5ea0afa8f95ae126e886d5c37f3de46dc5dd2e5b21be52f3079d5c5d3c354eef","implementations/python/packages/raes/accounts.py":"sha256:7d9d7b92a230fcd77514dccab154b1723ec62c620ab3be2e6531577e89b2e75b","implementations/python/packages/raes/agent_guidance.py":"sha256:5e814837d7ff38b8adf440894b462064d4c00eb9b1a5079b169d629ce967699d","implementations/python/packages/raes/agents.py":"sha256:bb86841f763e3e44d445401bac69f2e8e14992c2574475a46b81405111ccb83a","implementations/python/packages/raes/architectures.py":"sha256:fe253a852fd4519f1758719fc65c48c0a567975181117dab347e69fd1c85953a","implementations/python/packages/raes/artifact_requirements.py":"sha256:bb27efe7b17a9d776a78754492489e3800283d9a8437c9266a288d9301c64b5d","implementations/python/packages/raes/candidate_synthesis.py":"sha256:3ef69b491650d8594d2660a54d605bb3fb7d8860f79b671e6041d4fcd41e8e60","implementations/python/packages/raes/canonical.py":"sha256:70fdff6ccf985fbdb7eab9e1bce190ba36030d5edb4e234dd2a4e6d76de8ad24","implementations/python/packages/raes/classification_migration.py":"sha256:642e0fcfcdb246419c213b4bfac2aa2cd4514273f7d3d8ea60584028cbe40afb","implementations/python/packages/raes/composition/__init__.py":"sha256:04e158fe791e3fedfa4ed76df98506ddb0476fdece7a6959665e79ebe038eec8","implementations/python/packages/raes/composition/_augmentation.py":"sha256:ddcb7c6d0a4821c70127a5e35984116f20d7c9a4c68b610876654d2c70d9848f","implementations/python/packages/raes/composition/_behavior.py":"sha256:ef0fd35c2eee2c3127f2d0f8d3ce17e0557b91df2b0540a5de2ea48dcbdde7ff","implementations/python/packages/raes/composition/_cloud.py":"sha256:c663912ae6c2deb84b7f9ad11befeadd50988b1e5461c8fcc97c00c20f5f91d7","implementations/python/packages/raes/composition/_control_context.py":"sha256:1abf13e8df2869d501dab73b308053e98911809598f5bcaeb2c094908ee66f1f","implementations/python/packages/raes/composition/_execution_policy.py":"sha256:cf8f48e3a989cb8483daa86f818a2d12f5fd701d01591694e2f1ce94a9f5e97f","implementations/python/packages/raes/composition/_expand.py":"sha256:ee03a48d15f7985febeb93475bd519f537b5106c97ec563c757a74a704c11c36","implementations/python/packages/raes/composition/_import_admission.py":"sha256:fb5da54f01b83e4c164ef8a51644f379f476f4570ddfe12387c059e5fbf55df6","implementations/python/packages/raes/composition/_profiles.py":"sha256:bbf574e96175375f34823cef0f817098abb6bd779506543603746e4941711ab0","implementations/python/packages/raes/composition/_provenance.py":"sha256:8e5e3b3b8899fe08382ea27e546065ab01f088249226e78d519ae4ce25dad23f","implementations/python/packages/raes/composition/_references.py":"sha256:9fa66a00b8747876e330d54f068affab7d32a71a1d41ca2b996aafd672bbe2de","implementations/python/packages/raes/composition/_sections.py":"sha256:6055125c64bfef169f5658d294b9aab3655df794ddf0061f769d869d458a3996","implementations/python/packages/raes/composition/_terminal.py":"sha256:10fdee485686cace7eb157ab7129d69a2e3f8ef13cb62b76b19d714a62ed7fd9","implementations/python/packages/raes/composition/_tool_affordance.py":"sha256:63e806a7e49360a9167ec4654bc19a1064d4e25615a1986c24cf31ca935d1ea2","implementations/python/packages/raes/conditions.py":"sha256:f28474e3c1928e73145f80179e1af0cb361ad0b14f505534ba06028822b94daf","implementations/python/packages/raes/content.py":"sha256:280323d9dd8ce92063a97a49a8c40beb74231d0ee6c1176ab160af4f30c7c18f","implementations/python/packages/raes/deployment_tenancy.py":"sha256:e913dfc2c04c91e1ba18667787ebf2c4dd1790c38b99b4ffa67206d7070c4167","implementations/python/packages/raes/enterprise_identity.py":"sha256:78ad05c6980e420ea0cb086fd93191904cb0601d721a5a1cf471d6463a46797e","implementations/python/packages/raes/entities.py":"sha256:751a7bbc0fa69cee117a1fee961d922084b7f60a25c140fe620476163299b3ff","implementations/python/packages/raes/evidence_requirements.py":"sha256:c8d89dc6da18c1d6e270d17ea80d977eb863aec7edea2f3edc935354dea6b95c","implementations/python/packages/raes/execution_policy_scope.py":"sha256:09243bf9869dc121c6c590005a9316fd929aaba016da3353edbe3ff0221dba58","implementations/python/packages/raes/experiment_selection.py":"sha256:29d11596098fafd1fa533e8f2c68979ed73c89a3aafa873318f231705812ffd9","implementations/python/packages/raes/explicitness.py":"sha256:fe76086e25cca713ac957896068100973e800c202915fd913bcf795e98ac8a64","implementations/python/packages/raes/external_concept_subjects.py":"sha256:2a1c71f1bd7cc28d33b6a2abf477c149d93d97d570cbb73056a4061fb3d84bf5","implementations/python/packages/raes/family_admission.py":"sha256:464e19159ebd7b995d1766bd7d898110fffc74c99696d662c8d4a4fc6298c6d3","implementations/python/packages/raes/features.py":"sha256:f9f225fd8762023f49f3e32cf50934360a97bb34cff4d04de817700190f0fe98","implementations/python/packages/raes/formatting.py":"sha256:826340811fd7b9201070dfa4339dc41537f680a8cfbc03f2229b0991d7ba8dc9","implementations/python/packages/raes/identifiers.py":"sha256:22f14c4c67ece2c78b9357a3f589dc02c90b22a5dbe4a139300fac6ee71f88c6","implementations/python/packages/raes/identity_domains.py":"sha256:a366b01715d0f859f2387d747165f0f828cb15c2b35673f4afde0ffb756e3d04","implementations/python/packages/raes/image_provenance.py":"sha256:2d7f6b6621e9ca653acca01dbce38e84772021ba25c0dcda9d3aaf6f061f60ad","implementations/python/packages/raes/infrastructure.py":"sha256:7492333878c27291aa08e1b2d1b6b23b77dca37be4afdc2f3678fae2dcdb462c","implementations/python/packages/raes/instantiate.py":"sha256:b85e7b9c4bc4229f7061675e2bb625ab0f8990631cfff2dc855dbe36e0c246d2","implementations/python/packages/raes/language_service.py":"sha256:bbd6c4f7a0fd86b0894897a9b16e4a847129755b8342e5f0d6b4bc53f6302889","implementations/python/packages/raes/materialization.py":"sha256:0c2cac3fb8cc629b3ea285e9a931399fec82886164ca2b055fc45e6790057e20","implementations/python/packages/raes/materialization_provenance.py":"sha256:8b394b6ea00f680c932c721076e2bf5a75e01047b0e5b9803d4831ad4fb811ca","implementations/python/packages/raes/mixed_control_migration.py":"sha256:a5cf4dfdbc863f09f10fd1b616e72362e1200afc8a580cbb144da8b951c3f408","implementations/python/packages/raes/module_registry/__init__.py":"sha256:68fe989c137a5860ed962f9afcc74e60bcc45b59a8ba42aa4ac32bee016df9d9","implementations/python/packages/raes/module_registry/_archive.py":"sha256:6ab5bed9efa59e469cd1a967cb6368c2df093af37c933f3fa4dbc88f8d04dead","implementations/python/packages/raes/module_registry/_cache.py":"sha256:0b211478800301eb81a7a838170c2a79710c48933e10359726f0b85335d6c7a7","implementations/python/packages/raes/module_registry/_cache_integrity.py":"sha256:e86af80e8572ee5ef94ca01ca4424544fdb303703a0f2e74b03e31e3e2320f13","implementations/python/packages/raes/module_registry/_constants.py":"sha256:322137f58dbad0f4c4a356137848a3881bdb88af1367bf15cfeedf20f4efee02","implementations/python/packages/raes/module_registry/_digests.py":"sha256:436117dba4339b1f5e649d1257cceff702b46f995ea01dc221b151b989e0bc82","implementations/python/packages/raes/module_registry/_extraction.py":"sha256:4c9e72b3797d277a00ffdf9087963b534f2704489050268f6545b167cf8f0092","implementations/python/packages/raes/module_registry/_filesystem.py":"sha256:a629ba3d54e53fe93f8f15be1132c82c883c6dc75bb2500a4a7b067348f3ae95","implementations/python/packages/raes/module_registry/_registry_auth.py":"sha256:e8d44cac2b67d3502ec4a357a285478c0edb2dd76238a560ce5b9d7804945e56","implementations/python/packages/raes/module_registry/_verified_sources.py":"sha256:8bb28100773fd54d9bf7a9685170b8b2f34b559691607eb06b56bbfd3757fa2b","implementations/python/packages/raes/module_registry/models.py":"sha256:07fc6e9716942fd310e1c53c35337888da444114ef5a44b42770201aa5275033","implementations/python/packages/raes/module_registry/publishing.py":"sha256:387b9a46c2a2a27ded9319954c72c43360aa77b03f6d414e03fade9431dc8655","implementations/python/packages/raes/module_registry/resolution.py":"sha256:ad9a446beda989c953b180bc35585f03e739e4f68f22d0972078dde25b51550d","implementations/python/packages/raes/module_registry/signing.py":"sha256:d86cc9731a9bf927ac53ecf1e157de2a3008f9058ac7b1aea94debfa00c85f78","implementations/python/packages/raes/nodes.py":"sha256:6fda8f4c36e7feb9ee6984be42ff7b704a600dc826dd96fdda2d43e00b9d9350","implementations/python/packages/raes/objectives.py":"sha256:06661780fb7ac03f01fb69b03d4991c7d9a79797cae5062524e2990c4d1205a1","implementations/python/packages/raes/observability_plane_semantics.py":"sha256:bff57a3f882ac868e92a1649e124594e9e51e35c260ebff0d25a6566ce458df9","implementations/python/packages/raes/observation_scope.py":"sha256:90e7a5f32dbf595188a01a93ab9ab40303979bd2ac103718a3f59763478a8c50","implementations/python/packages/raes/operating_systems.py":"sha256:99606be0deaa04fa9a3a1219afc88012f62c55b91df6526792c93f11fa671ea0","implementations/python/packages/raes/orchestration/__init__.py":"sha256:b5f97c1f9bf1ddff21a4881c7bdf70ca544fc0b580e756ecf63b6a912368c815","implementations/python/packages/raes/orchestration/_durations.py":"sha256:4a0270a67607c01ffc9875ec7b764b0091658334fc0694a564b88241cc87dee4","implementations/python/packages/raes/orchestration/_events.py":"sha256:043af4a4714d219502b219330fe7a48a5814cc90fc17d96e2b5cc4594ae4478a","implementations/python/packages/raes/orchestration/_steps.py":"sha256:cc18428e0971cb6485f8adad1308b21570d07e3be4a2ffb2e191f6dd2ebc5844","implementations/python/packages/raes/orchestration/_workflow.py":"sha256:deef8bbcb5dae7c414ce0c98d70f108c9901b619c42db29d90e1b699b36d55e4","implementations/python/packages/raes/parameter_derivations.py":"sha256:e4c2ac7c1958a1be9f72884c00343772eb6f675900539ad7cdc9e097d9520c61","implementations/python/packages/raes/parser.py":"sha256:02de9e42aeba0d04ace12bc8cd62c2f1fc75da92ceb6da0ba42dd5b9ac84b8cb","implementations/python/packages/raes/participant_action_semantics.py":"sha256:72d4405179ce3b16808b0d62e2b51fc748defea35f9fced7e215081f5a245ad2","implementations/python/packages/raes/participant_attribution_semantics.py":"sha256:eee7e4c7078f57c1f32d044bd7c8e554f6c4c1e01a093eea61c5e566601a2d88","implementations/python/packages/raes/participant_behavior/__init__.py":"sha256:f721285dddb6c4affd815aa3a03b6ebafe0ab6949134db33dbb0ed05cb265b97","implementations/python/packages/raes/participant_behavior/_action_contracts.py":"sha256:ec67e11841933b49f2200845340fed41dd30874f99557a697ebe7ff94cbe5f04","implementations/python/packages/raes/participant_behavior/_view_boundaries.py":"sha256:d5fab0bca5d2c3f3a10b13170d0bf143f63ea1f758cae7d274bf826510cf92af","implementations/python/packages/raes/participant_behavior_specification.py":"sha256:ecfad64d7296d25a15a5a1184f7fc44eb79145cf01965622834a1d1e2c689769","implementations/python/packages/raes/participant_control_context.py":"sha256:f7f95fe18195fe8a76d6411dcc5c7d10c05963ead62139990d9270f4a0d6121b","implementations/python/packages/raes/participant_execution.py":"sha256:7974c9cb32dc3554b8f1505a794c08917d228a2c84207207d4dce09ebd077576","implementations/python/packages/raes/participant_inject_delivery.py":"sha256:8f5983de1fbe30fff0d409fe28a5a2d075691568a66063b791b85d1b8735846b","implementations/python/packages/raes/participant_local_outcome.py":"sha256:3292e9ba95a00f03d75affc5ea9a3b01373eff569daa909a6e9c96a1fa501040","implementations/python/packages/raes/participant_migration.py":"sha256:7746b48957f27da09baf14cd1d158f43499455f1d174f4a1ba4664addda0a8bf","implementations/python/packages/raes/participant_mixed_control_policy.py":"sha256:88c984465715f4f219215d857a4f0e80db90e1cad71ca58d56255375f9db88a1","implementations/python/packages/raes/participant_mixed_control_vocabulary.py":"sha256:6e34630a9a6d6b5dfff8373c3aa2bceb033ba3647d1d8e834d24db8a183ddd3f","implementations/python/packages/raes/participant_outcome_semantics.py":"sha256:161e4e9187a66bd7ba7e38bda643398e3c796dd31d664da6142b118cbef7e79b","implementations/python/packages/raes/participant_relationships.py":"sha256:df30a9c8a21856f1a26bfe4da117579bc94fb1108fbf489f0cf353dcae486ac3","implementations/python/packages/raes/participant_resource_budgets.py":"sha256:dc02d405aaba10862fea99453ee6f85f904f0d4b0c006685e08542769bf71bc5","implementations/python/packages/raes/participant_temporal_semantics.py":"sha256:a4dfb9191dd0cb2b22fdbb55060c882e2253696a22b89fd5e841ecef4ec55cd3","implementations/python/packages/raes/phase_contracts.py":"sha256:266e5d6462dbb3dac777779ac31ea03e926d8a6310f08d73670d9df1eac2c7dd","implementations/python/packages/raes/profile_selections.py":"sha256:f9dfe62ceda74265b648d7322cd8fc8851efe4223f9f420e4633cf9b7c1cbd22","implementations/python/packages/raes/propositions.py":"sha256:0945fb4bbdd16366107b53bdc707eb2c07950f49c74f2d6bd4979363c2d3b22d","implementations/python/packages/raes/prospective_content.py":"sha256:0cdde211372ed41d2ddf6a60045f405b0f79fd21d9560a39f180558954c43ef3","implementations/python/packages/raes/random_value.py":"sha256:f264fcf37e8e708d55b19f520581a845f42de6e932b3f44165f712932f80ac9d","implementations/python/packages/raes/realization_designation.py":"sha256:40910f5818e193c06c5c25e8b6d2ea969e356e94d9c6a112ea210b7a121c9ef2","implementations/python/packages/raes/realization_envelope.py":"sha256:a62f49569b788ce309c088473fbb3a2b78bc17f45437f41a12f221fc9fe9d7d5","implementations/python/packages/raes/relationships.py":"sha256:832512d4caac31d61234a2700df2f465bf93b10c5ea2c3c93ad8975fb5ed14a9","implementations/python/packages/raes/runtime_app_authorization.py":"sha256:f8993137b50b3c07fa2e5f207bda413a4853e4678b8ffd5ce444b191bbbaf176","implementations/python/packages/raes/runtime_application.py":"sha256:87fbe3ed1a0fb14525ca1e6921a84b745ff4af65ebe32cfa58c7c94d9660e387","implementations/python/packages/raes/runtime_application_values.py":"sha256:5867c2616225ad3f637e6795a5764cf9ca117761a0618ebcb38f8883ebb53acd","implementations/python/packages/raes/runtime_capabilities.py":"sha256:c9fea0e3ddf1889186143fbc0018931e38ffb23b7c5b17bcff33b6214f4f630a","implementations/python/packages/raes/runtime_configuration.py":"sha256:25be8a08e4f0cedfad9283a6d3004979c6f4ac0219890f23b64e96930f98f4fa","implementations/python/packages/raes/runtime_container.py":"sha256:532c1e12d18c694be863050205ed44c747a6e2885837b2f46d1b06ee4b089e84","implementations/python/packages/raes/runtime_database.py":"sha256:07eb505d17bb87c2b78b241119db2e2da890152d56686fc81a0c48c7f16ce70d","implementations/python/packages/raes/runtime_database_vocab.py":"sha256:3808ce47767fe9e0dee2d9fc88900d49ebfa151e72e2e688c1259cccecdfece7","implementations/python/packages/raes/runtime_datastore.py":"sha256:93554323c58c0cf7450062d1e67c09ae3bc1d5efa2ec100c458fd9e70562850c","implementations/python/packages/raes/runtime_datastore_nodes.py":"sha256:8de393e710bec8080e39dc22edc700f40823e5b16e986218e175e2e4516809de","implementations/python/packages/raes/runtime_datastore_partitions.py":"sha256:1f8a7bc111d5d406d0b5b6f3b74252135d6a081850694d8f4812c8c8b96b6b63","implementations/python/packages/raes/runtime_datastore_vocab.py":"sha256:2ea410546f08dd05a473bc24f0d681a4c9afe9d1bd199c1abb865a41ac5ad59e","implementations/python/packages/raes/runtime_directory_identity.py":"sha256:fb06ef7e60beed33c75bf02fd89fa351dd010e73fa71e15ce33b260bd9673059","implementations/python/packages/raes/runtime_dns.py":"sha256:0078cd06a90dc6e0a7ea239f0ba409e25864927475f9b20bc7d4cda2764cef5b","implementations/python/packages/raes/runtime_dns_records.py":"sha256:e74e2bb2dbee5380187f71d4b52af0dab1d01fccb83b0e552fee3783e23e8cc5","implementations/python/packages/raes/runtime_dns_vocab.py":"sha256:f6c7b42f434fa24dccee40d9f4483b345b400e9bc8fe982f1db5a4a7b23d94d2","implementations/python/packages/raes/runtime_environment.py":"sha256:fcc51597a29f4a1206291dd380b77b9660a474f5db00ffc60324540781deedf7","implementations/python/packages/raes/runtime_file_service.py":"sha256:9bec2b71a18425e508e8e88f4b7b3cf2910e26c17bbed5640680bf3600f355b7","implementations/python/packages/raes/runtime_filesystem.py":"sha256:f275a92fd5214181881aa7f6d3171ffeb5a41978c3466c44ca9da363b5562df3","implementations/python/packages/raes/runtime_forwarding_agent.py":"sha256:f3b021191ab6f6bc099ff7352e67bd3d214db97828c2bbe53354377dfd7917b3","implementations/python/packages/raes/runtime_forwarding_agent_vocab.py":"sha256:5cecaf20e06d2ba5bee65499ade6ec291ecbfdd293c66ee0990c194a86257cdb","implementations/python/packages/raes/runtime_forwarding_buffer.py":"sha256:208c1c7d809cafab7317fa8d20a0f1656b010429baf98dbacd89feffd1b27ff5","implementations/python/packages/raes/runtime_generated_value.py":"sha256:059f6205a1519f42e7ba4199a5c6db45dad0590ad20e99d03f4750c2db3ec189","implementations/python/packages/raes/runtime_identity.py":"sha256:f1be015e58073e2ec43ae3fac2ccd0efe7a97612f16f2d6bd6162d2d63a98572","implementations/python/packages/raes/runtime_identity_resources.py":"sha256:df6a81d578b7ae4d91924e8ac1cce52b6529782906ff7dac0c9d036ea1dbcb11","implementations/python/packages/raes/runtime_inventory.py":"sha256:82b9b51ce84d4f305e4a1689377225df33a1f4347a44539b2452461871ec6029","implementations/python/packages/raes/runtime_listeners.py":"sha256:288f691140821d054751bd8ab66a33bd0bd25238036716ac71e8f33f03668008","implementations/python/packages/raes/runtime_mail_service/__init__.py":"sha256:8518c090b2bb5d1ab75d68b688aa629365ad2b02371a164bc6316a1fee5cdce0","implementations/python/packages/raes/runtime_mail_service/_elements.py":"sha256:e7f7218ebe100a76b33ff558d789f1933638cca4816506d551f593a741a3d0fe","implementations/python/packages/raes/runtime_mail_service/_service.py":"sha256:0b715f86ab89939cce0afb11d2fb361916be9ade769a2afcc5f6b5df589a94ce","implementations/python/packages/raes/runtime_mail_vocab.py":"sha256:28fb1b8018dacb037998b989584eee3eee83e0dae3557a718e49ef8e7e6f5105","implementations/python/packages/raes/runtime_mounts.py":"sha256:beac87162c0b292b59cce2eb6444f0127a61ea430df08d7065f9b96d6e8bc7e6","implementations/python/packages/raes/runtime_network.py":"sha256:17e85ca74bac4e36370775fef6e12983b10274605b36be99ba32fcbe68f3d244","implementations/python/packages/raes/runtime_network_detection.py":"sha256:48fcd5366fabdbb21e4ba091a5cb8052a74f87a5f006eaad039eb74ecff1c295","implementations/python/packages/raes/runtime_network_sensor.py":"sha256:3eb90c7c0b4050d81bb3028d8ce9eb21e28e60f811b1d094f69ebaf4ff94ad4e","implementations/python/packages/raes/runtime_orchestration.py":"sha256:3a71ec48a28b78e3836734e8e2ffc56838dcff0f7b7a297ea44ad017441fc8c8","implementations/python/packages/raes/runtime_packages.py":"sha256:9899ebc115e18c995af4fae0f302cf4d9ac28357f01ca9a4b62322abe31dc050","implementations/python/packages/raes/runtime_platform_application.py":"sha256:46e2bc56ed33481620bbe13f8e1605a1643a712ec93d70f4ecf8a5b2636c95d2","implementations/python/packages/raes/runtime_platform_application_content.py":"sha256:8861ec9d5f316d89e341ba1372a4e0aa115056e90f2ed7b8e2fce704cabe2318","implementations/python/packages/raes/runtime_platform_application_vocab.py":"sha256:cde9c3c06342ea4c05b686a7febd8f279b526e72952df64c9529d9ed9bee0f1c","implementations/python/packages/raes/runtime_resource_limits.py":"sha256:53138b6bd6b2eb5f271b1c7b7182d12c4803684bff499f67d22eb396885a37ea","implementations/python/packages/raes/runtime_scheduled_job.py":"sha256:310dad371d9fe287a05a5317b38fa32410fe933d05f71fde0f2aa3869de2e413","implementations/python/packages/raes/runtime_secret_service.py":"sha256:9a2998919b1494cbe2ae2370e21cf5914f939b67211e7d2330ac7965da9c71ac","implementations/python/packages/raes/runtime_security_monitoring/__init__.py":"sha256:b0a06eab5196a1a20a2b9afc6fb6ba2f4591efc69bcd355ed67bcabb8daf1136","implementations/python/packages/raes/runtime_security_monitoring/_enums.py":"sha256:700abb87d685a7fafdef5fb549c5a93844ff52af47b30591a53234b3eb4c0035","implementations/python/packages/raes/runtime_security_monitoring/_models.py":"sha256:b63c1e18828ecdcea82ad99110a5af2a4137617f1c88393190143a8a8e577083","implementations/python/packages/raes/runtime_security_monitoring_definitions.py":"sha256:96424a9f5c5f1e24f20a101e3dfe1fed6cd1398f1cce58b46a22f6428ac9d7e9","implementations/python/packages/raes/runtime_service_units.py":"sha256:23ddb74eef9d3d313e6064a0d6e001232ba1f730cd70e5b31c3270825788c459","implementations/python/packages/raes/runtime_software.py":"sha256:d6e4a94fe28c33ac5bb077221acfa199e95aa8c905f49c1f96ca2de983b16bc1","implementations/python/packages/raes/runtime_software_profiles.py":"sha256:c2a72651e6544c6b57c402793153de73216b39f94c716db1fcdfa0ef4960e708","implementations/python/packages/raes/runtime_software_repositories.py":"sha256:805c26d8d8a0a7e92fecf6892f33d82cc03669a58374a4570954f71c546d2c2e","implementations/python/packages/raes/runtime_ssh_server.py":"sha256:3645a66d3156e3694cdfdf6d9aefec288ff08544af387bc0ebdf59889a258fe8","implementations/python/packages/raes/runtime_values.py":"sha256:10069302a9f8f5e6ff7c22f5c26969f6fc2145ffd2ec6d2161b3b3647c5ce2f3","implementations/python/packages/raes/runtime_vocabulary.py":"sha256:f4b3706c06f3448eeb7488d822acb5593c855eae5d83e498a8033070874bef8c","implementations/python/packages/raes/scenario.py":"sha256:9665193879afa612252a658d28802b4c8bf136ebe7de26e312893a5c28f48790","implementations/python/packages/raes/scenarios.py":"sha256:26cab68dd16ad36dd63259d7ccc4e6df75d80b4983963ea90216228d1d25417d","implementations/python/packages/raes/schema_catalogs.py":"sha256:36e55e286e7cab6068b0ff5944a9d695e23a4f18a9333a366e8668d7ec553043","implementations/python/packages/raes/selected_scenario.py":"sha256:f35f4ad34c2121573686473ad0ccca65ad720f0a96ce8d490f11fa080bb7875c","implementations/python/packages/raes/selected_structure.py":"sha256:bd92d02ebde1f2f3322fe953d75a0fd6a3c66e91f63d4241a5be8b92cc2b2444","implementations/python/packages/raes/semantic_migration.py":"sha256:38e96976770130ce47d5116037061a0e9a6d2451eeb005015cbd8727e01dfea0","implementations/python/packages/raes/semantic_revisions.py":"sha256:1032351f3d3ab044cfad40a8aa689cc041b2456a76213843467e9e43a620e810","implementations/python/packages/raes/semantics/__init__.py":"sha256:5518702d709ff0b55cb876a61aa65aa0716261f76d9dfffaf509b49b9e963032","implementations/python/packages/raes/semantics/_deployment_shared_services.py":"sha256:94fa5c30c73fa3e47e020e361b78126df4b514b65c278f9b912f8d7617231091","implementations/python/packages/raes/semantics/_deployment_tenancy_types.py":"sha256:64b16048c1c0586732606235929d6e638ef2d29fc9aa18529f2954325b047e8c","implementations/python/packages/raes/semantics/_domain_topology_bindings.py":"sha256:66abe751871d5841061ba8f6635fbb59383d12a672c3823ade616e75f8dc1870","implementations/python/packages/raes/semantics/_domain_topology_types.py":"sha256:839867814fcc9a53b3b7ed4f376f4a555c16acbf5b0919455ad3194870a84921","implementations/python/packages/raes/semantics/assessment.py":"sha256:f32464968b112148d11618e967ec45a27128130f5dd8256bb9351c508a50edf1","implementations/python/packages/raes/semantics/deployment_tenancy.py":"sha256:36cf57aae32854d42a5eb938c87f26ea4217cdd441bc3cd5966cc2dc180f03ac","implementations/python/packages/raes/semantics/domain_topology.py":"sha256:74b75714129a3a04fede634b72348ca59609a77902556562c2d6f6a67c07c0cf","implementations/python/packages/raes/semantics/enterprise_identity.py":"sha256:54d35a633d001ff54c8b5a225c934f3fdbdd2451171cfd3f8e9a2def7e7c81f1","implementations/python/packages/raes/semantics/objective_semantics/__init__.py":"sha256:7145134d15d5db5bf495c05dc6cc917a763727bc958632443cfee7f27f552fd8","implementations/python/packages/raes/semantics/objective_semantics/_analysis.py":"sha256:8a3a1d684e0b220a4b77078736cbb72ba700d3c69f9b9742a6e85cb7aa1ca87a","implementations/python/packages/raes/semantics/objective_semantics/_constants.py":"sha256:65dfff4c0b51e264440b92e6b3245d1a75a957a9c7699a39a5c56e073fe9b3ef","implementations/python/packages/raes/semantics/objective_semantics/_types.py":"sha256:4c2554c3cb28e074988b21c43cdcd49d9ee5b89f80c0da3bb81fb4bc5d496a53","implementations/python/packages/raes/semantics/objectives.py":"sha256:a6f4b93d8c62d95a86ac0915ace8643e8f826621168dcd490824dfe038060e15","implementations/python/packages/raes/semantics/participant_behavior/__init__.py":"sha256:f99f643b1a9506a21a418f285e90de706f172ce164fe731749931ce60ff9f5bf","implementations/python/packages/raes/semantics/participant_behavior/_affiliations.py":"sha256:08d8e6ac7f99765bbe9d6ed3cb9019800629654cddb1b264e135a87017ba79bd","implementations/python/packages/raes/semantics/participant_behavior/_analysis.py":"sha256:38e9250164fa8a83d7dd184455c67a352c865390ec89f1fd464b6026e35aae25","implementations/python/packages/raes/semantics/participant_behavior/_autonomous.py":"sha256:366bfa85f4df1477ab693252e1b4167e9e2477f6129a5494e0e322c14154668c","implementations/python/packages/raes/semantics/participant_behavior/_autonomous_bindings.py":"sha256:b96e2d0d78235fb5ef9514b0807f2e36882f248b2fd4945bbbd5c0c5755af9e2","implementations/python/packages/raes/semantics/participant_behavior/_behavior_spec.py":"sha256:e6cad5f9a6584b1b3e747aef60073d165311f3b9f1b66edb083cf09a28e390b7","implementations/python/packages/raes/semantics/participant_behavior/_references.py":"sha256:c13638da6d57279cc3edf8983b7f167206e43c93b373982e2a6cce3636a8c1bd","implementations/python/packages/raes/semantics/participant_behavior/_tool_affordance.py":"sha256:843f93d4646b3248080b1fd2d72adc5c7cab44aab33cb166b495c75157ace4ee","implementations/python/packages/raes/semantics/participant_behavior/_types.py":"sha256:6b857273e86cf942cffac51750db24d6eb756ab8f29c032d45079132835462c5","implementations/python/packages/raes/semantics/participant_interactive_access.py":"sha256:4c996162250c87369a84f6aad49181e77b35e1af9116664e024b487dbdba4bc3","implementations/python/packages/raes/semantics/participant_outcome.py":"sha256:9edc095f35526c4989a12779996f8584d4196ec1ef07b1a7eb0c6f11336cb78a","implementations/python/packages/raes/semantics/participant_temporal_bindings.py":"sha256:4ffadcf86ceda603430695709f14a1536ee23b01e3118441f3e61c8a49d9828e","implementations/python/packages/raes/semantics/propositions.py":"sha256:f8d8c69e8790590251f79cb293cfc49a965729da8ee967ce24d5b67d91cadf34","implementations/python/packages/raes/semantics/workflow.py":"sha256:6692d621fc1e06691654c1b3b030153d67c9117ec7537e7cc5314f60a7c1c92a","implementations/python/packages/raes/stateful_resources.py":"sha256:678cc4d08bc9530e42f0028aaee81865178e1da483ac8b325c9c75f208cebce2","implementations/python/packages/raes/time_model.py":"sha256:6275c8777d4a5ff2fb54c86d32598b8e2396f06e57a84339a78e041f1c1a7db4","implementations/python/packages/raes/transformations.py":"sha256:ebc4d735f9d76c70c06c6460c4d1279db13fad43bc8d5a206e1566a2b179dc79","implementations/python/packages/raes/validator/__init__.py":"sha256:61c32d4538184453cf6be462e153331aa7d0dd9772e7f5056441d39384b23397","implementations/python/packages/raes/validator/_accounts.py":"sha256:9fd6a1920da63a16d49acb9d646e46273783c0dfafa588df80c91f250b3e44bc","implementations/python/packages/raes/validator/_cloud_resources.py":"sha256:1d0b4b84f2fb94df1766f02f5f1af23674828469bcbd1622dd19aea8d6c07525","implementations/python/packages/raes/validator/_content_objectives.py":"sha256:bed4703d243bfb813dcc54fdb776075cc14f10ec505c7236f4f3d3157ad9a247","implementations/python/packages/raes/validator/_core.py":"sha256:66525cb88aaa462093d87340817e70798d79a8ed8873cc48c40d7e07c93ff086","implementations/python/packages/raes/validator/_deployment_tenancy.py":"sha256:b6274aa2be536f42f9c526ae369d51fa7f3bb99014002daf92dcf4b7f346dd05","implementations/python/packages/raes/validator/_domain_topology.py":"sha256:5bcf31ffd202c542d33d27a5ed176f5e6eebb4e7ebc41f5bdbee6e1cd1718ec3","implementations/python/packages/raes/validator/_enterprise_identity.py":"sha256:e9bb547eba03b0c6a9e1599cb9e5749f6874db42876eff2e2e5812dfcb364921","implementations/python/packages/raes/validator/_evidence_requirements.py":"sha256:f851a615df1cf5277b9c1e4884bbff42872a72b3b3714fa6eb640091a6ee5c9c","implementations/python/packages/raes/validator/_execution_policy.py":"sha256:5a776bdaebd78c614c9da05d43d1e95d67ea7c759e73a15dd3c147e0f7ffd83f","implementations/python/packages/raes/validator/_mixed_control.py":"sha256:3acc36f3b0f3dbd81f21b9a5cc8da2d69ab6a016941a039a49fcb5b0faf5d37c","implementations/python/packages/raes/validator/_mixed_control_policy.py":"sha256:c71bb965a9167347a6b649d8ddd6f864eed145e727a3545863443a3c4252f682","implementations/python/packages/raes/validator/_nodes_infra_network.py":"sha256:feebb3dfe1575386c2aaef31e2891f651f80771f1d3815a2941e0f489e7903ef","implementations/python/packages/raes/validator/_participant_effect_targets.py":"sha256:80f20c62535e36814a23bdbdbd8daff1d138207a9c55ffcb7c3d2ac00a5ebf19","implementations/python/packages/raes/validator/_participant_execution_renderers.py":"sha256:6272e91088a7ea2366521dcbca45910a15e0b7df19347dc525a45890d0caade1","implementations/python/packages/raes/validator/_participant_inject_deliveries.py":"sha256:b00232d3c248a49830441714958d2a57e98252b2d9559e7e87ab41c928e77c60","implementations/python/packages/raes/validator/_participant_inject_delivery_control.py":"sha256:ccd8528c0398feebc7537c686733defc636aaee16cd790dc0145845a392ce9cb","implementations/python/packages/raes/validator/_participant_outcome_renderers.py":"sha256:83379976ebf9c320d4649f67eedbd187d1947063bb33188c124ea1c45e958f21","implementations/python/packages/raes/validator/_participant_relationships.py":"sha256:509129477ebc2f988dcdfa85410e172d89886fee048a21ddc570cafcd96e2abc","implementations/python/packages/raes/validator/_participant_resource_budget_owners.py":"sha256:483f2de4c27d58521a70ea28e74b580204aa5c61f6d0563a1eb664787c636bc9","implementations/python/packages/raes/validator/_participant_tool_affordance_renderers.py":"sha256:206b5033a742c19221d6d2bc4c4b21ca66ecad8f6a6a5e9b1cc0459309afce41","implementations/python/packages/raes/validator/_participant_tool_affordances.py":"sha256:3820c2ff664c64b3b36b1c3a0f8fc967cac89ffb84e31ef4a4cd4bcb8f3b7b15","implementations/python/packages/raes/validator/_propositions.py":"sha256:4b27deda40dd9e0cc0ea784eff8c598c6aa7966f370f058471999dc5da977660","implementations/python/packages/raes/validator/_relationships.py":"sha256:9b4b2b81c3e3de17f2758fecc5f0442fd9a5d0dc8a4a3952b210ae24ed565508","implementations/python/packages/raes/validator/_relationships_proxy.py":"sha256:46fc87ee97e0176ead096c2c70fad7d45ee36f9b0e74ab5ee79a139b45347858","implementations/python/packages/raes/validator/_runtime_identity_data.py":"sha256:b80ebf65103020d2b63970f942621c6b386f92d321253bf86cf1244fdf34fcb1","implementations/python/packages/raes/validator/_runtime_listeners.py":"sha256:98ce804c309ffd1e93f2460940020e33e13253a251c42a63273e8364e57d336c","implementations/python/packages/raes/validator/_runtime_mail.py":"sha256:0089ebc5ff5590596e3ee0e27f96659539cd859c7f06940fedfbda8a146be677","implementations/python/packages/raes/validator/_runtime_orchestration.py":"sha256:b8311e2e9ecfd811fbb08a5caef29c55ed60a4a204c2ee89539105eeff611610","implementations/python/packages/raes/validator/_runtime_platform.py":"sha256:dd349d4c8a0f8d3b207119831d232376d0973efa9fc73c6f99cfa186d102fe61","implementations/python/packages/raes/validator/_runtime_process_limits.py":"sha256:f6d1c8160caefa7502668ba6e13f067ae74396c9254433bd9d5e0301edfa5506","implementations/python/packages/raes/validator/_runtime_services.py":"sha256:1bb60664fd4005889d463e5b8036f1591f62beb05e3ef2e89414d5498d869ae6","implementations/python/packages/raes/validator/_sections.py":"sha256:4530def4920753cb8dfc82bcd9c8489e856c075cf1c8bbf24689384ea642f7c1","implementations/python/packages/raes/validator/_service_materialization.py":"sha256:9138cf55e445fa02150335afe684d1faa178e9ae19ed8b84ab33eb2d2325de34","implementations/python/packages/raes/validator/_support.py":"sha256:cb7d132c63a8fefa5cfae62cdaf855ded4145d71fd1e6c85b0a327d4fc27e74a","implementations/python/packages/raes/validator/_time_model.py":"sha256:09bd14c6e1b77abd07920fbccd1fc5225f37fcc8bec2f1c261836514a4001e2e","implementations/python/packages/raes/validator/_variation.py":"sha256:48fd03f38190d07c196238d491da6ba5376ae6fc6e5662182d51e45e5bcb38ca","implementations/python/packages/raes/validator/_variation_satisfiability.py":"sha256:3bca432812acc6ca31e7bd51b42f6dd32e254c7036aeb5ab5a6d2be5c6d9a603","implementations/python/packages/raes/validator/_workflows_analysis.py":"sha256:663f3f52594be7953255849bf4809e64445e7cf5a0a9a3e79cda6668aea1a5b1","implementations/python/packages/raes/validator/_workflows_verify.py":"sha256:dc23da59eb30d0bdfc8b709213a9ba9dfcad37bf4a8d60a5e7a87f4f0bc1e6e3","implementations/python/packages/raes/value_parsing.py":"sha256:3232333a2adc80ebdae19c33bb4586227fdb6d35301c0e508a856951c02b3b2d","implementations/python/packages/raes/variables.py":"sha256:c8e1ae82a154c834ed3207c0d1043651798c73780dc0c2177ecf7cd13fe0d285","implementations/python/packages/raes/variation.py":"sha256:e6aec2fa65ba7b37a5c51f814389d312f9a488a704dbfc83a23fa5f70dd31085","implementations/python/packages/raes/variation_structure.py":"sha256:b931133ca31667ecdb958f4a0d954ffc3c7864288ad00baf24039a71a05380a0","implementations/python/packages/raes/vulnerabilities.py":"sha256:286870c9ff88c6693318bce96c9e0050134e49486dfce97ca5a4a87609daf66d","implementations/python/packages/raes_backend_protocols/__init__.py":"sha256:b9d9b3accd0e242fb0266cf94cb5bd97381dbb75fcbb85cd0c6acbc8a3509478","implementations/python/packages/raes_backend_protocols/_domain_topology_binding.py":"sha256:e124172d7db8d32dfa4dfcaf67e04d0573cc97f598be8fd8c0c352969dbb8633","implementations/python/packages/raes_backend_protocols/account_features.py":"sha256:d01d645f87684c305db80e39db3c12bffa4fd4a8f2a6eed69e5d854eef2c6556","implementations/python/packages/raes_backend_protocols/augmentation.py":"sha256:627db1112585b0f986b8a563ee1920b92c7fc8dd072d3c8a9c1e7ace301c3a35","implementations/python/packages/raes_backend_protocols/backend_manifest.py":"sha256:076b0ce24e88f9d6eed9bd591eb288ea39a435971d9bc0cb04612fb45dd1aa41","implementations/python/packages/raes_backend_protocols/capabilities.py":"sha256:f7abdb867425609c10ba2a41a8b0cdb7de98b2d4aa4f14eec87a9d966f6a8fe1","implementations/python/packages/raes_backend_protocols/capability_admission.py":"sha256:c596ce365543eebfb870fc84af504e876f4c55a03a1dd131e09c2e43ea3ed9a2","implementations/python/packages/raes_backend_protocols/domain_topology.py":"sha256:f6e4376188e5dbb8ced97f37b9d74fda1d67e01e9704aa1b158ed69ef8b816e7","implementations/python/packages/raes_backend_protocols/inject_execution.py":"sha256:b60c6acb721b6c7df77dabab6f188c0c691898c24b783c3b8dc934eb0e5b2f43","implementations/python/packages/raes_backend_protocols/inventory.py":"sha256:3d71ab788a3eeb8bc49563a0c327b2d2847192a1b26e57e8b0e366bc03b593c6","implementations/python/packages/raes_backend_protocols/manifest.py":"sha256:0e7e57495d30fedd78bd8d40a8a99cb10309e7960a40bb6dd15e45afe3f8cd05","implementations/python/packages/raes_backend_protocols/mixed_backend.py":"sha256:6a138da1b26cb0c4cf022a3e08baa1c1cd7deaeefc84a2bb05751a4d7e2bd8bd","implementations/python/packages/raes_backend_protocols/naming.py":"sha256:4a87c02dd21c23327a6ce086a708b3419193261062f19bbad09ca95e5d7b9388","implementations/python/packages/raes_backend_protocols/observation_capture.py":"sha256:6f5f0297e1242f9390c58138316b217e881df8ae9ed86c8cbc94af6d71579b35","implementations/python/packages/raes_backend_protocols/observation_manifest.py":"sha256:09baf9001d6a27130fff60376bd86defcf3f82505d87196c174876142bb8110a","implementations/python/packages/raes_backend_protocols/operation_supervision.py":"sha256:3f04ff36d812095fccbf1986a2ad8b9f2b90e6fb1ad18da5c008267ef0fda6bb","implementations/python/packages/raes_backend_protocols/participant_action_commit.py":"sha256:8c859066ae69df49cd442e4c97a21a7d96a31a17f6011ba125619c6ac8e7ce32","implementations/python/packages/raes_backend_protocols/participant_capabilities.py":"sha256:487623430bf594f0bcb77e4e39ab568289bab89ec30bff88a3e68f3116a4edad","implementations/python/packages/raes_backend_protocols/participant_control_admission.py":"sha256:189f6c2cf0d4ae7cfd069894322a2cdb162c8bd3c6675b45b25c7f21f43d4dbe","implementations/python/packages/raes_backend_protocols/participant_execution_manifest.py":"sha256:d1013152b9411167d19bfdcc60b9c2bd3e13b9e01a09ff16781ce81def1102e6","implementations/python/packages/raes_backend_protocols/participant_execution_runtime.py":"sha256:c3fcc8421f7d6124b605176a005af288170012f7dc7a73435dfa96b5d0a3d0b3","implementations/python/packages/raes_backend_protocols/participant_execution_service.py":"sha256:2034b22f467b0a82e3f982cadbfa1ee546147d1e4a1aa777eab0641e22bde3dd","implementations/python/packages/raes_backend_protocols/participant_feature_admission.py":"sha256:d1446ca2ccf10d8b979c0ff72bca7b9b886a8ac34fb0ff24fdaebb9b966414c5","implementations/python/packages/raes_backend_protocols/participant_reset.py":"sha256:1bbe991ffec08cce7e6de568e2f9a63e24286667eeaf44be97a9676bd5b90efe","implementations/python/packages/raes_backend_protocols/participant_resource_admission.py":"sha256:2cd226382cb89813643447723f0dd10d7b2f4d988429bbb6cfcda8ac381de3c1","implementations/python/packages/raes_backend_protocols/participant_resource_budgets.py":"sha256:da69afee35d962ae52c8a2551833826fe7d6e3f9fd0e46dfce07c9ed32b8bb87","implementations/python/packages/raes_backend_protocols/participant_runtime_base.py":"sha256:4b862c1b7c4b04ebf1a130e1974fddd61c90f392efac74e112fbe92f57ffc7b0","implementations/python/packages/raes_backend_protocols/process_resource_limits.py":"sha256:52e37d0decb47930cfbc818e56cb947ab0c2910a961a866cc9536b3484f0ea4c","implementations/python/packages/raes_backend_protocols/protocols.py":"sha256:15abf0ee2d0f3671368df5df63f3daa058cdc4d5f7790de92df1643b3b37fd0a","implementations/python/packages/raes_backend_protocols/provisioner_capabilities.py":"sha256:dcf434187534b42894f78e1d2253cd49f5fec43c3de49d7159bc4cd6bcc9e3ab","implementations/python/packages/raes_backend_protocols/provisioner_manifest.py":"sha256:fe8b0b895e73376036a5972c57404eaf7acca18d0b2c8f5b7946bf83b52db621","implementations/python/packages/raes_backend_protocols/recovery_observation.py":"sha256:35e3ef65a3140d2736d277b1539f1db6cf0126fe2e365b04ea19217508ed14ba","implementations/python/packages/raes_backend_protocols/service_materialization.py":"sha256:69d31f7dd286352fe79b7b0c1dd23c21203111906afc0fe4961637c2a1685aa1","implementations/python/packages/raes_backend_protocols/time_capabilities.py":"sha256:1e32fa64ac749d32ea9f881289b2c8148bd10acb0266644d5554ef32d30d90a9","implementations/python/packages/raes_backend_protocols/trial_control_admission.py":"sha256:dab93ac7cb4f2731f971ccb313de2ca33bb43c2a4110584cc91d24f024a3f834","implementations/python/packages/raes_backend_protocols/trial_unit.py":"sha256:6b6e91eed04a91ffb3772ecef4ba59a3b98e8f0ce15f421d0cbb69f07d667115","implementations/python/packages/raes_backend_stubs/__init__.py":"sha256:c4bc2318b8bb68c9a522af362488c9334cd97bf01e563c9f92e09dbad3371769","implementations/python/packages/raes_backend_stubs/evaluation_support.py":"sha256:8e3dcc7b082e1f192dc2ba3c0b879b13612d82e6ee2db0c6b45086aef444b249","implementations/python/packages/raes_backend_stubs/manifest.py":"sha256:4ff6fa1bfea360533634a42a212a0b5054890efbfad4d3c7ad8d3a55cd16a939","implementations/python/packages/raes_backend_stubs/stubs.py":"sha256:91e46a4676bbb6bdfd2f9039e45063518ca707dbf9350b85f9303bac317f3caf","implementations/python/packages/raes_cli/__init__.py":"sha256:8ed778ca474c2d5bb0a4bdb81ecde2de5e58fbe7f86992e1e079f5f425876ef8","implementations/python/packages/raes_cli/_semantic_portable.py":"sha256:d95657124adfd4dc6aa2868b73b57fac8fcf1186c3c8cdd841913dd710032a89","implementations/python/packages/raes_cli/_semantic_result.py":"sha256:afecbcb7d0c8031e5d5dd316a1edb5d06c350dd187a1dcf6fe6a37036ec483f1","implementations/python/packages/raes_cli/_semantic_sdl.py":"sha256:3ef5122999864246f144e2f9e5ba20d95e11b7ec74fbaac0576c159fb4f25b42","implementations/python/packages/raes_cli/conformance.py":"sha256:8f8b3850f4014bc7a7bfdc68b2344a76422097e511715bb4517fedd66612e727","implementations/python/packages/raes_cli/entrypoint.py":"sha256:57e2e652e5479fc9bfccccbd9a79bb4fd89ed0dbc1bac2698ee9aefd3f69b44e","implementations/python/packages/raes_cli/main.py":"sha256:2a97acf643dc94888364ce6b342a504187bacaf6b84a04420a144ab3b59572e1","implementations/python/packages/raes_cli/processor.py":"sha256:69fd31a64fb6655092ce6230542a8c1d1a2fe989bb085af22ef421d626bc8a8f","implementations/python/packages/raes_cli/runtime.py":"sha256:3c4cccc850037a24320885bcabe585260377989097b6656e3b7dfaba9d6d304f","implementations/python/packages/raes_cli/sdl.py":"sha256:3d7cd42bbbc9239410a0de1993f4d000d3f4872cea2f9910a5cc1f1365e4bd29","implementations/python/packages/raes_cli/semantic.py":"sha256:580d406c21c1359c58f75d196dc7fb872cc9ca72a9fbae39cc2ee14900a7f878","implementations/python/packages/raes_conformance/__init__.py":"sha256:3342173a2a9e576f6602745f7a3e0a9b4f15f6063b25e9b53f10a3f854ed4b4a","implementations/python/packages/raes_conformance/_authoring_observations.py":"sha256:e5d3fd29c2da1b7303eb6a4dccf0567c6fa43c7d4cc9763b11f5807a26cfc1e2","implementations/python/packages/raes_conformance/_materialization_scope.py":"sha256:2fb10351a2056771c76c57940d0b10fe1fd74924d46e9390e084ab3a99a9f68b","implementations/python/packages/raes_conformance/_realization_models.py":"sha256:049674e4340609b6533cd75ba2791e29da1af4ffb27850db8cffeaa9e05a4501","implementations/python/packages/raes_conformance/_realization_validation.py":"sha256:5e2126ba216f71be000ac9ce9d3d340cadd4fcbe2b63433e266d88c55f596499","implementations/python/packages/raes_conformance/artifact_transformations.py":"sha256:fe3885725d2e350137ab81984f4aefe4e44e51436922d0e0bcaec48e815213ac","implementations/python/packages/raes_conformance/authoring_adapters.py":"sha256:bced13d9c95508494694d721551437c04c8c617011b86c8df9da347fa03b0b99","implementations/python/packages/raes_conformance/behavioral_validation.py":"sha256:9ebbde02b6d6322673dcecd11c608c846ddbbd55ee4c1f36395cb8f956d21cbb","implementations/python/packages/raes_conformance/conformance/__init__.py":"sha256:4b048c05c649d7f0ec1e34495784fdf9ffb101e02068e4230d1b98e27b172950","implementations/python/packages/raes_conformance/conformance/control_context_assets.py":"sha256:c940799fa543097cc97971d64bbff49c7cfffa09bdc6e57ab28f0446a479566a","implementations/python/packages/raes_conformance/conformance/diagnostics.py":"sha256:990d42bd5971c735894a3c37525fc75612234ec6fa0df77765b4fbbc58f3f250","implementations/python/packages/raes_conformance/conformance/fixture_suite.py":"sha256:fe7f559b37edd9e070750e541c9b194acd392365c52e9a999922b4ea85df5ae8","implementations/python/packages/raes_conformance/conformance/mixed_backend_cases.py":"sha256:b224b153a554fff4990725f92693519cddc98250bf44c94de70762ca91823d44","implementations/python/packages/raes_conformance/conformance/mixed_backend_execution.py":"sha256:c6d0a03383ec1bda4e924a87773f2a1035bfa6bb4ce9d248400c762d42a14367","implementations/python/packages/raes_conformance/conformance/mixed_backend_judging.py":"sha256:c974ee32fdfa32d0dd98878a558fe040730817f85ceafff83465c2f270de27a2","implementations/python/packages/raes_conformance/conformance/mixed_backend_probes.py":"sha256:97943f23c4f3ca61e4c50ec21e8dcbc3391acd132662be9aa0b8de43365fa727","implementations/python/packages/raes_conformance/conformance/mixed_backend_types.py":"sha256:b9248bf3e75cf6492c3a6371ef988a94a076be24972b6532ea0162b5d5b2fe7c","implementations/python/packages/raes_conformance/conformance/mixed_control_probes.py":"sha256:23406636c9ba7a88fe878ac8da6741459bdd481396c03ed2df4fbbfd0e623a3d","implementations/python/packages/raes_conformance/conformance/modular_control.py":"sha256:3e5efdda8c988e625640031986539510ee0855da3822776cc707c98ce6d95f6c","implementations/python/packages/raes_conformance/conformance/modular_control_checks.py":"sha256:59ab4f66e6405d394e8d9cce86b627e688ba5fdae8b86b370e9fe97b5e4bd694","implementations/python/packages/raes_conformance/conformance/modular_control_execution.py":"sha256:929498bbb9b59cca10b4656a58fa40024d42064e1514d2fdac4c75659bd87b22","implementations/python/packages/raes_conformance/conformance/modular_control_observation.py":"sha256:ecc54e60508ae88f17bf292a356c865ae7a6a4fceeb553523e8fcdd0333e8479","implementations/python/packages/raes_conformance/conformance/modular_control_policy.py":"sha256:b751cc7ed3e3a2123fe3d0a955d034d6a2b13f1482b778e9dbf572b24b4050b9","implementations/python/packages/raes_conformance/conformance/modular_control_refusals.py":"sha256:9af876a7e7264138d256e605436f3fa2bbaa0b967743c1142af4c4adb85fd370","implementations/python/packages/raes_conformance/conformance/modular_control_replay.py":"sha256:1f56efef48b772b878187e00e49cbd9804cf5cc53cab92fbaa14dd67fc04f12f","implementations/python/packages/raes_conformance/conformance/modular_control_report.py":"sha256:d999b301251ac52d701484e0d56830b4da51f6ba12efff5f0f4f5a52d58a45d8","implementations/python/packages/raes_conformance/conformance/modular_control_types.py":"sha256:9361617608c53f01a43a12bee983ffc43fee62afa92fb32a24b5dca75914bede","implementations/python/packages/raes_conformance/conformance/observability.py":"sha256:b32ca6aa5292348a0a3cebf13e3a605cdda3b186ef221b86477003d562f6a6c5","implementations/python/packages/raes_conformance/conformance/participant_execution_probes.py":"sha256:0e0129196ffc715494976c90c36f9f4c1850efbce2ed12396639dfa998649596","implementations/python/packages/raes_conformance/conformance/participant_opacity_execution.py":"sha256:5602480b26aabf219d6ae512f865833a55aec2a6fbb8423d7a85324b6cfa2624","implementations/python/packages/raes_conformance/conformance/participant_opacity_probes.py":"sha256:280dc52b58469fc06d1c1948b7ac510cf4771904f3d32776a0fbd27d0c5f38ed","implementations/python/packages/raes_conformance/conformance/participant_opacity_projection.py":"sha256:05e36c500f301117d7d4dc5f3374c0e12b5fb1e9d21e32239962deb5da2888e6","implementations/python/packages/raes_conformance/conformance/participant_opacity_types.py":"sha256:aaa9800cb03e101cf7bc20f9e4c1a351a5b0e91e1775d6772026b7c8d6ed68de","implementations/python/packages/raes_conformance/conformance/participant_policy_execution.py":"sha256:79094459408cba28f692464fc2702a4d2f67991b6f35bc082667300cc9ed916e","implementations/python/packages/raes_conformance/conformance/participant_policy_probes.py":"sha256:e311a727ce53bc4658f51fe2462aa684e2b5b3422a7291b39a4e5d528ff9cdf3","implementations/python/packages/raes_conformance/conformance/participant_policy_types.py":"sha256:a29af3b6e1e100131106908ddb77572048a047f938645b1a8aff2e449e1b702d","implementations/python/packages/raes_conformance/conformance/participant_temporal_probes.py":"sha256:78e6c3e04e13060ec395f2136b5b434d6b11de3770781cd1db57b810f81efa8f","implementations/python/packages/raes_conformance/conformance/probe_runtime.py":"sha256:408b0fe61664a9cfb09e3352f729fe5a14a96ef6195cbbd7ea8a0e14f5843191","implementations/python/packages/raes_conformance/conformance/profiles.py":"sha256:83f184461620fd636d271a88d9786cd2ceaa6804f897896076ba1ce8fac1e12e","implementations/python/packages/raes_conformance/conformance/report.py":"sha256:530bfa3ac9d4ce0854915d1f2c5d7ff31309905ecc9ad0f973a5d77a062338b7","implementations/python/packages/raes_conformance/conformance/semantics.py":"sha256:24db36222e3f9511f0ead2def037d0beaf487804384a307bef3ea23a654e49a8","implementations/python/packages/raes_conformance/conformance/snapshot_semantics.py":"sha256:66bfc0f2b8b56fe8c8cfe97d870f6b347fe739f2391050c836bb500dfcaddcea","implementations/python/packages/raes_conformance/conformance/target.py":"sha256:b5d4942a6462a121d1f8e86c6235676eb370938567695a006505cc938ce328c2","implementations/python/packages/raes_conformance/conformance/target_manifest_probe.py":"sha256:466421cbd16c6ec212b12f220f24140e529a0ea64d476e8817f1ca7d94119acc","implementations/python/packages/raes_conformance/conformance/target_planning.py":"sha256:ed9e6061bc0e2786ad185ac110fd57d04e7e28b40db6845fc6bc6d81142f2ca2","implementations/python/packages/raes_conformance/conformance/target_probes.py":"sha256:5271e8c01b5246234686905b4bcf90abd2a901bc4fcfaa8ee68fa1058af51677","implementations/python/packages/raes_conformance/conformance/validators.py":"sha256:4fba9429521cc791489002870b49150294d70ea99b015e80db5383a249fd752b","implementations/python/packages/raes_conformance/necessity_evidence.py":"sha256:afc480bdbd909d25515ff23ef8b94e2cac5a923bdfd21b994c0eb6b45285a7e0","implementations/python/packages/raes_conformance/necessity_types.py":"sha256:c36707d3312e403cb2dc1c007f5877e9a174a7b7572df231a64c5403e56d1715","implementations/python/packages/raes_conformance/necessity_validation.py":"sha256:bece582346e43023c5f83a9d6e70dea194aca60a9095117d5bdc941546cd0cef","implementations/python/packages/raes_conformance/realization.py":"sha256:74f0d9acd557e9355a84c57031a94733c57bcae87b4be6f70334abdd0cc9ca7b","implementations/python/packages/raes_conformance/repeatability_evidence.py":"sha256:7e257761b4b53cac1bc8ec69e023874ad5c41050fd3fa9f4af7e4d65ff07fae9","implementations/python/packages/raes_conformance/repeatability_types.py":"sha256:aeba75172cdb3fa8e7243908a6f12a0a34f47cd1abc602e05b4c8b6c2c194d9a","implementations/python/packages/raes_conformance/repeatability_validation.py":"sha256:a81c7a7255235484073d6764c822ceff18fc22bf3f2cd38eaf13a5a24df32e53","implementations/python/packages/raes_conformance/time_semantics.py":"sha256:448388955317888e26f43747c4ead061661d560d34565844758e732763a0ec6c","implementations/python/packages/raes_conformance/verification_authority.py":"sha256:45ba8ab38c69726acc8731b31e9ce56f5d6517ff60a4ad28930d78f117f9c630","implementations/python/packages/raes_contracts/__init__.py":"sha256:0213374e29c98d3ffde797dbd676295045c20b99cfa7965aefd39220a44e7238","implementations/python/packages/raes_contracts/_base.py":"sha256:bafa6c345b77d1209eb06a3238042d9d770bd746b742bdc5dd5007d7cf3d4345","implementations/python/packages/raes_contracts/_behavioral_profile_loader.py":"sha256:9204a99e35cf7c2d26affb1a3b349ddf4313e885d51c5e86dea93051c9ba4fe4","implementations/python/packages/raes_contracts/_canonical.py":"sha256:235601e18c32b3b005f05145782b79542291408d9ddcf309e179d325456ec9ab","implementations/python/packages/raes_contracts/_description_assertions.py":"sha256:ce4170c8e3e10ce06f86917ea37f724b3786a10dc21e7a2b614dfe6f4ea08689","implementations/python/packages/raes_contracts/_domain_profile_admission.py":"sha256:ce2cd9c5d4b7e79397d3da99081da7d814598db88e941ee9e801d876b857ff17","implementations/python/packages/raes_contracts/_domain_profile_contracts.py":"sha256:839b060da3b1dfb4c3efc8c039b1bef5ef865231dce30c34ac5c7d2c772b53c9","implementations/python/packages/raes_contracts/_domain_profile_resolution.py":"sha256:f8de1fc5e2b000484cbb769311c228585511a8f4efa29de29d2bdac26e20d0f6","implementations/python/packages/raes_contracts/_domain_profile_schema_identity.py":"sha256:14553e46bc52e77927fb47c2cd56553e4768511063cccc58e3a2838a813e89b7","implementations/python/packages/raes_contracts/_domain_profile_schema_registry.py":"sha256:3ea0df50000c3ae1b00cfb437701a404e9edb0dc3bc0a63f6b31d17167a981e3","implementations/python/packages/raes_contracts/_domain_profile_validation.py":"sha256:6da14bf7e24e1ed2fa27b50015881b80d0c9709b428c686aa493dba28618d9f1","implementations/python/packages/raes_contracts/_evidence_content_validation.py":"sha256:2f5b8a6f2b2cebc0eba4414bbf0a79a2bdc951c0c2e857ff56645239b58eb3ce","implementations/python/packages/raes_contracts/_participant_behavior_types.py":"sha256:0406696774c5a363a0608610ac4481de23499572e8cf3f0293d312b919e23b1f","implementations/python/packages/raes_contracts/_participant_crossing_multi_profile.py":"sha256:2e946a618fa4cd74af6b846e2e5c2abb0afc6e77691939cf5d2a47ba8fa1fbbb","implementations/python/packages/raes_contracts/_participant_crossing_profile.py":"sha256:0d9474b24d431295629af1e8b9c9842f91e7448b95a1f3fc5ea1f21b824d7d2a","implementations/python/packages/raes_contracts/_participant_opacity_common.py":"sha256:10a984bb0f2eff43fe971c880e72d0d7f09aa2ebec9889fffe42c607daf10f58","implementations/python/packages/raes_contracts/_participant_opacity_model.py":"sha256:c572c9789e8b7f254f3810ddf32417abf406ed4baa3e5a8270cd659d7fb938ed","implementations/python/packages/raes_contracts/_participant_opacity_model_check.py":"sha256:e549204fff3e3615c8672ecb47e1a81c87817864aede3d5c527b4ca2c3c46377","implementations/python/packages/raes_contracts/_planning_validation.py":"sha256:53087d695ef90d8a2c4bb96be3d07183229ec00e7a9d4fc2ae46d6bd4de1e2ac","implementations/python/packages/raes_contracts/_snapshot_updates.py":"sha256:675e09847095f5120c2242bb58b4fff747636ca49a976768b580b8b4450694d6","implementations/python/packages/raes_contracts/_validation.py":"sha256:27ef941ed41551a8d9b20dceda70ffd97183bab668aee21def92ef53cfa39f3b","implementations/python/packages/raes_contracts/account_credentials.py":"sha256:e942bca965a6e5afd3f70aed5dd89fab66df1bf95bef19fc19eff76970c0529a","implementations/python/packages/raes_contracts/account_materialization.py":"sha256:3992c510bb73aeb2e68d6bf5afa55043a3a4c4bcb03a8a17513d9f33a94f7aa7","implementations/python/packages/raes_contracts/addressing.py":"sha256:f2cf89565217003403688097c082d5382c53e19e97a347a3dd11c376f545aca9","implementations/python/packages/raes_contracts/admitted_trial_plan_ingress.py":"sha256:a3b4fd10fcbc3b1cb26287c2e77f00c7bd61d8d99caab6f7529f2231e3f34918","implementations/python/packages/raes_contracts/apparatus.py":"sha256:1ecf7037770befe3b301b4900d70f87c0df6fa90483910d69a6ebcdd642fa0e9","implementations/python/packages/raes_contracts/artifact_generation.py":"sha256:464eee9c1b7d4e8f19ecd8a7c2e7e0a481d0305ac4d42cb9e3e20825134ebf70","implementations/python/packages/raes_contracts/artifact_requirements.py":"sha256:464a920d4210bae275a5c5fd3a76932240cc01514bb2a6e40b96f96a3b6d6c65","implementations/python/packages/raes_contracts/associated_artifacts.py":"sha256:84a1a07e4dc1c706c09d524266627846b6d7c8342423051c7e06be71aff075fa","implementations/python/packages/raes_contracts/augmentation_preparation.py":"sha256:8dd393b3cc951aa85e89e74ef78678903b1376650798b0347e89e7b40675da11","implementations/python/packages/raes_contracts/augmentation_scope.py":"sha256:66d91a8ca7b24b84887388101f5e225c145a7aaa0b98a2ccfa089b6e2ae5c370","implementations/python/packages/raes_contracts/authoring_adapters.py":"sha256:1ab4488af27c89a4e5ea60f7224829e2ddc9d74805b9aa4830668f4b2664aba2","implementations/python/packages/raes_contracts/backend_profiles.py":"sha256:969c766051af41696f3305928b75fec9e978234983a6abf93f80ccf4879cfb8c","implementations/python/packages/raes_contracts/behavioral_relation_profiles.py":"sha256:a37498cc4d139f5a6f77009ebb4d546152ea60953188e8c707093a06850628cd","implementations/python/packages/raes_contracts/behavioral_relations.py":"sha256:549addba85debad67420d288c9e5a6057050fc7224bee91a81b1a8f9a2def4db","implementations/python/packages/raes_contracts/bounded_domains.py":"sha256:72fdb024533c0a0be11f5507c6e23a2f8d7e36a121c2ad9490ce291fdc363e78","implementations/python/packages/raes_contracts/candidate_synthesis.py":"sha256:96bde3853471d4888732d1fd1ea95ba642448eb6768f59b116f840c0ad0963a6","implementations/python/packages/raes_contracts/canonical.py":"sha256:eff8b51fee43ebb09628abf71612ed73eb403825c93219851965079837fed52a","implementations/python/packages/raes_contracts/capture_dimensions.py":"sha256:a145c90b3969a171143b7781e3d4958e94ca79ba91a22c5091395f514b3bb265","implementations/python/packages/raes_contracts/compute_substrate.py":"sha256:9f55b91ec39faeae7e851f9d960ce16dbc98e8dcea36324a74e4ff3f28cf2199","implementations/python/packages/raes_contracts/contracts/__init__.py":"sha256:32305d87f4ec3f7818ce79a3a58fcc8f528fbd7704a7d6308ecc1f8081d94576","implementations/python/packages/raes_contracts/contracts/_backend_operation_exports.py":"sha256:04e0e57daab80dcb664c56f5cd27efbc576eaff14bad362de5954834eecab056","implementations/python/packages/raes_contracts/contracts/_bundle_access.py":"sha256:04aebc2ffe3007f89ae2fb479dfc3222c7d710ee3e0eb502138ecbb3fdf1ea5a","implementations/python/packages/raes_contracts/contracts/_candidate_synthesis_exports.py":"sha256:3342370dc977c8ac4e369610b85718a71b16570d493f8e9375cc153f8175b8b0","implementations/python/packages/raes_contracts/contracts/_candidate_synthesis_facade.py":"sha256:285abd768ecbefbbc58ca1a9e4523613b870e2673b9aa22ecab08b308ea1c544","implementations/python/packages/raes_contracts/contracts/_capability_schema.py":"sha256:1193568016144bbffe46ac7e09baafe380283b6bb6f027e90a1f06999c745973","implementations/python/packages/raes_contracts/contracts/_evidence_requirement_exports.py":"sha256:89e467f931cbd4a439787cfb76cf09d126741971b40869693795341b27980ee4","implementations/python/packages/raes_contracts/contracts/_execution_policy_exports.py":"sha256:8253608267c5fde17a45c25bc3ec382aaebec1d9fbf36edd34cc939313e15005","implementations/python/packages/raes_contracts/contracts/_experiment_design_exports.py":"sha256:e198af51a1809c48db49f7a372da1b2c16c67ee93557c31660ade93286ac6ae9","implementations/python/packages/raes_contracts/contracts/_exports.py":"sha256:685bca2fcb6815f93f98d5cb0242cf4c6f2ba6e00aa53903ffd03709b69a600d","implementations/python/packages/raes_contracts/contracts/_inject_occurrence_exports.py":"sha256:9d2948705b5e8c633f078d4239303eceea97a9aa2b89c73fe2d512fd816c96eb","implementations/python/packages/raes_contracts/contracts/_mixed_backend_exports.py":"sha256:5e2a160c4c2f618d7cd79ddbce7fb09b3e3f147efcae97f232103fc39b981f31","implementations/python/packages/raes_contracts/contracts/_mixed_composition_exports.py":"sha256:44d0d7b51e3d3754b1714e616ea71e21e8ce14a6c5c49acb7c29291be8b75356","implementations/python/packages/raes_contracts/contracts/_participant_control_exports.py":"sha256:f95af3663e911e0f0270bc5878c8aa2d85f75c81ddb7046b286bd88ff173a5ac","implementations/python/packages/raes_contracts/contracts/_runtime_fact_exports.py":"sha256:611b4a24d7f3f816e2c034bef410261a440f7fec1a7536808e9d0981b350b3fe","implementations/python/packages/raes_contracts/contracts/_trial_cleanup_validation.py":"sha256:9b3455c4d50d928165087bf46c1dc2e316bc7668904380c9c756fcc20e638698","implementations/python/packages/raes_contracts/contracts/_version_exports.py":"sha256:9a1b0889aa243d997c5fc6a897d97dc5e4cca44bdadc5d0f3975979692bda53f","implementations/python/packages/raes_contracts/contracts/admitted_trial_plan.py":"sha256:34fd5a8a5af4883816c175b4d09405fc01e0b66ed7d75a4dff44a36a003ad43f","implementations/python/packages/raes_contracts/contracts/admitted_trial_plan_components.py":"sha256:032a19afa106a80b58653f6da28754d46ccce85d8c94510ca83be094eae216bd","implementations/python/packages/raes_contracts/contracts/artifact_transformations.py":"sha256:509167193cc1e255999b020be894736061b26c6dffa6ff1eecbd5bf1a3b47f2d","implementations/python/packages/raes_contracts/contracts/associated_artifacts.py":"sha256:3431024b33e0b72ab632e09192e0ef044109d3a95bc397c9c5c61f4ac081b581","implementations/python/packages/raes_contracts/contracts/backend_operation.py":"sha256:d587b31778f9e6b1bfd94680088c0365f23301453d0fc56056619844d2ebee39","implementations/python/packages/raes_contracts/contracts/backend_operation_response.py":"sha256:cb18802d1fed61c6ab62687a87d4705e6710a1c6386b9fa08c2fa676f7421810","implementations/python/packages/raes_contracts/contracts/backend_operation_schema.py":"sha256:9b8daefc02e3465b16c2c8a337b38994444ce52714f2939c16e88bb2bd85e3d8","implementations/python/packages/raes_contracts/contracts/backend_operation_validation.py":"sha256:a2a9cc9357822932124805453689b9e12b88562a070d19c63cf6acca68adcc0e","implementations/python/packages/raes_contracts/contracts/backend_preparation.py":"sha256:0c701d833638e254e9937252a06e0581813615c934d830b46a67c554ae8cbd55","implementations/python/packages/raes_contracts/contracts/base.py":"sha256:faac49b16de9657ff8ab92bc18e5da28edee1488923157d2fdc44c1800e193e8","implementations/python/packages/raes_contracts/contracts/batch_execution.py":"sha256:2f76d706dbfd083aa06a6abcfc75cb95b25d878a431454bc3708fa46828968ad","implementations/python/packages/raes_contracts/contracts/bundle.py":"sha256:47f5e36c5838631ddfaa0c7341b3ca1517bcdf8ec427c35c5b0ef2bf3e1b715f","implementations/python/packages/raes_contracts/contracts/bundle_runtime.py":"sha256:cd402e2d4cbcda6d2c98a1a56bfdd1f1df7a25001ab57347cfdafc11be916f18","implementations/python/packages/raes_contracts/contracts/candidate_synthesis.py":"sha256:27e2d8dd181450f72d9b4123f4f52e3063a134b29895322f2cbc8db5a89cc562","implementations/python/packages/raes_contracts/contracts/candidate_synthesis_profiles.py":"sha256:17a23a17ae33a4b9b843925442eb1ffb46302958e721d48d92ebdcd9e2394ded","implementations/python/packages/raes_contracts/contracts/candidate_synthesis_traces.py":"sha256:6d6ac1523d867b6b6fb63d80cfa1a48b2029b32c1883dc064bb5288c349136e3","implementations/python/packages/raes_contracts/contracts/capabilities.py":"sha256:8ba5440e0886ac98c6f2888f39e74d9f71c16da831f78181f2fdde50eb51dc3f","implementations/python/packages/raes_contracts/contracts/catalogs.py":"sha256:23df2fe9dc8f6e9df9d1ec584367a3c188d56e1d15ed0da6b05e5c15edc837e0","implementations/python/packages/raes_contracts/contracts/difficulty_adaptation.py":"sha256:779a95101b3194acc35878e7c1e22e3db563835732efea87ad00e4c1e03cc1de","implementations/python/packages/raes_contracts/contracts/difficulty_governance.py":"sha256:6d3dfdd13c60c82294118385d33775313d0da9d0228979177a677a519567020c","implementations/python/packages/raes_contracts/contracts/difficulty_observations.py":"sha256:e4f4641e127eb1dc95c1574a041b67b6b9baf8aac17c6ec688330c9d9c3b5eb6","implementations/python/packages/raes_contracts/contracts/difficulty_provenance.py":"sha256:40b44e9d6ee4ae7bdea244d2e3f601940b35f1a2f30d18bb0a2aa010d0330a41","implementations/python/packages/raes_contracts/contracts/difficulty_resolution.py":"sha256:adf75df11017e4c9b33cb334e53f1617fee1be1bdb5864368bb307b4c4fcbea7","implementations/python/packages/raes_contracts/contracts/execution_state.py":"sha256:9bd5eb6467859b57aa6fad87dbc76e5b0942e938a4fe09b1c7851f02042d6b5a","implementations/python/packages/raes_contracts/contracts/experiment_allocation.py":"sha256:6a1000d9ac3b1367954b26adb14f3753547d8334ac53750bd172e22812800cb4","implementations/python/packages/raes_contracts/contracts/experiment_analysis.py":"sha256:e05b0f8ea2cabe3bd920cb8cf62dcd9bd86064ff4d5573f3957ee67e47254ea6","implementations/python/packages/raes_contracts/contracts/experiment_apparatus.py":"sha256:bda0362c6cc6eabe26e450d2f7dc82e6776b199b9fd7515f3671a84778c1e9f6","implementations/python/packages/raes_contracts/contracts/experiment_archival.py":"sha256:8e2f8a6d34804d088dac5e85163b4c229cee46c5d76e3bdb8157b758d695a99a","implementations/python/packages/raes_contracts/contracts/experiment_artifacts.py":"sha256:b39326ec3efa061c7f44135e34959f8f9744528781355a997a6c26365e6eb5f3","implementations/python/packages/raes_contracts/contracts/experiment_bindings.py":"sha256:b4095cdb6b9636cbb44900f3674ad8efbc98e8819225cb1ec894aeb379f5f7bd","implementations/python/packages/raes_contracts/contracts/experiment_capture.py":"sha256:a71ef8387bf0a5baef9fbaed2bbc72c35d89a2b54af303d865f5f0f8de0d9554","implementations/python/packages/raes_contracts/contracts/experiment_conditions.py":"sha256:31056caa2467ec92ad63d0a1858f2bd6f266f881a433e3f983511b34a3914fc1","implementations/python/packages/raes_contracts/contracts/experiment_difficulty.py":"sha256:80913e221e6b68d794bb07c66a8c237ef64da396264a9029152887b9c7d7048b","implementations/python/packages/raes_contracts/contracts/experiment_disclosure.py":"sha256:af61336e1122bcdc1c36d1723c8ca474468c1db6e0539e0ed882f2625374364e","implementations/python/packages/raes_contracts/contracts/experiment_evidence.py":"sha256:8e272ce58f309779a2c68e2514a9f47b91e94dac4f203766e0b7e2bbbe11762f","implementations/python/packages/raes_contracts/contracts/experiment_evidence_refinement.py":"sha256:d5dbfdb8b0c7c1294585fe885c5e6046b59d8f9e4e54fc1e286d0af04f1aa7da","implementations/python/packages/raes_contracts/contracts/experiment_factorial.py":"sha256:f32b0717606d2415c537c4b3690f32f40883bd5ff69fad8bc6528085be6a50db","implementations/python/packages/raes_contracts/contracts/experiment_factorial_treatments.py":"sha256:21de94698f40ae572c6ab917dc2c5cfd43abd66e6c6c7d5b65035e4c64672b12","implementations/python/packages/raes_contracts/contracts/experiment_manifest_references.py":"sha256:eee196f5ad172da5bf1de72a0b857494e1cd9a103357196a4bae6c155d812fa7","implementations/python/packages/raes_contracts/contracts/experiment_plan_controls.py":"sha256:ff0632be7595403c1ec7d9b7f8f11f5512cb82579f4830ca4198707d42e69048","implementations/python/packages/raes_contracts/contracts/experiment_references.py":"sha256:41e58dde62698c0ce710f05aeafdb9b78270f826bbf827c2c4723fce2dc45cd5","implementations/python/packages/raes_contracts/contracts/experiment_run.py":"sha256:0dbd0fb6b68d974ac1f8aca9ea4a589aeec893afaf3d793c5fcc65119484b35c","implementations/python/packages/raes_contracts/contracts/experiment_run_difficulty.py":"sha256:cd3f1bea34dc9b30b714bd588cff8cad2ab08bfc12fbbc27c9e02910b768b6a8","implementations/python/packages/raes_contracts/contracts/experiment_run_evidence_validation.py":"sha256:b3ab15d45761f10f53a2ef15d9258633adad2bc60803cbc85cd64671b990e176","implementations/python/packages/raes_contracts/contracts/experiment_run_stochastic.py":"sha256:ae866e571c58a427c4650ea717175d1e28e44be334e058a484c41e45f209aead","implementations/python/packages/raes_contracts/contracts/experiment_run_timing.py":"sha256:97df5bfbe6d4a6230cbf5903659a8653644cef8a7ef4f10be3dfe0e37e4abc4c","implementations/python/packages/raes_contracts/contracts/experiment_selection.py":"sha256:836c5cf4fef229893122c85d992951e2a8eec37241ddb9cf1db3f42f51d8ed2c","implementations/python/packages/raes_contracts/contracts/experiment_spec.py":"sha256:cf8404ef2a16b4c0c2a9677083c1bfb5b9a5baaf2636d35089dbdb51c4e0bf21","implementations/python/packages/raes_contracts/contracts/experiment_study.py":"sha256:185af0b7cd89ad068642dd91959a6e7fc150193f154b7c394209cda4cf013fdc","implementations/python/packages/raes_contracts/contracts/experiment_study_contract.py":"sha256:852666f436c5e5b909b22f02df61071b98b6c3518270c71309b807b83056c017","implementations/python/packages/raes_contracts/contracts/experiment_study_run_validation.py":"sha256:3ee70c4445b78b16254fae9495ed103a1123b724441de334f2ca2218024b0e47","implementations/python/packages/raes_contracts/contracts/experiment_task.py":"sha256:2ef3387b639b1162f4bf1add674e4f31bc56b71fafec2849c1efc4450996be5d","implementations/python/packages/raes_contracts/contracts/experiment_treatments.py":"sha256:6935480e6d3938049a61cd311fbc720876f356e2a8b6598a07de64e163bcc917","implementations/python/packages/raes_contracts/contracts/external_concept_bindings.py":"sha256:8c034e8fe4801a9767625d2bab9fef0cf7e8a4d3140154246b216d57ca851744","implementations/python/packages/raes_contracts/contracts/feature_support.py":"sha256:bd8d86b9d4dd4b015ff254330bf3a9bf9b3746058350b175ee7c14823b03f4f2","implementations/python/packages/raes_contracts/contracts/inject_occurrence.py":"sha256:8fbf7c60f490b62be5a5c703b39832a3b58553e3a606fc533b18311f0aca031d","implementations/python/packages/raes_contracts/contracts/inject_occurrence_outcome.py":"sha256:09657f4b311e2a67aa88966342b64ff1bdf8a2df8cc06409b68706f55967fa2d","implementations/python/packages/raes_contracts/contracts/inject_occurrence_schema.py":"sha256:c94e3a48b7763ae79c832b940850f906eac271206a575a4a8c01b62cfda71e18","implementations/python/packages/raes_contracts/contracts/manifests.py":"sha256:ba111f55e903ab2a88cbf7f68130bd9b49def0fa0e8e94ce0af9813bb8a2116c","implementations/python/packages/raes_contracts/contracts/materialization_attestation.py":"sha256:ddfdb301d6f6270992279f145e0b9210fc7302e45792ef10973420b6566e225e","implementations/python/packages/raes_contracts/contracts/mixed_backend_binding.py":"sha256:7c4439a1d68ed119be0c9415e54cbaf8b7ed0ed9926cd859c9141d368075a132","implementations/python/packages/raes_contracts/contracts/mixed_backend_schema.py":"sha256:5930acb14e5808ab19b1be76b12998b25859a9697c98620a118291a4b40e61ea","implementations/python/packages/raes_contracts/contracts/mixed_backend_stages.py":"sha256:86c042458cf49da47c40553534f914078fe91cc4fe1047f8db91b031bb17909c","implementations/python/packages/raes_contracts/contracts/mixed_backend_transcript.py":"sha256:09c69d345f4935f7f5f3fe9da0fae610180bfdc0722304133bbbefb029c77492","implementations/python/packages/raes_contracts/contracts/mixed_backend_validation.py":"sha256:1ef333a3f5e25033c1f3ce0c40d516d21de719bf2619c1d1a50d09f7c4f13a15","implementations/python/packages/raes_contracts/contracts/mixed_composition.py":"sha256:c4554583d32cb1aecb01edb7fd1988182250597618fd57ff24f2b78fff26e5c2","implementations/python/packages/raes_contracts/contracts/mixed_composition_resolution.py":"sha256:c9f79563bae5874d29e2323803ae3dedc6a3d125639fd9f6dadc69383f9118e0","implementations/python/packages/raes_contracts/contracts/mixed_composition_validation.py":"sha256:d8615866cef66c2d117323d6857c7ee80c3e40e4091cb59dc8b13c37ebcdde1c","implementations/python/packages/raes_contracts/contracts/mixed_runtime.py":"sha256:635e005856975cffd85b091c526a427ffb152c169100d311fd88f99518c2883d","implementations/python/packages/raes_contracts/contracts/observation_capture.py":"sha256:6d0980898ff345ebab2451f7469e93fd90920310e6b815e377e779c439d4fa35","implementations/python/packages/raes_contracts/contracts/operating_systems.py":"sha256:ef8c4068042b8041a5a6213470e48ce1de1f30384874cc8096a04dfaf1fd7300","implementations/python/packages/raes_contracts/contracts/operation_carriers.py":"sha256:9e074f1fa309f5628d9556cccc6daae09775611c494b281b2c817d63bc4228de","implementations/python/packages/raes_contracts/contracts/participant_context.py":"sha256:8739017dfd84d290c739a348798877faf8fbcc7024f8e0d9f05bd5d1177d29a6","implementations/python/packages/raes_contracts/contracts/participant_control.py":"sha256:696516fcd3eab4f5c610345b35ab45734177ab7a08405fb5303645e64a00050a","implementations/python/packages/raes_contracts/contracts/participant_control_applicability.py":"sha256:3e0440ffe9902b6836377dd800a997bcadffdc4eb81dc328ee1d26d7766a7083","implementations/python/packages/raes_contracts/contracts/participant_control_composition.py":"sha256:e62261c625e8fe4ca56247db1e2552a82f126ad7953bc5b8747f4c228adff829","implementations/python/packages/raes_contracts/contracts/participant_control_composition_v2.py":"sha256:cc17d0bb35a4204c858df1d012a2ab04d372b4e526acf123147995d68c56114f","implementations/python/packages/raes_contracts/contracts/participant_control_context.py":"sha256:b828a18356719b2612abe87908943851c3f1c2e4763e471298ae88182baeb82d","implementations/python/packages/raes_contracts/contracts/participant_control_continuation.py":"sha256:37b6b33140b7f7808fa0bd0bdfdcb41b484e25f8a004fd8cbfaac82f42e3f50b","implementations/python/packages/raes_contracts/contracts/participant_control_coordinates.py":"sha256:c36476c58a31d11d57f545fcc24d8c49f93f38d5a2fa51b28317a55c848150d5","implementations/python/packages/raes_contracts/contracts/participant_control_decisions_v2.py":"sha256:4c3886c28f2487537a15018104c6acc39ae5b0419bb1c79a8e508d56301ccfd4","implementations/python/packages/raes_contracts/contracts/participant_control_effect_composition.py":"sha256:eaf0268f4d56ef68d19a68b2ef8accbd8e0420095cd80dc7274edcab51117e21","implementations/python/packages/raes_contracts/contracts/participant_control_effects.py":"sha256:d7735f0c8438954080937ab255667036796a6b0f05025de7f08696c025a11585","implementations/python/packages/raes_contracts/contracts/participant_control_episode_prefix.py":"sha256:8692625e078af4b6c853b4d9e5c2b2128323eb277f4ac3e38eb0a2454d16822a","implementations/python/packages/raes_contracts/contracts/participant_control_evaluation_v2.py":"sha256:334c15dd980f94ea21c75d588d7c4f8d46748f44a0604bb945ddfd782f5fe5b2","implementations/python/packages/raes_contracts/contracts/participant_control_history_verifiability.py":"sha256:246684d3af9812e013b2ec0adc856d60036f0401b1dad696e90a33fa6322b2fe","implementations/python/packages/raes_contracts/contracts/participant_control_inject_resolution.py":"sha256:080de6df140dca68fbfaff136f1352e1cebeabad615eb17e587c885ddbd5e864","implementations/python/packages/raes_contracts/contracts/participant_control_invocation.py":"sha256:802f57ea4a4443799950a36cbbb0483a3383c50ffa836d625d42ee4128ec2497","implementations/python/packages/raes_contracts/contracts/participant_control_occurrence_v2.py":"sha256:7d0c2e127218cb10deb1af97870b8e8de2c7a01a361908f90d54489bd0a64e5f","implementations/python/packages/raes_contracts/contracts/participant_control_occurrence_v2_policy.py":"sha256:a30504d043ea0fb7089e551c60ff16f8ed40515b13bf84921e7049dc585dc000","implementations/python/packages/raes_contracts/contracts/participant_control_occurrence_v2_state.py":"sha256:caf0182990becd7b2a0eee16b0b905a49b88e1801e09c8e5169302fc94264f69","implementations/python/packages/raes_contracts/contracts/participant_control_occurrence_v2_validation.py":"sha256:6e8da89662bb5e1a7b5ad04884e72a75ac1ce089203795a85e1fcb2aaa853a64","implementations/python/packages/raes_contracts/contracts/participant_control_profiles.py":"sha256:a3b3d44d1acc39d8cbaba6eb4333a2947d617b1c200607ab111bb9a940a82c72","implementations/python/packages/raes_contracts/contracts/participant_control_resolution.py":"sha256:3ed9cd5e8e8dc8a922d1fa8a6019020de79c74b5e7878a0c4747336fbbceceb5","implementations/python/packages/raes_contracts/contracts/participant_control_results.py":"sha256:4815d7dca59272ec5022b5b8b357b09e5102105af9f584b7c9ae2d51442ce07f","implementations/python/packages/raes_contracts/contracts/participant_control_security_resolution.py":"sha256:46e45804f9bd28360258c5ee9ecc3424c385ed66df2d843588584608978348a7","implementations/python/packages/raes_contracts/contracts/participant_control_selection.py":"sha256:8d3c9a631ea3f7294611440b5eb4b05ae6aa753aa91b82aedf526166aa9b8803","implementations/python/packages/raes_contracts/contracts/participant_control_support_v2.py":"sha256:af8f5d29505264a742ae7987afc85f26a5e3329916bf3a6e677e847ae6328b63","implementations/python/packages/raes_contracts/contracts/participant_control_validation.py":"sha256:70342332dee6089e23e16645dba5e3b40ed95db16fd884a5ea636153e6e138cc","implementations/python/packages/raes_contracts/contracts/participant_crossing.py":"sha256:c3ac84309e48d6944b9f036940954af5df2f2127c4f56b47f4d803c736bf9e3f","implementations/python/packages/raes_contracts/contracts/participant_crossing_indexes.py":"sha256:403d446d6db5529ed9a8edbcdc19ac9876e258e1d0c0901b4dbd626430913da9","implementations/python/packages/raes_contracts/contracts/participant_crossing_prefix.py":"sha256:e098be8d5269a9ac0f4b59254bdd215299f6c2a0508ce939faa455238e9fab14","implementations/python/packages/raes_contracts/contracts/participant_crossing_validation.py":"sha256:be587d9c7fac7fb88143da8cd939c76610cd5446a88e235156ff9c05c62e615e","implementations/python/packages/raes_contracts/contracts/participant_crossing_vocab.py":"sha256:c8bae91c7a9f5f5802a80f6556c641c23c00e0de5f6feaf9ac9db4b62a526ebe","implementations/python/packages/raes_contracts/contracts/participant_decision_state_cut.py":"sha256:53f5cb5ebb30c28fa63b3c278805267738835bef624a88c6460bb98cba734215","implementations/python/packages/raes_contracts/contracts/participant_decision_surface.py":"sha256:396245a6e351ff51e64a300f370ddac5e92b69fa9ffa03ac61fe802f4aa7b4a9","implementations/python/packages/raes_contracts/contracts/participant_decision_surface_exposure.py":"sha256:49b114aeb38c190937901a4a85b960c9b2115521d4aa90365ab6b9cf74c44148","implementations/python/packages/raes_contracts/contracts/participant_decision_surface_exposure_v2.py":"sha256:89f88d3a2829315878e786f53e687b8b34e9d3a795ea8fb3bef27e5c2ee0e9fb","implementations/python/packages/raes_contracts/contracts/participant_decision_surface_v2.py":"sha256:6615e69ede0ea20480339753cd153d1a0d5a541a7bd751368b6d82ccb6388588","implementations/python/packages/raes_contracts/contracts/participant_decision_surface_v2_validation.py":"sha256:f8865d19836553c338d211ddbfed93590519975b87fe1a6d931f15916545337b","implementations/python/packages/raes_contracts/contracts/participant_envelopes.py":"sha256:fd65bc21a25327ee5fa97d8175c323a745cc3ba56fcd7f4d8761fac1594f4fbe","implementations/python/packages/raes_contracts/contracts/participant_execution.py":"sha256:30c5acf1072e28c2f987b78eb8c551bdfaf0ff73c23fac932b4b141bb95ccfef","implementations/python/packages/raes_contracts/contracts/participant_flow_control.py":"sha256:1fa1db7d9de956eee9232542b7ec2d9199552879458ef9d8ea8a1f4e6b83ce44","implementations/python/packages/raes_contracts/contracts/participant_flow_control_context.py":"sha256:4e60b2e56faf2500677e5310cdf3035c8a8c02f7f9364f253d4859ce0a1b0dff","implementations/python/packages/raes_contracts/contracts/participant_flow_control_incumbent_validation.py":"sha256:7239f1981c3ceaa256fc8735b7e0935c5e8e9e3fbdfc13159b24047ee16dbd57","implementations/python/packages/raes_contracts/contracts/participant_flow_control_profile_validation.py":"sha256:c1dc833a4cb8b7f72ae0849543187d0f80864cd43cccb17736635e291e6ca303","implementations/python/packages/raes_contracts/contracts/participant_flow_control_relation_validation.py":"sha256:92c45f747fb52a9d5e4722ab3a6d1ec00133f18561b6da62ed3e35b6c4dff7af","implementations/python/packages/raes_contracts/contracts/participant_flow_control_semantics.py":"sha256:b343513f8daec961377b6a4c5868a4aefcade20f5e6c1cec9165bbe45a56fc68","implementations/python/packages/raes_contracts/contracts/participant_flow_control_validation.py":"sha256:81f3954e5ead814670184dae90323e5e8987f40cd2dca5fa15acdb06f67237ba","implementations/python/packages/raes_contracts/contracts/participant_information_state.py":"sha256:a0304330958e679bbfb0808b1bed87e250f536c3fd7ffd442c139cb9c1026ef4","implementations/python/packages/raes_contracts/contracts/participant_information_state_sources.py":"sha256:156355208e60e680ae578284efc10d2abeea9f4c4fa02fc3fa862a2a19dd47e0","implementations/python/packages/raes_contracts/contracts/participant_inject_application.py":"sha256:293cbe1101d919a36bb45ef5284daa04fe01b930eea30b3f494aaa8b5e136605","implementations/python/packages/raes_contracts/contracts/participant_manifests.py":"sha256:bee590b0e8cf8f9330b90dcb43b8620fdc5e83de98734fb5af4eccb276415c7f","implementations/python/packages/raes_contracts/contracts/participant_observation.py":"sha256:021d39dd1ecee65b5db96bfb99abefacc7628288b6621011a72e70a1d64cb174","implementations/python/packages/raes_contracts/contracts/participant_occurrences.py":"sha256:df74ce67385134abf0f24a551ac48e635a55a63924817089b819c98c758bf7e0","implementations/python/packages/raes_contracts/contracts/participant_opacity.py":"sha256:78ebf9da77b1c713e064f6d74fd67345c1df3f30376568a0bd4fa4b187e16aa0","implementations/python/packages/raes_contracts/contracts/participant_outcomes.py":"sha256:d9cba8a70b4e13ffe24a7397c5971ec742059acc927d563753cb2623487ec7dc","implementations/python/packages/raes_contracts/contracts/participant_owner_flow.py":"sha256:0c0565db48437641d8e8aeea99b0b7c23f2d55db66759255209fc06eeff1f6e6","implementations/python/packages/raes_contracts/contracts/participant_owner_flow_admission.py":"sha256:2d4ed38f63da3780502b52a83098a6daa01d7fab685e542897e27c9cf5a19953","implementations/python/packages/raes_contracts/contracts/participant_resource_budgets.py":"sha256:1fefa84a8b00c1f23810cd69f194838c73041c0477486379e91a399d6386f849","implementations/python/packages/raes_contracts/contracts/participant_resource_types.py":"sha256:a743ed9d29d878c105356a73c55afddd4290000bb22751a78179c648804bb6e3","implementations/python/packages/raes_contracts/contracts/participant_resource_validation.py":"sha256:679ccb9d283c4a9e2950ea2a6b27f10d5bf705678a23386c38e690b3f72ec5d8","implementations/python/packages/raes_contracts/contracts/participant_runtime.py":"sha256:315a3acb436e142454b2ce6a1dfb8cd0cd0890f6c63b6f1ca59133c15f75b2cb","implementations/python/packages/raes_contracts/contracts/participant_temporal.py":"sha256:aad0ee2441762b9f62dfe695fe1461767eff66bd7e889ef9963c84e971161e1c","implementations/python/packages/raes_contracts/contracts/participant_tool_support.py":"sha256:a746263065813eac2573be4ae03143f1e0a13f0c9d848582ceb68c825382c514","implementations/python/packages/raes_contracts/contracts/participant_views.py":"sha256:62df900fe3f256531812927d884ee6a9332b3509abb73b5cde9f09bdb9964b2e","implementations/python/packages/raes_contracts/contracts/plan_operation.py":"sha256:757cf23dea06947b5cf3b604aafe76a3e37508a16d025d20b54145f39f168629","implementations/python/packages/raes_contracts/contracts/processor_capabilities.py":"sha256:099227de7a5a91133772a624a3dbbd11a0b66a11bdb50a945aff51e0df143dde","implementations/python/packages/raes_contracts/contracts/random_stream.py":"sha256:604dc5d3e44a1b50d811feac327f08d224b44a254abf51093d863de9ababb7d3","implementations/python/packages/raes_contracts/contracts/realization_descriptions.py":"sha256:ba6d1ef3b7b36f0ec58ee80bf3b3ed3de07753365561de5245b6fce42a697520","implementations/python/packages/raes_contracts/contracts/realization_observation_validation.py":"sha256:2501a5d451b70f05c2cccfe089f3e5f93476ac8b8f83575ce5713bdf87d59dbc","implementations/python/packages/raes_contracts/contracts/realization_plans.py":"sha256:41aeab98138bbd39efacaf3545ca245db099397e14b54eb0dcdedcba4cbacdfd","implementations/python/packages/raes_contracts/contracts/reusable_assets.py":"sha256:ee693fdd87e67a18e18bde0f0bd26f01b8428dd4fe6500eee9dc360ebbd834fb","implementations/python/packages/raes_contracts/contracts/runtime_facts.py":"sha256:805acf70e868d7f9946d973dba06a63e0ceb174242c90af79379f3f22333b1b2","implementations/python/packages/raes_contracts/contracts/schema_constraints.py":"sha256:a16219ff7578b3f3fda93468b42d516d42e0f819c3ba8093d77515538f1ae32a","implementations/python/packages/raes_contracts/contracts/schema_factoring.py":"sha256:ee5904b3c59d068cbaba8bc43869c32435a4d0af28724de6547807df995c60a5","implementations/python/packages/raes_contracts/contracts/schema_invariants.py":"sha256:d26667ab9d35b47fc661634191f1e992945ee8a40fe48c66994cb6bfb30f6241","implementations/python/packages/raes_contracts/contracts/semantic_profiles.py":"sha256:654ab2850ca87396f4ced4f78cac08ddc97134dfa4f96fa6937227b9fb0c5591","implementations/python/packages/raes_contracts/contracts/semantic_projection.py":"sha256:b6d84c4b5aca42109a903d81c80e7b8009211c593e3f1a01757cd45f027c6d04","implementations/python/packages/raes_contracts/contracts/semantic_projection_profile_registry.py":"sha256:b004add234df6ec19f901c47fdd0e66ec63779c600d01b9269aff6f94d474f73","implementations/python/packages/raes_contracts/contracts/snapshot_budget_validation.py":"sha256:a3c0dcf1cc07fc3d85e7e7033e828da3d33af9a8b1d6ddb95c6707efd52a816c","implementations/python/packages/raes_contracts/contracts/snapshot_entry.py":"sha256:d1849a54760383f74edc9dca260ba301b959e7dcf1004d46a9c1cfee8e5fcf9f","implementations/python/packages/raes_contracts/contracts/time_manifest_capabilities.py":"sha256:5e182a1445aed97e5d03666db9d1ee19d7a774369665fb468dc89d1439934041","implementations/python/packages/raes_contracts/contracts/time_model.py":"sha256:84ec175d0e0cee91f8f7f6cd6dc784b61aecd1d6234b6a9fa3e5f829b7fab9a5","implementations/python/packages/raes_contracts/contracts/transformation_schemas.py":"sha256:f59ab4e8d2ea5a2fb20fccc4b3388fb63e170ab409f137f6fb3c3bc9eb4ab712","implementations/python/packages/raes_contracts/contracts/trial_analysis.py":"sha256:d9c859280b9f26e6412cc00d123633c8fffded92983b934b5403398901e38f5c","implementations/python/packages/raes_contracts/contracts/trial_cleanup.py":"sha256:af56eae2f86c36ee08d5404a8256c9d8413a5ca1af7317e1e0f3b7fcb42280c1","implementations/python/packages/raes_contracts/contracts/trial_compilation.py":"sha256:17822f3a9432ccca2e4a87b753201b360c56cc2892a52e1a6f37ee4d4cace1b9","implementations/python/packages/raes_contracts/contracts/trial_controls.py":"sha256:e5671aafe11348188a75b59e0d1db4bb3b856c31133abbf176b309b9eabb7d18","implementations/python/packages/raes_contracts/contracts/trial_coordinate_order.py":"sha256:3fe02f78b6c438349c4ef7a2d236bfe11517e8ea847c4c3744ebfa10c569a195","implementations/python/packages/raes_contracts/contracts/trial_provenance.py":"sha256:ea37c929f29daca4dd3de54d2d36669d0afdcc3be31c33ba4c548528b5fa03a6","implementations/python/packages/raes_contracts/contracts/trial_replacement.py":"sha256:09a00b92250d062676832de13c93b09b1cd61fb74b4c8af0d8ce0b080eb196ac","implementations/python/packages/raes_contracts/contracts/trial_replacement_analysis.py":"sha256:24d275f039539d7c785d635c85e32dfd471c959cc87217a90768264b108be863","implementations/python/packages/raes_contracts/contracts/trial_replacement_archive.py":"sha256:9a276a1e44c6d912424a35dfc9f841e6dba67e57a9aa93b1b88bc772fc462025","implementations/python/packages/raes_contracts/contracts/validation_disclosure.py":"sha256:270b95fe36203c61beeb3a4b4db2f5f856f006ba732915e3af6e56ca4b8af0ee","implementations/python/packages/raes_contracts/contracts/validation_disclosure_gates.py":"sha256:1c8a91a9350b2476d40fa781e8c002da40d21061337f934699efc21b8d21e9f9","implementations/python/packages/raes_contracts/contracts/validation_subject_reference.py":"sha256:d139a6821fae22cf6eba828e78fda12a46e3c1f3cb0bb864152d86dafe502338","implementations/python/packages/raes_contracts/contracts/validators.py":"sha256:7a883bc162de4b17d1dd81c56dda669c1a2bea8cbbb2402bf5670d25908b2b65","implementations/python/packages/raes_contracts/contracts/vocabulary_sources.py":"sha256:c816882f18d5f0beb1eefc0305453a14c7ea2a4272c290823993e36876329990","implementations/python/packages/raes_contracts/controlled_vocabularies.py":"sha256:aa4e7006dd2b011ebe4bbab84db2912bf51cb8fb0491fb77f0805d013ba16525","implementations/python/packages/raes_contracts/corpus.py":"sha256:13c0cf475a0b1812bd50238329f56f2cd1d5c511f6d4a86ecd6e9f584ce32551","implementations/python/packages/raes_contracts/description_coverage.py":"sha256:038a9fb52c68395a1d80511ed6d007a00ff3d7751559cb21b58ba657a2ad5c5d","implementations/python/packages/raes_contracts/description_projection.py":"sha256:ea87b2ea9ef96ae523d156c5f5b11bf54c8f2e865608063e8546844132f907f3","implementations/python/packages/raes_contracts/description_promotion.py":"sha256:512797b9eab5e41507100f142e4685ff75c58469748a8ba3711df97383151b4a","implementations/python/packages/raes_contracts/description_reporting.py":"sha256:9cd6ce92829b99bf072364602a9f8288de6646adf3f32075d63a30c2f0859abe","implementations/python/packages/raes_contracts/diagnostics.py":"sha256:83035d6cd8cd3ad9fa7ba5505fc753f6724c3781a705ec49599485fd7dad52e9","implementations/python/packages/raes_contracts/domain_profiles.py":"sha256:5e0a85bce9702778ee83aaa9ffa0ee81033743feb36c0a3fcb6cb784ae00ee2d","implementations/python/packages/raes_contracts/evaluation.py":"sha256:4bcf242fa06b974d8d25a6af78cc33a5cf51946a5827369d3b6f2ae558cbcc78","implementations/python/packages/raes_contracts/evidence_output_validation.py":"sha256:b809af15758d95b667a75f18399d95d820d55eec5b158ba0228186e3c3fecc4b","implementations/python/packages/raes_contracts/evidence_proof.py":"sha256:683a7d75a4dd856770640967555ac6d91b3bbf8352ee19c3a23898b2c262f465","implementations/python/packages/raes_contracts/evidence_satisfaction.py":"sha256:7941a5919a1f1133c6da4ace193e7419f384bb786b4ae134e598f564fa487501","implementations/python/packages/raes_contracts/execution_policy.py":"sha256:852a6a813ec6fe9ecd4234d5765cb0089e77d96e05fec317d69717bae681015f","implementations/python/packages/raes_contracts/execution_policy_schema.py":"sha256:2f8118c405802ced941c2493f0e6b636f2900ec37003da6477cb167d20d4c054","implementations/python/packages/raes_contracts/execution_retry.py":"sha256:04082df9f27db888230c196caae727c1c08be04102e226396384af3b9e769d1e","implementations/python/packages/raes_contracts/experiment_bindings.py":"sha256:934b53480c630f91d44f8b650e20a19276b08d59164e2c8987dd8661d2a35c48","implementations/python/packages/raes_contracts/experiment_spec.py":"sha256:00d98734b1fa5134c6e7d027362aae1595cdf08bfc632d47613d2b6538d5d293","implementations/python/packages/raes_contracts/exploit_path.py":"sha256:57a515866bc5126e8b7b9983b04fa8b0acc193c934471826290a8080265498c8","implementations/python/packages/raes_contracts/external_concept_bindings.py":"sha256:d1f064d61b4d618f68124c40e66c715bbb5cd80ae4ca72d744a0e12756641c59","implementations/python/packages/raes_contracts/immutable_history.py":"sha256:c173240a724542d63199979e8baccc009d721c41097d56cda817f0ddaa9c6bab","implementations/python/packages/raes_contracts/immutable_history_stats.py":"sha256:25d845d0fd9fd26c73086414cb7485960bb51c81bd34ddbdbe80d7275705ce64","implementations/python/packages/raes_contracts/json_ingress.py":"sha256:b2ae13274cb0752f9f97828032a26283456efc2483110908dd09c52ca243faa5","implementations/python/packages/raes_contracts/manifest_authority.py":"sha256:11d976c918c39fb5a946563aea6b96c2e89ee7b0b6cf0dc41a93fa7a611ef00f","implementations/python/packages/raes_contracts/materialization.py":"sha256:ca1a2763eb96658ded2f8e9d342b98763220128c492c08f824f24e080630b8bb","implementations/python/packages/raes_contracts/materialization_inventory.py":"sha256:b4b750062b34822eb9253e84da9f2cb9922a487692a03de4923f90f5cceb3e19","implementations/python/packages/raes_contracts/mixed_runtime_history.py":"sha256:e22d5a52a08cef20e84a07c4da624757670762e0fd20f6acd9ac8dbfc1d171f3","implementations/python/packages/raes_contracts/observation_demand.py":"sha256:1bbc54fa0c6e7819d178a5670be07cc1e83901979232d9d057d991f7e07e0e53","implementations/python/packages/raes_contracts/observation_demand_resolution.py":"sha256:264166ed3a58b227ee0cba68715a289ecf555d5f83745fcb2cb4e03c42990c33","implementations/python/packages/raes_contracts/observation_demand_schema.py":"sha256:8523a4354a737b1a9a224c9922f75c32b8c6134412867ac793a9b178a8f9cb3a","implementations/python/packages/raes_contracts/observation_demand_scope.py":"sha256:a1aa5c10424fb4dca396cfcd05cd2c416cfc611b1b822ce040f61ffbf4330b9f","implementations/python/packages/raes_contracts/observation_demand_validation.py":"sha256:d10c1abdca80845a3da96296c4cf7af8b9caeb8d29a1934e9277a64d6bfe82b4","implementations/python/packages/raes_contracts/observation_lifecycle.py":"sha256:e10b67f22ecfd59394e3a9ce34351e09fa1cc038599cf2cf6e74d03a0f99837f","implementations/python/packages/raes_contracts/observation_reporting.py":"sha256:b705ef02c7c38446a611e204e281bc7a782a3222fd0738c375ec4c40f284a68f","implementations/python/packages/raes_contracts/operating_systems.py":"sha256:858bb12d1057ba22f38740f0aa08b7bc6a777acb767e3392715416fcca7e91c8","implementations/python/packages/raes_contracts/operation_lifecycle.py":"sha256:5c742903993d5a49e37502382ee2584b95f853028aeac24230ab9b86827cbebb","implementations/python/packages/raes_contracts/participant_action_arguments.py":"sha256:cab8b89d69aa72b6fafd26e5a0dcc4b987402d9a350628179d2b1b805ecfec3c","implementations/python/packages/raes_contracts/participant_autonomous_state.py":"sha256:95cd2c5d10684a21e348c73aed7a5c3f0a5e7bd057450e138525a4d7a82fd5a9","implementations/python/packages/raes_contracts/participant_behavior.py":"sha256:3fa5f031dd5022a6e7950c526bb0f2d7d279f1869b99aaf07bde02d8e6c0de0d","implementations/python/packages/raes_contracts/participant_binding.py":"sha256:9fbaecee8cd6e91bced07de829ea6fe3d222102dbe1e9ade46e12a7e21b30846","implementations/python/packages/raes_contracts/participant_binding_events.py":"sha256:8866f6845e773eaa56eb3fcd3473c52ff33fba25e896c9450549e6ecc4f9d891","implementations/python/packages/raes_contracts/participant_binding_history.py":"sha256:18ff4d2e11f97eb678195d236a3efcd9113c8697d60310479a54eba9ef5a5a62","implementations/python/packages/raes_contracts/participant_binding_v2.py":"sha256:9cfab9eb1660aa356bbe228a1d117398c67c7a28179ea6df80e9a3dea6bdc657","implementations/python/packages/raes_contracts/participant_binding_validation.py":"sha256:4708ebba9c838f19625e92e1bddd3c560fbb18fffa602b7b8c5466e61781d691","implementations/python/packages/raes_contracts/participant_concurrency.py":"sha256:d0303dd83586e3315b90a5801f26497acdc4d85e114743b1772dd795e0e4747e","implementations/python/packages/raes_contracts/participant_concurrency_time.py":"sha256:1bcbf1b9e66bef4a250657819604ecb95f146ff76da17ca8b235f182cb061a4e","implementations/python/packages/raes_contracts/participant_configuration.py":"sha256:e503425aa1577c92a48df1ac48a4fdfdc307d10590a3d9fabe7c99c95bec4d93","implementations/python/packages/raes_contracts/participant_control_context.py":"sha256:7f7ace7f1a1580ed126605fbb3bfacd884cdbff85be1c0e91f1fca964ec8237c","implementations/python/packages/raes_contracts/participant_control_evaluation_history.py":"sha256:a6765d8ae596735ec60154d93dd40c3970b2f39a00a25df96c2e6f09c5fe0b8c","implementations/python/packages/raes_contracts/participant_control_history.py":"sha256:d5d2d3bd158430acac146fceeea933c9e1a885324359574a923777b55e0545b9","implementations/python/packages/raes_contracts/participant_crossing_history.py":"sha256:b8e4ea4bf668789ef27c4b4e4643cdf6594c305ff92256e306e99fd20cc46677","implementations/python/packages/raes_contracts/participant_decision_surface_delivery.py":"sha256:f1e120a587b67e216ebb0d338ffcb0f4605aa1403a1b3366f4730aed49e801d9","implementations/python/packages/raes_contracts/participant_episode.py":"sha256:d3cc91f23a725809398a7fc51609141a3227341c255d31d38e093fb71d6f151f","implementations/python/packages/raes_contracts/participant_episode_closure.py":"sha256:5f89715990f7e68f46c64f33c099142091387b52d969f9de0aeff947b8c6fab7","implementations/python/packages/raes_contracts/participant_episode_snapshot.py":"sha256:1c0d1aa1b8303d5249499631875a75f9c299e4a7e0b85f57155e143830874001","implementations/python/packages/raes_contracts/participant_flow_policy_profiles.py":"sha256:1f0ec252f8b00dde7e45ef77f2ef198e7c2bef8e59b463ada20be146f2da246e","implementations/python/packages/raes_contracts/participant_information_reconstruction_profiles.py":"sha256:4fb764c4aedbf888cd609ec27b91fa494d1a20ebb06d1032973bb1c180e23c92","implementations/python/packages/raes_contracts/participant_information_state_history.py":"sha256:3d305d626010c30e4c138ecccc17dc0d5d3ac6bf98ae99d523a3f6bca590feaf","implementations/python/packages/raes_contracts/participant_native_execution.py":"sha256:9860274e77b20aba6f48b69d9ccc8074838f96eff7474800fd42a352f2561e9a","implementations/python/packages/raes_contracts/participant_opacity.py":"sha256:867f94d9897340e05dc0494117ae6f8b397ea3fcf95b69e24c3f0f9e22a42a15","implementations/python/packages/raes_contracts/participant_opacity_runtime.py":"sha256:8c4290506f16f5fe41280f7398dc8f1d2bbf3bccfe3b247f40829c4939219c8b","implementations/python/packages/raes_contracts/participant_outcome_history.py":"sha256:573c38f26152bfd80043027812d9bccc57ee4ce9a1b748ea8de7669dfb86edfd","implementations/python/packages/raes_contracts/participant_shared_state.py":"sha256:e55475addd64aa5caf67c8ad82acc638c8657c6961fc15410fb93d8b6ca4649d","implementations/python/packages/raes_contracts/participant_temporal.py":"sha256:b0a5f98b57bacbbcfb2acd4d1d93d59175e890353637937e808ae30509108dab","implementations/python/packages/raes_contracts/participant_temporal_assessment.py":"sha256:c14c5f3976fbdcda8756c1e96a567c1ee01fb8fd63d7a7f2314904973371a7a4","implementations/python/packages/raes_contracts/participant_temporal_history_index.py":"sha256:6a6fbf9d0fa4813d6bcb235e6e6ccb1ded99d6a7fece37d3d538c2a2b57b5e02","implementations/python/packages/raes_contracts/plan_effects.py":"sha256:7b801d19f77f2d2b36d2156bb2295e3b3ea2b1b081ccd82cc341764073f8d7a2","implementations/python/packages/raes_contracts/plan_projection.py":"sha256:cdb226173de8c4f6922cdb0aa6ef90a81c3f7410ffe0e4fdfe6ad25508bc2cad","implementations/python/packages/raes_contracts/planned_realization_constraint.py":"sha256:da09d1033a1e3c3bfe09ae78db02f37f29391ac0c381a12fc765460a51cf780a","implementations/python/packages/raes_contracts/planning.py":"sha256:00834fe50dca2c7abedd179dda641cb42a149524d40920abeddbb998f235d87c","implementations/python/packages/raes_contracts/profile_selections.py":"sha256:67069207742e54276810cce8696e34e2911b39ce6633f2e87be1ad663f8453e7","implementations/python/packages/raes_contracts/provenance.py":"sha256:3fff58fa29aaf0efc5502b1d7c6393cbaf7fba120133d1223cc4b47d01a5acc1","implementations/python/packages/raes_contracts/random_stream_engine.py":"sha256:b87b438a9a4c11e66b3467f539e6a9c37c8271d40131ebe39f0f2f962250cc31","implementations/python/packages/raes_contracts/random_stream_profiles.py":"sha256:39c6ed91e6e35dbf705d1762fb536e832c40e2835aee6b1c720fe48afecbc490","implementations/python/packages/raes_contracts/random_value_generation.py":"sha256:6654ba39835fa6fde8c77b1d99477dfb1904c2bcaee8c794c2d6df10c754f191","implementations/python/packages/raes_contracts/realization_authority.py":"sha256:a068f7c0556393b057a157db239cf6449e4891c10f64afc195f7142ef04109ca","implementations/python/packages/raes_contracts/realization_collections.py":"sha256:b5897eb4e08c3977b9e932dec7ed01fbefcedeb4e1db1c566f3a1c332da61775","implementations/python/packages/raes_contracts/realization_envelope.py":"sha256:d593dd2a4dd572d1b9f8f2b740c5102425e7680217bb741173d2bad255e838a6","implementations/python/packages/raes_contracts/realization_envelope_carrier.py":"sha256:adb59af6d16717ba5d4928bfc708d6d627a31e1f2b134a7586142773117d0cba","implementations/python/packages/raes_contracts/realization_observation.py":"sha256:8f0bce97d26c1ba4400f360956e5ccf29d7ca31990254b0fcc47b4ab836960e3","implementations/python/packages/raes_contracts/realization_observation_binding.py":"sha256:dc29d5e1df52e5c9f04d11a1011f306657352fada09bdda2b82207a93acc6a04","implementations/python/packages/raes_contracts/realization_observation_demand.py":"sha256:e948f94691bf3cca1461879a5d3f16462f0252c190b3f309122b0265e14fb111","implementations/python/packages/raes_contracts/realization_operational_observation.py":"sha256:f0c5972ae2df468c55688beba613b143eacd14c7c68ffdfaac36c54bf31492d5","implementations/python/packages/raes_contracts/realization_preparation.py":"sha256:b8ed68e50a6c7742bc10099ec903de76420090606e573696b41559e2583dd95e","implementations/python/packages/raes_contracts/realization_profiles.py":"sha256:ecd7e4bcf677cb498bc0bbd9fbfc253ee8a97535229d753a706ae319cdb85a58","implementations/python/packages/raes_contracts/realization_structure/__init__.py":"sha256:bb116357b0d9d59c1e920eca45aadbda39347093dd98789ab1070a7bf614e50d","implementations/python/packages/raes_contracts/realization_structure/_binding.py":"sha256:79d3499e3c96b231ffca948d235053811b6a7879c9314f50b254e525660d128a","implementations/python/packages/raes_contracts/realization_structure/_build.py":"sha256:68c0c2bd551b78f0ffeb64e17444a6c930a92e1d55a3b80d4faa2ea604ba39b8","implementations/python/packages/raes_contracts/realization_structure/_common.py":"sha256:d8f36c2e133c05061ba984e2fb8f78f1c3983d4066f7300fa02092dfcad8a5be","implementations/python/packages/raes_contracts/realization_structure/_compatibility.py":"sha256:9518c158f2a69c2756480180fb411555301a06dbbc12bfdd473e91f017fa0171","implementations/python/packages/raes_contracts/realization_structure/_compatibility_checks.py":"sha256:964c4072bed77bdc33c3b01bf18f1ed4c1683395bc4c1c31c9a1ebb7d75ec810","implementations/python/packages/raes_contracts/realization_structure/_compatibility_downgrade_helpers.py":"sha256:865e81d638b584a6ea4c5af624c14ec542ad63d81ae8ffce7e07082f9fd55ad3","implementations/python/packages/raes_contracts/realization_structure/_compatibility_upgrade_leaf.py":"sha256:87e2ebf15b94e91fe9269f61d504eeeda5b43a073d43ec4cb095de722c2bf240","implementations/python/packages/raes_contracts/realization_structure/_composition.py":"sha256:3ee5917872a0b45d2b8e5efc788c7cb549682a62b6e602cc63daec21912461c9","implementations/python/packages/raes_contracts/realization_structure/_evaluation.py":"sha256:152ff1a355b03194f3ab6cac6b24f1ccf750c4faf3f252d0c9cc20cfb6cb2dd0","implementations/python/packages/raes_contracts/realization_structure/_evaluation_collections.py":"sha256:05582b7c9ec8b33e08030aeebfbbec54cc97fa205420abfa779aef2031e1121e","implementations/python/packages/raes_contracts/realization_structure/_evaluation_context.py":"sha256:4933709e475db25f527cc6cae6ac585c1b9bd45795aba78fb3092d17cb32d30a","implementations/python/packages/raes_contracts/realization_structure/_legacy.py":"sha256:e26f10c6c170272be76c3415260c939f819bed82f758fabf2e441534fdbaafbe","implementations/python/packages/raes_contracts/realization_structure/_limits.py":"sha256:66c547688fafcb5fed065d5b700bfe7a3f3951d7e0137b520950c2d91fddae7e","implementations/python/packages/raes_contracts/realization_structure/_models.py":"sha256:a99dcb1be3c7e86d52c98ffc93446d677e3e873adc311c29bee0b5023cbcc42e","implementations/python/packages/raes_contracts/realization_structure/_normalization.py":"sha256:1ed3274d264ef6e64cccc3fd5fa7d6a99f159745bbae1cec51f11d4363a9bec3","implementations/python/packages/raes_contracts/realization_structure/_normalization_overlays.py":"sha256:cc319f7ca0ff0f4a3dfce7dfa8bc4f557e5752ac1916be9011b9a0248a0a33d0","implementations/python/packages/raes_contracts/realization_structure/_normalization_scopes.py":"sha256:6b655aa480d734bec350864f82eb44aa65a0998e357c115b51ffe3286c8afc6a","implementations/python/packages/raes_contracts/realization_structure/_scopes.py":"sha256:1ec39e0c4bf3a1dfcd94d199b0c94b01549f5aad9f6b11ffcbd09908216ce4d6","implementations/python/packages/raes_contracts/realization_structure/_semantic_addresses.py":"sha256:8eb2ff659d8e7c7ec51a5b2d78cb46eadeb6638a4ef84ebd293b67011c48db4e","implementations/python/packages/raes_contracts/reference_models.py":"sha256:d587236d62b3b47b2c4a9de8b8127c7b31b7f22867c4f7efdd6581a08fdf9ce6","implementations/python/packages/raes_contracts/resource_measure_profiles.py":"sha256:3b12c18d07d608709f46ffb6f9383eaa6c349c5889ba4d1a7fe99e1226ded592","implementations/python/packages/raes_contracts/run_scope.py":"sha256:1af2659cb5bc928bc064cb9a76d2c0b7f04357379b7eb96f8e44a333c8bb187d","implementations/python/packages/raes_contracts/runtime_state.py":"sha256:b72dc6ee3e4194f95a56298c95e848937f32fbf69b4731f8b0011ad7734d1f75","implementations/python/packages/raes_contracts/runtime_value_limits.py":"sha256:c23eb18b87fa3d5f6ad26b7ffb1acedb36473bb67c7d316470526eba53670fae","implementations/python/packages/raes_contracts/runtime_vocabulary_scopes.py":"sha256:5f66125c3c7af10c994fa869b3bd4c378eb23fe168aa401d1e5f8f5f213143f9","implementations/python/packages/raes_contracts/satisfiability.py":"sha256:c3998b00407098899e796795d5a3a33f5cb549b33ec868cc6054780c2de5606e","implementations/python/packages/raes_contracts/scientific_completeness.py":"sha256:4701455944f2b78a45a8007241ed708c61fc797418e49569110df9e20a23f8d9","implementations/python/packages/raes_contracts/sdl_semantic_migration.py":"sha256:b04dddf0344fc4b9fe18b2d12ae5c3c0d51b5467c969acf2122f92d3053bfc41","implementations/python/packages/raes_contracts/secret_references.py":"sha256:47f93b3d602998c9f6808350173571055c63bc4c6b899ff325b016e7b0d6636a","implementations/python/packages/raes_contracts/semantic_binding_effects.py":"sha256:97ba86678e66bcaed92d978f3ed36e6edde5992d91749de10b57176021993d4a","implementations/python/packages/raes_contracts/semantic_comparison.py":"sha256:fa2540593476d3c967abc2091b12d2ceaefc5851c0c2ad305da419c680ab43ef","implementations/python/packages/raes_contracts/semantic_comparison_results.py":"sha256:f39a402c045c7afadddb0191c2e261a5058d7285d8e82c01c4c72dc9f5dbff26","implementations/python/packages/raes_contracts/semantic_profiles.py":"sha256:637ab636e1e2949395ccf2bbf926d6e320d98eb76c704e54b5e9608b1c1d3e7b","implementations/python/packages/raes_contracts/semantic_projection.py":"sha256:f3c598ef383444a8a93e72d9d9d8963a8ac63e4f3b65ab2e66a8192d7758a05b","implementations/python/packages/raes_contracts/semantic_projection_facts.py":"sha256:2ff7513da41a10653f702ece1f35d562f9f92e05c1f14d6d2c59e62529d2ed22","implementations/python/packages/raes_contracts/semantic_projection_quantification.py":"sha256:b73ab1c231a188895b0eb288b98fa28563a780940f09a66ee2f2f0de03afd403","implementations/python/packages/raes_contracts/software_versions.py":"sha256:25da289a8208bd3edd0f08f0c403f53a8fa9dfe76259525134195ee016be6b79","implementations/python/packages/raes_contracts/trial_unit.py":"sha256:2b93771bb18bfd2dfa0211aa3bf1a9e0fc7f4b5c91d6ef7a7d421831e236586b","implementations/python/packages/raes_contracts/uco_alignment.py":"sha256:a0263e657f2bf2561eb8b29af5633b149d278fa254ed45d584287aa123d7abbb","implementations/python/packages/raes_contracts/uri_safety.py":"sha256:5ea9577b97d7cf5282ee462e5f6780fc9909f70a73ac9c3950d4d3e808a944b8","implementations/python/packages/raes_contracts/validation_profiles.py":"sha256:c5318833c76f428f4eb7418759f9d625f2125e7205327403467575f58787bfe4","implementations/python/packages/raes_contracts/versions.py":"sha256:57547aacab27ed1fa06df3e7e3518dc930a69453f4667fdd293a3217365a57e0","implementations/python/packages/raes_contracts/vocabulary.py":"sha256:2ffa2eed727570805e2e4fdf9322ef418df09257c8ac0e5d4b3e30f5434ed88d","implementations/python/packages/raes_contracts/vocabulary_sources.py":"sha256:f2d44cc98f8a8d3142f9557283744cf0a1c90d4bdb267a3270273e8b5abe2bd0","implementations/python/packages/raes_contracts/workflow/__init__.py":"sha256:966a9665500afa8807dcdd3c82da71b31a3e6cae8d98d4ad244e968aabe402eb","implementations/python/packages/raes_contracts/workflow/contracts.py":"sha256:947c4ccd0bbe7a24e848cea66091667568eae284d14690df88d97f17a70f1a14","implementations/python/packages/raes_contracts/workflow/enums.py":"sha256:09f7640150e39c600fe1c1ef0a0274ad5b14b87024e82205f889f3138e7bfef2","implementations/python/packages/raes_contracts/workflow/provenance.py":"sha256:1b8ad540e93c28fd312e328cf07e215386fa5731e406524e25335dcf22da16a5","implementations/python/packages/raes_contracts/workflow/state.py":"sha256:dd1b26951365f7098d89bab9b27c3ad370e76407c7ae2eab8b14113a2e3c351b","implementations/python/packages/raes_mcp/__init__.py":"sha256:6aa5720ea5c965eecdf099686b9cbcdcc734bc5199912f505ab001204aae2bb5","implementations/python/packages/raes_mcp/__main__.py":"sha256:6d0d2db20fb1161d7f5798a58b1f8fd66b2f7d8bbd6e335867cf59d1123ded95","implementations/python/packages/raes_mcp/server.py":"sha256:75c0fe948a7c0d2ce2eb219418479a27640d50197474de052b2d0351a6c620be","implementations/python/packages/raes_mcp/tools/__init__.py":"sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","implementations/python/packages/raes_mcp/tools/authoring/__init__.py":"sha256:ec7666fcd7dd1344d2d194dbc39983bf5c509d543421336698958e9739eafc0d","implementations/python/packages/raes_mcp/tools/authoring/_helpers.py":"sha256:56e15e882e1724c817c44d1c3d27867f8edbf8cf670cec06247471a70e515004","implementations/python/packages/raes_mcp/tools/authoring/_templates.py":"sha256:402f671baccf58e67de242b8fd874e2469038041da71a7d60aa9ac2df8bfe5e9","implementations/python/packages/raes_mcp/tools/authoring/tools.py":"sha256:ecaac58f2ffc298f5749f177e06280b72f4fc8c0dcfa2bf1494762448439ec76","implementations/python/packages/raes_mcp/tools/completeness.py":"sha256:6bc3b923498276b20d7e9a41b0667aaa1d201b3bc0e9c6013555f0d221a5a799","implementations/python/packages/raes_mcp/tools/experiment_authoring.py":"sha256:00720782a2e8ea66c35522165a8d8c60f98ef0bea0f5e3e44bc7d3abf6a88bb3","implementations/python/packages/raes_mcp/tools/inspection/__init__.py":"sha256:c8e5ad59c58e60b520d2fe7ca475e1b52fc3cb41281b2d0ae3bd56f82322207b","implementations/python/packages/raes_mcp/tools/inspection/_common.py":"sha256:59e6e0c513c8548766a8b5f2df3e59ce49628341f4f3bbeaa9da1d27fa4bbd74","implementations/python/packages/raes_mcp/tools/inspection/_elements.py":"sha256:b8e0a7b9d6f754668b989f8a140278a8688b11d91bcd2676cf7202316f3480e6","implementations/python/packages/raes_mcp/tools/inspection/_references.py":"sha256:244c7fc27753c3cb3506d067a7f03601f29b2907e9b7a5ed588447452ebb2bb2","implementations/python/packages/raes_mcp/tools/inspection/_summary.py":"sha256:080444abbedeb2b7ee64a37835a14e254d75402cff32efaf6461d559a86df2c9","implementations/python/packages/raes_mcp/tools/inspection/tools.py":"sha256:1d4d3ea1fd4320a1c9a5fa78458b5aa6191b0d831378a3d0cfe60ea697a0f61c","implementations/python/packages/raes_mcp/tools/language_service.py":"sha256:c12c65264a2ab85e8981cf3d1873e2eb968e4fc5e93f948ede9fd2d3b339426b","implementations/python/packages/raes_mcp/tools/operation_support.py":"sha256:ce2152e7a2ea162033ec08d709f3c4e0bad2a5f1ed0513da6fbdb3e210ce3bb9","implementations/python/packages/raes_mcp/tools/operations.py":"sha256:f2df8bd4d15adfd3b72bdacce389360cb5300ceb94805af8168cdaa4a325993a","implementations/python/packages/raes_mcp/tools/reference.py":"sha256:23fcd9c7a975a30979ef2aea10cb8bcb8f225eaa39ec9a7a79e0b5cfb6bb08bb","implementations/python/packages/raes_operations/__init__.py":"sha256:e691019d25dc28dd5bb9df1b98e22100cd1adf9d9339291bdb16504adcb5aa15","implementations/python/packages/raes_operations/run_artifacts.py":"sha256:a96c9580d8a28fba751a5b885d917736aaead4619c4952bf01912bceb218e37c","implementations/python/packages/raes_processor/__init__.py":"sha256:88b1a70f3414adbfb62985f852ea5dd884673230c0912a71ae874b7b39a65f30","implementations/python/packages/raes_processor/capabilities.py":"sha256:00c2da31178a8e52156847a17507d498fb9ef7bfb3e95309938453206ac3507d","implementations/python/packages/raes_processor/capture_admission.py":"sha256:66e48817a1900053024a2ec4fbce4cc14e9319c694999a26af37af597cbe9fb4","implementations/python/packages/raes_processor/compiler/__init__.py":"sha256:ff1f153d36e684537cfe391a81eef4dfa3f1c58cbbf4230ae672f20d2b5e0c7a","implementations/python/packages/raes_processor/compiler/_mixed_control.py":"sha256:18721cdba72e7e7a7279735f5d158fc6191da3efb183560987aad59c254d05cf","implementations/python/packages/raes_processor/compiler/_mixed_control_policy.py":"sha256:989004e28e02f125ccc3771ca409b31e33ba6adc7ebb1b35c07c984c7cd661c0","implementations/python/packages/raes_processor/compiler/addresses.py":"sha256:529917f9a18cf8eecbbd45c690d809e43f0ed1f267c546df75e7dd1e838990b4","implementations/python/packages/raes_processor/compiler/alias_index.py":"sha256:5851ceee98ae0d0345bfd2d3b86830d484caefeab1cf3720732e14f5f99c00cb","implementations/python/packages/raes_processor/compiler/evaluation.py":"sha256:bd1d1bda19262ac9aba1668ab6a9a93d64766cdbe77c0d3e96f1fbb54dde2fec","implementations/python/packages/raes_processor/compiler/execution_policy.py":"sha256:812e6eb782d26afbe8caaae4934a4cf2f3af96def77425b0da6aca0ae4bfa251","implementations/python/packages/raes_processor/compiler/materialization_origins.py":"sha256:04c8c69d59b35e8de869ef29a037d15eb9c21ef7544ec00e08a3e4c2b2e5f54c","implementations/python/packages/raes_processor/compiler/objectives.py":"sha256:886e24ebb7840bd71f773b57b8193133d559f96704e037b472ed6a30d7e9f717","implementations/python/packages/raes_processor/compiler/observation_demands.py":"sha256:392a11ec63d9ad1e35709924c7f374a62afe9233892e8301e48220efa9380476","implementations/python/packages/raes_processor/compiler/orchestration.py":"sha256:d79dec678584d50e490bf581319dcd1ea7ca28dbcc7c5635800eb7f5b7e835c2","implementations/python/packages/raes_processor/compiler/participant_access.py":"sha256:b57988a559b84613e4df850af3d8bd60d1eac16becae9bcc033e414b83758239","implementations/python/packages/raes_processor/compiler/participant_autonomous_execution.py":"sha256:41d8f1966e7b9b900b7e4cbd54d27b57224254530358e874d00e4e599da0569c","implementations/python/packages/raes_processor/compiler/participant_behaviors.py":"sha256:399ee4c44d237871af9f9026e3f0a93013ca140a867bba45d836b192dad5e65e","implementations/python/packages/raes_processor/compiler/participant_contracts.py":"sha256:0446df91a1f68190966d96190bc09b6c04b9d490f884e3cd50ae7f866b28b763","implementations/python/packages/raes_processor/compiler/participant_inject_deliveries.py":"sha256:6b2bb300d0e2946c539040bb00cf06afbf0b9415fd2f13977fa7d9fc12c42a50","implementations/python/packages/raes_processor/compiler/participant_temporal.py":"sha256:b0e486e1d9a553aaed37e4696f91dc746438de2141ed6364058cd58de8faa3c9","implementations/python/packages/raes_processor/compiler/pipeline.py":"sha256:e76b2c27f7529dda98911c452ea4a1a36243b82357e01fab03b0338bb341fc9e","implementations/python/packages/raes_processor/compiler/placement.py":"sha256:c8a917c09baf87de328812ffbc3ac667995afe24e081bd1e93be19682765d0dd","implementations/python/packages/raes_processor/compiler/provisioning.py":"sha256:21e86c94b8c27e0b6164bf8f9136872c6812e66ff589f06e5557ef7fafec0c8f","implementations/python/packages/raes_processor/compiler/realization_authority_posture.py":"sha256:01631fced6bdc2861b67c86c74a3bbe4e57f69fbd46472441d19b53834ef841d","implementations/python/packages/raes_processor/compiler/realization_compute_substrate.py":"sha256:4847257118c9f967483057d5f3e79bfe459e440d56cdcb0cbc6614d34b0a5e00","implementations/python/packages/raes_processor/compiler/realization_concern_binding.py":"sha256:0b4dbc804eda43297f1d31786e4034e1ac304509b24dce21312090fee9278d5a","implementations/python/packages/raes_processor/compiler/realization_concern_bounds.py":"sha256:33034d297eb3ee398e314c2bd55f1a43342996edcbff6bf2106a96ff9b8b5454","implementations/python/packages/raes_processor/compiler/realization_concern_explicitness.py":"sha256:8e0154037c1327a04037e6d41afc82950c3e4ce034c747912d69139f623bae93","implementations/python/packages/raes_processor/compiler/realization_deferred_constraints.py":"sha256:5873ae779bcaeaeeee847a88fe0a4e42e87c7845ff0d0181f21ba6df8e9a3225","implementations/python/packages/raes_processor/compiler/realization_recursive_constraints.py":"sha256:9aa96d69133b329fe3bf57ba79a193a10bb041acd411cd6a38be09276c00d180","implementations/python/packages/raes_processor/compiler/realization_requirements.py":"sha256:c57980bfbcc340ddf30e9fac5ece7ed9c4d3d9c10bd5b8e190e12f9bd15b71d1","implementations/python/packages/raes_processor/compiler/realization_scalar_sets.py":"sha256:a6bd1313237e1b65ff0a36abf9c6f702f63096ecd81a7da032fe44e7b70a410f","implementations/python/packages/raes_processor/compiler/realization_structure.py":"sha256:a4d910359f0fe6874238c1f0135d0cdccb676248cd7e111c34cad963dffa1e31","implementations/python/packages/raes_processor/compiler/realization_value_domains.py":"sha256:1f4b5ef381f29d1c4c82723a931757d02def76c24a0d5f25373b5bb4305e58ec","implementations/python/packages/raes_processor/compiler/ref_resolution.py":"sha256:b9b189a3f56325bd2e9f17b4cdf7106743897f8c4b63bfd738bc8d288f6b3e6d","implementations/python/packages/raes_processor/compiler/software_constraints.py":"sha256:f8cd1bc0761ec9e7bc2560080ce782fdfcbb08ff71dfc101fd19d17eb0357986","implementations/python/packages/raes_processor/compiler/software_profiles.py":"sha256:1471588faf40dd0d5e8d6f193c2ee704f1017e34b731562e29396b21cfbc9988","implementations/python/packages/raes_processor/compiler/stateful_resources.py":"sha256:53997c39f85fde82fd76b3c18305eadc5679fe49066f245dc18d68e34b9fdb06","implementations/python/packages/raes_processor/compiler/support.py":"sha256:e1b62131120b8f43b499ed9b88459babd981d92bbd338c6124e3e0306c14454e","implementations/python/packages/raes_processor/compiler/time_model.py":"sha256:f9630158606a4ab8ed7885cc635a5073e96d84c8cc9527b52a94f41a208333e0","implementations/python/packages/raes_processor/compiler/view_relations.py":"sha256:9c24057bb54de0df0828fa7d0f891b5686a6d5c8f7c8ad3e3848e5efb299307e","implementations/python/packages/raes_processor/compiler/workflow_steps.py":"sha256:f5c797f6a9aad5bc5a8376728a39f9b3cb1e39bc9fab466f42c7519172c566a8","implementations/python/packages/raes_processor/compiler/workflows.py":"sha256:ca1dd303adc02abec1d550b139ba954d5672a9995cb6e26013fc187fcbcc04a7","implementations/python/packages/raes_processor/exploit_path/__init__.py":"sha256:e21a2c27a77c112e73377c6b7aba881e840610004b7facb43be0e5180c331afd","implementations/python/packages/raes_processor/exploit_path/_diagnostics.py":"sha256:2c8a3dc664ee6d437f993b7c90be60ac5bfa76f286261425bdae57d9c195d019","implementations/python/packages/raes_processor/exploit_path/_preflight.py":"sha256:71efd8f989959da4537b9df49d80b4e8beff0f4062b147aab1ca2d4e39718a2b","implementations/python/packages/raes_processor/exploit_path/_search.py":"sha256:356b25673436955cde5a8cfd1fcce8b66978eebd7789afe03837a116dc7b7a44","implementations/python/packages/raes_processor/exploit_path/_service.py":"sha256:7ce4a1606a5109ba96957f49fc9ed27a66dc62fe9232ff5e075e8c159d89a015","implementations/python/packages/raes_processor/manifest.py":"sha256:5550fef9647d4a7bc5c10536d4da83307a4d64d3e39e9d389f98c22adc6df411","implementations/python/packages/raes_processor/models/__init__.py":"sha256:936cc38bc88dde312b8f5c12d04c857f40aef7f661ba10def8797c5857bf46bb","implementations/python/packages/raes_processor/models/action_results.py":"sha256:34d948b8b2ae0c14e78a662c66ec42aca3dd89f62e782bbf52721cac4a48873b","implementations/python/packages/raes_processor/models/attribution.py":"sha256:d7980fd8ba44da92e03d10922e499c6578b33dca58849fe03a999007ba632a8f","implementations/python/packages/raes_processor/models/behavior_anchor_checks.py":"sha256:fc2ef940ab62675ffb35be974cbe3f839b1f3e53d2eca33a3e661f65e12c25da","implementations/python/packages/raes_processor/models/behavior_anchor_index.py":"sha256:aa3281f8cd1d72a2a249c3cd9fb0e40fcb9790f1373d14bbf72544acd4f88493","implementations/python/packages/raes_processor/models/behavior_grounding_checks.py":"sha256:597ab8d342a98404544f6413ed8aad5e1456abb403061a53851fc2e5b7697fde","implementations/python/packages/raes_processor/models/behavior_history_violations.py":"sha256:0d97c59303d8ddf74928306382625b6cee9685f4793e06ed8c82d6426536779e","implementations/python/packages/raes_processor/models/behavior_ref_checks.py":"sha256:9f955141aab7ec8858b1c36be2610b3bf018ef16e6d70a55daaa1b96d3aa05cb","implementations/python/packages/raes_processor/models/behavior_resources.py":"sha256:b9a04ece1943b7819e3c0875cf015380ce4d42da3be4259011c8b7c36ad962ba","implementations/python/packages/raes_processor/models/decision_surface.py":"sha256:6f1e4307f5cad3e65ec54dd8b989313a40176daf190f8f5699514cc8ea499cc4","implementations/python/packages/raes_processor/models/decision_surface_anchor_v2.py":"sha256:9d0a8ccd71b3ad1fc928ff7e13cb7f9e87c2c0fbb9832a35839c9d654c44e0e1","implementations/python/packages/raes_processor/models/decision_surface_v2.py":"sha256:ff42a07284a1b157478280de46d415a02cb87e8ebc4122f41816554c900799ee","implementations/python/packages/raes_processor/models/history_event.py":"sha256:b5a4d2df9e91d37b8fc9899a4f6cacca155c3c07e1a5ed92a3ea1ae84e6fe937","implementations/python/packages/raes_processor/models/history_event_grounding.py":"sha256:89b61e48fba076b57b539eb6e9022690952f9f95b760b9259a62d7ee0f64b92c","implementations/python/packages/raes_processor/models/history_event_payloads.py":"sha256:060de85d14a98e407744cef8776db2043eeb93b741a7c1a3566dd740e276ae68","implementations/python/packages/raes_processor/models/history_event_serialization.py":"sha256:da3122f9442fba82f961ec8f72b6988efd100e8a1354ba462c2c8fe4e95be523","implementations/python/packages/raes_processor/models/mixed_control_resources.py":"sha256:e16dfb3d5ef52af49fd03a270ed045e489a3cec1378f032c223c0a4890e09298","implementations/python/packages/raes_processor/models/outcome.py":"sha256:b539f3f015e4ec7a0f4438c6066f753a2626b1e49e695295c14b874f0fbf304e","implementations/python/packages/raes_processor/models/outcome_interpretation_validation.py":"sha256:dbb46c30f727714201d955c905815e11851be499e046a4c128c44c9ed82151e9","implementations/python/packages/raes_processor/models/participant_action_arguments.py":"sha256:ca91b34fa6b9f750686d7826ec69739f31115e585eb4674bd997aa4d715ca4ec","implementations/python/packages/raes_processor/models/participant_exposure.py":"sha256:ded752e73e2a1ea5b2766ddb51fb02550d3c8ee5179da131d5225b2942ff2a9c","implementations/python/packages/raes_processor/models/participant_exposure_authority.py":"sha256:5839770efcdd308e917b53a03999d0edf45fcdc5efcaccc2e7985407f05df898","implementations/python/packages/raes_processor/models/participant_exposure_authority_v2.py":"sha256:b8208fcf4d075565155864191b14d2df046c6131b68bc8994faa466037fbc507","implementations/python/packages/raes_processor/models/participant_exposure_policy.py":"sha256:aa00bf06aa8f5e432c19ea1d27dc6751e7ce3eeb0933b84af5fe0b37720c28dc","implementations/python/packages/raes_processor/models/participant_exposure_v2.py":"sha256:77395b79cded1105576895c9fa512ffe5c29953c386ec6225590b774d7de145c","implementations/python/packages/raes_processor/models/participant_resources.py":"sha256:269ad6b63eab840ec57346a57707ecc282a14fb278043cf04bf36043fd9f4d14","implementations/python/packages/raes_processor/models/resources.py":"sha256:787abab3aedc4903170a1580bc6e2e8af72271920e8367053ed62a52eb35fc69","implementations/python/packages/raes_processor/models/runtime_model.py":"sha256:0112360ce081da99c4668e620277697c1cd12fdf56dc3e4960d7ed3569997331","implementations/python/packages/raes_processor/models/temporal.py":"sha256:28905f9a123df84360b96e999126ec5046f21c8b58da7eefb1dde3fa3d2528cc","implementations/python/packages/raes_processor/models/time_model.py":"sha256:3db36f318ba439af4272315f8e4ca5683c73cd2e24957f742642a885178316ee","implementations/python/packages/raes_processor/participant_opacity/__init__.py":"sha256:9d48488e4ac688aa1e218049c30dc99e3780ddf3c1f93c5273e54f2b61ed9b86","implementations/python/packages/raes_processor/participant_opacity/_errors.py":"sha256:6977132eb74b470a14c858aea8cf11f3510990a6c52baca6bd15377befcdeaf2","implementations/python/packages/raes_processor/participant_opacity/_kernel.py":"sha256:3a250c85f0bf48e950b820ac2b0c44a8093a2facc16c466bb0b3349b8578cd9f","implementations/python/packages/raes_processor/participant_opacity/_model_check.py":"sha256:923a8bf40bd1c7ed4063126f123c429ea17bd0d311b56846a5d7f7ae56cb5e54","implementations/python/packages/raes_processor/participant_opacity/_model_check_admission.py":"sha256:dc638e103695c3d036ca99e1ce674bec4c7a1e92c3389cc54ad540f44edb9fa3","implementations/python/packages/raes_processor/participant_opacity/_service.py":"sha256:ba423fb801f6f77731a08a9af55eeba2fe5b1a30fa283d57563126b3bbe8e274","implementations/python/packages/raes_processor/participant_tool_support.py":"sha256:0eb949a75ad073d002e08c5a4d25bcc48d517bcc01d00c4dfb568c9b9e5376b1","implementations/python/packages/raes_processor/planner/__init__.py":"sha256:57ee8e161a86f050daeea27bb6c37052e23d7b7ac988fbf1d4d06f2579d28e4a","implementations/python/packages/raes_processor/planner/account_credentials.py":"sha256:db8f649e87f6804373783c78151aebfebe60d85ca10bea3b4e7eec243ebe9133","implementations/python/packages/raes_processor/planner/augmentation_admission.py":"sha256:71cd6d081c866ac70b4168223694754fe4f87e6e27304d2eef8fcc3a0f6e9d22","implementations/python/packages/raes_processor/planner/backend_node_provenance.py":"sha256:a85bf40cef4732f9c2b795239396f023f30e01fdd83c96f537118b1e57597ae2","implementations/python/packages/raes_processor/planner/capability_domains.py":"sha256:7256943a7163e52f468999e24e478f4725f46497235f7ee47350092a2c1ad866","implementations/python/packages/raes_processor/planner/core.py":"sha256:9cc3fc1e8997a23ab8902a2072a419983296a0be7f911c3f0a521c4258e489f3","implementations/python/packages/raes_processor/planner/execution_policy.py":"sha256:1e8e1417993420cc3a4fa8e94de5434ded07f7ce3f84ed4a6b96c9b8130e5cfc","implementations/python/packages/raes_processor/planner/interaction_context.py":"sha256:17f7f60f300bec2794b848b561ca61fb68d7b00c655aa5ac2e9426ab91d24ccd","implementations/python/packages/raes_processor/planner/manifest_validation.py":"sha256:c81d4e6cd99c283e2e8b8aaa27bd5ff7c111f2d29991d221814c3d3c73f52879","implementations/python/packages/raes_processor/planner/materialization.py":"sha256:5639b7fb56d5529c53d8784c921c46aa396d72fe460d37e8237753c80f50173a","implementations/python/packages/raes_processor/planner/materialization_admission.py":"sha256:ee763995a97be89a74e9959d1483578f7f00e88ced0ae61cbe3e54588c70f2e5","implementations/python/packages/raes_processor/planner/materialization_inventory.py":"sha256:5626787bb729228faaab141040c58fc0e7325439fb325a94780032ce3a208638","implementations/python/packages/raes_processor/planner/materialization_lineage.py":"sha256:cae2113003f9931bf781f5b7a3a466ebdfbe6820fc073d2f78f73f0603733d66","implementations/python/packages/raes_processor/planner/mixed_control_admission.py":"sha256:4d3ec3036c3fcdca2da57310dba14e02aa7610b3307dcd699c669f282d0fb44b","implementations/python/packages/raes_processor/planner/operating_system_capability_domains.py":"sha256:099af507b4767fb64ff3c97660932735f0a61579a73d5050993caca22e3fecc3","implementations/python/packages/raes_processor/planner/operations.py":"sha256:62b277adec2569c3e6ab33db7e1ac1403a7a79799404c15b580cd2f8b338bba1","implementations/python/packages/raes_processor/planner/ordering.py":"sha256:fa902129d201689b0b66b838b621c556dd5fbd0340a57dda130b7f1db02ea419","implementations/python/packages/raes_processor/planner/prepared_node_admission.py":"sha256:ba78411784ac8c23cb57fe363733bc13256fbb8d96c88d3bb8a1ad679a18d3be","implementations/python/packages/raes_processor/planner/prepared_node_projection.py":"sha256:43cab5ce012d94f3cb4c615fbf668d02d7e9b5d4f5c43c002c8a0814d27c2a5c","implementations/python/packages/raes_processor/planner/prepared_node_provenance.py":"sha256:50ebb3614ee0bc85a76b55de1415243b1f25cc2780e7ad552dbc4827974282e2","implementations/python/packages/raes_processor/planner/prepared_node_semantics.py":"sha256:00f27b01817ba800f01cec7940df616db8eea1565602fcbe27b3ec86a506762a","implementations/python/packages/raes_processor/planner/prepared_node_support.py":"sha256:656ca5e234a6a6c6523dd48cf43f33fed9b5c3cc939736dc68e8010dc2659305","implementations/python/packages/raes_processor/planner/realization_authority.py":"sha256:23206060d4f8a6202330210f8bab8aaa3dfcaf4b3a07a082cc8447a945afb228","implementations/python/packages/raes_processor/planner/realization_authority_materialization.py":"sha256:613f4e740353553c0967d27781b257f90b9c121ec257d32c6de0b3c9d7943782","implementations/python/packages/raes_processor/planner/realization_collections.py":"sha256:0b2ba1f1b778855937c484a34cc1a1ee020bf0309a1fe0469e9947f247abbc71","implementations/python/packages/raes_processor/planner/realization_constraint_views.py":"sha256:89281f8643b6a4bd68ee6a413daa0f58c4812681d287ebe61c0c32326cb63662","implementations/python/packages/raes_processor/planner/realization_preparation.py":"sha256:09c2429fcec4d181e646f99802b5db9f34c72fdee54ea4be1d9150d81902273d","implementations/python/packages/raes_processor/planner/realization_profiles.py":"sha256:53c21a8850ccc2bf8a614db1f2ef72d30d91f1f6c1dbc8e1258b7e1e4f767387","implementations/python/packages/raes_processor/planner/resources.py":"sha256:13edc812cec45bb6709910f13ad8c90c3a80d6cb757c64e13d9ff300b8e19df3","implementations/python/packages/raes_processor/planner/stateful_admission.py":"sha256:956446c06669652e88a4993176241bb13b192652d29ff4575b6e93d9823ab1c3","implementations/python/packages/raes_processor/reconciliation_demonstration.py":"sha256:35720a64ffff0f11342a49d32b8581b85075d1b767f03b9a35aaf3a940643437","implementations/python/packages/raes_processor/reference.py":"sha256:89a92f12f959c97ccbef22ee5deb04a3f9958d159111069b9349df9ccd4ed331","implementations/python/packages/raes_processor/satisfiability/__init__.py":"sha256:66e1ac4711d021f1cfac705f0dfcf97d021acb9a261b77d079528c0f028266a6","implementations/python/packages/raes_processor/satisfiability/_service.py":"sha256:5a00aa1980dd54fa623509a7306004053fa10c7e1d8003eb88d0bcc60f33770e","implementations/python/packages/raes_processor/satisfiability/_solver.py":"sha256:34bb5df343b835c0fd7392eb63b312722229bd9a7478f7adb3b5619bb6535342","implementations/python/packages/raes_processor/satisfiability/_translation.py":"sha256:002003ef5714798503bc911792564c33d0f14ac29fd48d21245ccf681abedb6a","implementations/python/packages/raes_processor/semantic_comparison.py":"sha256:95458f8867d8ed31b5daca09528bb9f6f6957ea73ac9cca5dd8b9d7bdfc5a031","implementations/python/packages/raes_processor/semantic_comparison_adapters.py":"sha256:1f37311c706876105b675e9c2ad19a8e8a1533b967013b77bd911b12bc7625b9","implementations/python/packages/raes_processor/semantic_comparison_impact.py":"sha256:463deca4bb02dbbefeddf1661723ac3712d346a9d10bbc2a8c108b991252e3af","implementations/python/packages/raes_processor/semantic_comparison_projections.py":"sha256:398054dd02614e381c77a2788832c0b40c1340c2eb37807b3fb1dc57ac40ebad","implementations/python/packages/raes_processor/semantics/__init__.py":"sha256:1d7c88888521e3f3c688069f71271ecf62c2dea6af472cf4c05baa76c4126e75","implementations/python/packages/raes_processor/semantics/artifact_realization.py":"sha256:9d0843b13f3cdfd4817579bfa3f524515c6f23050846e7421a95f604ce2661fa","implementations/python/packages/raes_processor/semantics/planner.py":"sha256:6fa2ee3d0f81b9ddea586c330809253e1a3cedad644e89a9b7f9261e5036f97d","implementations/python/packages/raes_processor/semantics/realization.py":"sha256:0a7773095065132ea83f9c2bc487fd361e9cebe21bec216475f399fd1986b77d","implementations/python/packages/raes_processor/semantics/realization_apparatus_defaults.py":"sha256:35db222d42f4658df0aae10b28a6b320259b48695ece5aed6a69852cc7a8966a","implementations/python/packages/raes_processor/semantics/realization_authority_contract.py":"sha256:3401721d44579793d497ed569edba5bb8396e9bdb9908f4a289ac6214b42b4a6","implementations/python/packages/raes_processor/semantics/realization_compute_substrate.py":"sha256:666b49ca568cd5593fb350574c5fd4ca38380becfcf2a2afefee313ac12a0978","implementations/python/packages/raes_processor/semantics/realization_concern_observations.py":"sha256:751656f5a121eec5984129c9161af47150d07c9df184de105782bd6fffba758a","implementations/python/packages/raes_processor/semantics/realization_concern_projections.py":"sha256:7878fefe7d5f098460585ebe735bf019b333b24ed15c38476839274246de35df","implementations/python/packages/raes_processor/semantics/realization_concerns.py":"sha256:964965c47c13bb5a00f24ac6fea6967dffacc394a67fce3d5f0c96b5348181a6","implementations/python/packages/raes_processor/semantics/realization_node_defaults.py":"sha256:a70a29f74578a0c7b4a76ef7538141e076de79dfdca7385352710ed4e51aea0b","implementations/python/packages/raes_processor/semantics/realization_observation_admission.py":"sha256:14d7edc8994eeb44629f24abd12e508fadcce09f72a5cca04762bd4e63215643","implementations/python/packages/raes_processor/semantics/realization_operational_verification.py":"sha256:73154bcc81d9c53a80115099aa1349efe3884a8f587407d20a7c4861703237cf","implementations/python/packages/raes_processor/semantics/realization_process_limits.py":"sha256:4f89a2435fa3a3b78a8d20efc4f2c3864ffd4a6bb2812e225397b29ec9659804","implementations/python/packages/raes_processor/semantics/realization_requirement.py":"sha256:fbffc2e3fb8c73f0bccc668df71f1667762ae5f3aa4f1c14053323c878c4144b","implementations/python/packages/raes_processor/semantics/realization_runtime_common.py":"sha256:c83949bc3ff85b00688761ec7156a52475d6465a2c792917fc8981d32783bd7f","implementations/python/packages/raes_processor/semantics/realization_runtime_concern_profiles.py":"sha256:f1815a3537e251ffcf53a4df52aa9787162e9d4980da31edccf61a29997db315","implementations/python/packages/raes_processor/semantics/realization_runtime_evaluation.py":"sha256:05ae39e4b6bd5d158a391d6daa70dac40c31a868f07b062a76171b8616f0976e","implementations/python/packages/raes_processor/semantics/realization_snapshot_sanitization.py":"sha256:e6fad65b810f9316a51100e8ab1d6b1d5f12391e3baf820d8c3093407649d173","implementations/python/packages/raes_processor/semantics/realization_specialized_projection.py":"sha256:95e517397fdc9765341ef4e450f1d615ca3d361ccdad1af6655aefef40f37161","implementations/python/packages/raes_processor/semantics/realization_support.py":"sha256:d02274976daf94b16eaa895afaeb2b2f5d4db4b8c065dea58880806f532477f3","implementations/python/packages/raes_processor/semantics/realization_typed_runtime_projection.py":"sha256:18f186da5653dc5baa13f99299d79196cede6fac9d717074288fde6ffa0fba50","implementations/python/packages/raes_processor/semantics/software_identity.py":"sha256:1b17be9c66d1d4516a295435b3be7a3092ec63bbd655267c08889537002c942e","implementations/python/packages/raes_processor/trial_compiler/__init__.py":"sha256:2c4723e4af41c8b10df88ce715f176d1705233b768b690a81b6f500bd0e3cec7","implementations/python/packages/raes_processor/trial_compiler/apparatus.py":"sha256:52e2d1dca2b31f5862b2a05b37ab105434be4f05f4962fb24943ab907c0e5bbc","implementations/python/packages/raes_processor/trial_compiler/bindings.py":"sha256:5064c864dc21d1444cf884667899355129511f4a5d6684ad599477926201ccde","implementations/python/packages/raes_processor/trial_compiler/compiler.py":"sha256:70845b584c2e6d41b0cf034956b525f581cba36fd6321ebfd96625fab756ead3","implementations/python/packages/raes_processor/trial_compiler/control_admission.py":"sha256:50efae805d6761ea56fd772c324a56b968cdc00071097cd8215742bf77cf2a8d","implementations/python/packages/raes_processor/trial_compiler/domains.py":"sha256:ba4dde55092c89a87caad22130e096800fd8b5dc800fe638ca7034bb8e45ebdd","implementations/python/packages/raes_processor/trial_compiler/effects.py":"sha256:498d39a24509fa3d593cbffd0e6e43677ea253603d5b4d67e8473e706f8fd87a","implementations/python/packages/raes_processor/trial_compiler/inputs.py":"sha256:6d5e07c8f7a81e9ef724b5c7559cf02f30b0467baca3870d1985b01ae34a2496","implementations/python/packages/raes_processor/trial_compiler/models.py":"sha256:75974da2bcd43b7a6f829535ec64996d2859935d4f846d0b7e9ff1e59e03a22c","implementations/python/packages/raes_processor/trial_compiler/policies.py":"sha256:e94e07bff0d63fb1a17f1801529400bbfb933ad096d9940f73bf15faa65e42ca","implementations/python/packages/raes_processor/trial_compiler/profiles.py":"sha256:14d0a55fd2a277c2dac6ce7840d3f0b4e4675a8428311e32b743394011559611","implementations/python/packages/raes_processor/trial_compiler/readmission.py":"sha256:2009114795a977aa2e42416452ee7b40bb1535e8cf6e629f1ad430d6088de5bd","implementations/python/packages/raes_processor/trial_compiler/realization_admission.py":"sha256:9e26842ec4bef218e25baa8c1e44f4f1107fe24cc2ab45da9e407d3345199e59","implementations/python/packages/raes_processor/trial_compiler/replacement.py":"sha256:44fc7ef44367a713f84ce55426653498b2bbdabefc7cc9de8fc4b79314b9318c","implementations/python/packages/raes_processor/trial_compiler/replacement_inputs.py":"sha256:19ba845a95d87f6cf9c0e80f5f35e820c4d04fae84f540656ffc954113780d62","implementations/python/packages/raes_processor/trial_compiler/sources.py":"sha256:5b69a0338c9910fff9d6488ccfc87448e4b2fa830d47511f730979a5cae462ca","implementations/python/packages/raes_processor/trial_compiler/tool_support.py":"sha256:2d7da7e58ef95bff824f9735696c565cf0be8c1552254aab7b5f4dd1ebd52ecb","implementations/python/packages/raes_processor/trial_realization.py":"sha256:0159320d3e5ab8be64e21543caf080287058a212f92a29cfc4936ac7d2ddd244","implementations/python/packages/raes_processor/trial_scheduler.py":"sha256:436494386dc0dddb667802cb9351f7c53a58499ab19fccd6521d827d2ccae9b4","implementations/python/packages/raes_runtime/__init__.py":"sha256:2656c77029b842830d385880897cf5d280c463044fb901f1430292c85d8709fa","implementations/python/packages/raes_runtime/apply_failure.py":"sha256:a23dc50e6ffdcb30848e5d44ce7dbc7dbae24836a23f135fe035fdd070eaff85","implementations/python/packages/raes_runtime/backend_account_credentials.py":"sha256:d1e4d921f7fdc45f6e2a02d2b0b1868191d1062c1601204f4cb712a661930125","implementations/python/packages/raes_runtime/backend_apply_results.py":"sha256:491d90df6fe4df8eb90b6ff19e02c5c0a7d68a36f5378a570e0a60d7de2dd5f2","implementations/python/packages/raes_runtime/backend_augmentation.py":"sha256:7b656e3d22860d729a74eb00aa11d73ef55b7777bab4e79ac771a0d504813182","implementations/python/packages/raes_runtime/backend_call_contracts.py":"sha256:39666dee85bb3082ab8c935f70629e4283b307939f6c6fa578fa9fb8af1c84f3","implementations/python/packages/raes_runtime/backend_calls.py":"sha256:711b048027ae862c037297a7649a28190ce84d14e6bba64eea597bc782d9e1d4","implementations/python/packages/raes_runtime/backend_effect_transitions.py":"sha256:8ac3396bf0118386e6c652b35889d136ff611cf4114554b034380a61e27ed8bc","implementations/python/packages/raes_runtime/backend_entry_transitions.py":"sha256:fb088773d23a9755b235782967895b1338c27890cfc2e0ae9617546bb44065e3","implementations/python/packages/raes_runtime/backend_input_contracts.py":"sha256:8c42561656539743996ab4287a2519eebe15537cb830e04d11a43dd2d5f971e3","implementations/python/packages/raes_runtime/backend_inventory.py":"sha256:ac5eef01a3ca9e8bbe51b251e5cd693e9cab3debfba160128ab094cdae94f69b","implementations/python/packages/raes_runtime/backend_materialization.py":"sha256:0ab19d1b21f212dd0f7dda93d44338484da51ab9af12c5e519020c3f208613a1","implementations/python/packages/raes_runtime/backend_observation_calls.py":"sha256:1c0d707bd3a85a5163e2c861788d7e718c080297d3a38127f0a8c86971c84683","implementations/python/packages/raes_runtime/backend_preparation.py":"sha256:4ae8d8abf8bdef9943ace748c03ce650a137cd8e47b5695e88da92da61a11df3","implementations/python/packages/raes_runtime/backend_profiles.py":"sha256:50f5cb3bd14d7b5fef6ff9ec3712ea2353b3b45deab6769d9eaa6b258f265af3","implementations/python/packages/raes_runtime/backend_realization_authority.py":"sha256:141e88689dab8e61c15ebf0ae76955270a2bc3ba978e5b624292a4109ed906a5","implementations/python/packages/raes_runtime/backend_result_diagnostics.py":"sha256:fcdb3bd4d41451cb1f4c07f92fe4ebd1260992f9fd2db984c37a5bc48772ebc9","implementations/python/packages/raes_runtime/backend_snapshot_contracts.py":"sha256:93ec700bfbb53d869c456f2a388112ff1fb1fe5976100ef6d27fb38ef0957bcd","implementations/python/packages/raes_runtime/control_plane.py":"sha256:937e54599839aeae42d8b2370aa65a1e26e1bc960e4b4ccb04b4748363fd6efc","implementations/python/packages/raes_runtime/control_plane_admission.py":"sha256:fc716e8688bdaa5089831208da30242468546f7d832d549b5c57bf3591f8c413","implementations/python/packages/raes_runtime/control_plane_api/__init__.py":"sha256:35c58d1269c95065e073c25a98b6408145d7eec77d02b879ed8fe485e6c5b992","implementations/python/packages/raes_runtime/control_plane_api/_auth.py":"sha256:d21f1be6c4e03fbc8a4594b2970e2d8ae71a411e79c7a9dc1caf8563ebe05852","implementations/python/packages/raes_runtime/control_plane_api/_health_routes.py":"sha256:5fd18e83e62a5fb0a75b63ee59843db098a9a85c25bc1878c7b00f2bb2108bbb","implementations/python/packages/raes_runtime/control_plane_api/_inject_routes.py":"sha256:a720868cc84baeb0486cbc18b9a295e8f2999a9ac4dd5bd9edbae1e005cb2a76","implementations/python/packages/raes_runtime/control_plane_api/_offload.py":"sha256:68a739d41e11b87a8d058f3d01ecea771b22fb82070b676e2c931bf5d44f59c8","implementations/python/packages/raes_runtime/control_plane_api/_operation_routes.py":"sha256:5fc782c0adddc1a8a3d3bf5e352c15f30b95fe8b86405648c0fb47fbbd7f591b","implementations/python/packages/raes_runtime/control_plane_api/_participant_routes.py":"sha256:33ba5a6e2802c68227f20480a0f33fb5b959d824f86302d626fa655613b17cb1","implementations/python/packages/raes_runtime/control_plane_api/_responses.py":"sha256:c6ff5f977f6ed33b2acbf9286f0c891a22cb568fe333f1fd2735ca94fa95b952","implementations/python/packages/raes_runtime/control_plane_api/_runtime_routes.py":"sha256:016c15145ad2f0c27e65ea561a0cc5703d65babf535efd115eb1198de3810077","implementations/python/packages/raes_runtime/control_plane_api/_supervision_routes.py":"sha256:96e8cc88f738df4704b878efbb306d7f5058c67e117ea38439d7c62763da2a16","implementations/python/packages/raes_runtime/control_plane_api/_workflow_routes.py":"sha256:8c703843f8ad634cbc914569ec0d83d6f7c8ffe62ea8828de9613d5e938acca8","implementations/python/packages/raes_runtime/control_plane_api_guards.py":"sha256:7752d4e2f8a0d5a6401bbc80078162fc62f4735e8b363362f7608090468dc73a","implementations/python/packages/raes_runtime/control_plane_api_models.py":"sha256:1826f5d7aaebf9c7018ff8ceb894ce63cf1165a60e8e7b15e990b2517c63cea6","implementations/python/packages/raes_runtime/control_plane_api_participant_retrieval.py":"sha256:be3f781412af7bfeb6069a029741bea78d1ab2f1f614d922b96c3ffb9e61fadf","implementations/python/packages/raes_runtime/control_plane_audit.py":"sha256:98fc0e3d23652669900ae92e50cf4dc347515d212ade1aa9d70fa1c353e968b1","implementations/python/packages/raes_runtime/control_plane_composition.py":"sha256:e2790739082b6d35f1f426764279c4eb22e6f3876a0a4dc62c2d7c604bd73861","implementations/python/packages/raes_runtime/control_plane_configuration.py":"sha256:61e5bec926b94a51b99527a658d2cbb408b60dc0257a7ecbedb335cf4682e1c3","implementations/python/packages/raes_runtime/control_plane_durability.py":"sha256:c326613d6521e0844161eb4701f326adafb3bd628a58b74085be0debb884c530","implementations/python/packages/raes_runtime/control_plane_evaluation.py":"sha256:f63a207548bde8a3a1cb11760cfcae798d1a5ee0b6c8a331ab6b58d40151441c","implementations/python/packages/raes_runtime/control_plane_execution.py":"sha256:ab48c24619c6cab9f937f7bfdde66ebff028cb0a5bd85e94d14e426dafa395f7","implementations/python/packages/raes_runtime/control_plane_health.py":"sha256:6f97f4be6ad2550d2425c64b8b9336a2727d8ceeedd95ca6a6a4f106868a59f5","implementations/python/packages/raes_runtime/control_plane_injects.py":"sha256:397ef19bade58ebfbcb102d53c4c6bd3c3811abed8cb3e3b5c22f4c1fd2b18e5","implementations/python/packages/raes_runtime/control_plane_inventory.py":"sha256:6378d7a3c83b3493c7a10b6c40d3d750b409bd0f0f919eb8301d8cf94a2b8db2","implementations/python/packages/raes_runtime/control_plane_lifecycle.py":"sha256:d96e3b4e6021aca7967bc7cf6ac3a77818e379d574ee655ee8d8164de976ac45","implementations/python/packages/raes_runtime/control_plane_mutation.py":"sha256:3643941d1a3abdf3bd6aceaa2973a7744c65508a50d6a9b6d1e8d0fe841510f4","implementations/python/packages/raes_runtime/control_plane_operation_context.py":"sha256:20ed1fd691b0b1a6841c014823c81797e8948d223d63a302014f7b060eb5e003","implementations/python/packages/raes_runtime/control_plane_participant_apply.py":"sha256:755965f93f725eb24a8b2cb9a402b0b47b1ef067f79d9867478792a1ae94528b","implementations/python/packages/raes_runtime/control_plane_plan_authorization.py":"sha256:1a9ed13a59dcfe10f5feb217b6dca17955592130ba075b41b6f3c08364d101fc","implementations/python/packages/raes_runtime/control_plane_profiles.py":"sha256:d4df296f77df69854170b6ad8e5a6bea6b9b2225d81c1f4f0e79a7f8a783ec8b","implementations/python/packages/raes_runtime/control_plane_recovery.py":"sha256:d25647629d92f5f5b8944884eb936a1d9ee9674c701436b19f5f0d2e495e0e53","implementations/python/packages/raes_runtime/control_plane_resolution_records.py":"sha256:842bf9ee657102f95e01f919c86317a1c444eb376d98c6e82c4e79d181e48285","implementations/python/packages/raes_runtime/control_plane_security.py":"sha256:e17210885ae58150243c02e4e0f34561455527e38002c5219a128c8a731f2d06","implementations/python/packages/raes_runtime/control_plane_store.py":"sha256:8cc466c536d9b852b26c3a23459f76038e4bab2e5f5da389df1c245c70022e5c","implementations/python/packages/raes_runtime/control_plane_store_bounded.py":"sha256:e17f3ea41c1a5fdeb254655a5d0cf6a5f77100398c9604caaf578caf35956177","implementations/python/packages/raes_runtime/control_plane_store_changes.py":"sha256:3aed4a9208b072b929334b296a10b2aadf955b996c02324dcb11a482186758f4","implementations/python/packages/raes_runtime/control_plane_store_compatibility.py":"sha256:aaf4c22d0ccc484d0e49d8ef79364389dbc477590d221be29dc8de04992f89c3","implementations/python/packages/raes_runtime/control_plane_store_history.py":"sha256:d753ab043faf48789f5f891e3481dd6846732017096c461048421d16cd63cba1","implementations/python/packages/raes_runtime/control_plane_store_history_rows.py":"sha256:9b38c3fd5e7190c76dbd9d00ca388cb1314a9a7069935303964454aac504d8d1","implementations/python/packages/raes_runtime/control_plane_store_lease.py":"sha256:7da2d452b75ded33125c7f99e0743198430465dba59897ac537bd22863e079da","implementations/python/packages/raes_runtime/control_plane_store_legacy.py":"sha256:9c87f7b437002ebee358912165b769237b1ef1d218baf524f3ea2011fd736f9d","implementations/python/packages/raes_runtime/control_plane_store_local.py":"sha256:1c2c5401ae330fd5b1df093997d26fb8f6a6b2e556a82168557e5b27336ca70d","implementations/python/packages/raes_runtime/control_plane_store_local_cache.py":"sha256:7533f49a6442bbaec8f27669743338ba35d19385d53d287480812b42fc0da2a3","implementations/python/packages/raes_runtime/control_plane_store_local_codec.py":"sha256:c87424398fa1f1724d4082ed99ce9b02b2cc4c02b18e6fff8340105715d28089","implementations/python/packages/raes_runtime/control_plane_store_local_invocations.py":"sha256:9060d713bfcbbc0127de7b96cfdbded17a25d62f9f06742f1056e70e8408e6a4","implementations/python/packages/raes_runtime/control_plane_store_local_records.py":"sha256:846963fc26cc0f7daf0f776f91868cd76d111fab61f390939114bc60d90a2132","implementations/python/packages/raes_runtime/control_plane_store_local_scope.py":"sha256:111e7513a7f5824d4f585ced75b62a14cef9255d64dc1ebef23be329ea9c21c5","implementations/python/packages/raes_runtime/control_plane_store_local_snapshot.py":"sha256:e2aa5805a1b17e1591536c0b823299ab2231009fe48be3894c61488da40a253b","implementations/python/packages/raes_runtime/control_plane_store_maintenance.py":"sha256:49d4c329bf48474761f6a9375651f616c8dc1d77ebe076b4a9bf54dba345290f","implementations/python/packages/raes_runtime/control_plane_store_memory.py":"sha256:0358b5b4a17922d7e57b6638ea14e99b97f7bc2b74569b000388b63c411d91bb","implementations/python/packages/raes_runtime/control_plane_store_observations.py":"sha256:80fbba5f378e8f45d4c1735e4a1b5b1dc530385bc3356b0dd91cd0e65ebb54fa","implementations/python/packages/raes_runtime/control_plane_store_paths.py":"sha256:080d82e5948a9cc18e03f5b7d226faff2d8eb66f09d25861c458ec42b99079a7","implementations/python/packages/raes_runtime/control_plane_store_payloads.py":"sha256:2ab553ecab8c0645c1720399c27aa48ff6ef189dea937d30d6f07578083a31cc","implementations/python/packages/raes_runtime/control_plane_store_postgresql.py":"sha256:b3f004900c75dc535251f4b788c7ab01239e53d0b6c2e2ef82077b966f4a5d9b","implementations/python/packages/raes_runtime/control_plane_store_postgresql_mutations.py":"sha256:f3f2f77cdc2449fc250f34f5f1fec14418ad0fd0c863726c28a7115c08bb3840","implementations/python/packages/raes_runtime/control_plane_store_postgresql_projection.py":"sha256:c733406d909abc18749716a3e79e311b92ebd663e54096f01b5e75c9202a48a0","implementations/python/packages/raes_runtime/control_plane_store_postgresql_schema.py":"sha256:208936495b2f67fe1e951a0420de67b63435c0df3b2c39050804c61ee935371e","implementations/python/packages/raes_runtime/control_plane_store_record_migration.py":"sha256:8bc5cc17e119ee06b329a130390a16a975e28525b6334914ce2b3cde30bfa1c3","implementations/python/packages/raes_runtime/control_plane_store_records.py":"sha256:122fb319133207016bb7bbf8c9368b207a14887afa3d6b87b8b93e0aeaaa6173","implementations/python/packages/raes_runtime/control_plane_store_revision.py":"sha256:b79d8bf98de13f8dee31147099249278d87de117c9de4948cbf5b3f6234a13b5","implementations/python/packages/raes_runtime/control_plane_store_snapshots.py":"sha256:5d67a340831ea6eb5eabb51af940a92b89e27c521c1c6a860ba0d70afeb84c77","implementations/python/packages/raes_runtime/control_plane_store_sql_changes.py":"sha256:621cfa5a2fae88c271fe3c8f62bb1e24df73178f2af822c923bc303617ae4a99","implementations/python/packages/raes_runtime/control_plane_store_types.py":"sha256:12f850f82ac60cff88955edd0eadff6537f8c482341ee214a8c0990b0f9db23a","implementations/python/packages/raes_runtime/control_plane_submission.py":"sha256:33bbf54b7ce21a4ed78aa854b8b3f1186eb580ec011b2cc5aeb1449746d46446","implementations/python/packages/raes_runtime/control_plane_supervised_execution.py":"sha256:afd9c95aaaf75993e48ef7273c3758322ebf5310cf5d0717da426bc745fbf1f0","implementations/python/packages/raes_runtime/control_plane_supervision.py":"sha256:ae89480acc064d7c3ebc29254af261402a0c71867cac46b6394be526e7f61204","implementations/python/packages/raes_runtime/control_plane_timeouts.py":"sha256:0a997df994773d35e61ee213c8966a7abe69a59ff693fad033041b94316a5bc8","implementations/python/packages/raes_runtime/control_plane_workflow_control.py":"sha256:7424e4d725a689f46d2e65a8eec22546f21bf50eae21fd601aff37d5882e2790","implementations/python/packages/raes_runtime/control_plane_workflows.py":"sha256:91a34dcca3b5b370d2f25bbe24044b37610f0ceb6d5fe9edbee33779ca0f8565","implementations/python/packages/raes_runtime/diagnostics.py":"sha256:8d3a4bb17bc01a003773b66f8fd989f1ecc97939e65c6d13160bae9a42abfba9","implementations/python/packages/raes_runtime/evaluation_result_contracts.py":"sha256:f0927383ba82490e75d6228429afd4306a501437c21502c70f92fe07cf416c34","implementations/python/packages/raes_runtime/inject_capture.py":"sha256:5f93cdebdc0ee29cffd4236d0593121b2d9ca1c399f7d4d3f970f42c8ce2ed0c","implementations/python/packages/raes_runtime/inject_claims.py":"sha256:0e52447c79cf914294bae81587f7d8aeaf2fe57b641fc59506afd3731afba2f9","implementations/python/packages/raes_runtime/inject_execution.py":"sha256:2099e199a7b4850f16e48f18538bf714d03171dab09c5f71d6973410b351dc77","implementations/python/packages/raes_runtime/inject_outcomes.py":"sha256:ac61feccdf2efe135b2dda75aa0a1d76f862e0a2be6ad651903f0311f8e2a8ad","implementations/python/packages/raes_runtime/inject_schedule.py":"sha256:916189ea7c26af11bf13009d33c3a4bc8f6325829e6f8545bc763b9e10f0b492","implementations/python/packages/raes_runtime/interaction.py":"sha256:154c0cc6214c82e5bc1652665945b80071cf6a23d097984e1f2430e2aa8e15a0","implementations/python/packages/raes_runtime/interaction_dispatch.py":"sha256:e7f29ddb383a3aa1ea9ffc48dc12984a2753e8e0e418aa8b6c1df7102cee69e2","implementations/python/packages/raes_runtime/interaction_evaluation.py":"sha256:d4e87520599bbb23a064a4832603db50047f250910e09e1162910f7558672b37","implementations/python/packages/raes_runtime/interaction_results.py":"sha256:f2cb1d349b41d42ffb7859503d55b3e97039cddfce65626ac4805cd132f5c07d","implementations/python/packages/raes_runtime/interaction_time.py":"sha256:6762e861597ccb560b10d3e98f801340b08cadba7dffecc3aabf46bb40248575","implementations/python/packages/raes_runtime/manager.py":"sha256:2f735b76c0e3c898204659d67a1e0d12d5fa481d91bcbe4d0c05ee7bfe36954f","implementations/python/packages/raes_runtime/manager_augmentation.py":"sha256:3e0fc0c9eddd8cfffbe226313cb863543a5d3c0969f1a93e1d9a1601f9f0e439","implementations/python/packages/raes_runtime/manager_destroy.py":"sha256:d2b495376cc3837bee289a93477fc73545076199b46e4711d2cc25b298142624","implementations/python/packages/raes_runtime/manager_inventory.py":"sha256:884ada90967d9ce6f27e1d1678c3a5a338be7ac2754ffc35cf1f424fe8966fa9","implementations/python/packages/raes_runtime/manager_lifecycle.py":"sha256:ba5d6ba1d38b4bb52111dfaae3ff9c7616059f76f98dffc6a0d9e38bf56eb083","implementations/python/packages/raes_runtime/manager_plan_admission.py":"sha256:b3e781cce4449379a33cbbe1b8b83d1634a4631c43fc0834681eca64f13f7253","implementations/python/packages/raes_runtime/mixed_backend_action.py":"sha256:3edf8d3a90c317b2dcd66b7221ad1b805b58d21cb690c2edd2c4cec4e9571bbb","implementations/python/packages/raes_runtime/mixed_backend_installation.py":"sha256:4f0f0116677c153d808c42cd69353a3c353e333d74f71c9cbe33dd7b596900dd","implementations/python/packages/raes_runtime/mixed_backend_invocation.py":"sha256:0e896aedd9bab9f69034ea1458e5b5cfca82d92f712fc394fbd826f91dd16e52","implementations/python/packages/raes_runtime/mixed_control_admission.py":"sha256:1344e0baba4a3805740f6318e96cb7403aca037e2e61d21988ad3a32c5550cc4","implementations/python/packages/raes_runtime/mixed_runtime.py":"sha256:a4831aee61d8f552f470f0871efcc06ecc15b3e148c32c66371423a894e93834","implementations/python/packages/raes_runtime/mixed_runtime_dispatch.py":"sha256:1e131af1ea2ee20fbedc94b9161e2932ecba1846b87c34126b48efecac86d735","implementations/python/packages/raes_runtime/mixed_runtime_edge.py":"sha256:2276702026ab0e3ffcfedc04205ec0537da79cefa730b9cb564df4eea4a53544","implementations/python/packages/raes_runtime/mixed_runtime_edge_execution.py":"sha256:a76132ff6fa28eb4246fe83b8252f395246b14929e6dc87e32a0bf11142961f5","implementations/python/packages/raes_runtime/mixed_runtime_handoff.py":"sha256:ac05a88966841f93a0ba2645755561ae5c923014a633fbfffbc1f6944bc3ce2a","implementations/python/packages/raes_runtime/mixed_runtime_handoff_execution.py":"sha256:be7468c83fedefb5b1121d19fb66adb778df3a09175549f1107719f335e8e9ec","implementations/python/packages/raes_runtime/mixed_runtime_lifecycle.py":"sha256:e084385d79773a541294e7e2f0f4ac9007bf041ef7155fd8c5c327f1f564f3cb","implementations/python/packages/raes_runtime/mixed_runtime_phase.py":"sha256:e98b269b6bf36c4da91f5c40d8f01499c22db15c583979bbc0a779a5f94b4ce4","implementations/python/packages/raes_runtime/mixed_runtime_recovery.py":"sha256:31d31b1a74b81411b0153a921f0cc0225d7bd866dcd975fb59d750b15a45a50e","implementations/python/packages/raes_runtime/mixed_runtime_result.py":"sha256:2065a85acec4b6d21fb8a40140b5a280869e23d9840f76b571580467a5aff9d7","implementations/python/packages/raes_runtime/mixed_runtime_state.py":"sha256:17b3c54b5c7d448139e6ebc3fe96050ca794965c8e599adb23d8cee1cce584b1","implementations/python/packages/raes_runtime/observation_admission.py":"sha256:6fd8ed3455b77dbdcd03ab23ffd89f09f2d4f4ad5a51126f424b24f340a1160b","implementations/python/packages/raes_runtime/observation_capabilities.py":"sha256:613ea28df035c0ce87bb35d3a0e20ca80887d61eee1d948a04def88c2e2d8904","implementations/python/packages/raes_runtime/observation_execution.py":"sha256:a7a294aa9fb10c1b46f925faeca53096afcafe7632df19b7d1c07027d4cd2c15","implementations/python/packages/raes_runtime/observation_native.py":"sha256:cdda442869e3f881b7d7caf99a5bbcccbf537895d0c32db41a3206debfe6ab56","implementations/python/packages/raes_runtime/observation_results.py":"sha256:a0ffa31636d9ffcfc2781e0e91a1842b3b0e41948d008ecfe75a65081acb76ab","implementations/python/packages/raes_runtime/operation_command_commitment.py":"sha256:54da237cbb318324029a063a4a37e99bbf1950f10b881de61f5cd17222123ec9","implementations/python/packages/raes_runtime/operation_control_budget.py":"sha256:63072abd9ea9daf2ac2a451adf83f6db531e14e204e61afd4e1aa70e66cc2d4e","implementations/python/packages/raes_runtime/operation_execution_adapter.py":"sha256:c5609eb40b96686d5bd6fa5839528d93224fdf89cf02f69b441e0cd8e5f014a2","implementations/python/packages/raes_runtime/operation_inventory_binding.py":"sha256:d21fc26e7b643dcba03c55ef3f51f836bdd693ca78520639b1aefa411c4def3a","implementations/python/packages/raes_runtime/operation_invocation_ledger.py":"sha256:1d5afd06f2b63841be2bdbd08bdc8100601afee92f53aa20f0ddaef33a12cc29","implementations/python/packages/raes_runtime/operation_ledger_transactions.py":"sha256:cc2c1199aadb660faa4367da460e8406d661d97d8903012dda59cdd652e50eaa","implementations/python/packages/raes_runtime/operation_policy_admission.py":"sha256:19dba819a67bce6f0c092d3c060d7d6fa6afae252d5739bc0fae319ed6ac3842","implementations/python/packages/raes_runtime/operation_provider_control.py":"sha256:441689d8af063c73e9c712d530710b1e955aa3903f1c73834b50465250868085","implementations/python/packages/raes_runtime/operation_provider_execution.py":"sha256:a5e486b8524173d81f69cc419416b0764f07fd9fd03f773e2afc5c16e481d4c0","implementations/python/packages/raes_runtime/operation_reconciliation.py":"sha256:104a224d15ad7bac4584582b49e49ef2b952f074ed7b68ad8c1d95196b846d47","implementations/python/packages/raes_runtime/operation_reconciliation_ledger.py":"sha256:0172912192348fd15519a945a7e9e2ff18040877b689e4cd514aa1c0c29f908c","implementations/python/packages/raes_runtime/operation_remote_authority.py":"sha256:1abbc21defdf22b2c47003da37b8c3f051ee0575a65a25daac86fe2f5ae22c48","implementations/python/packages/raes_runtime/operation_result_finalization.py":"sha256:4cddee804b46dd50025c1edda8cd5543ca9811ce07362d7b30f7f7540ecc0f2c","implementations/python/packages/raes_runtime/operation_supervision_configuration.py":"sha256:641dc3ee683f3e90a4ae71d7561309a7b514b1cd0089fb1df1157490d0f8e36f","implementations/python/packages/raes_runtime/operation_temporal.py":"sha256:51ee7667482319b798de77832410789a883bc6ac920c2bf72dab80b06b686051","implementations/python/packages/raes_runtime/operation_temporal_worker.py":"sha256:0b8bf9d61d3f2a5f1d05f865b3e891b46c554d0c9626541f9906180571781244","implementations/python/packages/raes_runtime/operation_temporal_workflow.py":"sha256:366950d2c6f587a7a554cc2c162b5f1b84cb12438944afb7c72dcafacc0bdf7a","implementations/python/packages/raes_runtime/operation_transcript_policy.py":"sha256:379edf636ef7b1679f154d0c64f7031d8e52e45ad6dd01c52a499c091cab6adf","implementations/python/packages/raes_runtime/operation_worker_authority.py":"sha256:7c1250da447b3ded9dc72eaa4fd4c0e44dce09c617621a250df2e56ec7765783","implementations/python/packages/raes_runtime/operational_apparatus.py":"sha256:f5a7dec713542ef6cf9d01161128168057b90059738cb5bb89f83fee1d38e9e2","implementations/python/packages/raes_runtime/participant_action_validation.py":"sha256:57461693688d864b177ea8858ae4939d85002f27bd883f39a799cfe85545b6d4","implementations/python/packages/raes_runtime/participant_activity.py":"sha256:6d7da07d360421eaff3f54dbfa735da367a9562ed2bfab38e5bf4870df4e1504","implementations/python/packages/raes_runtime/participant_activity_support.py":"sha256:9c4b97cbcaba23b7b434004bdadebf2b3f044447c83b8c0b3b004c3d9f1480f9","implementations/python/packages/raes_runtime/participant_clock_driver.py":"sha256:51d08f452949ce30ce498d17c3de7de1a47777610036f88b98eb4c55723af319","implementations/python/packages/raes_runtime/participant_control.py":"sha256:2bb51a5a7c0976549f15991f08e2b3075ed64102451ed9ba15c7d8999fd37e8d","implementations/python/packages/raes_runtime/participant_control_action_admission.py":"sha256:cabd882793ebc1927f400e31b3efbd89349eefa420584727582f6678bd7b5bdc","implementations/python/packages/raes_runtime/participant_control_application_mediation.py":"sha256:1713c5d7c176bcd96bce8ae268139199fadbc771d552ca44272edc0b3631c469","implementations/python/packages/raes_runtime/participant_control_applications.py":"sha256:933dc3173dc26d1497d8c5b0668fb965d1898b6b523c77734767fb36114b9b56","implementations/python/packages/raes_runtime/participant_control_archive_projection.py":"sha256:84dd60f6c1bf407dc1fd087bb114c0e0458746587a5c7d4c473fffab3893c748","implementations/python/packages/raes_runtime/participant_control_batch.py":"sha256:dd96677086b0adcf237ccfee9484bbe047cc79b225808775c8ae40807548a661","implementations/python/packages/raes_runtime/participant_control_binding.py":"sha256:ae2147f31030e6508b5b0b278ab2f6bd2e4552eb35cc0c42b839b9ff1b62791f","implementations/python/packages/raes_runtime/participant_control_cancellation.py":"sha256:4ee73736ae0f4e9a49220fd5fd337b699167ae457a495ca9b0a19ed40929598f","implementations/python/packages/raes_runtime/participant_control_causal_state.py":"sha256:e17d23d7179b545ed16487dbfef15818f769730fefd0eac7f46d047799cd4769","implementations/python/packages/raes_runtime/participant_control_cut.py":"sha256:e4e097c73da456cb304b09d3179bd98edecb79679fd7921ed0a7c6c4d3877df0","implementations/python/packages/raes_runtime/participant_control_diagnostics.py":"sha256:511c0911dc73c1029f9397b030fea7d61cb12e1aa3eb4a955a16f386a4353180","implementations/python/packages/raes_runtime/participant_control_effect_continuations.py":"sha256:cee7439f1a4f506c984a2329acee99eaf76f6a220bb69314f02231711c8bf3a9","implementations/python/packages/raes_runtime/participant_control_effect_drain.py":"sha256:f08257946ccf6b049bb7cba27637e6184bf9bb1d78e5e8fc507205d7f20ebef3","implementations/python/packages/raes_runtime/participant_control_effect_evidence.py":"sha256:12f8de236214c37fc29332f4583730c29c21dba6b4dbc53850d9af6a07b082ac","implementations/python/packages/raes_runtime/participant_control_effect_owners.py":"sha256:b0f43051b3e04152dd0e350e4c8e68db40bfa2c3a4fa1c23f9c8d86eced88cc9","implementations/python/packages/raes_runtime/participant_control_effects.py":"sha256:0fff8f94f9885760560055ef45734e01af027c5d7f08b5b78be9cd7ce7cc08b6","implementations/python/packages/raes_runtime/participant_control_episode_admission.py":"sha256:2c2d60addddabe9a40d72552b7664170fe015b97b550ccfc984b2d674ecd6736","implementations/python/packages/raes_runtime/participant_control_evaluation_v2.py":"sha256:ec26cb34f3fc2cf58164fb21f5a9944a934582f923f64c8e1581a3a38dd2b5c1","implementations/python/packages/raes_runtime/participant_control_intents.py":"sha256:a9d2a3138d3185bac5ac5070f65c4588b95cb60745222d8852be3e1aed584770","implementations/python/packages/raes_runtime/participant_control_mediation.py":"sha256:81d1a48513c839ee89393aa4a60651672d75622b6d3a3a462da6c360d0038baa","implementations/python/packages/raes_runtime/participant_control_occurrences.py":"sha256:4cfe3f7df6efbaedc0f5663bb972536b7d0ca402403ebaaf61876f4db459b79c","implementations/python/packages/raes_runtime/participant_control_operation.py":"sha256:a706e4417bf66c2deacaaa660db6f38aac824f6a1d87b8f28ac6e52061898c93","implementations/python/packages/raes_runtime/participant_control_operation_index.py":"sha256:9ff2264d59be28e4802dd6958c0ea6df2f60e4cd6e7e864e644770e46a7a16bd","implementations/python/packages/raes_runtime/participant_control_orchestration.py":"sha256:9ee9753c84e42f3c01b64a16d609cbc8507a3e067c416ead81bbee1e54d2c207","implementations/python/packages/raes_runtime/participant_control_parent_outcomes.py":"sha256:c886ec29ba934ae5c7845181e48bea6bffb30281f607ead51262b6b670952a99","implementations/python/packages/raes_runtime/participant_control_projection.py":"sha256:855bdd55ab3d117a2b1395f9ef41e3755ab106f221381fd5b744e44788a96c04","implementations/python/packages/raes_runtime/participant_control_provider_state.py":"sha256:82f7064298f3df2b7cd4c303655a62e307477709d84f7133e3e3d59263c129e9","implementations/python/packages/raes_runtime/participant_control_receipts.py":"sha256:ee37c0f9e1ee760c69ddfd61751b83582c136f62c3f7005c75f59b169c8dd5ae","implementations/python/packages/raes_runtime/participant_control_records.py":"sha256:b4b1236aeba54094cc859fb92eb4cde2ce1929eef3ebf4a186a1944508baef69","implementations/python/packages/raes_runtime/participant_control_rejections.py":"sha256:198ebbb4b9a46a07532edab634e07a27c5723e2ab930e38b8cc8f61ce9a73b0c","implementations/python/packages/raes_runtime/participant_control_replay.py":"sha256:c8fbc4def1e6479312fe9ccc0d8f5ec5463de0c37ba7bc30bf44cacbe93a1ac6","implementations/python/packages/raes_runtime/participant_control_request.py":"sha256:bf1bcd23f7f89d5aec2d5b74f9f42f24e0b9a6ae170f1bfd09e25d89d3fe8da9","implementations/python/packages/raes_runtime/participant_control_runtime.py":"sha256:e8f8bb48403e261565747005f8bdfa41a189b31739b80fdfb105ebe3df29f1c0","implementations/python/packages/raes_runtime/participant_control_targets.py":"sha256:886875d6ccf34b76f84668e95507f454668bedf0e425bd28be6a990917aadbb8","implementations/python/packages/raes_runtime/participant_crossing_action.py":"sha256:2dd76272317698ad5f91371ce5fc1de55bc7d2fbced41f647ba876d5efc17b70","implementations/python/packages/raes_runtime/participant_crossing_boundary.py":"sha256:f4eb6e2ba9deb49a839a362561a88837926e82914f0076ac9d9c5ddf48e3f162","implementations/python/packages/raes_runtime/participant_crossing_commit.py":"sha256:0a687c3e02c832a94fa25c88bc0e64c93098ad8f974011b5903132edaa76ba96","implementations/python/packages/raes_runtime/participant_crossing_egress.py":"sha256:035d82bd9db689e8dcd5ed2689375145bbbd11336836b62e20f9264737d06706","implementations/python/packages/raes_runtime/participant_crossing_intents.py":"sha256:2cf40875e2f0ab2e22a5a7b5f182bb28e044df07b2dd6b3c833caf7d610b888a","implementations/python/packages/raes_runtime/participant_crossing_mediation.py":"sha256:ab2ba02e568c2e182651877019e4960cbe34c81522ccf8ac14e6568c372b9371","implementations/python/packages/raes_runtime/participant_crossing_operation.py":"sha256:54427dd46eb8ea2b8c137b5e8cc488fcd4e238268237455d4f38a55ffa751d27","implementations/python/packages/raes_runtime/participant_crossing_policy.py":"sha256:50344823aaaa545deca2848e1eeaff3e84d1143d9d3a679536e0848ee6229ee7","implementations/python/packages/raes_runtime/participant_crossing_projection.py":"sha256:e0aeb644507c8a9108512d4c9d0ffa9a89a876092b2e9fa7fd142fcae11c82f2","implementations/python/packages/raes_runtime/participant_crossing_records.py":"sha256:281f8a4d5582fb41fd9e75f8a31f576e668790a964cfddc76408efd6ee037355","implementations/python/packages/raes_runtime/participant_crossing_state_cut.py":"sha256:3bd347d26c08888ea61d8d19600c43f7f1cad01daedc37da34d413b8153b24c2","implementations/python/packages/raes_runtime/participant_crossing_transform.py":"sha256:f7d9ac5535df7c6f8048c3689b8b8b5693dc043345ba62c1839de3d857e61f2e","implementations/python/packages/raes_runtime/participant_decision_surface_control_v2.py":"sha256:4aab758c63ec7d636681d15308404e4856a00cc2b791a2b706c8528d3e125ca3","implementations/python/packages/raes_runtime/participant_driver_failure.py":"sha256:8d4fbb78a5fe0e13159187fb8f3f0e80a853585ef55ffee6b442dbcce189bdd1","implementations/python/packages/raes_runtime/participant_effect_authority.py":"sha256:53c4a9af4ffb117cf48543bdc75d6e34339cd13f2ec0375b8e6eb00644ece400","implementations/python/packages/raes_runtime/participant_episode_control.py":"sha256:8904efd7f5c9d568b1629ddac4adafa5a7ac8cd0b55195679b07401a3512d108","implementations/python/packages/raes_runtime/participant_execution_control.py":"sha256:db584a450d485cff3e286511e1459e83d8470d06ddeb5f23f0d135d28d703875","implementations/python/packages/raes_runtime/participant_execution_control_boundary.py":"sha256:27bb108ae83c62c99c28194f292269f991725b08661a4ff2074d6acf75ae01fc","implementations/python/packages/raes_runtime/participant_execution_scheduler_state.py":"sha256:1b8b983ca8e680dae745b48bdd33820d3dda57f27348c1f204b741247208d567","implementations/python/packages/raes_runtime/participant_flow_sink.py":"sha256:179f49890e55f469badb58060e2d1054add3fe2db10683aea386f12747934e40","implementations/python/packages/raes_runtime/participant_information_state_validation.py":"sha256:1919e0b6f6e6fcc947b0f49a539eaa88acf2ad18b2b55ff471252a8af9313f59","implementations/python/packages/raes_runtime/participant_inject_application.py":"sha256:2dc4e343e8514235200cc7c9d47416b555fe80ed49d96b6389afca24f0c16736","implementations/python/packages/raes_runtime/participant_inject_control.py":"sha256:626e640495745004fef05691366c22cec895d3bfb0bbca31c60e38f3c105589b","implementations/python/packages/raes_runtime/participant_inject_delivery.py":"sha256:26e3a036ae971653ef68882467d93ef04cd702af4d84c2580ec8651b81984c35","implementations/python/packages/raes_runtime/participant_inject_temporal.py":"sha256:02d039931935ee59230e58c135654299a91e7b6aa52c0d3426f85b835d76f56d","implementations/python/packages/raes_runtime/participant_opacity_enforcement.py":"sha256:4214e590dd7dbc523503ea23df8bf728da8f33e2edcc981d09c4092474a2c725","implementations/python/packages/raes_runtime/participant_outcome_control.py":"sha256:446f4aef52750ff64e3b33298da809d64d186e567122499bde4c829461956db1","implementations/python/packages/raes_runtime/participant_outcome_state.py":"sha256:734ff621a3a85ef9bd86c42c70be326fd861e9be4d54a07fcfbc4124c7260cfa","implementations/python/packages/raes_runtime/participant_resource_accounting.py":"sha256:faf33ebe98e39cd9c54667107e2764978160aa2a3fa34b58701d1ced95d37576","implementations/python/packages/raes_runtime/participant_resource_budgets.py":"sha256:a194a120a9dd6eb590c13558c8c1a95dd24a2a19f0332710516bb9ef8e79c655","implementations/python/packages/raes_runtime/participant_resource_pool_ledger.py":"sha256:c39120e2c09da71f9096b20c412ac6787e4381b984fccd084b1592d44f183321","implementations/python/packages/raes_runtime/participant_resource_reservation.py":"sha256:23c6654ce88ddaccbf295e12a2764a3888267f1b76bdd5389ffd1dd204110929","implementations/python/packages/raes_runtime/participant_result_contracts.py":"sha256:f894583eafff11d279330265a3cbab0e908b87314e044df0cc013cbfa26ec81a","implementations/python/packages/raes_runtime/participant_retrieval.py":"sha256:0256db04365fa7c8ac511c3a5039410660b4414eb71735befd3f8e32a8e53d96","implementations/python/packages/raes_runtime/participant_retrieval_context.py":"sha256:719fc1f384f6de6e636db5a067dcb95c8403210b7d34f42f3ed49babf163b328","implementations/python/packages/raes_runtime/participant_scheduler.py":"sha256:f3721e19b502a5bc6271d8fb3cda944640ad75efb53f56ec25c336f14b0f41d4","implementations/python/packages/raes_runtime/participant_scheduler_activity_state.py":"sha256:57e59b5372ea1b14bf7252ada6082b880ba465e484c395c7efbf68c5cee2b310","implementations/python/packages/raes_runtime/participant_scheduler_binding.py":"sha256:7d10411ce5dc215f65c59ad3c6cd18e565e89cc07e935503b80430d52c4247c1","implementations/python/packages/raes_runtime/participant_scheduler_concurrency.py":"sha256:7df7f1faa933e17f771f9a07dee3cf920ceacc8367616a8cb28f14f8f69859e4","implementations/python/packages/raes_runtime/participant_scheduler_concurrent_commit.py":"sha256:012343543367bae60462879dd59d496c85259c6550e801a8656c2c4dc4817311","implementations/python/packages/raes_runtime/participant_scheduler_concurrent_dispatch.py":"sha256:964c1a79ce862cf5bf9d213d600b30a3921759294dc2c29e33486282bfe8f50f","implementations/python/packages/raes_runtime/participant_scheduler_concurrent_settlement.py":"sha256:1c87fb26ec216957c086bdfb7a3e315bafac233b72e741c351eb9b9252e4b509","implementations/python/packages/raes_runtime/participant_scheduler_concurrent_state.py":"sha256:ebe744c70e2dc0d5838a3c011b7621f08ef2d98dcf8eff798bdafb38a9461783","implementations/python/packages/raes_runtime/participant_scheduler_due.py":"sha256:3c215b67748f9c19242f3f39aec1b748e8fa25cd3de7bdf8edb653153efe4f1b","implementations/python/packages/raes_runtime/participant_scheduler_initialization.py":"sha256:98d4cf572aa1c82b036040e58d94c826ad252fbae3e5bf4ceb47aec41e75b2f0","implementations/python/packages/raes_runtime/participant_scheduler_lifecycle.py":"sha256:bc6e3bc9751ce88ded7cccaa8bcaf6565a068d330790f5c96e4e9a86ddc1f404","implementations/python/packages/raes_runtime/participant_scheduler_operations.py":"sha256:785200c3d5e35cffc2aaeb4fa575a657a1268a42ff59158fc5903ad087f4340d","implementations/python/packages/raes_runtime/participant_scheduler_policy.py":"sha256:b0351d3a68ce4f3eaae1581f39a36891a63af04b24fc86bcc0d67545bc855ef3","implementations/python/packages/raes_runtime/participant_scheduler_reset.py":"sha256:ba45f1ffb614392a536b785f71f0343fffcb8de9c817491cbb8ee858934a8904","implementations/python/packages/raes_runtime/participant_scheduler_resources.py":"sha256:44181ba9ccc5d75ffbce8c7a5cd11b27aedd2d3c88c17858fcc1750734b2bd76","implementations/python/packages/raes_runtime/participant_scheduler_time.py":"sha256:1ce15d01dfc692a7cf1717e1591501f844ba50a2ecd0d446a6b55b60f650ef00","implementations/python/packages/raes_runtime/participant_scheduler_types.py":"sha256:186b5be4a40cd0c483ddce933ce1227a32de87d5e0ecdbd76b370d02889e96db","implementations/python/packages/raes_runtime/participant_submission_options.py":"sha256:0ef73481a5a542f8f7e761a148be7ecddf4e0ac5d6e7c95ae0a25650ab06d2d9","implementations/python/packages/raes_runtime/participant_temporal.py":"sha256:6f09e7487faaf27e0e18e121a7de13d3fcca54d0c0936bcaad7fbf49c415661a","implementations/python/packages/raes_runtime/participant_view_serialization.py":"sha256:3ff58639fc577d4a756de3a9ec197e96c3cd8bf002c27f5aedac2123d4822e94","implementations/python/packages/raes_runtime/proposition_truth_contracts.py":"sha256:4bc18264d945ad233b553a56be4d6648334e7a527814c752b4617030c554fb58","implementations/python/packages/raes_runtime/registry.py":"sha256:c93e9c105d6046a99bb65e224b81495c901a10ead65d2f730f9d1014e6d01987","implementations/python/packages/raes_runtime/registry_probes.py":"sha256:d9be53a8f238a3dad72e8c005d9066ec76df9c77522b60a189bba301e21e3313","implementations/python/packages/raes_runtime/registry_scenario.py":"sha256:06eaddfff59c20da58159986353a6694b11ebd214a2e2748f3f462155cd530e3","implementations/python/packages/raes_runtime/registry_target_validation.py":"sha256:3b6fee5577fc43f1433704c96d11d5acd2b94959b1d6b64fcd9930336886c13a","implementations/python/packages/raes_runtime/result_contracts.py":"sha256:2b2fc06f369c82f696bcd1ca34a56c572d1282c7dd74b2c1f8743ed35b831427","implementations/python/packages/raes_runtime/runtime_decision_store.py":"sha256:f989f52bfc9b4898d795731e6a98309af5abf0b88293cfab83b371f4441a9120","implementations/python/packages/raes_runtime/runtime_decisions.py":"sha256:800b5b6f8dbe9981e2adb4efd7f3dfa67f38e6e388ac9023253ce8ec9fd9e97b","implementations/python/packages/raes_runtime/runtime_engine.py":"sha256:29fb1c6ed9a0baa352aa375b9350539b9599a7b8ef857c8640cfde93b9528554","implementations/python/packages/raes_runtime/runtime_experiment.py":"sha256:14f445d4cc3ac1291386f5ee922707868ef6d28f2cc04bd54134988c987dc865","implementations/python/packages/raes_runtime/runtime_experiment_admission.py":"sha256:6273acc5dd3022df8315137708ed75c0536b03054aaad247c67c3ad697b3a40d","implementations/python/packages/raes_runtime/runtime_experiment_progress.py":"sha256:b1da8a696b9968f5338f1aae6aeb916468bed6f79f73dda651b370d9314dadb9","implementations/python/packages/raes_runtime/runtime_experiment_replacement.py":"sha256:90647de25d83ab570d06a2ad660a2366f4f4076592a0f0541bd2aa1d26eb96e1","implementations/python/packages/raes_runtime/runtime_fact_binding_policy.py":"sha256:742c3e0675d4de2f09a2ffaff70a736ad04050cf42b14a4e64173b4feaa4ee6e","implementations/python/packages/raes_runtime/runtime_fact_bindings.py":"sha256:57fd381ed56fc3232be8a566d04eaaca8a055d24eadfaa7036a6e881d13ad3ba","implementations/python/packages/raes_runtime/runtime_fact_dispatch.py":"sha256:b58103fb701f27458fcf2af99b953e5d526dbee90f3a059d1261231b85078caa","implementations/python/packages/raes_runtime/runtime_module_step.py":"sha256:74e0e9abdf03469d5c6243d5e0e675d04612e0979205584a3f1ff573a599af96","implementations/python/packages/raes_runtime/runtime_operation_routing.py":"sha256:06091223874c6d52a690762783f3b47c2fc05307724a79ecf50abf68aa6cd73c","implementations/python/packages/raes_runtime/runtime_resource_ownership.py":"sha256:947db06f51a765e3b82db48c2579fc4a01d5d056bb7cd3e3b9939abbaf7ae855","implementations/python/packages/raes_runtime/runtime_run_cleanup.py":"sha256:cb963a47fb0df22b463f7943985be25ac3bbe09a5119018a3e5598f7429b0220","implementations/python/packages/raes_runtime/runtime_run_context.py":"sha256:87a9d754c8d643e50f2653c734242823b40ff57e0a4e4b87c68891c39b3a33ba","implementations/python/packages/raes_runtime/runtime_run_driver.py":"sha256:c6aea19d0df593a346c7606a7bb3cc2f28c9fd685b608aa0859a8d3d372acda4","implementations/python/packages/raes_runtime/runtime_run_preparation.py":"sha256:ea0730169edfe99cdc6176bc9ba302deb64e17e9436e6318001c9405e786d174","implementations/python/packages/raes_runtime/runtime_sequence_authority.py":"sha256:645b21d98cb6988c968b1afa671f784d51596b275c63e2995a529c0274389e58","implementations/python/packages/raes_runtime/runtime_sequence_reference.py":"sha256:5922973783c4adc585c5b470123568b4f517a37f21ed8092134a564a86b37cbb","implementations/python/packages/raes_runtime/runtime_temporal_delivery.py":"sha256:ee998124d3c17c0f9cbd28adc16b9e0746c7372da4523d0415fa959cf1662b6d","implementations/python/packages/raes_runtime/runtime_temporal_worker.py":"sha256:3effc2e7710b8a012bdac900955c0fd40c428e8d18c326e8200e9c8e1c7c681d","implementations/python/packages/raes_runtime/runtime_temporal_workflow.py":"sha256:72ba92b248827df61970188cf18c0eccf7e276db58c1f97423279f199c04db5f","implementations/python/packages/raes_runtime/runtime_trial_decisions.py":"sha256:6611d9d9f0b3d7d5c881da80c9f9a32b43d327ea9e536f0e1fcf647941426cce","implementations/python/packages/raes_runtime/runtime_trial_services.py":"sha256:4dcb07ba7f6d6c0a908ae887ad8a23e18bdeaf97f4150d0b41b6fd280aa96ac0","implementations/python/packages/raes_runtime/runtime_trial_unit.py":"sha256:f3702238d8e46cd67e3b255bddc47e793239b74cd7f0e974e67fab75e9127b2f","implementations/python/packages/raes_runtime/snapshot_contract.py":"sha256:d36ac453e396a7bb4be938673ef371925d93575d9f73f9e6bb65efbe06abdd7e","implementations/python/packages/raes_runtime/time_control.py":"sha256:c93b7aa3c16c079e0d1eb613899bfa62c99d77e6a67627960fac2704ce6a0e6c","implementations/python/packages/raes_runtime/time_coordinator.py":"sha256:a7272e71697d246a49af5df35da55a6d678c0a6316926d5b3fcef6cfb6e93448","implementations/python/packages/raes_runtime/workflow_result_contract_checks/__init__.py":"sha256:ec8ed6acff2bb8394d912236e8b7c4ea3206fcc708761bfd005098ab7b4f4627","implementations/python/packages/raes_runtime/workflow_result_contract_checks/_context.py":"sha256:59526702e01fac1e082ed7c9eb7ec1d201378895c5e4d6cc3305a5d4d61c0d90","implementations/python/packages/raes_runtime/workflow_result_contract_checks/_history_checks.py":"sha256:9659ee1359aa93e648100a4c3ef530fb7a4cc15549a6caeefe4ad441b332e80b","implementations/python/packages/raes_runtime/workflow_result_contract_checks/_models.py":"sha256:175b675d8691cc4789220a5f612f04b77f83a460a75937216e0a3362651b57f7","implementations/python/packages/raes_runtime/workflow_result_contract_checks/_step_checks.py":"sha256:6e35b75745dee09a0be8ec6e68cc7308f524dff29a4e7f4fe2c32e0857968e8e","implementations/python/packages/raes_runtime/workflow_result_contract_compensation.py":"sha256:277a1b5f72a34d33384233fd3e6f01d42847e665ac6fb86709db931faf55baff","implementations/python/packages/raes_runtime/workflow_result_contract_context.py":"sha256:8fd7ab880c725c3b1dd510247dc68f15925da7005fee1f35d1adc40c2ec45a7e","implementations/python/packages/raes_runtime/workflow_result_contracts.py":"sha256:22c05f22567131156e9e29c7d91053b8eaa3267c27f074b0f7ab5d44fdf07293","implementations/python/pyproject.toml":"sha256:b6748e63d3bf02ed0c37b8ea5230e6b61bfffac0a45549bb9aa8b09cde6a8565","implementations/python/tests/_act_614_temporal_fixtures.py":"sha256:18b620891ead27aaa39229f7aaa5a6d7b0158d878357bc087121d4851461117f","implementations/python/tests/asr535_policy_probe_harness.py":"sha256:62abce6c77862f6ab96162d16ecbcebbde0d54c842014523d63528e5ca580010","implementations/python/tests/cloud_resource_fixtures.py":"sha256:80a39af83a3973ab5165f8f1f3e2264338307d65da651d193fadee8fd1ed0283","implementations/python/tests/control_applicability_model.py":"sha256:774f41b0f73d2b38b4ae069e665ad1045d76ed3dbae45c4b97181f006e5dab76","implementations/python/tests/control_plane_conformance_fixtures.py":"sha256:c1dd48ff5511cabb6210ca3a07fabadf043eed6db00a427ffe15e149842e27c7","implementations/python/tests/control_plane_crash_fixtures.py":"sha256:772991d2ab3d44b2e2ad75c13d7c8684402c71aef8948df7cc69d65e81e9ff71","implementations/python/tests/control_plane_supervision_crash_fixture.py":"sha256:09c1b135c140c8850500773531ca8bb9586386bf1cfc11dcc13f6db0efe9190e","implementations/python/tests/crossing_model_fixtures.py":"sha256:8ea0b642b4e07e339f857e7435e8f1822f42141fad4011d72666e8a532cab596","implementations/python/tests/crossing_runtime_cases.py":"sha256:863f3c05bceac6f05ad85204eb2252fec72dd261d43f3a3c0c9542830980935a","implementations/python/tests/crossing_runtime_observer.py":"sha256:511137e1ed373abe13510f3f9f18c08fda5c9b064ce5c04e7f01f91e48a71581","implementations/python/tests/data/boundary_captures/lilrae-aptl-backend-manifest.json":"sha256:2ec2ab8540f515efa8de84c733466c0cdf7ab73f57b08f75385d9b01914be8c1","implementations/python/tests/data/issue_1481/application-api-service.sdl.yaml":"sha256:ac320cfbdf09f25e6bc91d27c64261136d5e4b7cfe5d7d2363d547fb0c3832ef","implementations/python/tests/data/issue_1481/postgresql-database.sdl.yaml":"sha256:9973da725f3786d8279579e757d99df9a7d63b7942df237860dfcee1c291a38f","implementations/python/tests/data/issue_1481/reverse-proxy-api-gateway.sdl.yaml":"sha256:fcb05b8e24fb2e9e74af0ef24c10832423ea00e13605dcd3248888c039b38389","implementations/python/tests/data/issue_1481/smtp-imap-mail-service.sdl.yaml":"sha256:31493b8cbad1698352dcae9dee2df14b07555a3b388368483f718315011e6849","implementations/python/tests/data/realization_envelope/invalid/empty-interval.json":"sha256:984ed13fb23bb5f3b0c0b1d7d05bcb74620b3e23d20b3bbf578fc09af4465138","implementations/python/tests/data/realization_envelope/invalid/exact-nonsingleton.json":"sha256:bf4e69d8fd6b7bee8f010d2a696a69837e700847be32c4c7dd0cef821ddee92b","implementations/python/tests/data/realization_envelope/invalid/open-with-domain.json":"sha256:8b7dd3aae09402862328dbf9ddd8a3ef1cd33c93ef75fdff15dac0086226265e","implementations/python/tests/data/realization_envelope/invalid/record-cycle.json":"sha256:83722979c2ed7eca8334ae2bbdc384dafb666be1b2fcbb427149da58fcab30ba","implementations/python/tests/data/realization_envelope/invalid/unknown-domain-ref.json":"sha256:aa0de329ef1afc5de5202ce434c9fe6e543168b3613e2943e59aa2dbbe275d25","implementations/python/tests/data/realization_envelope/valid/closed-scenario.json":"sha256:98a17fffad91662eea9e42a0977556c7ae03ecb26fd8796b286b1ca197a83674","implementations/python/tests/data/realization_envelope/valid/record-node.json":"sha256:bdedd91aa5c59101dd9257298a6c15c5bb97b6037330e93655f2dd690c385ae9","implementations/python/tests/data/realization_envelope/valid/resource-bounds.json":"sha256:eca8113ec725dbc5564341f2e660f3fac6d77a209e101aa0df11a0d44fe63b90","implementations/python/tests/data/realization_envelope/valid/scenario-web-family.json":"sha256:d0e1efd8168eba3e28a6277cd11c0087c108f2562ab55ab245039ff76ac2e452","implementations/python/tests/data/sdl/invalid/mapping-key-cycle.yaml":"sha256:2e5b4e02e0f739d4d08706b08a76eef5846f04b9f8f722d09a016b1a99314e87","implementations/python/tests/data/sdl/invalid/mapping-key-exact-root.yaml":"sha256:a4f1922eee529656b804f3f0d389906847eb5fe5275feefa06c67101f4a2f226","implementations/python/tests/data/sdl/invalid/mapping-key-merge.yaml":"sha256:4fa7548eb70eaa8059e422d95fed4ecf9e039db51dba9c185e236a126af5a9a9","implementations/python/tests/data/sdl/invalid/mapping-key-normalized-nested.yaml":"sha256:63128c7070ab7773349093069fb19fe84aca3de76894f9be85e1eb912ac32f7e","implementations/python/tests/deterministic_participant_fixtures.py":"sha256:f6f800fa480f2b58d17c2333a599dbb332206d3e33df27e601ec9338e0bb5442","implementations/python/tests/evidence_test_fixtures.py":"sha256:1f633e58704dc9d06348adcb8f0da28cada214d01b884c249933eee21f871e27","implementations/python/tests/fixtures/behavior-authoring/scan-behavior.sdl.yaml":"sha256:e28d0b63ec3ba1863ec84ca2b8a085d698de8934854070838ab119c5f1629ecb","implementations/python/tests/fixtures/behavior-authoring/twice-imported.sdl.yaml":"sha256:a06a64554dcea82429643eaa7e3bb0031f9131d403318f64e84012d0ad8002de","implementations/python/tests/fixtures/issue-1339-declaration-kinds.sdl.yaml":"sha256:674761f1ac2302946d08b276b0d5ec7ba7e91dacaa8ec3afa0e88040d0c5e9b7","implementations/python/tests/fixtures/progressive-conformance.yaml":"sha256:c178c370d3a2def140d2412f4682c04401fdad85fc65d2792792bc6bd976cc20","implementations/python/tests/fixtures/tool-profiles/imports-profile-twice.sdl.yaml":"sha256:a47f59027a3480ca84249e5c0d71fb8ea33ade440fdb934461d5a5fe25d34d0b","implementations/python/tests/fixtures/tool-profiles/profile-module.sdl.yaml":"sha256:5ceb7431fb349f3412e165066125dc66bbee3305033f2cf4213f1c91746155b2","implementations/python/tests/fixtures/tool-profiles/shared-boundary.sdl.yaml":"sha256:700d0da6082bb8433a3f4293c0187cba11d3d8cf90754be867e4a84ef87af182","implementations/python/tests/fixtures/tool-profiles/two-role-toolkit.sdl.yaml":"sha256:67f065bdfc35c1f29c2182cacc99071d302bae6586decb54908b588a5e50b844","implementations/python/tests/governed_effect_runtime_fixtures.py":"sha256:9c0b0b7a85211af202df4e3e4900a0af436fb1f3e1976c9e108dbd9952c2910b","implementations/python/tests/ifc_profile_variability_model.py":"sha256:fdf6bdfae35166c605e496b5796f5755f935d025a0f3d9f11c222fa40da9ece1","implementations/python/tests/inject_execution_fixtures.py":"sha256:6a2e945e00e83f4b1cce74a9f469bdb8890b1716c379a19935610a99821b2bd3","implementations/python/tests/issue_1007_intentional_subversion_harness.py":"sha256:42411a1ad31d4e0ace34bd0aa9325755232f02b1072e9eb25fca8f0e69af18af","implementations/python/tests/issue_1219_installation_harness.py":"sha256:91db99c30e871a5772a2fc131bb490de5108aa57b845fa60f77ba47dc00a9b4f","implementations/python/tests/issue_1220_proof_input_harness.py":"sha256:daa10d7c36c571ac3198fe668e25523269f9e6a0a3e2e0f87a1938770c713a83","implementations/python/tests/issue_1373_workload.py":"sha256:a168e149077bd053d2453efff364dca8d41029c9ec2e87ee0eef099ff9693ce0","implementations/python/tests/issue_1629_archive_fixture.py":"sha256:da58ed572c98570acf0b546da38e787cfece1f885e3132e79e486f17377fee20","implementations/python/tests/issue_1629_provider_fixture.py":"sha256:986a263e27e1dc675624f23f5617f4f8b0c844055437d75c8d9d1c259fa02d11","implementations/python/tests/issue_1629_trial_fixture.py":"sha256:eb2d776bd3aca8b4e9a6b50bc3f5b9877b571476d1c9dd9d553556821f8b3def","implementations/python/tests/libvirt_interface_fixtures.py":"sha256:5a83b2d3a5c04059e9bd4cd068480bec330d23b27825ce5a6a75d6ae8be4c9dd","implementations/python/tests/mixed_conformance_harness.py":"sha256:4d78d800ce0b511c9f788e795e34385d1127c45c64aec49fda15f3a6aa713a99","implementations/python/tests/mixed_control_demonstration.py":"sha256:9cf9154e016da0a6582cf6c6782a7b26f05a58dca98beb7971d2f29cb3bfae9e","implementations/python/tests/mixed_control_demonstration_harness.py":"sha256:22e1773220217180053b1e16aa58e36d0809d9ca5685b6e3c120bd8f7f52054a","implementations/python/tests/mixed_control_rev1_scenarios.py":"sha256:950401806fb21af1d523f7960e36aa25f35f87843929a066be6654a76b1f0e40","implementations/python/tests/mixed_control_v2_support.py":"sha256:2de66f737ea447866a59c5511a31d1992fb3343c7ce78541f2faab2d228e0330","implementations/python/tests/mixed_execution_fixtures.py":"sha256:0c393abda562d32e10fbe8538f5d038d705d845dabd190fda5666b0959f0e914","implementations/python/tests/operation_supervision_model.py":"sha256:fd8615c7bf72a7783bc113cc605e8b572482e703f6533b20dd5955572160c6c7","implementations/python/tests/participant_control_contract_fixtures.py":"sha256:a88a23aefcb72b5575e95f1baa073b6bdea9c3bbbd0bfb3fe8c10c887ea7154e","implementations/python/tests/participant_control_runtime_fixtures.py":"sha256:7df57202dca583338da332489a24396dd4f01bfbb1a918c688298d78d6d4e798","implementations/python/tests/participant_control_v2_fixtures.py":"sha256:4e1c8534c246457128add2725a572309fdf899eb1044f192cd7b5c228aca1e87","implementations/python/tests/participant_crossing_fixtures.py":"sha256:a991fac2763ac12d1cf7d5fe97422f732060ebeaa74b9f6e2b00562f6f3818d5","implementations/python/tests/participant_execution_test_backend.py":"sha256:7d69026069cd0f3cc1beed9a00db4c469cd1be3fbdc58f5b85afd76c91295443","implementations/python/tests/participant_inject_runtime_fixtures.py":"sha256:cd8a8843fd30644f53b6db2b71e7cbc1e9db46f330c7cbd1fa4370a06429bfdf","implementations/python/tests/paths.py":"sha256:91eb28d7667f7edf22a13c1938c3d9c1cbf6e101f4537641d8be7608668ae21c","implementations/python/tests/postgresql_ledger_fixtures.py":"sha256:aad356569d4f04bca36df1521d4bc568952ca3b3bdecd46604bc9e2f4b3a95a2","implementations/python/tests/realization_authority_fixtures.py":"sha256:49263060f26b2b9089f46a7febdabb0b56c52f9654aba295d61270c42b2a07a7","implementations/python/tests/reusable_control_runtime_fixtures.py":"sha256:ad51c4191eae41cf6cade7e90107f1e1c8f821abad54d57205331ef653abbd07","implementations/python/tests/runtime_descendant_fixtures.py":"sha256:eb40ed5d01b1077ba2643a166a18bbc1b2168eaf3a44cc0a46ee8856c3c66eac","implementations/python/tests/runtime_engine_model.py":"sha256:d9fa535a4a1926dad2f5fc5925fd2e4129202106ebfb68cca21ae73aae95f117","implementations/python/tests/runtime_plan_fixtures.py":"sha256:4d86bcc2f2af4d30542acd54a7d17795262b56ff6f02f4f8a696c649b8df246f","implementations/python/tests/sem230_information_flow_model.py":"sha256:57459900fa9ead00f76796a4ceb0ee3a5a943f5aeb9397829abacb1bff868934","implementations/python/tests/sem233_boundary_flow_model.py":"sha256:fde59c45d395d7bf4f6ddf08dbffab4b2a465486e6727608c5c2d84822e1d100","implementations/python/tests/sem233_flow_sink_fixtures.py":"sha256:781daf140f1a6bb56f5dc6de886d1b44c20d9ba534f41705a5ab13802344ce4b","implementations/python/tests/sem234_mixed_composition_model.py":"sha256:fca0e8547e0609612b2884517fe719e69fac51f076cc87938d8540095c7cb4e5","implementations/python/tests/sem235_modular_control_model.py":"sha256:10fb7c661db3b35a931a49760ccf83f81c3e31583161041b9e1bb60f3b515684","implementations/python/tests/store_commit_failure_fixtures.py":"sha256:ba312f0e784a8d2b466bb522c6571006eb92c284fd8c036d8ae20af24633c109","implementations/python/tests/t1_profile_targets.py":"sha256:619551a7eb00e890c01080af2726c2f70b2387706a20cb6c2bbbde157e5a0271","implementations/python/tests/t2_envelope_manifests.py":"sha256:afa951e09b3995be3b30089f46921cb994a3c83dc038bded5bbcd022e3472780","implementations/python/tests/t2_native_readback_double.py":"sha256:ba921f51837e74bd41f7e7a03fbc9d005edbd384f7a1fb4f869ce0615e8f71ca","implementations/python/tests/test_act_604_dynamic_information_state.py":"sha256:21b4663aa500c26a20f3c5e4e41c384443aeef881773537af2b341ed788b2928","implementations/python/tests/test_act_612_participant_relationships.py":"sha256:8dd38992d364ef599b18ef06f52a1b774ac19ad9bd75ab6d66a16d81fe5c9277","implementations/python/tests/test_act_612_relationship_integration.py":"sha256:2f7e5f7d2abd3ef855db4e8f1d5f1814498ffcd1d344c407172c9db235daa515","implementations/python/tests/test_act_614_temporal_admission.py":"sha256:5bb12823d4ae41cf03b3bd6e06b9f34d0cdbc8e0de0790af1c9db4a4ddfc2f0d","implementations/python/tests/test_act_614_temporal_conformance.py":"sha256:d9807a2c10edcb1d0c24a3d020ac72489a51b6355b95110b49c1ca36571abaa3","implementations/python/tests/test_act_614_temporal_durability.py":"sha256:0eca05fcaa5db29ef0342dc5d54037ea7dc1cc588bd0f4db1f1c1c143f378185","implementations/python/tests/test_act_614_temporal_profiles.py":"sha256:67e171a3c0850d493810000b45ebd4c65d2c49dd165bb612657240acc759136e","implementations/python/tests/test_act_614_temporal_runtime.py":"sha256:3e0eecf1b6418b8fe4bab8346dc2787a76d5708823e9ba6b3baa1e60ec0a4835","implementations/python/tests/test_act_614_temporal_security.py":"sha256:153fa6da6970f491387bf0172ee6ebc32e02359d7473227816c7a66b3335ee14","implementations/python/tests/test_act_617_mixed_control.py":"sha256:6fab6ec08cbca5b0b9bb80507b7fbc107733419e8adb5fdf7fdd009ddb5ffe85","implementations/python/tests/test_act_618_outcome_control.py":"sha256:412c8c52e233024dccbecc4480e5c50d5fe25807630c6227e700aecd34021d44","implementations/python/tests/test_act_618_outcome_definition.py":"sha256:b6b21a668bd3dc50a3ce26579b3a6d022f1e9a9f2f10f5677f46c9d288224a99","implementations/python/tests/test_act_618_outcome_state.py":"sha256:79d7975fd22d2e2496fb6b83d43b8de808be48da4bfa215ec15753e39defd18e","implementations/python/tests/test_act_620_control_context_assets.py":"sha256:2a6f33ac3d27327ee0d8c9ed618542dbd43c466e7c4421e4275d050ab21d91be","implementations/python/tests/test_act_620_control_context_authority.py":"sha256:427a8b909793d6f93ffaabafdccdc235599ea6e7bef47eeaf5b17e6ab99aa44d","implementations/python/tests/test_act_620_control_context_publication.py":"sha256:7dfa151d8743ed0f19270074a7d7814f007cd23c5ca2f7391e5368e55a23af2e","implementations/python/tests/test_act_622_participant_action_arguments.py":"sha256:b74a4ee3d1bb01c52c9809f3229b75262fd413935760a4d4eec7895f7932dc30","implementations/python/tests/test_action_policy_reusable_secrets.py":"sha256:737ef718a125d097c29a56c144e18f5b4d8752761f549e3eeb2d04a7b8ec3df1","implementations/python/tests/test_agent_guidance.py":"sha256:0421106689356aa6d4772c6ef19ccb405596b5ab5c9b113116f482244a121850","implementations/python/tests/test_agent_guidance_policy.py":"sha256:b574da452b8bbd5d12e56bc343637c70edd6549dc9f180e9bfbf436a46bf1229","implementations/python/tests/test_agent_inventory_skill.py":"sha256:a09a4cb593aae54c66be271289b28e6f2074107811aa2ef04d244795e748a5ce","implementations/python/tests/test_api_409_participant_control_occurrences.py":"sha256:a21c08c06623e3b353a43d97c7b38e0803d4b023ca09c267ecec08de2c03af49","implementations/python/tests/test_api_421_time_contracts.py":"sha256:7de40faf45ba81976110c716015db1e75eca760b0cea8a05b47d21dfbcd35aec","implementations/python/tests/test_api_423_participant_crossing_contracts.py":"sha256:cbdd2a0b85fb18ffb5f2a72ef73383d154736ad878ca8d320b0d354f3dc2a66a","implementations/python/tests/test_api_424_capability_admission.py":"sha256:bb2893f256b9114881d4424166a287cef992772b0deb001444654196c6684607","implementations/python/tests/test_api_424_composition_boundaries.py":"sha256:ab3abba66e3efd5f0098f64c760b149f89929b8063b645af10dd60d4f288a883","implementations/python/tests/test_api_424_composition_derivation.py":"sha256:e9b81389f47bab0fbcf978b2dee09ba4cd4867669cf8596927b58dd303c45925","implementations/python/tests/test_api_424_control_effects.py":"sha256:6f64effc33ba3172dc658cefd74cb3979f451ec549e9ce22f55dde1359383a6c","implementations/python/tests/test_api_424_control_resolution.py":"sha256:981c43be8ed01570f0ece3b515124d09103e0f0d05b111849f6bfa08da9428cc","implementations/python/tests/test_api_424_governance.py":"sha256:f95e8949bf246d0da0e62caf089eb19f0a738222e16c4970581fa55a47137966","implementations/python/tests/test_api_424_participant_control_contracts.py":"sha256:b42ad2c93cf32fcd4183e110916269169ef2a079cbc82d371b4e87330e440fe3","implementations/python/tests/test_api_424_publication.py":"sha256:e71564127b14c7c1e44365a4428e884b727bff5bcb6794e42982ab3cd8147cc3","implementations/python/tests/test_api_424_review_regressions.py":"sha256:b6314d7ff5889e64e6072354d964a0ec0e6b808bbf9b4bcc9dd7bc636e59a7fb","implementations/python/tests/test_api_424_security_profile.py":"sha256:b0375f223858a12f9ea0e478ed231ec3313951a722983589764e874b02b4e925","implementations/python/tests/test_artifact_requirement_satisfaction.py":"sha256:0823dadc0d5c5be92c0075ca2966a832583231e5eb42807c7623952620aafc52","implementations/python/tests/test_artifact_transformations.py":"sha256:e7dc08000346a29ec72fad051960d989c7e22992c16c54dc4db14ca16bccdbb2","implementations/python/tests/test_asr_535_participant_flow_assurance.py":"sha256:a1d2fb8d3511a0f891b163c79d50e9205dc4d5a5fac9850e5f62d0c37e11c1f5","implementations/python/tests/test_associated_artifact_manifests.py":"sha256:8563bc09a1cc4a15debae0be82699c4c1613b31073dd98f94694e5f4deb0e5bf","implementations/python/tests/test_assurance_policy.py":"sha256:7027d66c6f3909d7f6376dca6ff1fc8eeaab53952660174984b2788969fa8476","implementations/python/tests/test_authored_domain_topology.py":"sha256:dde243fe3f98d9958601916c8b3e8cf5f7b56078352f697ddb5cdf4b0f596b4a","implementations/python/tests/test_authoring_adapter_governance.py":"sha256:38b8beaf1441095fcae4f8b94bb0bd486fd1a8889f954d40f4830e5eaee1e891","implementations/python/tests/test_authoring_adapters.py":"sha256:18f4f07bc0b84ad9cb4b743fb7f3c002ffb358f90773d234467504026f8a5ecc","implementations/python/tests/test_authority_boundary.py":"sha256:b3840ebb6eb635ab98aceb53a184c937669bf70fc601a6eb054fa025b72009a1","implementations/python/tests/test_autonomous_behavior_vocabularies.py":"sha256:a2834c4052fddf775b2e140c4422df7a571d458275a220e1e5a9fddf9027e516","implementations/python/tests/test_backend_conformance_cli.py":"sha256:6db3d69131ff643c0a78e9ab6928415aef01c8be1c4ea47de7e3f9936c15a3eb","implementations/python/tests/test_backend_manifest.py":"sha256:5bae435be5d7ff618c674422dceef6df5f9617b084b6b6df627b4a35eb79c49b","implementations/python/tests/test_backend_manifest_v2_adapter.py":"sha256:f2163fac6cd430bfe17e4f294fa7b4308190e7413419554039b8e760df211285","implementations/python/tests/test_backend_profiles.py":"sha256:69944d6f69f0c89a9c52e2e95757c096a82d1056c7b8f82e1b65e172fb096fa9","implementations/python/tests/test_backend_protocols_account_features.py":"sha256:63945c1d944da3c9d165724feb4bfee26ce0a86d54a403149b20a98891d1ebf1","implementations/python/tests/test_behavioral_relation_claims.py":"sha256:c1f9a5ab775ca771ca5bb4da9074b866c82f8f741b70ef9fc8db9ed52404de36","implementations/python/tests/test_behavioral_relations.py":"sha256:24c21dc3bedac33a81905d7e5d63420652fa11ec45264ffafd6603d0df94d30a","implementations/python/tests/test_behavioral_validation_probes.py":"sha256:101099b95edb3d19498aa4c286291d9dccb17c891127074c6608b038f6c187a0","implementations/python/tests/test_candidate_synthesis.py":"sha256:ef30d3b14c56679a98faa91fb4c6819119c887f64e5b639f8edafe9581ae59c1","implementations/python/tests/test_ci_latency_report.py":"sha256:a099a201e4f64ef126e66b920319989725900d12856e26a09da9d253c20e1a21","implementations/python/tests/test_classification_migration.py":"sha256:5eda8fab008541e783308346677ca83d874c4d4193cdfb6a275a5978b587803d","implementations/python/tests/test_concept_authority.py":"sha256:3cd5c92c261f9f074e51e8614e069b0c4dde4e4c48f54ffa719f5b4122e4b4ec","implementations/python/tests/test_concept_authority_governance.py":"sha256:05884f38992cbd21448537978e12552fce985c7c4ecd5df418f28e3a11ee7394","implementations/python/tests/test_conformance_facade_parity.py":"sha256:d9fdd5e6523e8d2bf0ca5d7a9dcc6838dc04bdd41c8739c2f6f2c6ee3e746666","implementations/python/tests/test_contracts_facade_exports.py":"sha256:e910a9ed8deb0f0932e3d42edd21c0b136991ed79a626e8506570d075f721c6f","implementations/python/tests/test_controlled_vocabularies.py":"sha256:aeec294354800f53f6bffded8c86ac509e299fb5b1f0ce48e2db4da5278931e0","implementations/python/tests/test_corpus_packaging.py":"sha256:cbfd1e3eb11dc9d8085957a3c17b5fd4407ee6b8acba060e4ff9d492043b6d24","implementations/python/tests/test_corpus_resources.py":"sha256:c16fd620603e9591aff2c452aa9018650b7712b07c2352e67198f4a8b86d5bfd","implementations/python/tests/test_cross_backend_minimal_scenario.py":"sha256:29d1b8f4c2b8634c24661177fb2cc96990e0029d26357c5de38c2033b632cdc4","implementations/python/tests/test_deprecation_lifecycle.py":"sha256:54565eeed347b91c44bd1c04a08599b500850370d54fae9743dde3223dca28c4","implementations/python/tests/test_design_drift_audit.py":"sha256:0047c80cb94990e20a1eebaf91baac7e10bb563bbcd6a704458401cf88196d98","implementations/python/tests/test_domain_controller_placement.py":"sha256:5faad0554f0d4d0aec37d494506088649615008272b465e48faac4c59300a853","implementations/python/tests/test_dsl_115_authoring_specificity.py":"sha256:8e50b7e2d2c36df0511bfe98a2cf0c8de95f58662db70c46d198c1f33e2faaf1","implementations/python/tests/test_dsl_118_control_context.py":"sha256:49a3bc643b0301cf0edde9dc56ceaf043a00459b96e1d4588069043819b7350b","implementations/python/tests/test_dsl_118_trial_control_context.py":"sha256:aac596ffc5bdc2dd2c6f3b0458130ed08059cd40d2b2cdbe5518826b51637f25","implementations/python/tests/test_dsl_123_scenario_native_observability.py":"sha256:e36a38a820ff7b7f21a099ddb98ca028a8611a01cc40ae57d5146e28b5aec0fb","implementations/python/tests/test_dsl_124_authored_evidence_requirements.py":"sha256:5836b35169399c24cef885f8f558234ac5820f7e57d9cbf786a5fd8399cd3a35","implementations/python/tests/test_dsl_142_participant_inject_delivery.py":"sha256:384909d8672245a33763f56d0f1850a1489aee723b65ac0e061206ff68018823","implementations/python/tests/test_dsl_437_benign_participant_execution.py":"sha256:62c21eaa17bf8947c8c2473d7fa9f19c30b1b020069096a12db952e1b18ce818","implementations/python/tests/test_dsl_437_evaluation_authority.py":"sha256:e489d8b08a44e4c465e1f665c54c37296989079c2a9cd78fd27d3e9d96ec44a5","implementations/python/tests/test_dsl_437_snapshot_durability_conformance.py":"sha256:1a1127c7b7fa7bec6b8f4e3c392f43b4d8e6c3d18e6f74026b0d5fca563a0642","implementations/python/tests/test_dsl_language_evaluation.py":"sha256:93c1b561b2203f140e2db952a9385ded003c11aec2ae14904b339c0ef3f85397","implementations/python/tests/test_enterprise_deployment_tenancy.py":"sha256:95fd21f4851afbb4d6775bd3036e3fa6d8213d7792e37a48040fffa8e5ca014f","implementations/python/tests/test_example_library_policy.py":"sha256:18dec8fbfac4783dce395ea0a41efe697f721e260478f266f4a3d648f677a669","implementations/python/tests/test_example_schema_conformance.py":"sha256:6e2ce2209bf254ff2da33d4e635d89d9836a268ee3ffc89785b1ba012a83ed80","implementations/python/tests/test_exp_719_factorial_allocation.py":"sha256:4d76f870f0d5bb8d8ccc976416271f1590dba5a52f7ba2adabd8ca8cde3e5d17","implementations/python/tests/test_exp_719_factorial_ingress.py":"sha256:f9ec98e8768c485786ff74da9bfb3c2b65b99a429806d350805b6b42c53c4c09","implementations/python/tests/test_exp_719_factorial_realization.py":"sha256:19abf4641068267f83bcb2bbfc885c9b3a5b273f7e7b3e8edfc995ca1a16d0b5","implementations/python/tests/test_exp_719_review_regressions.py":"sha256:7db91f199f1ed704da379a7556359c1ea7c673b6ea059456289a9dc7100ee5a6","implementations/python/tests/test_exp_731_archival_validation.py":"sha256:c7046ec543589af6a3b53365cdf3bfb2dea5538287f6dcea8a4b35ef841ee6cc","implementations/python/tests/test_exp_731_evidence_requirement_refinement.py":"sha256:8f208f2d6131495705018fd88b13efe4178d37530d7a4c9bf6722789e0998366","implementations/python/tests/test_exp_731_trial_realization.py":"sha256:491dd4bfc0bdbc2217d695216311dec3c056548a0ee266f2a6e7d9726b4a87a5","implementations/python/tests/test_exp_732_evidence_provenance.py":"sha256:ffcfdca9bf80c2fdbe4544a3eb1871593dcf956b87905638f0744ef560747628","implementations/python/tests/test_experiment_authoring.py":"sha256:d4db7cc6b24d5927f12ec190f8abfbae1d1ba563598b1630a4e412d12ff74008","implementations/python/tests/test_experiment_bindings.py":"sha256:29ad421c5497fad13a404f4847a6ef0d9f5afa850af53236862c47c65b70ad66","implementations/python/tests/test_experiment_core_properties.py":"sha256:b51dc8ca72fa89d8eea8c4ea4a392798ca9c663f9abf47f507d17f44df5898c3","implementations/python/tests/test_experiment_selection.py":"sha256:49762f1ed0e6b06dc69de7a8ede88321a0a00a2025e1f1f88830c68ddc0a90a1","implementations/python/tests/test_exploit_path_analysis.py":"sha256:81e6dd6334bac3e20a45e13d7f1ed76e748ac1532ee944ac7ce478b35264310b","implementations/python/tests/test_exploit_path_cli.py":"sha256:c366f9bd072d459cd14f9bd0bc22540716c245fc66bcf8ecd28d873b64e3eea9","implementations/python/tests/test_external_concept_bindings.py":"sha256:f980e99db59bf78d542399815f210ee1c197b16c4fa05c9969f84cac32253367","implementations/python/tests/test_fm2_semantics.py":"sha256:7a53711a9808a11a441d0c58be8b1cad3add77d08732f49d51951ac6a8c9eac9","implementations/python/tests/test_formal_semantic_validation.py":"sha256:9730dbd71a977a3d713971b7c95a8138b744b3de64626a75cbe5292875133227","implementations/python/tests/test_formal_semantic_validation_review.py":"sha256:d06241df3b5a23fa9db5f5bedbb1be28ac4a72305f68ebb20b22e5145c3272d1","implementations/python/tests/test_identity_cutover_policy.py":"sha256:0948d5dbb721327f0ae94e0df894cccd309ac7ec92caf0f475d9d9fbd266a0e4","implementations/python/tests/test_initial_service_state.py":"sha256:f3aba3e976caf5cb357a9478802c18fa68a91d11bad580f33e6c491fae0c5d37","implementations/python/tests/test_instantiated_scenario_schema.py":"sha256:cbb1f664c152981fac6d08e972159e0e47ac6f8a0104c8d258db6482577f4b5f","implementations/python/tests/test_issue_1003_final_sink_flow_enforcement.py":"sha256:2beb6fa8bb1cfee4385dd092569353afc3914534d43219dffa0d83b647f8ecfc","implementations/python/tests/test_issue_1004_apparatus_backend_capabilities.py":"sha256:c30e5469eff7320f6e0a496f7e70999016d2be0180d0bf1d46306fa4b043dcef","implementations/python/tests/test_issue_1007_intentional_subversion_evaluation.py":"sha256:6b8bca26dd10a1e907f726152318347f16197458f06f6726235baca8b4ad4d4d","implementations/python/tests/test_issue_1014_mixed_composition_contracts.py":"sha256:60a16c04f3ade71313221f1971dcf82e99e7ed19f46489ad770fa5359f1fecd1","implementations/python/tests/test_issue_1014_mixed_composition_governance.py":"sha256:9ad00a914b3ccb0f4c8c5066520d07d870bbd6282e85534b1812982c57302d4f","implementations/python/tests/test_issue_1015_mixed_staged_trial_admission.py":"sha256:6219ac4211632d15c66743d4e9416b28a22e186d5f3e6fec61c2bd89b0b746bd","implementations/python/tests/test_issue_1016_mixed_runtime_coordination.py":"sha256:07b88ef491bf559e65d30a5604e205e209bc1af59496f2ce84c9d423899f09e1","implementations/python/tests/test_issue_1017_mixed_backend_conformance.py":"sha256:16c8ae16193ec6498c8511c1ea19bce6d35a45c62133ba78b1bb2905222d58d9","implementations/python/tests/test_issue_1018_mixed_control_demonstration.py":"sha256:c0cc9d4523cc51c27a204fdf7854721a78d33e3757725a164be139f524e26dfc","implementations/python/tests/test_issue_1043_forwarding_agent_posture.py":"sha256:a154b9366595b50d19614106480e3b58885fa4bf983729b06306b56fd61e9b45","implementations/python/tests/test_issue_1043_realization_corroboration.py":"sha256:82717ebf38c1d88bfc3579f057f09b3738ebbc579ab3a7b1fcee361e0477f857","implementations/python/tests/test_issue_1066_runtime_resource_limits.py":"sha256:2839df66bc862c778509419ad49cf78fb9706da76ed3969d0a0f37a39ae1d15c","implementations/python/tests/test_issue_1067_resolved_realization_authority.py":"sha256:6ded97e1eb5caf4677828400595e75ac80f68fd5865974806386f33f8435e586","implementations/python/tests/test_issue_1069_control_evaluation_authority.py":"sha256:77514fb632edd54b3a57758b001251a2a43d57676f2436f1593ecd19ff3849b8","implementations/python/tests/test_issue_1069_control_evaluation_carrier.py":"sha256:9f764fa8050d42618e38c289cea3113a40cc68829ae5f177ef856ca8dfedfe05","implementations/python/tests/test_issue_1069_participant_control_binding.py":"sha256:e2039b33d9b5e1d70298831da49a7575c1324b58f59d1007398a9ac2f22762e1","implementations/python/tests/test_issue_1069_participant_control_durability.py":"sha256:b3f578a1cbd84985100a7471a5f44306f9a508f9efa4a9bc8e87084d2919bc88","implementations/python/tests/test_issue_1069_participant_control_effects.py":"sha256:3b3a1333b8692896da11e9304efbf6a0ed737599ec19d4dccd56e5d6590b3f7e","implementations/python/tests/test_issue_1069_participant_control_orchestration.py":"sha256:41362c10f551ea80afb926d424548b729fe5b35f5a3f8b3e4059e4247f32b46b","implementations/python/tests/test_issue_1069_provider_evaluation_v2.py":"sha256:0ddc5302a17fa4c80a6f5b969ee3169e3094ff6dc09eaf1e01157ea687e9ade5","implementations/python/tests/test_issue_1071_effect_conformance.py":"sha256:63a4f889ecb4457e2fd8e4b712b1d40d70622b0e447c7957dc1e540329220a77","implementations/python/tests/test_issue_1071_modular_conformance.py":"sha256:49bc3b9fbfc314adf4508f13f01fb4d339dad1a8f75b3c4812f113ed6b626717","implementations/python/tests/test_issue_1071_probe_matrix.py":"sha256:777d9bd445153ba0e0ad1c345f75c40b34c290ddc794a26f004fafbad8345ef2","implementations/python/tests/test_issue_1071_review_regressions.py":"sha256:795a8fd6f0ed9d71c44ccf34c5645793ca639b0c86f18ffa420a6f1130209981","implementations/python/tests/test_issue_1074_generated_artifact_env_consumers.py":"sha256:3ef0b8c32ff079ca77fe6f7a8e0807405ef82ee96443b9a865a552db484dbda7","implementations/python/tests/test_issue_1076_compute_realization.py":"sha256:cfbca0419078613943d4738062790742e2253779bcfaa7558b464c63c074dde6","implementations/python/tests/test_issue_1077_os_identity_realization.py":"sha256:24ba507815043191f2c89e69802d33c1422f079625a4f4e132481a8d4dc859ab","implementations/python/tests/test_issue_1078_runtime_boundary_coverage.py":"sha256:e9e5e3849c0ff4aebb5531d5678addadbc9440ab1c372e61f1a0be49d086b502","implementations/python/tests/test_issue_1091_request_limit_boundary.py":"sha256:f6adb20b71efb6e49212b05979befb8a340719cd45578e4cc0dc4ea8134f5a91","implementations/python/tests/test_issue_1092_control_plane_crash_consistency.py":"sha256:2895c396344afb40bb47c567763e51c6538e510c05754c8c115dc616956b4be6","implementations/python/tests/test_issue_1093_request_rejection_offload.py":"sha256:089e024bff95050a8dfd3dd8207fb0fe8e61fb8345788a188d2eb91fafa767c8","implementations/python/tests/test_issue_1099_compiler_explicitness_performance.py":"sha256:162c9ed039891578e19b0f99d7c53d23e4844d0c5bf310ca29e1f99d7619a5f9","implementations/python/tests/test_issue_1107_oci_source_snapshot.py":"sha256:06c9686144747ea6e3379d11c88ff2a7b57a8342120f368dc35dfd8587e22505","implementations/python/tests/test_issue_1109_proof_workflow.py":"sha256:aa18685a678b2d2be195a35dafb81075bcac465f438139d2414199fa827e11e1","implementations/python/tests/test_issue_1111_cli_version_startup.py":"sha256:9bdba1846c8d5bca9da5d5441a4472a27b76f2d746027055942346fcf1b1b5a8","implementations/python/tests/test_issue_1112_capture_admission.py":"sha256:b162b0b050be6a81ac458e8cf171a56386d6969040d4e1c9fb4f74853dd565df","implementations/python/tests/test_issue_1137_maintained_client_acquisition.py":"sha256:8895a8b30fdb6ceadd3ff11f16523d5530bcac74a7af57c4ac431714cc9e0e9a","implementations/python/tests/test_issue_1151_runtime_control_plane_design.py":"sha256:13767b8c2b0b5c1c35708f2214734401ef6cc8761d88029eb66d261817f3aa75","implementations/python/tests/test_issue_1179_startup_reconciliation.py":"sha256:6bc889bd2b80f36c2d092c9594a2a2366487ec6c873963ca5314753d29006ae8","implementations/python/tests/test_issue_1180_snapshot_revision_cas.py":"sha256:5f09ef0b63ad610e4da5328c2d31a2e576c6e9213dc36df37f41f51eb727354f","implementations/python/tests/test_issue_1181_unified_control_plane_mutations.py":"sha256:cb33830a1a063b4a0a4ff6ad56a83ab2002e8e9802ccf199b7883508ab822ffa","implementations/python/tests/test_issue_1182_operation_lifecycle_contract.py":"sha256:751fc902b748e8f9cba7ff031ee9248da6ea837cfaf3bf7a8f5fac6e6b354bfd","implementations/python/tests/test_issue_1183_store_ownership_leases.py":"sha256:2b82a8849a03be164cb2e23c84ff7d58ae56dded1303440438e2bc8f2b38ab98","implementations/python/tests/test_issue_1184_atomic_idempotency_claims.py":"sha256:77e21b2219a308f2c6a11c6ec640fe5d8e90553d866b746a0e5d3c4f55058235","implementations/python/tests/test_issue_1185_api_404_profile_alignment.py":"sha256:799c953e5e261b032fe4c14ca516d7861244c70af364715998a32d9a4bf4b83d","implementations/python/tests/test_issue_1186_control_plane_recovery_operations.py":"sha256:ea4fb1e1e3aa74aa2b69315d5eaf86a11e2898450f27e445f1f9cd2d6bd2b053","implementations/python/tests/test_issue_1187_control_plane_durable_carriers.py":"sha256:31c7aed458cbdabf32caab10ae136eb5766441fc40ff346df00269a57783ffc3","implementations/python/tests/test_issue_1187_control_plane_lifecycle_properties.py":"sha256:e6ec3cf419b88bd519b93cb23c5a6926b1da3e460c87b661cf7ed6d3593677de","implementations/python/tests/test_issue_1187_control_plane_process_loss.py":"sha256:3aed6c564badcb1d360592a633dfe0328350af54d6447a9580f0fa353da9fd73","implementations/python/tests/test_issue_1187_control_plane_profiles.py":"sha256:82d12f568323d73b7308aa65eda0fb379ce6262308918091f80006b611dcc8d9","implementations/python/tests/test_issue_1187_control_plane_security_conformance.py":"sha256:57c3bacd034b4b898b2942b595386adcbba75c5722a097505fce74017341db33","implementations/python/tests/test_issue_1189_control_plane_profile_declarations.py":"sha256:a58d0ac5966aea5f2e12e9f8558b7c6d79483e17eaad9b6faea0c2e252a821b2","implementations/python/tests/test_issue_1200_mixed_runtime_constraints.py":"sha256:52367e9d819846ca1024fbe1e7ecae4b7b9cd66a66a31ff936d4c2da87a1d953","implementations/python/tests/test_issue_1201_description_lifecycle.py":"sha256:472c8c5c9bb73fbd939f8b271fa553c33cb56a13963a9abf89b622f563ca8962","implementations/python/tests/test_issue_1201_partial_description.py":"sha256:0bd2d357395b7855cf3664c10fde964e1b6ca48f8820373c2c4a1dd07219ff8c","implementations/python/tests/test_issue_1202_domain_profiles.py":"sha256:f05c2cdd4eab3fa2ad2a8a5e09840ea25314566af43354a60249bfef9cf898c2","implementations/python/tests/test_issue_1203_recursive_normal_form.py":"sha256:efeff893f325c245223d27fd31fbdf8d54fda12da8f9d8f8cfe4131ca1d2ccbd","implementations/python/tests/test_issue_1204_backend_preparation.py":"sha256:e6acc45ce9e50e5829b66578ba37f6454fb2a52197e5af59e29d775622baaf8d","implementations/python/tests/test_issue_1204_collection_lifecycle.py":"sha256:dc89a5c5fed3d031ca7413adde3f35e2b4a935e7e196bf6dea341754f1ecc162","implementations/python/tests/test_issue_1204_input_bounds.py":"sha256:ead8958ee9cdede90d966c25ca40bc1bc415acb9d746c8918745d3af75904fbd","implementations/python/tests/test_issue_1204_nested_domains.py":"sha256:aa30404eec0757a6d2c3e53ae42063533c675bff1d15be7f744e766983492756","implementations/python/tests/test_issue_1204_preparation_admission.py":"sha256:a9c8a1239334ee46b286df12437e2f454377ca2be5bb50ac0d6f0cdf6f23d5e2","implementations/python/tests/test_issue_1204_preparation_contract.py":"sha256:3a9957f289717625020383829d1154b2d2e502f3a6e791bee0689fba1e805918","implementations/python/tests/test_issue_1204_preparation_os.py":"sha256:57c800fce1ab3ee60cc01d4fda5a86a197a180cf06993bf6c17461ddaa3555e6","implementations/python/tests/test_issue_1204_prepared_credentials.py":"sha256:2688664d6cdfc3c1c259a6523799e2e2241fbb412f93c655281dec74d750e935","implementations/python/tests/test_issue_1204_prepared_node_admission.py":"sha256:4176d6cd0b2519bfecadd1a79be86539d3e50ce37f3bcfc8912aba74455953c6","implementations/python/tests/test_issue_1204_prepared_node_semantics.py":"sha256:3286bdb3031da17ea64d659b4332764e32fd0e708ff30e8f85f7315bb0770ae2","implementations/python/tests/test_issue_1204_prepared_sequence.py":"sha256:ed70428563f4681fdf2c1ad53872cbd870e15e50a418895bed3d979c39c04a03","implementations/python/tests/test_issue_1204_profile_carrier.py":"sha256:6899c5e489a1ae4b574b705a93d9c3463ee5b8a14dd8d9600466f2a2e7e56ec1","implementations/python/tests/test_issue_1204_profile_offline.py":"sha256:7311ac7e593afe92c7235cc26fb57e44f19df927b0d8aa280ff5b8909695e7da","implementations/python/tests/test_issue_1204_recursive_carriage.py":"sha256:e6092cb52c549476e3b24701bea17ae92579749a4b0abc2e1b6aa37efba0e9a0","implementations/python/tests/test_issue_1204_recursive_defaults.py":"sha256:2f7a6040b7a1a7d40179702c8451130fe741287221d61baa8800318ac8cf9014","implementations/python/tests/test_issue_1204_recursive_environment.py":"sha256:c7abfd50c8855fba2e6c03151acf718d30a1eed4dd8d45dbef3522d3c4d3b8e9","implementations/python/tests/test_issue_1204_reference_profiles.py":"sha256:2c9901c52058dd9e5f2c80cdec7679b5041dcc31a6b79ffe52030479f7dc616a","implementations/python/tests/test_issue_1204_repository_governance.py":"sha256:33d7ef93af1b1fef998f9fa4962c592d23413970fcaf1d2e53d555773e3b967c","implementations/python/tests/test_issue_1204_resource_collections.py":"sha256:086bfde6520f5cfd3f39d38b3a9a49eb86bbf3de706a12d0743f28242f1bda06","implementations/python/tests/test_issue_1204_result_durability.py":"sha256:254c6b38510369aef56ee38a1d674b05aa806c782ca7e51562ea517754953b3b","implementations/python/tests/test_issue_1204_result_owners.py":"sha256:186b8576eaea3b33ab14c776b8ebf5f8283429535e39e4ca305b3f5931b4145f","implementations/python/tests/test_issue_1204_result_shapes.py":"sha256:f9e92c5ab988472f859e6c9d7cdfa4ace89109f146060fe6189f83f79b073c77","implementations/python/tests/test_issue_1204_result_transitions.py":"sha256:bcde21d3c53fa63443eaac962e058540a3be01f3a3bd1e0be682ee3ce336a038","implementations/python/tests/test_issue_1204_safe_presence.py":"sha256:e12c483b77f03b703c6b072eb4f16631e079b91243f7b73c6de800cbc79e73b8","implementations/python/tests/test_issue_1204_service_dependencies.py":"sha256:85facabd2ee50820e1a0fb1ac13304979385fbeb90c0324949bb03bd148012ba","implementations/python/tests/test_issue_1204_specialized_constraints.py":"sha256:df8504f6938ca9491503891d31ad85f47ce20b3cea30b5e31205458e736fa760","implementations/python/tests/test_issue_1204_substrate_handoff.py":"sha256:cdde8d1e70b55f0da6105985d77203c1e6d7c47b4132b06da78429976d514594","implementations/python/tests/test_issue_1204_targeted_effects.py":"sha256:694b3ab13914e77d9e64df67a38010bc2f4c0fe44bbddeaf5e14dc953c6d389a","implementations/python/tests/test_issue_1205_kali_ladder.py":"sha256:c2d0ec430ecfdb1dd3d5bb680795820f87b403e514ec5af6e65958ab0756f0d4","implementations/python/tests/test_issue_1205_package_identity.py":"sha256:00945899ce761d6e0b2202f4ad76811b6cb629a5e26d47e80860fb22f027aaf6","implementations/python/tests/test_issue_1205_profile_execution.py":"sha256:34995294684318cf22bd278ad08b7e923968ac68117025b56c01ae158dd192e8","implementations/python/tests/test_issue_1205_refinement_ownership.py":"sha256:de32f07fcfc1fdf48f001916699ddb2debeb845da320ee6203b6039b99023386","implementations/python/tests/test_issue_1205_repository_governance.py":"sha256:c497c52a05ad683125397590ec110896947689355fe003f488759cb309b9a490","implementations/python/tests/test_issue_1205_repository_state.py":"sha256:cbde671bf46714a0ae501ec5a94566f789ed94795f51a51ce0bc595d5990b43f","implementations/python/tests/test_issue_1205_software_carriage.py":"sha256:f0840697889412c10a0ba9a907e6ba3cd1b681aee989983cee1fc51628e20c04","implementations/python/tests/test_issue_1205_software_profiles.py":"sha256:e23f4e11d002499fd1a282dc5d837b03501d595f8c5da4629478afa424cca04c","implementations/python/tests/test_issue_1205_software_reporting.py":"sha256:a5d108fe768546ca88d94bdb172d7b4a8efd23b1392cf6f4dae2a34f0f555c59","implementations/python/tests/test_issue_1205_software_versions.py":"sha256:db0d6f77323424247cf24aab2a2a255d210f47ae52d73be3d005ace16cd6aa47","implementations/python/tests/test_issue_1206_review_regressions.py":"sha256:4bcf2c57aa08df52527ebc25f08bc3edcb7c7d0ed2b5fd24ec72d25a5b0f76b1","implementations/python/tests/test_issue_1206_runtime_vocabularies.py":"sha256:17343e6c92196c09762590a1cd515fcd289920370fddfa7183b3a0edc4e45526","implementations/python/tests/test_issue_1206_vocabulary_consumers.py":"sha256:1368979d8e39f3ab916010e32d80281ea0bf7f38b8f212adfbbe620574a93d7c","implementations/python/tests/test_issue_1206_vocabulary_families.py":"sha256:a6a875201d660b44df00c9d98578d683fafc40e1fdfaf9be77faddf855cf5f77","implementations/python/tests/test_issue_1206_vocabulary_governance.py":"sha256:f544ff41bdd37fd4670f3052bbe635d22c228957d2fa8c99c70b8ae51091831e","implementations/python/tests/test_issue_1206_vocabulary_roundtrips.py":"sha256:b3740dbb2209e526a3f8a3ce7bda83a9ffce6815f3e95a2c9f0f49b1e4af0ff8","implementations/python/tests/test_issue_1206_vocabulary_schema.py":"sha256:8fb0000365e7c39efdfb1e4cfb48eef77aa68d3aa0927ab3432f4f5b3da78ab9","implementations/python/tests/test_issue_1207_description_lifecycle.py":"sha256:60403d72f4b4e0839b2c674919c7ce83dd9cf67c43e7e8fce4df57845a73c287","implementations/python/tests/test_issue_1207_partial_descriptions.py":"sha256:1791f5d5a0e94939b529d91368b77e917922962a5c0eb8a7df05b84f86736dea","implementations/python/tests/test_issue_1207_policy_ownership.py":"sha256:ab70bee9bc3e48152b11c21bb648ec65baec2bba1dba612a8922cd8bd4136877","implementations/python/tests/test_issue_1207_profile_admission.py":"sha256:139536d960f123627982458488dcb6b11959757fc9167585121ca540e27537f0","implementations/python/tests/test_issue_1207_recursive_inventory.py":"sha256:3611c50aa3bff0a3d9f795c25f58a36c603ce0f064da73f2421f50dbfda252ca","implementations/python/tests/test_issue_1208_overcap.py":"sha256:8091c1572180258018b5fc5e94e7c3b975e780834087aa7646ef1c2dfe49daef","implementations/python/tests/test_issue_1208_profile_boundaries.py":"sha256:382e9feb8854543794f7feb58f49d1c872b0946c6cabd487e9a9c42dc1d83bcc","implementations/python/tests/test_issue_1208_profile_composition.py":"sha256:5a893d237b6d603c28e0193bd81b4e7e5d9c063df417d0e237e668b15629a922","implementations/python/tests/test_issue_1208_profile_selections.py":"sha256:e1118e814653383b45cd8c7955c45f0fbbf8e96eeb66e7331954657f19af1e86","implementations/python/tests/test_issue_1208_resource_profiles.py":"sha256:66ef0b91487bfced22715764ea9cfb5dda5e85e22b9844bac9b37e061508e690","implementations/python/tests/test_issue_1208_review_boundaries.py":"sha256:c693fbc4a6befcff9e834aa95bb959d3e6409bc0242083f1bfcebb2f897b405e","implementations/python/tests/test_issue_1208_self_review.py":"sha256:e5c5a1a105fb5acf94851adef34ede3c53933d025439598a4f2e7598db86965f","implementations/python/tests/test_issue_1209_description_evidence.py":"sha256:48c7791dc6c48c4f9f3b442a080d4a0241717b4681e419e18cf7fbc63857a775","implementations/python/tests/test_issue_1209_description_lifecycle.py":"sha256:03c2589c7ea257fb133e50faea767a5857c5d3b7f08695b8949f14b38a2e4804","implementations/python/tests/test_issue_1209_description_profiles.py":"sha256:cf08f4fb41a1a363777c1ed875bee47a4a8177947f007a581604a98a38481be9","implementations/python/tests/test_issue_1209_description_relations.py":"sha256:2ee81104d100f486a6f36212e35608e258b64a4fdb8e4fe73de778f94efa3f46","implementations/python/tests/test_issue_1209_description_review.py":"sha256:c32c4617e77180eb896efd412a25b8eb3850e46a656d5d2158f0c351f2d536ff","implementations/python/tests/test_issue_1209_descriptions.py":"sha256:c1edb12f36e7542ec1f529af41db93e06190c5879eab20beddfdc4003ee54c24","implementations/python/tests/test_issue_1209_policy_ownership.py":"sha256:3e809786ff52c60f783049b5cd678a1d70b1d3a81169cb728cf74ae6bfdb3787","implementations/python/tests/test_issue_1210_formatting.py":"sha256:0bf60fc34cff54294af71a1c5d9d6175162e0db6d3677e6e3d17c6e35e865df9","implementations/python/tests/test_issue_1210_governance.py":"sha256:20299e966e2eb9637b392781db4e6e1ab0365d2e69976198fddf0a7b4d7c22d3","implementations/python/tests/test_issue_1210_semantic_comparison.py":"sha256:38e0f479591aa1f671c7e3990d6ddd4008bd26118913d4d4eaab9f0ec0d531a1","implementations/python/tests/test_issue_1210_semantic_migration.py":"sha256:5f28f5a1dd9fb8269d3ffb872ddf91c026a5016505bd21c5cf5609ea28bd75f4","implementations/python/tests/test_issue_1210_semantic_revisions.py":"sha256:6220b1ca9a667d51e01481879230c5150177529a774ee0317453bfdda38d2b74","implementations/python/tests/test_issue_1211_progressive_conformance.py":"sha256:499c7238568e8c019b7b9f24e90d5ada6aa9c1cdb2179a945b2607624c830c28","implementations/python/tests/test_issue_1212_native_failure.py":"sha256:9fad1e1a3ca1ec49ed3f38cd33c6c903340bb1d150c7830c577a6bde5fe146f0","implementations/python/tests/test_issue_1212_observation_demand.py":"sha256:63f9cfae2a3306b290d971bdd5a230e2ff3e001e08174a931480c07ca594e488","implementations/python/tests/test_issue_1212_policy_boundaries.py":"sha256:76b476aba6b0baf1f020351d8cbc881c40d169f117e6f42c992428b1c4f46e72","implementations/python/tests/test_issue_1212_runtime_boundaries.py":"sha256:71710a9ba347211e22d0706c353f51222f40de4a741de1839d46f0e03206b21d","implementations/python/tests/test_issue_1217_bootstrap_profiles.py":"sha256:df5ef8bd9815905703031aa971fa3db40598179d36b3902c9cf059f833e3962e","implementations/python/tests/test_issue_1219_verified_tool_installation.py":"sha256:c669c869bea31b42e5093b6a35741a1ecfd3a9702d601d40db3fb5ac4a91573e","implementations/python/tests/test_issue_1220_isabelle_acquisition.py":"sha256:4f4fdc3626e68930e241f5d06ab95adce4b1fd3bd72055d10643f20f78a99d60","implementations/python/tests/test_issue_1221_vocabulary_maintained_client_acquisition.py":"sha256:4fef399f84afe7f73feb00d05ff40020d1a6ba1e0c96008a86a0cb48c1bd8a14","implementations/python/tests/test_issue_1226_attestation_verifier.py":"sha256:1d3c6a0f8f526a119638d3e8c30d3ec9035f8037f9204c54b44604e7f7c6684e","implementations/python/tests/test_issue_1226_evidence_documents.py":"sha256:d7fbf9ccaa356a57cc01de8c386dd159151652786e33b0bd1369be9efbc480aa","implementations/python/tests/test_issue_1226_release_admission.py":"sha256:7414e5d24eae39e9fe18efe4effe0f8ded1e54b31c394e4f6fa80c72a1e67da6","implementations/python/tests/test_issue_1226_release_evidence_cli.py":"sha256:076a21b00053da1f42e6f0eab59b76429af7cbf3c07069c619c266c439dcaed8","implementations/python/tests/test_issue_1226_runtime_closure.py":"sha256:0a387582d3d852a9417cff8b7d0a5c53e90477fb3cea6b596503b4ea1b28569d","implementations/python/tests/test_issue_1226_target_markers.py":"sha256:118e96d5dc54df132b283f51dcba99b82a198eb767f0f1e2acfd1c0677be9c88","implementations/python/tests/test_issue_1227_release_publication.py":"sha256:003a1b32fd586f8315cd59f31ada6b4f4b0d2ab935bf6bd5f986b66427ab4d81","implementations/python/tests/test_issue_1237_capture_dimensions.py":"sha256:12d99c86941236e1e661343cb062ab28ed0181bb6e69863d48a8b7c4205a1b3a","implementations/python/tests/test_issue_1237_capture_ingress.py":"sha256:dc11d011cd87eeffbf6c417baef9b621883d55a30d233f3bbc70fdbee5d0bc1b","implementations/python/tests/test_issue_1237_evidence_proof.py":"sha256:76c0635c038422c9fade3d3e27276fd94cbdcbb7234f9b9d1e1186d819ee2def","implementations/python/tests/test_issue_1237_governance.py":"sha256:aaa53d108ff36347f45688a8b9794aceadbf1cf3224f6655eef064bfd486f216","implementations/python/tests/test_issue_1237_output_registry.py":"sha256:99943a46d8745c36702a5b35d303d141057407f99783b9b38a82b0f2fee321ed","implementations/python/tests/test_issue_1237_requirement_scope.py":"sha256:e8d2b2108c5fff4303e19d86f5f69f2f35ae67299300f20f994112138b64c962","implementations/python/tests/test_issue_1237_source_sufficiency.py":"sha256:99664e60742bdfc812ed7da8bebc3a17cdfcc9994a1022ffa29c5e5b6a6eded3","implementations/python/tests/test_issue_1238_development_container.py":"sha256:67070c504d0ec4d967e43a7cfa15a898a3661367a6f561765e22830c34b5de43","implementations/python/tests/test_issue_1241_inspection_plans.py":"sha256:ea7ebd6bc02faa198011c0447588e34ffbcc0ab055c0b1e9e33b30bfc5831703","implementations/python/tests/test_issue_1241_materialization_archive.py":"sha256:3679e57dfb2352638296a5204d8b3a26bb3254b6c1ee51030bbfc2d2b1e2e42b","implementations/python/tests/test_issue_1241_materialization_artifacts.py":"sha256:9e820b756bab635a3e3b79acbc0286b7d354131bfcfd5820956dee837e128eeb","implementations/python/tests/test_issue_1241_materialization_context.py":"sha256:9e5713420ad93e35146b7afbbea274a2863d0002658c7ba500b457f6dba52d1f","implementations/python/tests/test_issue_1241_materialization_durability.py":"sha256:96da11d014717bc9b534f6973f165e09a28d01e41bc40e2e22e2cfa4696574ff","implementations/python/tests/test_issue_1241_materialization_evidence.py":"sha256:4a0d5dee9ac16ccf708607f3fbdd45b17d516a074d7a412d677e5eaffc30484a","implementations/python/tests/test_issue_1241_materialization_inventory.py":"sha256:2dfa9a0f5d5350f976a16e02726a4d025290f38c1dd331a149e10baffea6bd9b","implementations/python/tests/test_issue_1241_materialization_origins.py":"sha256:d08bdeb392817fbedcbd6cd612c29cb5b388804b6106423b92db416b0b815e1f","implementations/python/tests/test_issue_1241_materialization_runtime.py":"sha256:3bfac64f3fd3527169111b09789a1a22dc56e918eea72d34833eccdf57b9b691","implementations/python/tests/test_issue_1241_materialization_schemas.py":"sha256:7620386d82e229b63d9772edfbb90cf5ce35aac59cb1afb7c29e2b6d27fbcb93","implementations/python/tests/test_issue_1241_materialization_snapshot.py":"sha256:eb808849dd0ad568d69f73cd78510747627e2f5008b30cb238b40e69e55dfcaf","implementations/python/tests/test_issue_1241_materialized_sdl.py":"sha256:5869adb11937d1c63a9439872101668627f44b4de38b94597f5136eb64b2b749","implementations/python/tests/test_issue_1241_planner_inventory.py":"sha256:68d56c352109864e24461523224095a23fe7df07ad3252991ec372617b7861bd","implementations/python/tests/test_issue_1241_policy_ownership.py":"sha256:a748cfdc8ced200dd6d2ca2bc32cf98bf1493c3356a236ee21c7c1cfb98e1e77","implementations/python/tests/test_issue_1241_schema_omissions.py":"sha256:48a766f7c28c01d00fd9e5b6be6aa6502b75fdf49825bde2d3cd38646e751825","implementations/python/tests/test_issue_1241_schema_publication_size.py":"sha256:b317dc6cff784c18ee9d79b93cb976adcb0268fa6955e72496816b9b5cc1a035","implementations/python/tests/test_issue_1242_augmentation_scope.py":"sha256:82ad7e0ed4bf10cdc835eeeac6cf475adc260167ca04782c4bf2a53f0f942d32","implementations/python/tests/test_issue_1242_review_regressions.py":"sha256:3ba0cb908f6f157afade48000141588ebc544c220ace099c0841a32d72bf5af9","implementations/python/tests/test_issue_1242_scope_admission.py":"sha256:2fe1f838b7b7d4ab2f72388a19d7fd65ea36bab4892825ea1b0408346c4ed54c","implementations/python/tests/test_issue_1242_scope_contracts.py":"sha256:40ae3bd6743d6152b7eeadc6f7c7ad8bd7efdbc28ec2e185b578e51bff55c79d","implementations/python/tests/test_issue_1242_scope_durability.py":"sha256:9da33bbe63aaaf588b1b0c4745d81c1ce89eb92b6b798105df2ad21dede94513","implementations/python/tests/test_issue_1242_scope_runtime.py":"sha256:fb3cdbf2fe540fafd4fda17fba77c17551ac71f1d3eaeb585470851d3732deea","implementations/python/tests/test_issue_1276_random_value_generation.py":"sha256:bd3ae568c60711b84f95273fc980a437764b7b9ac78bb9bc162407bc671625dd","implementations/python/tests/test_issue_1297_service_manager_contract.py":"sha256:61cd966116df4799abc8d04f5aee24a299d4e02216fe449a81925ace98f356c0","implementations/python/tests/test_issue_1298_http_method_identity.py":"sha256:eea581531f33a9babaa7acec9c3252b8e71c2313dcd8ed5ca616189fded9a892","implementations/python/tests/test_issue_1299_partial_listeners.py":"sha256:887e911ad112e38373a21ce5858832b2f3b360e2710c93641c447c96adbf521b","implementations/python/tests/test_issue_1313_workflow_policy.py":"sha256:e0202a0f3d6fcebf554d5d4b4347c1e5f6d4cd35205e84f0419c8d25edfb9153","implementations/python/tests/test_issue_1330_schema_coverage.py":"sha256:7ad4f011489d98c2faf5c558b3f9de581cd63dfe0f00e93249f455dd8b69a095","implementations/python/tests/test_issue_1338_identity_authority.py":"sha256:d7652ea21f9de9c079e29f2d042f0e7062f53116c17bf113f8c83a7edd9849f3","implementations/python/tests/test_issue_1338_identity_evidence.py":"sha256:682ea4b2b129bd6c9a59dd57f40c58cfdaf1d21583525a34f86952f67216745d","implementations/python/tests/test_issue_1338_identity_examples.py":"sha256:2bd99b9aad10eedc7729caed07e9bc9dd83dc75e3ce3d2f38e18e7b489bc5a41","implementations/python/tests/test_issue_1338_identity_migration.py":"sha256:866e0a975aa784ffe1238e1e07336e5adadbe21b6ab28f4aaacdc397893e0641","implementations/python/tests/test_issue_1338_identity_stages.py":"sha256:4a26bb8e9972fb76b821f95a5cee3422f18f5c660407d1f472a644aa50a88fd4","implementations/python/tests/test_issue_1338_participant_identity.py":"sha256:7be0247669d34f6677202ce198efb272bed04b76c1a527abafd295bc03a7fb3d","implementations/python/tests/test_issue_1339_declaration_locations.py":"sha256:6897abb9eef59335bf214aab29f78be0fc295181a3701f58c69f815a0c5aa013","implementations/python/tests/test_issue_1339_editor_eligibility.py":"sha256:5bb8820de22ca28a6b3c49ab54a884e9d07dd32e8b03b3a90ba815340b4b5c55","implementations/python/tests/test_issue_1339_editor_imports.py":"sha256:c40e8aec77295a911bf6f6c98372f38bae1c1e069a660c0e1805fd0b91062c07","implementations/python/tests/test_issue_1339_endpoint_editor.py":"sha256:4915401e183d2bada1da422d0ebd87cc85fba050fa9fdaff9cbe054359166a6d","implementations/python/tests/test_issue_1339_import_safety.py":"sha256:0afdedd17df4d4186933c2e13d8381be008c6611c1a34c884a18ba09ff3444cb","implementations/python/tests/test_issue_1339_namespace_integrity.py":"sha256:3d595977c89310a46f4b5501e266082c40c455391c3a700fd54c97f72ee2c7fc","implementations/python/tests/test_issue_1339_reference_eligibility.py":"sha256:35135ea763e57a99d8f9ea59e8c69d7e731d081c43d1502e876b87fe8a5a158b","implementations/python/tests/test_issue_1339_registry_decisions.py":"sha256:64f49ef27715308ce17229e1805c7b2a28371ca96b19da90685a6a616be618b0","implementations/python/tests/test_issue_1339_relationship_candidate_parity.py":"sha256:653a893575fa375040fa0a871e8869c319c6e796491e3fb90a3fd48c85608189","implementations/python/tests/test_issue_1339_relationship_endpoints.py":"sha256:c5cc0de7bc23a49b6243f8b33dfc0029f33c46850b305575cba6f0e13ba73833","implementations/python/tests/test_issue_1339_scope_and_effect_integrity.py":"sha256:61734da2df1740f79f4355dfe2f7e318937cc8aae66908eaebbb50c4093b3b85","implementations/python/tests/test_issue_1348_operation_supervision.py":"sha256:f3b9152e9a018c650cd7a2c386d65711504ff3377dc8e9d0f7173938ddff8d89","implementations/python/tests/test_issue_1350_fixture_secret_scan.py":"sha256:5e2e99f083d65852f8f81cd64785533af10ed1c79854c9fb253c1f0219027456","implementations/python/tests/test_issue_1351_mixed_control_design.py":"sha256:c6dbd281d295b1b56a97cfb3745d32c759bcb14b79362ee3cc859cebe82d828a","implementations/python/tests/test_issue_1352_control_applicability.py":"sha256:daedb0232a1f44ef3b2715ff5ecce88ef37e9065907c1c19df1a66e063688ca6","implementations/python/tests/test_issue_1352_governance.py":"sha256:6219bab385637a20bdac4adb4f8df79e67d0296636ff240fda45c90a788dbdff","implementations/python/tests/test_issue_1353_external_inject_design.py":"sha256:23ffffc798aecc3e8d4dbe69d456bca74c27e889fafbadc31d48214d1daa6068","implementations/python/tests/test_issue_1354_governance.py":"sha256:a5f03cd634b52597c6dcc8420a074a7ea229d697d60f703b9dcd2efc7a97934e","implementations/python/tests/test_issue_1354_ifc_profile_variability.py":"sha256:b7dbb97cc00c4b65c3d524b95c35dbb05b923bbb8113a6f8f313482277af1217","implementations/python/tests/test_issue_1355_mixed_mapping_time.py":"sha256:26d5718b177e2b95e68b6f259d5121164a4d8098868d006ff8f3404f49f56726","implementations/python/tests/test_issue_1359_runtime_api_trust_boundary.py":"sha256:cd692067e0e5339b5d002164fe41eb574b4e7ca5226354745d58679b5139e5be","implementations/python/tests/test_issue_1360_backend_operations.py":"sha256:2eee5f70be306aea4fc558cda14333457caa919c3ecda4e4433214d6069fb6d8","implementations/python/tests/test_issue_1360_operation_rejections.py":"sha256:7fa837722e8fef9e5738f5da4f41bb528e2ad1e5cfc4de3b1132cf01aba9ad4c","implementations/python/tests/test_issue_1361_execution_policy.py":"sha256:8d7df5771be30902b847af58deb29bb24af5bb722efdf6c9921bd9611b095d48","implementations/python/tests/test_issue_1361_policy_admission.py":"sha256:198e348a41a8541a77cac865fdf52d4c86bc04a0f205f892ecaeafa393204f9d","implementations/python/tests/test_issue_1361_policy_composition.py":"sha256:92e2d8b17e2d6bcdb2abeb118705e010be3c78c6c2d35685bc05a5cff384e06a","implementations/python/tests/test_issue_1362_bounded_execution.py":"sha256:b869619845325a417f4ac6e220e9aefdcc7836e61cf1b66f3597bbcf6ca1577f","implementations/python/tests/test_issue_1362_command_privacy.py":"sha256:14d4856fd7a3787f1b9f72229cfbaebc45d01fefd962099097bec5c0f74c1754","implementations/python/tests/test_issue_1362_commit_authority.py":"sha256:59225a18592418f947f249878b999c869c74eade1e50d2b95c0a9c0b3b09cc58","implementations/python/tests/test_issue_1362_control_budget.py":"sha256:1a19eb4e477daa33503a3b3876b171081dad14f270b2c7e229fcaa6c9e7faf00","implementations/python/tests/test_issue_1362_dependency_admission.py":"sha256:7d99dd77ded335e01105e11fa9eb245a0888b8075ed158ddb13ba15104e6683c","implementations/python/tests/test_issue_1362_distributed_authority.py":"sha256:9920aa5588eef2e3190753d7ac452b66cfb51842b261ec079d080162995561bf","implementations/python/tests/test_issue_1362_distributed_integration.py":"sha256:a74d6ca89fb4f76979ddc2db9eee88304ec2908e8ee5aaf5cbc35a9fcd188600","implementations/python/tests/test_issue_1362_http_capacity.py":"sha256:dfe2f3aa34650fcc6b104bafb378515e8cbaf49a69c512bf9409cff3a19a4b48","implementations/python/tests/test_issue_1362_invocation_ledger.py":"sha256:30c6fb4f0152a998ffff92c0eb91ab4faac6bef2191e505b675d4a154de22b9e","implementations/python/tests/test_issue_1362_lost_ack.py":"sha256:2724cb5268e8e580455461619fa32b128f28839c40296309ad87b29cf0d8879d","implementations/python/tests/test_issue_1362_observation_retention.py":"sha256:ad13584ad7aff4dda74dc3942007929e484858b9abaf06c2a0dfaf6b90b775f6","implementations/python/tests/test_issue_1362_policy_bounds.py":"sha256:fbdb537657c995abd94fd2f409d58ae176bf1ba0cfdb407c086e600e968915c7","implementations/python/tests/test_issue_1362_postgresql_store.py":"sha256:e5ac2c3d92c7fa9a5468734294e1e1494778d58e63da971808b881590f9ee0b2","implementations/python/tests/test_issue_1362_provider_execution.py":"sha256:8cad745af7c92052e767abf43aed4a520d3a5cdf4066f99a4a5b008bb4c229e4","implementations/python/tests/test_issue_1362_reconciliation.py":"sha256:8b0738bbda129df4564a6747dd95dffee4b2ddb84c80aa83a347a0898b56080e","implementations/python/tests/test_issue_1362_resource_ownership.py":"sha256:421c792195eb090ee8537e24ec09ffd2ad470fb6dd44cad022b42f6517ac1390","implementations/python/tests/test_issue_1362_review_regressions.py":"sha256:3d5f12fdc611b965a944d64b96420fa764639a95fbdc0655280041e9d0d4a942","implementations/python/tests/test_issue_1362_review_round_two.py":"sha256:bf73acbbb13da92987de6ba0cec79c7d95867eee7fc02b5ed2b52ec4955bdcd2","implementations/python/tests/test_issue_1362_runtime_imports.py":"sha256:46893cae9920166648f4ce86ac735f5f5aa2750fe71c8a9197a71a45bcf14e3f","implementations/python/tests/test_issue_1362_runtime_supervision.py":"sha256:b2c543dd34e78f20e21380ff5e34d288bc314e31031e9b23014c710581ffc736","implementations/python/tests/test_issue_1362_state_authority.py":"sha256:454b8efe44dfb5aefe66a1591d0f6806736583b252b6c48c5e6fed102611d291","implementations/python/tests/test_issue_1362_supervision_http.py":"sha256:d0f4cd66e88c5d8505a8899b71537c5280eb13ac0a17afa0bd7756f09959bccd","implementations/python/tests/test_issue_1362_temporal_adapter.py":"sha256:e8bf9290c54c242b33ea102443676a6bf59fd8ba9673998c40d52c7b837e811e","implementations/python/tests/test_issue_1362_temporal_input.py":"sha256:a39eb569439930d66d2d9d424ac236b43551277d6ac156b6bdef1ade5cc0fe3c","implementations/python/tests/test_issue_1362_temporal_worker.py":"sha256:5f20a0e9e5634fac4e5dd60f7f6c0b432824aa1ee4182d655b2f5666205e9b6c","implementations/python/tests/test_issue_1363_delivery_and_admission.py":"sha256:01debee9add8413250574cb24eae8b3632cc01928c6496af5d0638afc837f990","implementations/python/tests/test_issue_1363_identity_integration.py":"sha256:199628fb9cfcc908153bbef41ebc941b531712590f614534b811bd7e46c71c80","implementations/python/tests/test_issue_1363_mixed_control_authoring.py":"sha256:7d3de85effc7c3f0cddf931a045fd2f87c20e814f0cf1ff3c4bc492bb5a56f92","implementations/python/tests/test_issue_1363_mixed_control_migration.py":"sha256:c8fee00eb6415f85ef6a7c271592d6a105ce494957547b354ea561ee6c1cf98b","implementations/python/tests/test_issue_1363_occurrence_v2_context.py":"sha256:830adf12cea07b30c920c3213e9847e7b7fe8afe746cab8cd178d4666269417d","implementations/python/tests/test_issue_1363_occurrence_v2_contract.py":"sha256:41f947b0354e1095cb0c976437eab3664e1dddf3253351dc1042bee5c020232f","implementations/python/tests/test_issue_1363_projection_integration.py":"sha256:512964eac142e0474d18c841ae1de7f029f1f3acb3d0db3373f1fe0c748ac634","implementations/python/tests/test_issue_1363_schema_parity.py":"sha256:4fd4ec990e906b3262cf98f4a2e8684d28afab416b8d29472211584bf67a90fb","implementations/python/tests/test_issue_1364_cancellation.py":"sha256:a2ea7af42910bef42147cd06a4215dae8645fabdfd5104b9901a39ed32973c58","implementations/python/tests/test_issue_1364_cancellation_evidence.py":"sha256:32b01775d195ce4bfe2eda7da12a4f8f21d5be02633628c3374bc6e0246434b3","implementations/python/tests/test_issue_1364_control_history.py":"sha256:d48729f5cbb19785a659fd30e7424f76b6208175914c12466b0c7e6f9ab25e38","implementations/python/tests/test_issue_1364_http.py":"sha256:477bf4673e07b9561cb570f9066829c877412aa59ddde011d53ed7feda2f464f","implementations/python/tests/test_issue_1364_reusable_runtime.py":"sha256:3b5e7dcadabac9c9a5f10c1941413082ba276103c8fc226766ea81e4d0c4f88d","implementations/python/tests/test_issue_1364_review_regressions.py":"sha256:e6d1d43f1802c61ca454933c58599896669cfafe573b438b4935e9d48e07ec37","implementations/python/tests/test_issue_1365_applicable_contracts.py":"sha256:cae0e817a53fdc946d99c3eb80312c4ed1c4e1ef454837ddb2a3c3bb07f108a8","implementations/python/tests/test_issue_1366_inject_occurrence_outcomes.py":"sha256:f6cb7806572017ff25856e3984f0a399faff7df492b5056bd031179c5446d059","implementations/python/tests/test_issue_1367_inject_claims.py":"sha256:c8e983aa3bd44b0a1c8fa1036a84afe3252d233111fe611115b66d6000b98088","implementations/python/tests/test_issue_1367_inject_execution.py":"sha256:a40937f43a7ded6a48583d63c83f24218a42e510f96828c5c2211a7732ead628","implementations/python/tests/test_issue_1367_inject_http.py":"sha256:4c96ba7f40ede85d3ae2df5e070f19b53cf4acb717dcf88f0317cc2d695c446b","implementations/python/tests/test_issue_1368_control_inject_owner.py":"sha256:8ebbe6df24c20c13361172035d7e7ec7aa1e0735e2930e8dfefb0a6ce32a6e40","implementations/python/tests/test_issue_1368_delivery_contracts.py":"sha256:656bfef65538d6a1e3aeeaf92953b503471fe7ab37a31487eb369430cda44cb2","implementations/python/tests/test_issue_1368_inject_delivery.py":"sha256:b980479b6dbc7a20d1e82b01094e991292a80d46e2c8d6456d19f8fb651b064f","implementations/python/tests/test_issue_1368_inject_delivery_http.py":"sha256:f6b3ddcd7dcc5f26d8180cb7aaa90e7b29fcae2761a6830b59d33385c8dcf321","implementations/python/tests/test_issue_1369_cancel_recovery.py":"sha256:bba7c2de80cc9722dcd054b0def3516bacb0c137d3dcd456a93d196cd8aae3d3","implementations/python/tests/test_issue_1369_cancellation_effects.py":"sha256:aea8c893888275fb9e235b5c596aeebc0f880d3d596e145302e838c75e6f35a9","implementations/python/tests/test_issue_1369_continuation_limits.py":"sha256:606b89748b4c04835aa75eba75ef6a29ed4e7a7a936301900b89e55b2a405851","implementations/python/tests/test_issue_1369_deferred_authority.py":"sha256:7d649dff06e50170446b96e6baec7b10974bfa2af1df0c60b3aa5db4dedaec60","implementations/python/tests/test_issue_1369_effect_continuations.py":"sha256:3299224ed41b09a80358e97c90753ad4495ce37bbbc02e2975439ce8562bf7cc","implementations/python/tests/test_issue_1369_effect_recovery.py":"sha256:e0bfe0c0df3946dc9c5fc42124ca2b3ecd8d3c92e1547e21b91662548d603a33","implementations/python/tests/test_issue_1369_governed_effects.py":"sha256:991428f3c79af0bfb2c3d33f29c056a5e48aa74249a5ac279d3d16627b3baffe","implementations/python/tests/test_issue_1370_ifc_admission.py":"sha256:63f17a1c1bda44f4a36fc9f2bdaf309f607fbb252172b38765fd3598d4845ecb","implementations/python/tests/test_issue_1370_ifc_profiles.py":"sha256:e409e0fbcb58eaf8e8843deb0af8312cc35f54957a368f42d9f8fd1ff18708e1","implementations/python/tests/test_issue_1370_ifc_runtime.py":"sha256:a13b5afd54b5faae8943a5b561b07defd8cfa300efeb47733664fcfad5ca9c32","implementations/python/tests/test_issue_1371_mixed_backend_contracts.py":"sha256:0a86f2992317bc8cbe1390f8918215bf2161321421d0c191c1a749767b63cf1a","implementations/python/tests/test_issue_1372_mixed_execution.py":"sha256:221e83c5d8997d070e10b1b7ba3df177a86109bc6b2e0d933b19ccc809f41387","implementations/python/tests/test_issue_1372_review_regressions.py":"sha256:c23dea1b970e6af4031aac8a63f08ed9f6a193898123b1363f353780c6f01aa3","implementations/python/tests/test_issue_1373_control_projection.py":"sha256:d8e0f3aa52af2ec3aab73f87ac1670b1ef409c85f8a9f2365fe192ad2133ce73","implementations/python/tests/test_issue_1373_crossing_prefix.py":"sha256:f886855cb3330dac7be596518666886ef36575b468ddfdb8034d9076408b0edb","implementations/python/tests/test_issue_1373_durable_history.py":"sha256:3c864e2f51c3a9be0fddc9688e30eca7ef129389c2a0f0b9a5b93bc94dc9c4a1","implementations/python/tests/test_issue_1373_effect_work.py":"sha256:abe89e7e6ae75b9f7f64d90edac193f83365b1806b4e8deb09d1b75e4990a886","implementations/python/tests/test_issue_1373_history_consumers.py":"sha256:e87635df86a450899997044a6dbc3a4219ba78bbded8861deba09f996b873241","implementations/python/tests/test_issue_1373_history_prefixes.py":"sha256:346c4f63b515c579c2f963e5be388ce0319809c574a44eb22f8af9dbf33540ff","implementations/python/tests/test_issue_1373_occurrence_prefix.py":"sha256:4b4796d08bdbe4b21c9dcda90f508d4d1ddbe507aab84ea81b06414717ecc738","implementations/python/tests/test_issue_1373_operation_changes.py":"sha256:aea9d2a22f727b0d567c9f05c5ccaa4e7d96ec97cdb17ce4ba0e03800eba48dc","implementations/python/tests/test_issue_1373_postgresql_history.py":"sha256:467fc797e68b9dac41fc64c39902b6a1679928780f7cfe77a96ef366a2f9cc11","implementations/python/tests/test_issue_1374_incremental_validation.py":"sha256:621a2ab82a8711f6a5688a5add5bfc57c630eccef9e39f8d8cfe18502ee2e552","implementations/python/tests/test_issue_1395_crossing_export.py":"sha256:3c5eaa856ff19ade15ce906821eef9aba72d0afcf0507fcc3ace449ef66e51ed","implementations/python/tests/test_issue_1395_crossing_models.py":"sha256:c84c09ad89d1e0d3879d1d2d0f46e578b432487acd6d827f812bb3aaebb66b8d","implementations/python/tests/test_issue_1395_crossing_profile.py":"sha256:63b6dfbb281b683e1749dc8f7acd9301ecdc36d3fcb39324721ad2e7dfda402e","implementations/python/tests/test_issue_1396_trial_replacement.py":"sha256:4076ea30f14bad1408ff7491fd9a96f7312f130bf86aff8d17d2c06399e130ba","implementations/python/tests/test_issue_1401_media_type_coherence.py":"sha256:476ec824a6f78807899c5848c1405f5f5b1a09be6ec6674334bd2d87db81e654","implementations/python/tests/test_issue_1414_release_upload_repository.py":"sha256:389801239e246780e49885bf9c19e97a6757d580d23018f580d1e497e009a752","implementations/python/tests/test_issue_1416_protect_files_hook.py":"sha256:6f1ca0f486c1b12999a4f2d106fe067fad141d684afa49a488f019765d5b8d3d","implementations/python/tests/test_issue_1421_time_readback_isolation.py":"sha256:327de67fa99d63c226c4f62f3684cb155b808bfd1c30d4857e60c9e66129060e","implementations/python/tests/test_issue_1423_inject_occurrence_contracts.py":"sha256:264a057d425d54a539d5ac554b320a8bc61e89e52e9510ee09b36a350aef8782","implementations/python/tests/test_issue_1425_relay_plan_parity.py":"sha256:e24e91a3fd5638a4f0b0653866471893d77fb4af946b2f1e5f54b61d6aca54d2","implementations/python/tests/test_issue_1427_post_edit_policy_hook.py":"sha256:e96cf3efbfbbac39d1c7e3e29b7f500efd690d3ca3484c5221bfb3a632680ab9","implementations/python/tests/test_issue_1434_typed_runtime_domain.py":"sha256:7642e8613aefba22f7fafc62e3733357125d35d5168e0b78b2e78c7a7c5c929d","implementations/python/tests/test_issue_1435_profile_clause_verification.py":"sha256:09d40314731e7f192de20f4421ea40df6cceb787b03485eb6779a8b69b52bd7f","implementations/python/tests/test_issue_1439_participant_initialization.py":"sha256:1a2b303c64f3c092b73d76e99df30b8b46580be938658283767b6d29511073c9","implementations/python/tests/test_issue_1454_conftest_evaluation_errors.py":"sha256:fa1a4e65ae3c10f9ea3a1a99a6ed7e6c3a58353cae616a214aa6d7bbdfca2637","implementations/python/tests/test_issue_1479_oci_anonymous_token.py":"sha256:8b30179f4be4db7cffee68798b681434c4ff28ef6218fce6d675508c3c2e4fd3","implementations/python/tests/test_issue_1481_parameter_authority.py":"sha256:42c8ef5f517d6c6911f0c17f0ab63d37e0477b62708ef4c677f3140a80971860","implementations/python/tests/test_issue_1482_mixed_runtime_canonical_manifest.py":"sha256:bad7654063b6304ac86f58bf4fad056a5dd38d64bb4508764516361644e26e1c","implementations/python/tests/test_issue_1519_experiment_tasks.py":"sha256:40ccf0c31cd6d94527b8be46f997ad18b262619ee5a5701d37d75ba866191ac1","implementations/python/tests/test_issue_1541_runtime_fact_timestamp_offsets.py":"sha256:c213574a37694a12f2f2ab1c57db83463f592c2179147152eba6e0545a5fe0fa","implementations/python/tests/test_issue_1547_capture_reference_version.py":"sha256:ee1b4dee326ffff2ca4ea3e966c07542919a264ff933c98494ff90db3ccf6372","implementations/python/tests/test_issue_1549_external_backend_trial_realization.py":"sha256:343e36e21fc49b4aa55d12f250fda63cba19c26d57458a7ce1c42b33432490c8","implementations/python/tests/test_issue_1551_target_snapshot_published_carriers.py":"sha256:b30fa1ca8f0dac50a9e41f189172f9aa4ecc18321d0f5f4d74cbc8c34da1e2df","implementations/python/tests/test_issue_1563_experiment_spec_invalid_date.py":"sha256:14695613cb91df83c050251bd1a98f824d7179d9dc26a2cdce80360b6732f943","implementations/python/tests/test_issue_158_runtime_result_integrity.py":"sha256:7d9f663a55496c8b0679ed7ff4647acf8205e14835d126a01625989386902cda","implementations/python/tests/test_issue_1603_credential_artifact_evidence.py":"sha256:9c518edda532eb98b900e9fa5eb7a3bf6e977eb64f1a28beefa5fc688d2cb0e3","implementations/python/tests/test_issue_1625_structural_variation.py":"sha256:b3397156e5e2ec2771168d80d3c79eb836490473a38c8a01e068d8f6433ce222","implementations/python/tests/test_issue_1626_trial_participant_bindings.py":"sha256:ca2f72a5538a1563bd2f1d81dbf59991cdcae53a85471a9513a3af433f6991ed","implementations/python/tests/test_issue_1627_trial_unit.py":"sha256:f15190a497c8c348d4adb277a8ef0fcff36f714e7fffbc6d9a004fbdf06dc61e","implementations/python/tests/test_issue_1628_trial_control_admission.py":"sha256:c5599bd08173dd935aa7a417d62def1edbd24c6669dc341819b0977f24feb17e","implementations/python/tests/test_issue_1629_engine_model.py":"sha256:e092c39185d3ccb56486d442eecd94452fdcd309c708124797b544fccbaddda1","implementations/python/tests/test_issue_1629_experiment_recovery.py":"sha256:f443a41b377e56c86027435f001f2d85fc06239c02db5501f06d4e986c382bad","implementations/python/tests/test_issue_1629_experiment_replacement.py":"sha256:cc93ed68799d22d109b378e01605536fd6c33220530239589677dbe1e3e3b125","implementations/python/tests/test_issue_1629_experiment_runtime.py":"sha256:1bfd70f7f0a508faf1d96dc7d4366f1d3b1782019cd0e39b44056e53b653bd70","implementations/python/tests/test_issue_1629_run_contexts.py":"sha256:3e0cfb7806972abbdb8b7709c08b100217ee9cc87f9b884fd27163f65494160f","implementations/python/tests/test_issue_1629_run_driver.py":"sha256:c24e2cc46164c5784ef588d0ff2fb6c2dd57fac4488b86464438488fecfdb1a4","implementations/python/tests/test_issue_1629_runtime_decisions.py":"sha256:5d337d7b8e17c6be4db78e6fd699520fe5c48695649a51609cde6dca5ada4f2f","implementations/python/tests/test_issue_1629_temporal_integration.py":"sha256:8cbb26b29b03e6fe00f905bf319bc8bcbb515192c86016ad6513062b94665f6b","implementations/python/tests/test_issue_1629_temporal_runtime.py":"sha256:905c251cf7f18e67b6784040d0632b1fcf84aeb0977b99ad3abc9df783f29d3a","implementations/python/tests/test_issue_1629_trial_guarantees.py":"sha256:22087d8453a8d822b3cafd23539b29521ad60f95c01ba62f301c5e75a887c28d","implementations/python/tests/test_issue_1629_worker_contexts.py":"sha256:69fb7145cd5431361f2c4e8c08e893470b89da57c3f6a5501e0dc35287026c9e","implementations/python/tests/test_issue_1638_credential_realization_observations.py":"sha256:f7d05e306510fc4a9faf6d353570f52216198667d49b2235d4526fecb8c4cc36","implementations/python/tests/test_issue_1649_inventory_admission.py":"sha256:12db7073de93664581ce35f6eddc053e1171a7942d2d6f8b6404e06bc0ee491c","implementations/python/tests/test_issue_1649_inventory_bounds.py":"sha256:b8c754a10603f4f2c0b91702618835d5a30a23de8b61c039b201f912723b3256","implementations/python/tests/test_issue_1649_inventory_contracts.py":"sha256:4af3a0b00d8e3a5f5d64358c2dab970dc503327185a78afd3d5a60bfe19e9915","implementations/python/tests/test_issue_1649_inventory_durability.py":"sha256:a8c2d22e711451191fbad8b1e98f37e5cfc6e5b262b508158ed35d9d341fc9bd","implementations/python/tests/test_issue_1649_inventory_http.py":"sha256:48f4ae0fb5a81a68b40a046808b400985225482fbc9b782892e313895908a059","implementations/python/tests/test_issue_1649_inventory_provenance.py":"sha256:8242abd855c01292d7e884f599943b8911ac23bf0c319a243912916b27ea3b0a","implementations/python/tests/test_issue_1649_runtime_descendants.py":"sha256:7649a6284d5f19b7110cb687f5eb99e783c36241d841aa9b696937675cf45565","implementations/python/tests/test_issue_1649_supervised_inventory.py":"sha256:289b696d833cf06b0398ffb9a3d4bba82e27bcd4305ccc898ecfa2fda0c218ec","implementations/python/tests/test_issue_1653_cloud_lifecycle.py":"sha256:ace0a61de44e92da2d141a32f2bd765a3c0e9c26a5d8f8d608f09e3024b53de9","implementations/python/tests/test_issue_1653_cloud_models.py":"sha256:097079c191c8442d8d3ea4c0e28d036e1c08fc00205fe36a78ed0c71fced69ee","implementations/python/tests/test_issue_1653_cloud_references.py":"sha256:7fc2f878adab1589a8accb5a3ae08acc0d0a017a5bdc6929b745a7bd0a33f885","implementations/python/tests/test_issue_1660_provider_observation.py":"sha256:f54b5f391fa965746dece870b5082a78f2b8615000f9e02fb6eacb61cae28518","implementations/python/tests/test_issue_1660_review_regressions.py":"sha256:1ceacc171e065cdc0b6b7d581cdebbd0009e72196c42a503c31214e7fb2b46ab","implementations/python/tests/test_issue_1660_runtime_lifetime.py":"sha256:fe8216e2d4268c2bb1e55a7553b13ec18a4455e171ea1eef6b24bb28de1d135f","implementations/python/tests/test_issue_1665_factorial_treatments.py":"sha256:8c099ce79ee84d276c8775cb47fe979e5e02177cd326759abee049223f9589be","implementations/python/tests/test_issue_1665_treatment_type_agreement.py":"sha256:696fd0a2feda2536a219198eb893e333ae6586af97d754d86d2cb5e72cdb0e61","implementations/python/tests/test_issue_1666_factorial_admission.py":"sha256:14b2f6e3e4874c2c13051fe9947ea6d64be8f6c3fef48a8fdca5d5cb4354bede","implementations/python/tests/test_issue_1666_factorial_compilation.py":"sha256:6a306547351a8829b0907f5aa8025739d5efc2236f4a2b753d999b64866ce690","implementations/python/tests/test_issue_1666_factorial_replay.py":"sha256:b2bd63b3e5d4f04b4140f49518020af5f74d3be3372c2c6dccbacd948ad32283","implementations/python/tests/test_issue_1667_target_materialization_conformance.py":"sha256:68a58139c69e7ec6b1b2621def9130d5d8ca44bd872fcbdf8b1078df45f9e94e","implementations/python/tests/test_issue_1697_preparation_provenance.py":"sha256:7e1982efb92f33489f124765cdf7666353524cc2244c79c39450bc5743a25539","implementations/python/tests/test_issue_1697_preparation_reporting.py":"sha256:48ea84240d78fb0184cff0e1a72dbe3300d93fb7441b6a6f3e7c102c0bc17a90","implementations/python/tests/test_issue_1697_prepared_artifact_provenance.py":"sha256:82543ae292b6d2452e9df8f9bfda563935a59e2bf36f3004e7a731d4674fc7d9","implementations/python/tests/test_issue_297_behavior_authoring.py":"sha256:81c65ef9be2bbe59d52589d07fd81ec4a81479307ba401edb1840c81f11c2ccd","implementations/python/tests/test_issue_298_tool_authoring.py":"sha256:7e879b880da36ef945d9181113cc8f64a0d187e5a50b0118d5ab74df03268492","implementations/python/tests/test_issue_301_history_alias_visibility.py":"sha256:8539a701bb1e6178142c5575d05411270e16c73add564a3ec9e041e2eacdd045","implementations/python/tests/test_issue_301_participant_tool_profile_conflicts.py":"sha256:10b0cacc2ba58b3b0614b7a3d062d6872eb1c54313a50eae2110bfc5c62fcf56","implementations/python/tests/test_issue_301_participant_tool_profiles.py":"sha256:1e51c2a360f3dccf4da0f208de91abfe325d8eb022710afcbdd398bdfb6ce30f","implementations/python/tests/test_issue_301_private_references.py":"sha256:12993f7f60db73dda0b6b724da3d158fd248f194d881254cbd02b9ccae7f33bb","implementations/python/tests/test_issue_301_projection_boundaries.py":"sha256:0495abb9cddb021c4039dd2ba7b9b16cdab1d87f6c52e5ceccb2ef60cc769826","implementations/python/tests/test_issue_301_selector_schema_parity.py":"sha256:81102cedbccdb03a47617c0deb76bbda33f641991ef5995a10fa60a2c3901e06","implementations/python/tests/test_issue_301_visibility_references.py":"sha256:65ee460942dc6e0c6d2e80c3022c55ed4cdbd351674178e507b58bc21e283060","implementations/python/tests/test_issue_304_tool_support.py":"sha256:1f08ab39971e7804d5d7d6ddbc31dcf3477d5e251824ac693f3f2240b3f67ff9","implementations/python/tests/test_issue_378_scenario_templates.py":"sha256:91f40a206723c8c026dc8d91d8a4cc468851d82cd461261620685ca5521eed87","implementations/python/tests/test_issue_380_experiment_templates.py":"sha256:e8b76d526ad2168daf053cd960d3f3fe64614ca0bf4afa96df84c121d602bb62","implementations/python/tests/test_issue_381_example_catalog_metadata.py":"sha256:8c82415aa81bac016447a4716a9047cd534a3c134780bf73524b17eeb58c43a7","implementations/python/tests/test_issue_613_scenario_plan_guide.py":"sha256:fedfba617b790e9f8fcd1fc4c1786295009f10abce389b0afaafe7137bc1e3d5","implementations/python/tests/test_issue_673_account_credential_bindings.py":"sha256:153173ecc628d64218b230dbd131dba9c341f53b91367c9ef3cabcadc24260fd","implementations/python/tests/test_issue_712_contract_requirement_tracing.py":"sha256:1ced9e586cf6f7a35c463c74b6532a67b86f21a0acf4c21c6b94e04fe4159060","implementations/python/tests/test_issue_794_participant_io_adoption.py":"sha256:ef143280a3ca6e75fcb5e930d0e883c736ec60f1282ece71d3a29d26e97fb642","implementations/python/tests/test_issue_802_participant_control_migration.py":"sha256:e9b54cdc63984f66285f29ee436744379ed118c034cfd196f8f77a2741262766","implementations/python/tests/test_issue_810_participant_opacity_design.py":"sha256:569afb3a5dacf0211a1827348b42db062bfe0205975c4e817d9a97342f9c71ee","implementations/python/tests/test_issue_811_participant_bisimulation_design.py":"sha256:2477ee5cf48d1f2699072a12901d2fc6c79a0a00eb9a19ee3dfe4dfd59573694","implementations/python/tests/test_issue_812_adversarial_participant_control_design.py":"sha256:011447f031b4596fa16d38bbc1809c254adb968b0fd792cf4b5c7fde35222a0e","implementations/python/tests/test_issue_813_cross_backend_participant_control_design.py":"sha256:f988e12b89f78858ca1adce29dfd138d2590dbd58236a8ae61611bedc6720d1a","implementations/python/tests/test_issue_847_runtime_package_repositories.py":"sha256:905a2c4213460074ae560d41d9b271ea5f4e852c7f7d9af63893d9cf02e2c872","implementations/python/tests/test_issue_898_participant_execution_control.py":"sha256:c90087b71b27e0fe570472e048502d15dbef723070f3ef07cf415326a2b03ee6","implementations/python/tests/test_issue_899_participant_resource_budgets.py":"sha256:ba65b571ca64d1210e1f8851a2083a0e012a79de5979710ec301aacc2c29c5d8","implementations/python/tests/test_issue_938_landing_page.py":"sha256:f8af1b1c738aa4ed10cc07b1026bee69433f6e81293996be68fcd42c5678348d","implementations/python/tests/test_issue_954_docs_publication_boundary.py":"sha256:71d3daf6da388c39b657b9933c5da12f7a3830eba7b608269998eaba5a6a5540","implementations/python/tests/test_issue_959_audit_coverage.py":"sha256:0f95a9985dbf61fe8fe23a3ec65963dccabe433eeb67698ff3362d2f62e8da46","implementations/python/tests/test_issue_961_participant_opacity.py":"sha256:780d3ad084ee77b7bd481e5c03a36a3d28a2c8e991b694b0fec59ee59511e321","implementations/python/tests/test_issue_962_participant_opacity_model_check.py":"sha256:a018314e6a71edcaa67cc64f81e82d21919619e07642e3d218b687df0490977d","implementations/python/tests/test_issue_963_participant_opacity_proof.py":"sha256:2f5e5929af00792cd88a618b3d3bf0b7c79c4d6d0a1f89724c5ee346d26f9d33","implementations/python/tests/test_issue_964_participant_opacity_runtime.py":"sha256:9a9c8f426a73c5eb384db04846f90c59795837d835f89fc93caaea8a2194a42c","implementations/python/tests/test_issue_965_participant_opacity_backend.py":"sha256:b807aa7ff72bb7efd8f1427bf9099ad291a8aa5df3c940d00fad141d20095fd8","implementations/python/tests/test_issue_967_portable_backend_boundaries.py":"sha256:ec0df8741b451843cedbdb2868a75376b1cc7ec193c0b44b74ed608316e5ed81","implementations/python/tests/test_issue_971_crossing_export.py":"sha256:c1988bcb8d8294cbaae7ae3bd87b6d7c19050e4a0293e8c62d956b8dee40c998","implementations/python/tests/test_issue_971_crossing_models.py":"sha256:3245077066c07ef9966f89192b3b9e2f2e0a6c9f05a5084771fdeab6b42587e7","implementations/python/tests/test_issue_971_crossing_profile.py":"sha256:5212ee7fcc5c66422e22f4975cd520b1a5c3689aa6ad7f164d5831fcf8585aa6","implementations/python/tests/test_issue_972_mapping_export.py":"sha256:1540c7d33a1df07fe1f4d2ca488bbadc6b533dcb1ec3fd856910c42fad825516","implementations/python/tests/test_issue_972_mapping_ownership.py":"sha256:78342f91869455c1d4ae939f16d49c6f849ffc238ec19100a4d3f305b8985b4f","implementations/python/tests/test_issue_972_runtime_mapping.py":"sha256:63ec2212716d5c419501362071ea33833d6ab66eb82299232d3a33ae3d98d90c","implementations/python/tests/test_issue_985_realization_projection.py":"sha256:d21d59a9e07455698c4305eab4762a900806c8eb636373f95fe252aaff53606e","implementations/python/tests/test_issue_985_runtime_observation_contract.py":"sha256:a41a10418766d1eaeb78ae203f31ee0f63a30b870fa5762ab4bc52d4171dd93a","implementations/python/tests/test_issue_985_runtime_realization_concerns.py":"sha256:06410ac896967983c1492e563fd3eea8132cb73a6e61dc4c7e5c43ba0d1b2d10","implementations/python/tests/test_issue_989_versioned_evidence.py":"sha256:0d24f9f419bcaaa4c34a95de98385c8cf5ac45277acf29cdf06f9b3ff3cd564f","implementations/python/tests/test_json_ingress.py":"sha256:f8d253bfdc8b5f3a5da826e67566388ec19a40051abad6705a4f004a3206d19a","implementations/python/tests/test_language_service.py":"sha256:f3e336f2409e7b8e8fe347bf5baa1ae696bc8aa905548147110fa1aad9c5afe1","implementations/python/tests/test_mcp_server.py":"sha256:813393ae9a73630fd31d9d28ffb32bacf564c22c4989d3770ad59da0dc1d99a9","implementations/python/tests/test_necessity_validation.py":"sha256:ddddd5d60f6b592a2a79a47ac7c8508d9e74e686a03501c134635b9f604c9c8b","implementations/python/tests/test_network_namespace_sharing.py":"sha256:494874d8964c83c3a6f3189bd9d11ac85fdadd68217d4f97465300d68c2d3d40","implementations/python/tests/test_node_architecture.py":"sha256:a5aa786b28bbc1171fb738ff63d92af695ee01924db930e224d4207ddc12bfb3","implementations/python/tests/test_nox_shard_wiring.py":"sha256:8e21f9df06c3a15cb8ffca43cbb3e012b0a285644f998b138a7275abf8d18b4e","implementations/python/tests/test_nox_support_test_lanes.py":"sha256:c21f556fe40d39ff9d59a02d214da3b4550d4bfd0955d12651537c8172bb61c8","implementations/python/tests/test_observability_evidence_conformance.py":"sha256:3f4cd66bac37fcfff0bdf706b6a15f3c7ac047e4f701467bcb92529856141313","implementations/python/tests/test_participant_backend_contracts.py":"sha256:6b18fef05786699dc02ad0096eb6283f4ae81ba7e68179333e61b30b88428bb1","implementations/python/tests/test_participant_concurrent_batch_reservations.py":"sha256:f460d479611e2e2263facee4482c30ecf1f10df241abfa9c8b26bbbaf8aea6c6","implementations/python/tests/test_participant_implementation_manifest.py":"sha256:48d978b4d2e5742ecfe7e0f5c280f3ad8b904ff5f2692b9af5992b8e130e9bc8","implementations/python/tests/test_participant_interactive_access.py":"sha256:dc985cda89ecffbb9cf2988a493e041b9c4a8855d361eb1420360f6d0c6a8bc2","implementations/python/tests/test_participant_runtime_invariants.py":"sha256:cc3b51a5dbf834908f914d574fc855262c980c6c647f6ae1ea653d1f0fbfd0a7","implementations/python/tests/test_participant_semantics_invariant_oracle.py":"sha256:1eb956225228f1623cae17debc93e91f53e6248704e37edb2da8c78e6d6d04b3","implementations/python/tests/test_pipeline_determinism.py":"sha256:f5b749e12f6667648e01ceec49db34a5828700402874c1ee2e2390076548e357","implementations/python/tests/test_plan_inspection_cli.py":"sha256:34b4659813326543550e693814e87f43c1b4f4630c11ac8d6c74e4dcdf5aa43b","implementations/python/tests/test_plan_projection.py":"sha256:c82ad864d2992b4c0e4ca46e477c72b8ed8d7d92f0939632d4284641919bb056","implementations/python/tests/test_planned_resource_accessors.py":"sha256:fe84ff7a12e009492d5aae6e495f7742d75a08e9c13fe79466e86f93ec91a4b3","implementations/python/tests/test_pr_body_guard.py":"sha256:2a231ef1c9402c869634e982c4587a107abf7755a5c13276383478db0fd71197","implementations/python/tests/test_pr_body_policy_migration.py":"sha256:1f8ff45486e7cda4d30a8917f87a4e1d1cf7d95fc6232eb1f41f25a78e71759c","implementations/python/tests/test_pr_title_guard.py":"sha256:1ca328e6548afd19b3d68fb8b3da50121fd54a9b4fa6415c2fe62db336235cea","implementations/python/tests/test_processor_manifest.py":"sha256:d2ed5f43f855cf6a6bd81c4c5396ea8778034a8d4fd5b59cfa233cec5441936f","implementations/python/tests/test_project_positioning.py":"sha256:97ee9772c98a3e0ff648ed23b87041a6c7a6530f46f29658414781607618663c","implementations/python/tests/test_proposition_capabilities.py":"sha256:0591493fd7c46967b3daf721048339cefe51011b5152d35f85b512542296e32b","implementations/python/tests/test_proposition_semantics.py":"sha256:d636c36c5d3bfdfa29f71ba41e5b2aa342d3ae18658f958f375a8925f67412c4","implementations/python/tests/test_public_docs_policy.py":"sha256:a5ac9aeebaffdbc0377bbba38b9207f655f13d93deeb883bcc30089b59efdedb","implementations/python/tests/test_public_project_readiness.py":"sha256:692b77c4f632b971c5750bbf918d3e3f3cdac336dc57c568e29ec40786d45d06","implementations/python/tests/test_pytest_shard.py":"sha256:b04c1a8eda608ebcfc9a42d3539f184514cfd43d01ba3fc944df6f02229260a3","implementations/python/tests/test_random_stream_collisions.py":"sha256:26aac96abf68c56a7c6d7e067c496fec7a46da8230f7557b7823020e95fa1286","implementations/python/tests/test_random_stream_contracts.py":"sha256:cab380a5afd312a8b6b0825aff91036c06b93468d21fb149038df66ea053b088","implementations/python/tests/test_random_stream_determinism.py":"sha256:a015021392108dc67820775ef754507f0790d6212da7b20c322ffad92cb83d13","implementations/python/tests/test_random_stream_profile.py":"sha256:90f78e356800c85967472f6a79330f02c1fd801e19780b2d9e2d781cd9a0dcb5","implementations/python/tests/test_random_stream_run_integration.py":"sha256:fbb557a94a8fa4793aaa13a8b3a44edf16c2d40e9fa28f7af50a92225df71362","implementations/python/tests/test_random_stream_study_integration.py":"sha256:67c6da022c82d46e4c9faf5f400ad5e4df6a949e5f5607338786f2963108c960","implementations/python/tests/test_random_stream_vectors.py":"sha256:0f17a4ebcf2be0b7efd165d0940d9a84c1d55aca286152b8be992b476cd1b13e","implementations/python/tests/test_realization_envelope_contract.py":"sha256:bfb7652fd66e0f024a48b1d1f66312edf60f9952d4700673dfb90b6caf165a90","implementations/python/tests/test_realization_envelope_relation.py":"sha256:3cf26ce2e7be7351d0d70f87244e0c83f235ce0e679d31be97e3a1df4019415b","implementations/python/tests/test_realization_honesty_conformance.py":"sha256:b44c9ba690022f53a1a16952e986f553e63f5c98bc81c2a90c96db083c634ac7","implementations/python/tests/test_reconciliation_demonstration.py":"sha256:c171bd901b83c0457cff70f0aea2a0ad4cafd2681a1a4a42c32cce83be6f0a2b","implementations/python/tests/test_reference_field_pruning.py":"sha256:2d6734287603c6f886fe93d0eda1edb0484927c2f4cdfe70589becc632575971","implementations/python/tests/test_reference_models.py":"sha256:40496af20d4b69c4b3e186f7ac2caf4d5d00092720912b5a92170529179b3210","implementations/python/tests/test_reference_processor.py":"sha256:fe9b9a5a00ff1a20abf4fe75211f95d18f456b20dc250b6c74a519cdca09f95c","implementations/python/tests/test_related_work_comparison.py":"sha256:34cacc6011b3127717f58a3ecec6229c76351ecfb90403b021204a6fd4cb3338","implementations/python/tests/test_release_workflows.py":"sha256:150e90dd525588faa03465b5c325f25ead4b7140f1292c36f6b33348ebefcd71","implementations/python/tests/test_repeatability_validation.py":"sha256:e9fe3c3d5b2e6cfcca6da4e5f687e62fb03881c75edf60aae04ed450b0bfa1de","implementations/python/tests/test_repo_policy_tools.py":"sha256:76ff0a091bd156dd5bb37302e407a8ef5992ae592cab59c2f7f40990ddbd91b1","implementations/python/tests/test_requirement_governance.py":"sha256:2ddd9384f839ee05d04b50b62a30273ffc0776bdf0b7f2034d4c9a68825faf81","implementations/python/tests/test_research_capture.py":"sha256:24ec99daa91beffb8f462d6c400fc728f270db7cd2b25ff1e7c0f735db199267","implementations/python/tests/test_reusable_asset_trust_policy.py":"sha256:f7fe1e8f1d4e5507263e2ff5473f9ac511d771e80d292b3ad73e7fce5a1ebe6a","implementations/python/tests/test_run_300_lifecycle.py":"sha256:2b9f565703093aadd8dcb89fd0280e187217a533b40d7b5873f6bc0646e84596","implementations/python/tests/test_run_305_participant_runtime_state_history.py":"sha256:d1fb45658763ebec2471fa91783c4f9cf916f657f30316d54423f1dafb981ab1","implementations/python/tests/test_run_306_participant_decision_lifecycle.py":"sha256:41869b7241cb220a8887fe568aae19335f1527d4a0ebce8f58555615eabe45a2","implementations/python/tests/test_run_307_shared_operational_state.py":"sha256:d4338f9237b6ac3695cd247dd4370574f2eacc978f4043c7db681a32ef8d40d8","implementations/python/tests/test_run_308_concurrent_participant_execution.py":"sha256:eb00ed2fb534fd7e0514135e47094eb9f3eee1fcd1e679d330be58791199c50e","implementations/python/tests/test_run_310_supervisory_lifecycle.py":"sha256:1949e3a5245f431f39ea549af188d750b51a93e350614cfdef883435cb552def","implementations/python/tests/test_run_311_participant_episode_lifecycle.py":"sha256:e14a303a12efb54e6f5ae4dc205055ee43509f645dfe7479210c4997b05188cc","implementations/python/tests/test_run_319_participant_flow_policy.py":"sha256:afe6d161be2f8e6c7dc4154da91c4dd9e80f77728382105e4d86c9674de71afd","implementations/python/tests/test_runtime_app_authorization.py":"sha256:0983342d11fccf8be3e644e076367a176e4bc1e90e3f28d4fe716b1701b52437","implementations/python/tests/test_runtime_conformance.py":"sha256:7322ffccc37fd27a1554138545714a86f83c9ccead0a6b728c6a1fe82bb15fcc","implementations/python/tests/test_runtime_contract_boundaries.py":"sha256:09c983c5c4116c487a019a928abd91264f98705defb5a935b5ba952859ed31e0","implementations/python/tests/test_runtime_contracts.py":"sha256:c7b898ac228cfee66cd24d12c670f0b975e4f1c5a76bfc2d7535ba11632a23ec","implementations/python/tests/test_runtime_control_plane.py":"sha256:6ca13065425d2de1c3ea2ee1fd9a99326a498d48636c7ec4fe023be7e33700d4","implementations/python/tests/test_runtime_control_plane_api.py":"sha256:9d36766d981e11be0555f76fc8fcfb899dd5c33282906abb22dfdea3f29b523d","implementations/python/tests/test_runtime_datastore.py":"sha256:f71844847e1b37d4f6887eab2d6f1e36db3ec20806fe2cc1dfe278c222d67248","implementations/python/tests/test_runtime_fact_bindings.py":"sha256:4279ee83f329b9a432c568dae2db66bdd84c7ec4b4debdf7a30aeb07bc406e3b","implementations/python/tests/test_runtime_family_invariants.py":"sha256:e166373243eaa3480aeee407c65ebff17b6f3fbf31e4428257d4ce952d94f85e","implementations/python/tests/test_runtime_forwarding_agent.py":"sha256:f442f8c7d0cb29a93b39ea61e62508e530566b44cfcb4c13363dc3145f6ef006","implementations/python/tests/test_runtime_mail_service.py":"sha256:a367da57d94c078808d089d04fe8d7cabcf237fbb7153ad245ba5093995a48cc","implementations/python/tests/test_runtime_manager.py":"sha256:05d28dca237269a81543558db7c711c2693f57cb3d683749f41dfbb55a6829ae","implementations/python/tests/test_runtime_models.py":"sha256:8b6f1b987fb87aca8c5eaa276904dee76c947566c9a309002e555d32ee6d9437","implementations/python/tests/test_runtime_network_detection.py":"sha256:20ee13bbce2d61638337f9ef57bee5bd675824ec719dfa14b9122090b588f5c4","implementations/python/tests/test_runtime_network_sensor.py":"sha256:56dd5265be4a4f3e63df3eb6e2d30aebf7b6173d202a126f465edaab56ea8fa3","implementations/python/tests/test_runtime_observed_values.py":"sha256:21f0fe2dff4f90cdfd3a408377c9f8a4b614d62cf09d45ca31e5527490c5d10b","implementations/python/tests/test_runtime_orchestration.py":"sha256:d6ccb2366450dd4373832eb9a5d804d4aef29272ece59434800869216a4f58c0","implementations/python/tests/test_runtime_planner.py":"sha256:35b582fc4507501aace24c347e2d587785f373eb9440cd7d8b627faad4c27a2b","implementations/python/tests/test_runtime_platform_application.py":"sha256:7c039f10bb858d42ce1c5ad5ccb05c9fa3d89f375daec8d624c00318a1d8b10f","implementations/python/tests/test_runtime_proposition_truth.py":"sha256:8d80fcbcf3262debff6c51029349b488064a2fa1d67d2ac2b8661aa03ff5d2ca","implementations/python/tests/test_runtime_registry.py":"sha256:dd9249f188f9c2b862529b56d43e0382a9346b5cfe290456f03474a7dfe6717b","implementations/python/tests/test_runtime_result_envelope_properties.py":"sha256:860a57fe4b80eea0cab878c8eecfc006380f1647ba1ef6dc28d5d00182bf1b76","implementations/python/tests/test_runtime_scheduled_job.py":"sha256:2092b26b39a996683bd103d7ea58109786bee09582defd0bb2bb7329dc18a05d","implementations/python/tests/test_runtime_security_monitoring.py":"sha256:ec74b24f25da4cf29cc4033e2edc4d9d5d35fd1e89f712ee11b54a09707687e2","implementations/python/tests/test_runtime_service_listeners.py":"sha256:500b425c57455ef858d5c46534a9576fb029e3462e42a8602640a8aab0f4f93d","implementations/python/tests/test_runtime_service_units.py":"sha256:15b01cf686cb85cf52d8ba8422f8d56633175b3f1eb5352d640d56d120b2734d","implementations/python/tests/test_runtime_ssh_server.py":"sha256:9a71360e1bcf421628149d8e578b98fb18365c83202badb7f39f129e7aabe05d","implementations/python/tests/test_runtime_workflow_timeout_reconciliation.py":"sha256:16d2c4b0e0b7764243ac7f8f5a8af06d018760f4537727f25845ac988106cf96","implementations/python/tests/test_satisfiability_cli.py":"sha256:545122ceb074756c8f8afb0dd60b660c2f6b7a5064445f7c7a46b17a79ff8211","implementations/python/tests/test_sce_002_admitted_trial_plan.py":"sha256:cf83fbe4089b4026424f7b1925fc35fd6535576cfeccb875192b99d1f43e2bd4","implementations/python/tests/test_sce_002_selected_scenario.py":"sha256:142d6dc2993a58d99d7a1d5214a48412877fc9e82f631a3f9dda4ffe9c87477a","implementations/python/tests/test_sce_002_trial_compiler.py":"sha256:2b46cb18c1db2a5c87394212b779e1087a0fcca83e6f1f383ad73c0f69e0de0a","implementations/python/tests/test_sce_002_trial_realization.py":"sha256:c11fd6656ddae7f3a387ea2f567a9baaee9ff29352b9acc3081c28eb09193581","implementations/python/tests/test_sce_003_adaptive_difficulty.py":"sha256:2af7b7e5b6222c892ec092920f662665db7a8ea3dc938c3d26327f0c419994f4","implementations/python/tests/test_sce_004_goal_oriented_steps.py":"sha256:af13ec09e8fd1d9c0195e4658cd50de82f12768c72bab89b20c8cbde6f8910d5","implementations/python/tests/test_sce_006_batch_scheduler.py":"sha256:34268a94bf9e65e5560abdcf322c1794977738bf95d8bed78c338184bf7a3ef6","implementations/python/tests/test_sce_006_cleanup_contracts.py":"sha256:6ebb70071ad48f3489699fe4b80d664fe25fc67bf9dc3f5280536658c86c514e","implementations/python/tests/test_sce_006_requirement_governance.py":"sha256:cccb02b6dcd79b9e91c4350e7fded3ed805ca154ab3fb1d10c64079a50971c86","implementations/python/tests/test_scenario_family_admission.py":"sha256:99ef87829a0c650db3adfe1bf3aa1fe188f8ea68478665bf038056202bb531d3","implementations/python/tests/test_scenario_satisfiability.py":"sha256:0babf86085d291c1e15a5c5fa8a9337e34efe8d11b48397fbbb154e611e45a63","implementations/python/tests/test_scenarios.py":"sha256:b43dcecb6cf4e6437a23daf46bba9e72081d8110dddcc4d8dd42a1a1b1d13a98","implementations/python/tests/test_scientific_scenario_completeness.py":"sha256:44253130b9206666cf61356ace2a63c67652731fa155a6b5384377119c7d54a6","implementations/python/tests/test_sdl_canonicalization.py":"sha256:5215d04142186e1645f0ab01a8ae1e6ee36578c742a7f656cef85afaa54f141a","implementations/python/tests/test_sdl_catalog_parity.py":"sha256:65961762c4afdf91b6e1344e5bded0c1fa92ec19fa5cf32135623dec4db938b2","implementations/python/tests/test_sdl_diagnostic_boundary.py":"sha256:4336f9bffc10de89443e5c39074c6a9a6864c35138601074a8a353fcd7e2372a","implementations/python/tests/test_sdl_format_cli.py":"sha256:d7af6a5e65032605c99c064e6fe20e814063a17a17eb5b3ea127dd02d0941d6c","implementations/python/tests/test_sdl_fuzz.py":"sha256:c7b1acd662f9a54564799fac02ff68c0384f109bfb363ea324058e842e043964","implementations/python/tests/test_sdl_identifiers.py":"sha256:2d2913dd5804a8b7c2a24f3747324b4ed2843bb9c52bbfac5c6b02340b1f7ee9","implementations/python/tests/test_sdl_lineage.py":"sha256:b750634055607ed328237683cc048b7a8b5b383ec1ebad429e8330bf0b547079","implementations/python/tests/test_sdl_models.py":"sha256:f7a0cc22ca7475bce3550d6878365824cb477c08c6703f2db555ca76507f7179","implementations/python/tests/test_sdl_module_registry.py":"sha256:4a625887d7dbcfb92675e31a5172e5e20cbf90a9585dafc2d1f09019a84363e8","implementations/python/tests/test_sdl_parser.py":"sha256:75bf52ef5db373ea10e81174492c1c7de0de40241a47ac0eec88c5093f1f26d8","implementations/python/tests/test_sdl_phase_contracts.py":"sha256:e30fa0a053e59e3b4248af11339afff31c1d43cbcb22b5e641e642bd4869a588","implementations/python/tests/test_sdl_realworld.py":"sha256:d24a007aa6e376189aaebac66cee6138c9b7cd15c93d3464a8601d57e7d6f1b8","implementations/python/tests/test_sdl_source_format.py":"sha256:f822fe4a126184f06549f6447543cc45d40113cbd0e5bf6b5a752ae41ff68992","implementations/python/tests/test_sdl_stress.py":"sha256:0af58a67f5df4c09a904d4b3fad948ce0f18096d1f337b28ca80ff5e0e683226","implementations/python/tests/test_sdl_validator.py":"sha256:c6f943091d60deae08dc6a2127646bad3f6260c36cff88727118268e7dbaf928","implementations/python/tests/test_sdl_variation_points.py":"sha256:96fe857020d9f0ec52cd0bd22a7c0f2d5f3a828893791725df282eb2b48e73ee","implementations/python/tests/test_sem_208_participant_behavior.py":"sha256:d0b1ffc9cce338b05cadd2bff1825fad384c8d8303c0c59800747186697248ab","implementations/python/tests/test_sem_211_participant_action_semantics.py":"sha256:9bb89077253662631024d391c052822a0369daa3c25543825b26b1b0ab532eef","implementations/python/tests/test_sem_212_participant_attribution_semantics.py":"sha256:63d40599cf949c9012b86bb0f8790f2bea0f38d1dd029fd2acb5179f7857cd60","implementations/python/tests/test_sem_213_temporal_participant_semantics.py":"sha256:1bb12a115055a3a046109ed408fe855bdb7ea9854b3194f243e8b4859b4d87c9","implementations/python/tests/test_sem_215_participant_outcome_interpretation.py":"sha256:513a53bed7821201a781d92220087b34fb2cd3e3583df0514d444da20fc4312f","implementations/python/tests/test_sem_216_boundary_semantics.py":"sha256:55d06cbc1618915541ba5fcf3dec8c578ac0884771586003a0617f5a61088435","implementations/python/tests/test_sem_217_knowledge_bindings.py":"sha256:97319747dca8579cfd94c65188eebb2ab4b6c3f6a3cb36c06f6146cea566b90d","implementations/python/tests/test_sem_218_explicitness.py":"sha256:b2d06f1c2a37882129dd3e711d69453ba35fac7854d423d8f59799fea8f7491b","implementations/python/tests/test_sem_218_realization.py":"sha256:d09f97aabede7044e19f99e8da3af97273d10bd40de31bd8a979fadb81f244fb","implementations/python/tests/test_sem_218_realization_designation.py":"sha256:4225f99c82a5f597917fa4871d92581e968bf1ebb08388a77e063631edfd4cc7","implementations/python/tests/test_sem_218_runtime_realization.py":"sha256:6b40b6e11627fde70aa53bb17c4958ea0f462b2106b26d843f3933cbf1ffff78","implementations/python/tests/test_sem_220_participant_decision_surface.py":"sha256:ed0c1b8cf35f714eef96a85ca53a5d04cbeb775f29101faed33865e8b350d981","implementations/python/tests/test_sem_220_participant_decision_surface_v2.py":"sha256:f8920aef93c2279f08137668bdbd2b7d0392a3a8584f8609b0183af1d9504546","implementations/python/tests/test_sem_220_participant_decision_surface_v2_runtime.py":"sha256:caa14b4bcd0bfc4ce186f57508027ca804627a1abe45d28dd48d9ffb9006765c","implementations/python/tests/test_sem_222_episode_termination_oracle.py":"sha256:afe8ab759c3b2da1cf7a84b48a235b2ad630135dc009c1e27811e2adc76ff8b6","implementations/python/tests/test_sem_222_episode_termination_semantics.py":"sha256:6080f3067c70b22898e2fe0bb7cf52d0364d63d2a82421e8cc103c5d00656758","implementations/python/tests/test_sem_224_observability_plane_semantics.py":"sha256:19a49b28bbc176ee80fb570e41bb9593c73053a551ccbfddb1b2c9a925eac538","implementations/python/tests/test_sem_225_augmentation_semantics.py":"sha256:3e3be0d848d6c0bbec95415b5c3ef8fba6a0696e1102c9a05e21f8b110cb806b","implementations/python/tests/test_sem_226_participant_exposure.py":"sha256:55de25d5aa38f7d4e7d77ee40a1c8e92e938bd2fc7354d55026884b07f2b0f97","implementations/python/tests/test_sem_227_shared_time_model.py":"sha256:6e72ad5fc8c3d3b2e442988b1cc1340e7609cf468f8d3c0ed03cb7c058bcf10d","implementations/python/tests/test_sem_230_information_flow_control.py":"sha256:79f288d7357d8f1e1f56b709b7274a072a4826c8c56f099d8738e64ac364fd57","implementations/python/tests/test_sem_231_participant_predicate_opacity.py":"sha256:a307980f6200b68e253bd3a75ecf93c6e7f7450cbda4a72f6473fb4dc9000968","implementations/python/tests/test_sem_233_adversarial_boundary_flow.py":"sha256:e119dde15899adf6c55f2293156f2b0dc7c29c3620de7ea20ef1d28bb5a557c8","implementations/python/tests/test_sem_233_flow_control_contracts.py":"sha256:d51729722c738173e247bdf515745336f09d73554b2a8aac15478641bd89a2c3","implementations/python/tests/test_sem_234_governance.py":"sha256:238896acce4253abb2ca44954a458cb472f5b000b452fa1ac0cb7a1f5636865c","implementations/python/tests/test_sem_234_mixed_composition.py":"sha256:05a136a066688490d9ba65c8bef4f34fcd3f2ec440b0876968fcfa15f453e727","implementations/python/tests/test_sem_235_governance.py":"sha256:0c78f7126003a49e69be43deca4a24e013f7bd58d5517d0fbfe2d84db8187beb","implementations/python/tests/test_sem_235_modular_control.py":"sha256:08a6cc446b29abb48f74d16b473b02cd5d4dc81d881ec369f8bd1632b5f533cc","implementations/python/tests/test_semantic_cli.py":"sha256:0773de582b308459f040552e0a009faa436f95d31068f535b67714a624cb979f","implementations/python/tests/test_semantic_comparison.py":"sha256:1ee720041e9ecb91b42291d536b08a6388d2b1de655a686ee3ccbbc070126173","implementations/python/tests/test_semantic_coverage.py":"sha256:d677c4e59d05e24f4e8bc22a5b6c59665e93183bc6da6bfdb11450f6e7aed2db","implementations/python/tests/test_semantic_profiles.py":"sha256:6408e898527aae2321929a70e4c3aa334307133f1f8f63107eb75002e6fc2814","implementations/python/tests/test_semantic_projection_reports.py":"sha256:1bfd9f388de4bf98cb0aec00f831d7adde35b004805a0a5118d75eda98c6038b","implementations/python/tests/test_semantics_assessment.py":"sha256:659cf59288d6b25b85c1a18d0ed65770d3aecdf8540b87e505f3a55335079281","implementations/python/tests/test_semantics_objectives.py":"sha256:38269a2c1d70e9717c2ece9df54191d9c06cb7d7ba7383a6f02a968ee7dad5e3","implementations/python/tests/test_semantics_planner.py":"sha256:f996948cede7b6d77940903ff14b6bf70f6531201ecff53eee994f41b8678903","implementations/python/tests/test_specification_coverage.py":"sha256:feb48928b321653055cc48a5baf0e52b91537677134338d9ed7bca432e403925","implementations/python/tests/test_specification_coverage_units.py":"sha256:ace0cd966e35500e3c50df3cf7ab63d8764ec8dad2ef09e43a65b3da3b756655","implementations/python/tests/test_stateful_realization_resources.py":"sha256:9b89211c068619e39a219adf09529352689e9bcfee55320646a0377a8e4732fd","implementations/python/tests/test_stub_backend_components.py":"sha256:c689a855bf8340b16d81a2bc57973c965994f8fb4d9bd1a48ee59bb2b75889c3","implementations/python/tests/test_stub_backend_provenance.py":"sha256:ce7d8efbe1d7878d6bd3f56d01d0a86e975942ad227408313811b1353e5ce045","implementations/python/tests/test_tooling_artifact_policy.py":"sha256:9c2e452f4d5006f2f7c627d14ed0b3f08085c845eb350d2ead6cf812722aebba","implementations/python/tests/test_truth_result_contracts.py":"sha256:c83bed9af0d958960b99d0e13b90faa570693e67ab4be9b05b7d868e034b025d","implementations/python/tests/test_uco_alignment.py":"sha256:df0f42d09e8a7a8dd57dbf1aabc8055ace8699dff1a1abcdb58016b24571c5d6","implementations/python/tests/test_vale_tool.py":"sha256:d22a0262ab32dafe298ba3fa52a06f448b1d1282fe7502e9e2bab171d3cf07e3","implementations/python/tests/test_validation_disclosure.py":"sha256:e96ec147ddbc40ed0671e3f34e5cf1aecf6b510b5e046bb492c76ece94233b89","implementations/python/tests/test_validation_profiles.py":"sha256:a2e9d7f5f861ab25a574324b1dc177d22ea20d04ba3c8a97a1cc145521accf4a","implementations/python/tests/test_verification_plan.py":"sha256:7e2c9b09a6dfee3a1191942305885ce463fbcb91db80bb793a49a91bc2261eb8","implementations/python/tests/test_version_classification.py":"sha256:8d9d2f8fed21d7333f167a667eb2493f81c23d9b49ad3a5b32a2a12ac1a524bc","implementations/python/tests/test_workflow_semantics_properties.py":"sha256:9da7068e88822fee9ee194d047f76d2e1ad484ecea3dc1510bb8b91bf0a13212","implementations/python/tests/test_yaml_mapping_keys.py":"sha256:a688a244470a1c2d3b708b4c910f441e0dfd82dc16dec2ae454079e96febd0ff","implementations/python/tests/tool_profile_support.py":"sha256:957f2cbe9a141103fd50a65fcd679e727fd194a5367494d636cc2d6093f9dd0f","implementations/python/uv.lock":"sha256:33230932a79ac6486c8072e6ca3c2eb64bb88536bdb44c7e2cad1814c2fcc464","specs/formal/participant-semantics/participant-crossing-runtime-mapping.md":"sha256:b8ef06ecda03b9e005cda93c93f87536b2965fd3e88ec893242ccd17175cfb55","tools/bootstrap_profile.py":"sha256:efb9df143c1b778883ca99f9af25157c84c673e03bf5a1fd594c276ab9f8a9ff","tools/check_adr_immutability.py":"sha256:cf0a420a00e8718ebb2cad3237b8be0f4cee25d55a156ebf8dca83f500a25722","tools/check_agent_guidance.py":"sha256:02a2f4f6b505e8f0da6ca70919b93a579a88cc02b9b2db1f2da3be607060645c","tools/check_assurance_policy.py":"sha256:dd719ea35f16b19f2572bd4fc1a84c534bece333977d2229b83dd61b104a58be","tools/check_atlas_tactic_vocabulary.py":"sha256:3b3e3ad12e0d719cb79e61ec6086560a27bb41b88cb0f3730e79da7f5f5b8a60","tools/check_attack_tactic_vocabulary.py":"sha256:866897d22d28b53ff646d20e6c9a8f3da4327e3700d01520908912b3ead9b397","tools/check_authority_boundary.py":"sha256:3c2f218a26f2d1bae0b64d9bebacd3f2a458cb45a90048253a687f5dc474ae32","tools/check_autonomous_behavior_vocabularies.py":"sha256:3471246d334944e70b9ccbfc69829577c3d114646b22b07db5e7bb4d1c4a367d","tools/check_behavioral_relation_claims.py":"sha256:0b6be76ced8dc3ce1e8c8da554a75c5dc3689d4b55073660165d9effe0680a48","tools/check_concept_authority_governance.py":"sha256:c993ffec218981d14beca7739f87ecf11e7430390bfd121c7bf245507ee85090","tools/check_contract_requirement_tracing.py":"sha256:bd9be70559e8d9654bef3d6210cccbabe8614d8973a05f9147547cc6a9d56631","tools/check_deprecation_lifecycle.py":"sha256:567c07c4d75d2f2f4b92e081b6a07009c64dc2f216879dbeb048b69fe27b8173","tools/check_dsl_language_evaluation.py":"sha256:6a7457934c07ca58a7829fef445fc7fd9c6f9765e55e7116ca38741f288051b5","tools/check_example_library.py":"sha256:a17dac1d38f56a342aed7952bfc70be896dccf6a99a1ab0f676616b7727bd77e","tools/check_formal_semantic_validation.py":"sha256:13cfa171bb74092119755c78ed96db6c377670f8b52b5864cb4c1fe0c8bba420","tools/check_generated_schemas.py":"sha256:f107b468bbe719422d70d8629213f826d637df7f567f0a36ed0b49250ef5b379","tools/check_identity_cutover.py":"sha256:6e52af38d62550fdb3d622082dc16ca92ac326dc8ad6d28853d8e383fda851bb","tools/check_json_artifacts.py":"sha256:aa4d458025cb05fc0839a2ad111b5946ebe0c459344dff10ff998e5283cb7c37","tools/check_nist_csf_defensive_vocabulary.py":"sha256:6e5c56f6d38946458ee877db25cb80835c1833bc52989dd9510716003304f7a4","tools/check_participant_opacity_proof.py":"sha256:f0120269f98f89de5a4263c3d3c779762a0cbac490a4003356359596372966af","tools/check_pr_body.py":"sha256:b65c484270ebcdcb9ddce580caf8ab073b68ddba7cfa3e839940d629353d39ef","tools/check_pr_title.py":"sha256:c8a91d20fc2e81f5f97756d1054483b4e4cf661ab435f7b8122eabf6e8d0d9bc","tools/check_project_positioning.py":"sha256:4a11dc87c322f5fea80fd22468a72aa42f5edd75fcb182a9b6bcc6a9cc081b77","tools/check_public_docs.py":"sha256:44959d899a348c72828d74a9b3b1315ac677979d821c7419f6ab99e303c83a9d","tools/check_related_work_comparison.py":"sha256:e9225e459ae2773620597d4c3ce2816636e57f7d6e81f524a7539dad54c95c37","tools/check_repo_policy.py":"sha256:269c70fe8255936947cd935c55cd7bd327aac09079062d04c1db26acb76da376","tools/check_requirement_governance.py":"sha256:daa849f47cea46197fb3b91437ce0767a8818360dc10fceb771f293f82034468","tools/check_schema_coverage.py":"sha256:bc761b938a24cc43c72374bd13676cf3530608b008f6c874d162e0c5134b3552","tools/check_schema_publication.py":"sha256:a81b1d9961b8b20d2cb1786ec41bf0e67cea98ec38dc7465fb7ec94c15967ae7","tools/check_scientific_scenario_completeness.py":"sha256:fa17a3fd898eda73f9b1ba9af45cd4a816a1dcd1dcea3e9f952fba686584833f","tools/check_sdl_catalog_parity.py":"sha256:b5833be01e40aeb21df61dc40c6ab72bd3a3b68d86c108d2dc8abd917b0bcf58","tools/check_sdl_lineage.py":"sha256:e9ce9c50af6e7a68f2c7e3cb8c22a39f8297092ebfecec9a214e65fc51183734","tools/check_semantic_coverage.py":"sha256:1438f777f0e37190847c508b1ae1a05f217cb0c9cd4290b72947c97dac73bbef","tools/check_specification_coverage.py":"sha256:1f1aba0cef2a82db82e2a543a0ed238b55ceb105fedf86d708b0304720822d84","tools/check_tooling_artifact_policy.py":"sha256:e2bcbdbb5aff762b7edd121d6c3a0251a5b85e995e2d4b2e8b0fc5da6445a08a","tools/ci_latency_report.py":"sha256:743acad6d0af94ac438c2591a3dddc00ff407eee4774cf26266db175007cafbe","tools/devcontainer_image.py":"sha256:e566087b7588e238215ec68e66ca129fa5e56ca2b544b6aa3685e52d1fb27b2f","tools/devcontainer_setup.py":"sha256:11a0a6a021571318ea864a8cd8a55b5a2fe0f78a30dffab5b5d5d6a82e836c30","tools/dsl_language_evaluation/__init__.py":"sha256:970628c76d9e009a5817770cfbe23a2eb9e6aaddfe8b970b5b71dd4c550000ee","tools/dsl_language_evaluation/_analysis.py":"sha256:e98ba82215050cc73ab812ea68e538e3f16dd089e35195178ee53da6f0b1a865","tools/dsl_language_evaluation/_claim_strata.py":"sha256:3f4d1ce3246e93994598e954ffe4d83bbd164dc4ae6e4a9184f09222c610f87f","tools/dsl_language_evaluation/_claims.py":"sha256:649e5e53854e061fb100a4df9d91fc1264c85b6da7455849f6c6ad9095e4d8ec","tools/dsl_language_evaluation/_keys.py":"sha256:4a3928fd9a1d05c46f0c94e4521b1e07d91a93b58cc173f6525c8c26ce79f5ba","tools/dsl_language_evaluation/_measures.py":"sha256:bcbb5ba4ef318fce458b29a5179f6f52fa0481f1ba2338bb336cc75823109534","tools/dsl_language_evaluation/_protocol.py":"sha256:a5f74263b2177676ed7fb59058ef6cd5335ef7796984a6b65d35740aa1269a82","tools/dsl_language_evaluation/_protocol_plans.py":"sha256:1bbcb341fde2fe49a157792e6d6944ae54e4219e0a00acd169a06331d9fbaefa","tools/dsl_language_evaluation/_shape.py":"sha256:074e7ead8946cbf0113cc229e3fdcc991656b1af21d74d787059fbe108a4eb53","tools/dsl_language_evaluation/_snapshot.py":"sha256:d4d640aff8df097d3d3c68f0d17529b0814c3e268eee7ed200c90ac93eb54b97","tools/dsl_language_evaluation/_snapshot_completion.py":"sha256:cc9f2f29b12172e799295e9ea0bb03ba467f3660ee8d65250bc78d05fda8c051","tools/dsl_language_evaluation/_snapshot_execution.py":"sha256:dacc81eb8cdde5a62b496d4f43e8cdd6f1977fc4f709772b073a9a3a7861c163","tools/evidence_bundle_index.py":"sha256:78adb0ac7d315ed6cfc2fe06a6a21ddb867bb2e35efc6556f62b73cce8a8e65b","tools/example_library_checks.py":"sha256:7e230231ef2cf3434a74a64666dbdd44672f275251777cfa4fa2f31b3538ceda","tools/formal_semantic_validation/__init__.py":"sha256:06398e9424002c5d8d9f537c138aafec02c57cc8cbe4d775d830f63d3c137649","tools/formal_semantic_validation/_analysis.py":"sha256:c36747b59c91edcfb99b3ae622b20155d96c9c9edfd7305314001efb60e1c46a","tools/formal_semantic_validation/_archival_invariants.py":"sha256:e70c27d16deda5a434c99f13f26a7e9b37ca13ce2fc1f4540bc07d6a2ecbb728","tools/formal_semantic_validation/_archival_shape.py":"sha256:2e50254977791441776bb09fe1fb702f1a300e060e4b739f09ebade29d7a0d17","tools/formal_semantic_validation/_baseline.py":"sha256:36400f7393592d1c7595a1f4f81c8b19e1c3045be10026a21872cddd34557e21","tools/formal_semantic_validation/_bundle.py":"sha256:ecabcae3dc480593b2bb923e2009808fc6ae6699c6b12b56e44a5b1180f4af57","tools/formal_semantic_validation/_claims.py":"sha256:6e07d986b63cb98b16790e4f500c72d112bf541cc4d853f3a2b9a719b761a914","tools/formal_semantic_validation/_corpus.py":"sha256:6f4b0b1873ae401ec6003942493eee131581c6b312d0fe023950abb6310e5202","tools/formal_semantic_validation/_loading.py":"sha256:161cb80363a1399f90d411057bc6817ec0ced4f7a0f6c69e72e7cd1207910c96","tools/formal_semantic_validation/_production.py":"sha256:9b2b3df15dfca8e71cc932a5694273a4c21f6ef0da33f8a982872a3e8f4586dd","tools/formal_semantic_validation/_protocol.py":"sha256:320ab194e2a5dfe74c10e7eaa587d96ecb933e312acf6befb8645c5fd008511a","tools/formal_semantic_validation/_release_revisions.py":"sha256:b6babc85c0c94633db185e89bbdc8fa951adf0f79da3c28ab7fdc50203aa1a5f","tools/formal_semantic_validation/_releases.py":"sha256:1c135a8dae4b9cea22aac7467bbae0c1d5504154f2e13bba53f5bb5e7b6f3c55","tools/formal_semantic_validation/_replay.py":"sha256:d4f6cbc9cbf9b6545e554db301fadde1524439e9399d72fbe2619ce899952400","tools/formal_semantic_validation/_retest.py":"sha256:456ba010cf09675057e7933d83c5079fc36055cf2c2dc5ec1a06ce921a1f0968","tools/formal_semantic_validation/_retest_header.py":"sha256:5fb97d7a7abd3b4bfc8602bcd2634d46724910c2963a12dffc88a8999cf59b3b","tools/formal_semantic_validation/_retest_participants.py":"sha256:9ea6e13ae1b36f01ff0984feb675af551ae5e9fcd1f35666e39a4268d1637a5b","tools/formal_semantic_validation/_satisfiability.py":"sha256:3585d65f6155b50a411e849d12bc318bbbb5eeb295b24f5be2334380b8912287","tools/formal_semantic_validation/_shape.py":"sha256:20ce8dfd436694340e50de7c90fb0a46ba851619afa72078694ac29279e4c31b","tools/formal_semantic_validation/_snapshot.py":"sha256:f0714533bacad45ff35986c303971a46fe3d95e06daa96f4ef55261785139adc","tools/formal_semantic_validation/_supplement_loading.py":"sha256:8656416230956b3bb3fdcd481bed32fd16258cb53a1299406f9d0dfa44cd6614","tools/formal_semantic_validation/_types.py":"sha256:9f40b7a307b7ffe03f571779143f530d3b06734a412d7101d3c5652b9004f784","tools/generate_contract_schemas.py":"sha256:aa291c544668609ed43243aaa6830ce89722f00c082c31c74deece924e7c1b25","tools/generate_python_closures.py":"sha256:87cf688642ca7086a8b45dc3a014b30af7c9cfd6c8a4d78fbed2eec6edd02420","tools/generate_python_closures_locks.py":"sha256:e209b6853969b80b617b939ba0a62759f7e944edef6d7b705d1a47ef1d2b3392","tools/gitleaks_tool.py":"sha256:b31023f81d55e6293da2a4ebfbf930c95e7cb4acd8acdecebbf939d1db010d8e","tools/isabelle_sandbox.py":"sha256:bb0babaaac2a3df6cfeef3918f751258bb32547b95842420e368d7fe4766fd50","tools/isabelle_tool.py":"sha256:be01495f6e58e325045c2a8cda358cf9b48d1f48f3bf708726c4e5e5a2bb2268","tools/maintained_client_acquisition.py":"sha256:0529ca32a87d33aeca570d659dec8d12d7f3227d38726077a39f344f7cbf2dc0","tools/nox_support/__init__.py":"sha256:fc85d4290b2f8822789a21197b5814d5e171f16c9c04aa6e356f650db1ec799a","tools/nox_support/compatibility_lanes.py":"sha256:1ae4ada04687b70b23f2a2e70394772f183cc2f618f0a95f0a9b7f4ce4030df6","tools/nox_support/config.py":"sha256:e9a8e343376d684b512804f82dc887f7041b27b5d7f001d3fc406e664136d815","tools/nox_support/graph.py":"sha256:0de15d1d40dcf9b747c5bd97d029be3e6329e6abc7b57e11ca8603a21b85472a","tools/nox_support/policy_lanes.py":"sha256:612f158a9330abdc6f3c40a6fa20b64322dc858ab037cd51d69dcbbcc95b9f89","tools/nox_support/runner.py":"sha256:e031e8b0a06810b7f0188a6adb32e525cdc170edbfecafdf4f036c70fe9f1c94","tools/nox_support/test_lanes.py":"sha256:f8bdd985e9d79c66bf05a0a62a6b32c8ddf754a0837cb2eb3e0cbce46e2d881b","tools/osv_scanner_tool.py":"sha256:d59c428ed0e868ed85f34a2480676e970778274da440325928fdff9120ce8aa5","tools/parallel_verification.py":"sha256:69228c6ac26a8a552a773281d9d5b35f59e56a036f431a4fb8c9eb1927599574","tools/policy/__init__.py":"sha256:9cf59cfb6332e2fddc42d003b61744893a2be0799ce85d17da30ec4511c973e2","tools/policy/adr.py":"sha256:55ec4e396dfe317ac60efbd866ae28030b751de3bd89ef8f0996249c23c935a6","tools/policy/adr_policy.yaml":"sha256:d19372e1a5075c48525dbeda27f0c25859c0ae773f61818f17e3fc5d67111979","tools/policy/common.py":"sha256:e5d78ddb5b1528892931e6cff798f842f422c932bac9cf707a656234b9e3460d","tools/policy/conftest_tool.py":"sha256:ca4920f7d08eb084a90b7704220a86adb75d98b36a1f0a20ccb363afb0516c16","tools/policy/exceptions.yaml":"sha256:e88c490df40d9f415c46a616b449e05e0478b611f5bc76e0a635577f85b6b918","tools/policy/historical_identity_records.json":"sha256:0dfa7a769d01bcfff48d5540cab1575024c5d1d9782c5195bd63c6ff86071890","tools/policy/oversized_allowlist.yaml":"sha256:c4a242bc85be5070dce7e202274f9d0e31dda5bf0941d3a8539b1a76dace0428","tools/policy/repo_policy.py":"sha256:f3b9918a9707392384ad80aa94888e1ed56fbe34e55cd414116491a582a93edc","tools/policy/repository_requirements.py":"sha256:28aeef404e57de4cf24418756df3787e8cc14aca7132c047fd17a2f48356b6e8","tools/policy/requirement_governance.py":"sha256:2f8b08269c147a4e3444baf4927c14ba5f40f0fd98d673a107881e23fbb4ceaa","tools/policy/requirement_order.yaml":"sha256:bf6521a1f02713af0a4424d9af292a65b32bbee738c101b503feac5de595e245","tools/policy/requirement_scope.py":"sha256:b5951a250137c6cb3b99f24adc29a3b32647b01fd35699ad859bb8df72035aef","tools/pr_body_issue_scope.py":"sha256:271afe45e06d3d99a245f586ca0f797eae36de9ede7a6a6ee547d34e939af9a3","tools/public_docs_guard.py":"sha256:68db58d0fa59dc57f633a32b176739a81217c1e231e7cc2953c690120ca9b73f","tools/public_docs_markup.py":"sha256:493db9303866ad2f1981042d847049d310a2e30afc862fc43a6ef23fdec92ffc","tools/pytest_shard.py":"sha256:6f4ea944c6c8ac4cc7493dd3fedd25cd3290f42985d1056b785bcfde0eb1956f","tools/pytest_shard_plugin.py":"sha256:56601755e7fd9fc433f7bc53521337019bdd0768b137dae144c1f9ea6eefb9e4","tools/python_closure.py":"sha256:fb90d96928c5aaa0044ae6cc88ba83ec76831ed34073eb4dd3693b4f47b94d7b","tools/python_closure_profiles.py":"sha256:ecc6c365f16d627ee92ea9db8eb02c8ea950d25bf4b8680c4c24b80f06f4d7cc","tools/python_closure_wheelhouse.py":"sha256:367054507608a78065b098c261236a63867f13537bd3d6bbbd72fb117c42bda0","tools/release_evidence.py":"sha256:8fe9c248961337f080e0515f58ae92f38eaffd22c0ea215b21342a8dd1278451","tools/release_evidence_admission.py":"sha256:06c2a57af16cc935fd0ea34376fd6a097443eb89adda94a6f568a41a4099ab1c","tools/release_evidence_documents.py":"sha256:e14621df98c028ab0994f2a29c2102aa90b5bdb870b070ab08308f75f9f1afe4","tools/release_evidence_publication.py":"sha256:6447cdc52beffae511358cf7cbe7c55fc5a8a4b33ff945e7970ad511e55f4f0a","tools/release_evidence_sbom.py":"sha256:19b27667db69512a5b737a60b63c163b5e90d41e5902e1ab86e159200d40eb91","tools/release_evidence_verifier.py":"sha256:ee00ac245b3321f0593de7e28d833ccff7d81fb4a36c305a060f9bbdf82bc96d","tools/release_evidence_workflows.py":"sha256:004b9005c6369ce405c09c8a0d462f9271a7b6e93b71800e13d86388e5cee029","tools/requirement_context.py":"sha256:3704e9cd4fff4b25a72cd34f2361b9db1efab636bb24eb9a7ebbd2e5e8b0b5dd","tools/research_capture.py":"sha256:f755e0c90de639b26c81bd86980cf9725869ba6d71bb6d7443859c57f2d55fe6","tools/research_evidence.py":"sha256:4a783177b279e8f4679058b235ae1f319607f65eaf01c1aff6e67cd60e98bc78","tools/schema_coverage/__init__.py":"sha256:1c0891b962304c468526889308191bc16de6ca483ffb7625569c24d26879ee73","tools/schema_coverage/_classify.py":"sha256:f7bede83e417c11b54515aeaad6604d3319ceb6dadb0245473890c3f5ae4e2e5","tools/schema_coverage/_declaration.py":"sha256:3bec29da68412c6799457225156cdb313d871af481145ee4c1dbf6d0c43a1c35","tools/schema_coverage/_evidence.py":"sha256:843245b9d45dd7f188cb2997db87108510dbd78b7a512f952dbe3c401772f033","tools/schema_coverage/_keys.py":"sha256:c20c841e2d78a55ca5c85fb2afeeb9eb2da2d31dd104982b2620dc7c96a11b8f","tools/sdl_catalog_parity/__init__.py":"sha256:3418682a7c243801ca1229c1d804f4a382c7cd636d1d01d257f9b92f34be3e4c","tools/sdl_catalog_parity/_checks.py":"sha256:7925b4cd2556bc1f2861ab538716047b6e5d90a6ea0b778d6019fd6169031b23","tools/sdl_catalog_parity/_expectations_1.py":"sha256:9e38dcd32f9ce329cd359340549544644b1b1f8059bd623f0661a7cd210ba4e3","tools/sdl_catalog_parity/_expectations_2.py":"sha256:b758e05bf20ac96b2d91ad551daf96d49c48d21ad2e88f1d3829867c42bc3d71","tools/sdl_catalog_parity/_expectations_3.py":"sha256:da6a007ac1ed2aecf12bd06eb3ce956ff13a08d37701643a3ecaf8aa52b15e6b","tools/sdl_catalog_parity/_expectations_cloud.py":"sha256:31cf821d44ecc90b8188454787e7dbc80cc25caaaec3eaa1e6f0f299ceae945e","tools/sdl_catalog_parity/_expected.py":"sha256:2fc354025e73cadbcf81224fe7e70734bbfd9b99c01c3e8d153303e575c77ecd","tools/sdl_catalog_parity/_model_paths.py":"sha256:f592aef1675df1da4349841fbcaa9032f4ec7c3c009720c7348073836db55a65","tools/sdl_catalog_parity/_paths.py":"sha256:1dea743f74dd6dfe66eee5a2abb9f3b3db4d36fe4127ab916cc86805e72279fc","tools/sdl_catalog_parity/_prose_checks.py":"sha256:af384fad1662104504d97f144b660393aeae54f10fb5626dd1df38254fedfbc7","tools/sdl_catalog_parity/_registry.py":"sha256:92e65511a734ce90f2e56e8c9a17230465899530e08ca1eaedc415a43040bad0","tools/sdl_catalog_parity/_rows.py":"sha256:d41b6f5a781b026f8a6b68615440168c0bb5c87f14de12fb0892bce45a39c2d6","tools/specification_coverage/__init__.py":"sha256:3d24b219b805c06dabefd46a30a2fcb792b7769b395b36428a4e5f92519ca4de","tools/specification_coverage/_analysis.py":"sha256:d52f8b03ea3652775f870d05103e5338b8eaa3a68db1a4127bace4dd1545b611","tools/specification_coverage/_artifacts.py":"sha256:d0b05ea3db6cb03884a974090af6b2b3d3d8d1d03036ded27877eca44d2b87dd","tools/specification_coverage/_baseline.py":"sha256:3afd005e3df0abd93c748125a6a063011bff0f4c466446a1b0a5221b648e77a2","tools/specification_coverage/_keys.py":"sha256:6bdc7d4d631e59e7366360cb45905322ad61999ec31b6eb925857923af86b4cc","tools/specification_coverage/_primitives.py":"sha256:652d54ada29c7e3dc0e8af2e064c8009c4c25c8a15f905f117132e190a88b501","tools/specification_coverage/_protocol.py":"sha256:44e8023529692f025b27c5f27b43531e565c666f04a30e7dbfaeccc6c042c7ce","tools/specification_coverage/_protocol_concepts.py":"sha256:0441fcec9f47ada3a695abb7fc1700f3846a4063cec18506c424c6d653602d90","tools/specification_coverage/_snapshot.py":"sha256:3d212412b0fb2f5300d51701430b9a2331e4e2c9ab6d572dfdc0ac7f4bc8c9f9","tools/tool_versions.py":"sha256:8032c89f06b3e88df39a0bd96d33efb55fca7429718e1d6332cd65f3e1871434","tools/tooling_artifact_policy_actions.py":"sha256:51c55faafd116f2a3bfb20672bfad19631cbb124dcc5f1f238cce11143c81332","tools/tooling_artifact_policy_artifacts.py":"sha256:0ab9d4dbf33c213c4c7209ce348e596a3ed5522fde26481765f4d11899fd763b","tools/tooling_artifact_policy_common.py":"sha256:79fb332cc856fda1ae819a1b114523ae639d13411ef39ae881dc41964a5cb251","tools/tooling_artifact_policy_container.py":"sha256:b801d97686ee62b5a4eee8ee9795ddc829a05729db424e145a1fa6939776f5a0","tools/tooling_artifact_policy_devcontainer.py":"sha256:d1f46f7bc0f4721b7569ce2549b0d28e1f5f8f7fd769f9bf80a828f0d8b5d411","tools/tooling_artifact_policy_discovery.py":"sha256:af0795cddf93a66c8c0a4fe1ebb060023f5526bebf23a9c1a8817ce6065ca6c6","tools/tooling_artifact_policy_oci.py":"sha256:85d088582847860287b9df936461f61812771f024f75b11e2a0340843ff6220e","tools/tooling_artifact_policy_python.py":"sha256:277523052d85fca061e57e8999f0683a3bb5aee8c29fe61f0d6405ac458b404d","tools/tooling_artifact_policy_python_profiles.py":"sha256:262b91b803e60cd2c54e57b2d0935e35eab265b330609d5af1ab66efb82b9039","tools/tooling_artifact_policy_selectors.py":"sha256:b853b22e045ab5af118097b21e167270a5fc5a0783a6122886bb1cb7d64aad52","tools/tooling_artifact_selection.py":"sha256:55690f7813a605ccc9b3ff04b3f53cf46f6f21543454fb601600d9e6d352390c","tools/tooling_installed_tree.py":"sha256:84d272f07e970184ba65db7c4ffc2ebbdc4b381cb4a9ee5a1be373a40748a846","tools/tooling_oci_selection.py":"sha256:747eed256589e44b76e57636cb5ad77f4fd56ea767da46e654901aec0c583378","tools/tooling_policy_gate.py":"sha256:2a83148d01ad827a2ccdfed8243d0c4abb2b944f57112df12be7b5720d3ec034","tools/vale_tool.py":"sha256:0ce91bca524b6d56dfb8eca4a6de3600c0f65cfcbc21c1713a3df19f0b07d4d8","tools/verification_plan.py":"sha256:953d30ca9af569d24ea92445fbebaccc569837fe4fa1242e63ba760cd414d106","tools/verified_tool_installation.py":"sha256:3edbdd81087951d497f49d8dcb59ea859b13e40819e8492b329a7f5f5e668efe","tools/verified_tree_archive.py":"sha256:f806d12fb0053ee99c5f1fb86397c25a6eeca4b0d8492b1568f3949ad623acc2","tools/verified_tree_installation.py":"sha256:6b0b98830f65a7bdce132f1b3e920941950bbbcc44b25c876f6218fd4ac2484c","tools/verified_tree_manifest.py":"sha256:a2b512cceddfa9f2c3c3c70511a4f29cd709d8728bfbf13f207aa79b577b96d2","tools/verified_tree_validation.py":"sha256:19bacd3659ca0d1b709cf7c1f11510b6048f7116958670a2ec4e9715666bbdcb"},"source_exclusions":{"contracts/schema-publication/tombstones":"Historical schema removals are not live runtime-mapping inputs."},"taxonomy":"raes-behavioral-relations@rev8"} From 5123059998d657cb28bbabe6b6f6d606a54579fc Mon Sep 17 00:00:00 2001 From: Brad Edwards Date: Tue, 10 Nov 2026 20:13:04 -0700 Subject: [PATCH 11/11] Fix current repository policy checks for PR 1480 --- .../packages/raes/module_registry/__init__.py | 45 ++++++++++++++++--- .../{_registry_auth.py => registry_auth.py} | 44 +++++++++--------- .../raes/module_registry/resolution.py | 12 ++--- .../test_issue_1479_oci_anonymous_token.py | 16 +++---- 4 files changed, 76 insertions(+), 41 deletions(-) rename implementations/python/packages/raes/module_registry/{_registry_auth.py => registry_auth.py} (88%) diff --git a/implementations/python/packages/raes/module_registry/__init__.py b/implementations/python/packages/raes/module_registry/__init__.py index f89f59c3c6..ccb258a27e 100644 --- a/implementations/python/packages/raes/module_registry/__init__.py +++ b/implementations/python/packages/raes/module_registry/__init__.py @@ -18,12 +18,13 @@ import time import zlib from dataclasses import dataclass +from functools import partial from http.client import HTTPException from pathlib import Path, PurePosixPath from typing import Any, Protocol # Registry requests resolve ``urlopen`` through this facade, the transport patch seam. -from urllib.request import urlopen +from urllib.request import Request, urlopen from raes_contracts.digests import sha256_digest from raes_contracts.errors import OperationalError @@ -90,7 +91,6 @@ _same_file_identity, _write_version_pointer, ) -from ._registry_auth import _registry_get, _RegistryTokens from ._verified_sources import _cache_source_result, _VerifiedSourceBundle from .models import ( Lockfile, @@ -104,6 +104,7 @@ write_lockfile, ) from .publishing import publish_module_to_oci_layout +from .registry_auth import RegistryTokens, registry_get, request_anonymous_token from .resolution import resolve_import, resolve_lock_records from .signing import _signable_payload, _verify_signatures @@ -160,16 +161,41 @@ def _read_capped(response: _CappableResponse, *, url: str, max_bytes: int) -> by return data +def registry_tokens() -> RegistryTokens: + """Create a request-scoped token cache using the facade's current bounded transport.""" + return RegistryTokens( + partial( + request_anonymous_token, + timeout_seconds=_OCI_LIMITS.timeout_seconds, + max_metadata_bytes=_OCI_LIMITS.max_metadata_bytes, + read_capped=_read_capped, + decode_json_object=_decode_json_object, + ) + ) + + +def _open_registry_request(request: Request, url: str, max_bytes: int) -> bytes: + with urlopen(request, timeout=_OCI_LIMITS.timeout_seconds) as response: + return _read_capped(response, url=url, max_bytes=max_bytes) + + def _json_request( url: str, *, headers: dict[str, str] | None = None, max_bytes: int | None = None, - tokens: _RegistryTokens | None = None, + tokens: RegistryTokens | None = None, ) -> dict[str, Any]: limit = _OCI_LIMITS.max_metadata_bytes if max_bytes is None else max_bytes failure = f"Failed to fetch OCI metadata from {url}" - payload = _registry_get(url, headers=headers, max_bytes=limit, tokens=tokens, failure=failure) + payload = registry_get( + url, + headers=headers, + max_bytes=limit, + tokens=registry_tokens() if tokens is None else tokens, + open_capped=_open_registry_request, + failure=failure, + ) return _decode_json_object(payload, context=f"OCI metadata from {url}") @@ -190,11 +216,18 @@ def _bytes_request( *, headers: dict[str, str] | None = None, max_bytes: int | None = None, - tokens: _RegistryTokens | None = None, + tokens: RegistryTokens | None = None, ) -> bytes: limit = _OCI_LIMITS.max_metadata_bytes if max_bytes is None else max_bytes failure = f"Failed to fetch OCI blob from {url}" - return _registry_get(url, headers=headers, max_bytes=limit, tokens=tokens, failure=failure) + return registry_get( + url, + headers=headers, + max_bytes=limit, + tokens=registry_tokens() if tokens is None else tokens, + open_capped=_open_registry_request, + failure=failure, + ) def _oci_cache_dir(base_dir: Path) -> Path: diff --git a/implementations/python/packages/raes/module_registry/_registry_auth.py b/implementations/python/packages/raes/module_registry/registry_auth.py similarity index 88% rename from implementations/python/packages/raes/module_registry/_registry_auth.py rename to implementations/python/packages/raes/module_registry/registry_auth.py index f80868124b..799e2bd1b1 100644 --- a/implementations/python/packages/raes/module_registry/_registry_auth.py +++ b/implementations/python/packages/raes/module_registry/registry_auth.py @@ -16,9 +16,11 @@ from __future__ import annotations import re +from collections.abc import Callable from contextlib import closing from dataclasses import dataclass, field from http.client import HTTPException +from typing import Any from urllib.error import HTTPError from urllib.parse import urlencode, urlsplit, urlunsplit from urllib.request import ( @@ -164,11 +166,17 @@ def _challenge_for(error: HTTPError, request: Request) -> _BearerChallenge | Non return challenge -def _anonymous_token(challenge: _BearerChallenge, *, url: str) -> str: +def request_anonymous_token( + challenge: _BearerChallenge, + url: str, + *, + timeout_seconds: float, + max_metadata_bytes: int, + read_capped: Callable[..., bytes], + decode_json_object: Callable[..., dict[str, Any]], +) -> str: """Request an anonymous token from the challenge realm over HTTPS, following no redirect.""" - from . import _OCI_LIMITS, _decode_json_object, _read_capped - token_url = challenge.token_url() # No HTTP, redirect, FTP, file or data handler: the validated HTTPS realm is the only hop. opener = OpenerDirector() @@ -176,12 +184,12 @@ def _anonymous_token(challenge: _BearerChallenge, *, url: str) -> str: opener.add_handler(handler) request = Request(token_url, headers={"Accept": "application/json"}) # noqa: S310 - validated https realm try: - with opener.open(request, timeout=_OCI_LIMITS.timeout_seconds) as response: + with opener.open(request, timeout=timeout_seconds) as response: # Messages name the requested URL only, never the challenge-derived token URL. - payload = _read_capped(response, url=url, max_bytes=_OCI_LIMITS.max_metadata_bytes) + payload = read_capped(response, url=url, max_bytes=max_metadata_bytes) except (OSError, HTTPException) as exc: raise OperationalError(f"Failed to obtain an anonymous OCI registry token for {url}") from exc - document = _decode_json_object(payload, context=f"OCI registry token response for {url}") + document = decode_json_object(payload, context=f"OCI registry token response for {url}") token = document.get("token") or document.get("access_token") if not isinstance(token, str) or _B64TOKEN.fullmatch(token) is None: raise SDLParseError(f"OCI registry token response for {url} carries no usable bearer token") @@ -189,49 +197,43 @@ def _anonymous_token(challenge: _BearerChallenge, *, url: str) -> str: @dataclass -class _RegistryTokens: +class RegistryTokens: """Anonymous tokens for one import resolution, keyed by realm, service and scope.""" + load_token: Callable[[_BearerChallenge, str], str] _tokens: dict[_BearerChallenge, str] = field(default_factory=dict) def token_for(self, challenge: _BearerChallenge, *, url: str) -> str: if challenge not in self._tokens: - self._tokens[challenge] = _anonymous_token(challenge, url=url) + self._tokens[challenge] = self.load_token(challenge, url) return self._tokens[challenge] -def _open_capped(request: Request, *, url: str, max_bytes: int) -> bytes: - # ``urlopen`` and the limits resolve through the package facade, so its seams apply (issue #48). - from . import _OCI_LIMITS, _read_capped, urlopen - - with urlopen(request, timeout=_OCI_LIMITS.timeout_seconds) as response: - return _read_capped(response, url=url, max_bytes=max_bytes) - - -def _registry_get( +def registry_get( url: str, *, headers: dict[str, str] | None, max_bytes: int, - tokens: _RegistryTokens | None, + tokens: RegistryTokens, + open_capped: Callable[[Request, str, int], bytes], failure: str, ) -> bytes: """GET ``url`` anonymously; answer one Bearer challenge with one token-bearing retry.""" request = Request(url, headers=dict(headers or {})) # noqa: S310 - trust-policy registry URL try: - return _open_capped(request, url=url, max_bytes=max_bytes) + return open_capped(request, url, max_bytes) except HTTPError as exc: challenge = _challenge_for(exc, request) if challenge is None: raise OperationalError(failure) from exc except (OSError, HTTPException) as exc: raise OperationalError(failure) from exc - token = (_RegistryTokens() if tokens is None else tokens).token_for(challenge, url=url) + token = tokens.token_for(challenge, url=url) retry = Request(url, headers=dict(headers or {})) # noqa: S310 - trust-policy registry URL # Unredirected: urllib copies only ``Request.headers`` into a redirected request. retry.add_unredirected_header("Authorization", f"Bearer {token}") try: - return _open_capped(retry, url=url, max_bytes=max_bytes) + return open_capped(retry, url, max_bytes) except (OSError, HTTPException) as exc: raise OperationalError(failure) from exc diff --git a/implementations/python/packages/raes/module_registry/resolution.py b/implementations/python/packages/raes/module_registry/resolution.py index cbc1c5e9fa..37c5095f58 100644 --- a/implementations/python/packages/raes/module_registry/resolution.py +++ b/implementations/python/packages/raes/module_registry/resolution.py @@ -17,10 +17,10 @@ from ..scenario import ImportDecl, ModuleDescriptor, Scenario from ._constants import LOCKFILE_NAME, OCI_BUNDLE_MEDIA_TYPE, OCI_LAYOUT_MEDIA_TYPE from ._digests import _descriptor_digest, _satisfies_version, _select_tag -from ._registry_auth import _RegistryTokens from ._supplied_admission import require_import_pin, require_lock_record from ._verified_sources import _local_resolved_source, _VerifiedSourceBundle from .models import Lockfile, LockRecord, ResolvedModule, TrustPolicy, _scenario_module_descriptor, load_trust_policy +from .registry_auth import RegistryTokens if TYPE_CHECKING: from ..parser import SDLSourceDocument @@ -333,7 +333,7 @@ def _resolve_oci_manifest( import_decl: ImportDecl, locked: LockRecord | None, source: str, - tokens: _RegistryTokens | None = None, + tokens: RegistryTokens | None = None, ) -> tuple[str, dict[str, Any]]: from . import _bytes_request, _decode_json_object, _json_request @@ -361,7 +361,7 @@ def _resolve_oci_manifest( def _resolve_oci_config( - *, base_url: str, repository: str, manifest: dict[str, Any], source: str, tokens: _RegistryTokens | None = None + *, base_url: str, repository: str, manifest: dict[str, Any], source: str, tokens: RegistryTokens | None = None ) -> tuple[dict[str, Any], str]: from . import _bytes_request, _decode_json_object @@ -397,7 +397,7 @@ def _resolve_oci_config( def _fetch_oci_bundle( - *, base_url: str, repository: str, layer_digest: str, source: str, tokens: _RegistryTokens | None = None + *, base_url: str, repository: str, layer_digest: str, source: str, tokens: RegistryTokens | None = None ) -> bytes: from . import _OCI_LIMITS, _bytes_request @@ -455,7 +455,7 @@ def _resolve_oci_import( trust_policy: TrustPolicy, source_options: SDLSourceParseOptions, ) -> ResolvedModule: - from . import _extract_bundle_to_cache, _verify_signatures + from . import _extract_bundle_to_cache, _verify_signatures, registry_tokens registry, repository = _parse_oci_source(source) registry_policy = trust_policy.registries.get(registry) @@ -465,7 +465,7 @@ def _resolve_oci_import( ) base_url = _registry_base_url(registry, allow_insecure_http=registry_policy.allow_insecure_http) locked = _lock_record_for(lockfile, import_decl) - tokens = _RegistryTokens() + tokens = registry_tokens() manifest_digest, manifest = _resolve_oci_manifest( base_url=base_url, repository=repository, import_decl=import_decl, locked=locked, source=source, tokens=tokens ) diff --git a/implementations/python/tests/test_issue_1479_oci_anonymous_token.py b/implementations/python/tests/test_issue_1479_oci_anonymous_token.py index 261fd626e2..9f0ea3038a 100644 --- a/implementations/python/tests/test_issue_1479_oci_anonymous_token.py +++ b/implementations/python/tests/test_issue_1479_oci_anonymous_token.py @@ -611,13 +611,13 @@ def test_tokens_are_cached_per_challenge_for_one_resolution( token_server = serve(_fixed_route(_json({"token": token})), tls=https) registry = serve(_registry_route(layout, token=token, challenges=[_challenge(token_server)])) url = _url(registry, "tags/list") - tokens = module_registry._registry_auth._RegistryTokens() + tokens = module_registry.registry_tokens() module_registry._json_request(url, tokens=tokens) module_registry._bytes_request(url, tokens=tokens) assert len(token_server.seen) == 1 - other_scope = module_registry._registry_auth._parse_bearer_challenge( + other_scope = module_registry.registry_auth._parse_bearer_challenge( _challenge(token_server, scope="repository:acme/other:pull") ) assert tokens.token_for(other_scope, url=url) == token @@ -655,9 +655,9 @@ def test_tokens_are_cached_per_challenge_for_one_resolution( def test_bearer_challenge_grammar_accepts_rfc_9110_parameters( header: str, expected: tuple[str, str | None, str | None] ) -> None: - challenge = module_registry._registry_auth._parse_bearer_challenge(header) + challenge = module_registry.registry_auth._parse_bearer_challenge(header) - assert challenge == module_registry._registry_auth._BearerChallenge(*expected) + assert challenge == module_registry.registry_auth._BearerChallenge(*expected) @pytest.mark.parametrize( @@ -681,7 +681,7 @@ def test_bearer_challenge_grammar_accepts_rfc_9110_parameters( ) def test_bearer_challenge_grammar_rejects_malformed_challenges(header: str) -> None: with pytest.raises(ValueError, match="malformed Bearer challenge"): - module_registry._registry_auth._parse_bearer_challenge(header) + module_registry.registry_auth._parse_bearer_challenge(header) @pytest.mark.parametrize( @@ -706,11 +706,11 @@ def test_bearer_challenge_grammar_rejects_malformed_challenges(header: str) -> N ], ) def test_token_realm_must_be_an_absolute_https_url(realm: str, accepted: bool) -> None: - assert module_registry._registry_auth._is_https_url(realm) is accepted + assert module_registry.registry_auth._is_https_url(realm) is accepted def test_token_url_carries_the_service_and_each_scope_entry() -> None: - challenge = module_registry._registry_auth._BearerChallenge( + challenge = module_registry.registry_auth._BearerChallenge( realm="https://auth.test/token?account=reader", service="registry.test", scope="repository:acme/shared:pull repository:acme/other:pull", @@ -720,6 +720,6 @@ def test_token_url_carries_the_service_and_each_scope_entry() -> None: "https://auth.test/token?account=reader&service=registry.test" "&scope=repository%3Aacme%2Fshared%3Apull&scope=repository%3Aacme%2Fother%3Apull" ) - assert module_registry._registry_auth._BearerChallenge("https://auth.test/token", None, None).token_url() == ( + assert module_registry.registry_auth._BearerChallenge("https://auth.test/token", None, None).token_url() == ( "https://auth.test/token" )