From 6f21d07ed2096021d6d101f463cdf7f1510c041f Mon Sep 17 00:00:00 2001 From: abrichr Date: Tue, 18 Aug 2026 14:37:19 -0400 Subject: [PATCH 1/4] Add strict production acceptance verifier --- .github/workflows/evidence-freshness.yml | 13 +- docs/eval_results/PRODUCTION_READINESS.md | 105 + scripts/check_published_evidence_freshness.py | 251 +- scripts/import_production_acceptance.py | 2089 ++++++++ .../live-certificate.json | 133 + .../qualification-admission-trust.json | 11 + .../qualification-admission.json | 111 + .../qualification-campaign.json | 4772 +++++++++++++++++ tests/test_import_production_acceptance.py | 1379 +++++ tests/test_published_evidence_freshness.py | 128 +- 10 files changed, 8956 insertions(+), 36 deletions(-) create mode 100644 scripts/import_production_acceptance.py create mode 100644 tests/fixtures/production_acceptance/live-certificate.json create mode 100644 tests/fixtures/production_acceptance/qualification-admission-trust.json create mode 100644 tests/fixtures/production_acceptance/qualification-admission.json create mode 100644 tests/fixtures/production_acceptance/qualification-campaign.json create mode 100644 tests/test_import_production_acceptance.py diff --git a/.github/workflows/evidence-freshness.yml b/.github/workflows/evidence-freshness.yml index 3b03d0f..75f4052 100644 --- a/.github/workflows/evidence-freshness.yml +++ b/.github/workflows/evidence-freshness.yml @@ -12,6 +12,7 @@ on: paths: - 'docs/eval_results/**' - 'scripts/check_published_evidence_freshness.py' + - 'scripts/import_production_acceptance.py' - '.github/workflows/evidence-freshness.yml' concurrency: @@ -35,4 +36,14 @@ jobs: # Standard library only: no dependency install, no lockfile, no cache. - name: Check published evidence against the current published release - run: python scripts/check_published_evidence_freshness.py + env: + APPROVED_CLOUD_ACCEPTANCE_COMMIT: ${{ vars.APPROVED_CLOUD_ACCEPTANCE_COMMIT }} + QUALIFICATION_ADMISSION_SIGNERS_JSON: ${{ vars.QUALIFICATION_ADMISSION_SIGNERS_JSON }} + REVOKED_QUALIFICATION_ADMISSION_IDS_JSON: ${{ vars.REVOKED_QUALIFICATION_ADMISSION_IDS_JSON }} + REVOKED_QUALIFICATION_SIGNER_KEY_IDS_JSON: ${{ vars.REVOKED_QUALIFICATION_SIGNER_KEY_IDS_JSON }} + run: >- + python scripts/check_published_evidence_freshness.py + --approved-cloud-source-commit "$APPROVED_CLOUD_ACCEPTANCE_COMMIT" + --trusted-admission-signers-json "$QUALIFICATION_ADMISSION_SIGNERS_JSON" + --revoked-admission-ids-json "$REVOKED_QUALIFICATION_ADMISSION_IDS_JSON" + --revoked-admission-signer-key-ids-json "$REVOKED_QUALIFICATION_SIGNER_KEY_IDS_JSON" diff --git a/docs/eval_results/PRODUCTION_READINESS.md b/docs/eval_results/PRODUCTION_READINESS.md index a7567be..b46eefe 100644 --- a/docs/eval_results/PRODUCTION_READINESS.md +++ b/docs/eval_results/PRODUCTION_READINESS.md @@ -10,6 +10,111 @@ evidence set matches the current published `openadapt-flow` release. It does not mean the campaign is production acceptance. The evidence manifest records that distinction in `campaigns[].evidence_scope.production_acceptance`. +That campaign field is now descriptive only and must remain `false`. A person +cannot promote an evidence set by changing it, changing an evidence class, or +adding summary counts. Production acceptance can enter this repository only +through `scripts/import_production_acceptance.py` after the private-export gate +opens. + +## Independent hosted-acceptance verifier + +The verifier mechanism is implemented. The private-evidence import is not +enabled. `import_files` refuses every file import until OpenAdapt approves one +exact private-export contract. Do not export an admission or campaign to this +repository. Do not set `production_acceptance: true` while this gate is closed. +The checked-in fixtures are synthetic test vectors only. + +The future approval must bind the complete payload schema and digest, the +destination account, service, container, and prefix, the encryption-key +identity, the immutable retention mode and period, the authorized importer +workflow and ref, and the approval authority. A broad enable flag or approval +of only the admission and campaign digests is not sufficient. + +After approval, the importer will compose four evidence inputs: + +1. The closed `openadapt.execute-live-acceptance-record/v1` certificate from + the protected Cloud production workflow. +2. The signed `openadapt.qualification-admission/v1` envelope from the + protected qualification authority. +3. The full `openadapt.qualification-campaign/v1` artifact with every retained + trial row and normalized evidence receipt for the exact qualification + contract. +4. The GitHub artifact-attestation bundle for the certificate bytes. + +The future importer also needs external control inputs: the approved Cloud +source commit, the approved qualification signer registry, the admission and +signer revocation lists, and the exact private-export approval. The evidence +artifacts cannot select these values. The full admission and campaign stay in +the encrypted retained evidence package until that approval exists. After +approval, a protected job can stage only the approved payload for +verification. The derived public result contains hashes and bounded counts. It +does not contain tenant or workflow identifiers. + +The verifier asks GitHub CLI to verify the certificate against the exact +`OpenAdaptAI/openadapt-cloud` workflow on `refs/heads/main`, the GitHub Actions +OIDC issuer, and a GitHub-hosted runner. It then validates the verified SLSA +provenance. It refuses an unknown repository, workflow, ref, source digest, +issuer, runner class, signature, or empty verification result. + +The expected Cloud commit is an external reviewer input. The importer requires +the certificate commit, the GitHub signing-certificate source commit, and the +SLSA resolved `gitCommit` to equal that value. It also requires the signing +certificate and the SLSA source dependency to use `refs/heads/main`. The +certificate cannot select its own approved commit. + +The evidence manifest does not store or select this approval. The repository +checker reads it from the protected `APPROVED_CLOUD_ACCEPTANCE_COMMIT` GitHub +repository variable. A production declaration fails when that variable is +absent or differs from the certificate and verified provenance. + +The certificate is necessary but not sufficient. It proves one authenticated, +qualified browser transaction and binds the private request, idempotent +responses, runner delivery, result, report, receipt, target attestation, +single-use runner permit, independent observer, webhook, billing outcome, and +separate signing identities by digest. The importer also verifies the external +qualification admission. It checks the exact issuer workflow and main-branch +commit, the Ed25519 signature, the derived key ID, the active time window, and +the external admission and key revocation lists. It refuses a trust key that +the imported evidence supplies for itself. + +The admission signs canonical hashes for the full campaign, qualification +contract, outcomes projection, oracle, and exact task inventory. The campaign +must retain every condition in the bound qualification contract and at least +three unique trials for each condition. Trial indexes are one-based and +contiguous. Attempt IDs and run IDs cannot repeat. An excluded or hidden trial +causes refusal. + +Each trial refers to hash-keyed Ed25519 envelopes for the runner, independent +observer, webhook, replay, cleanup, and cleanup-absence result. Fault cases +also require a signed fault receipt. The importer verifies each envelope body, +signature, authority key, source digest, task, condition, trial index, attempt, +run, workflow version, bundle artifact, runtime validation, verdict, and time. +A digest with no signed body is not evidence. An unused envelope is hidden +evidence and causes refusal. + +The importer classifies the verified rows itself. It rejects a count-only +claim, declared production class or boolean, unsupported failure class, +vacuous invariant, healthy-path contract that permits a model call, silent +incorrect success, over-halt, wrong-record effect, duplicate effect, +collateral effect, uncertain delivery, platform failure, or operator +intervention. + +When the private-export gate opens, the output claim will be only +`qualified_browser_workflow_on_bound_environment`. It is not a general product +production-readiness claim. The checker can accept `production_acceptance: true` +only when the evidence manifest contains digest-bound links to all four inputs +and the exact derived output, the protected workflow supplies the external +trust, revocation, and export-approval controls, and the importer reproduces +that output. Until then, the importer refuses. A bare registry boolean or +campaign label fails the check. + +Cloud does not issue a complete acceptance record before it verifies durable +retention. The private evidence envelope uses encrypted immutable storage with +Object Lock and KMS. The public record retains only opaque digests and the +verified retention facts. The importer verifies the public retention receipt +and its exact binding to the candidate and retained envelope. GitHub artifact +retention alone does not satisfy this contract. + ## What the current public Evals set establishes The Flow 1.31.0 set contains four campaigns. Every condition has three trials. diff --git a/scripts/check_published_evidence_freshness.py b/scripts/check_published_evidence_freshness.py index 2de3544..6e03890 100644 --- a/scripts/check_published_evidence_freshness.py +++ b/scripts/check_published_evidence_freshness.py @@ -19,11 +19,15 @@ 5. Every ``superseded`` set names the set that replaced it. 6. Its verifier, result, replication, public-report, task/oracle, campaign, browser, and installed-dependency inventories are complete and exact. -7. Every campaign states whether it is production acceptance, and the checker - derives silent-incorrect-success and over-halt coverage from the retained - result instead of accepting an unsupported maturity label. - -Checks 1, 2 and 5-7 are offline and always run. Checks 3 and 4 need PyPI: pass +7. A campaign cannot declare production acceptance through a class, boolean, + or summary count. The checker accepts that state only from the independent + certificate/admission/campaign importer. +8. A production import is digest-bound, GitHub-attestation verified, signed by + an externally trusted qualification authority, contains at least three + retained trials per qualification condition, verifies every normalized + evidence receipt, and derives the failure taxonomy from those trial rows. + +Checks 1, 2 and 5-8 are offline and always run. Checks 3 and 4 need PyPI: pass ``--current-version``/``--current-wheel-sha256`` to supply the release out-of-band, or ``--offline`` to skip them. A network failure is reported and skipped rather than failing the build -- it is not evidence of drift. Actual @@ -34,6 +38,7 @@ import argparse import hashlib +import importlib.util import json import sys import urllib.error @@ -44,6 +49,14 @@ REPO_ROOT = Path(__file__).resolve().parents[1] DEFAULT_MANIFEST = REPO_ROOT / "docs" / "eval_results" / "PUBLISHED_EVIDENCE.json" PYPI_URL = "https://pypi.org/pypi/{package}/json" +PRODUCTION_IMPORTER = Path(__file__).resolve().with_name("import_production_acceptance.py") +PRODUCTION_SPEC = importlib.util.spec_from_file_location( + "_production_acceptance_importer", + PRODUCTION_IMPORTER, +) +assert PRODUCTION_SPEC is not None and PRODUCTION_SPEC.loader is not None +PRODUCTION = importlib.util.module_from_spec(PRODUCTION_SPEC) +PRODUCTION_SPEC.loader.exec_module(PRODUCTION) class DriftError(Exception): @@ -142,6 +155,119 @@ def _relative_file(repo_root: Path, relative: object) -> tuple[Path | None, str return path, path.relative_to(repo_root).as_posix() +def _production_import_file( + value: object, + label: str, + repo_root: Path, +) -> tuple[Path | None, str | None, list[str]]: + """Validate one digest-bound file link in a production import.""" + + if not isinstance(value, dict) or set(value) != {"path", "sha256"}: + return None, None, [f"production acceptance {label} link must contain path and sha256"] + path, normalized = _relative_file(repo_root, value.get("path")) + if path is None or normalized is None: + return None, None, [f"production acceptance {label} path is missing or unsafe"] + if value.get("sha256") != _sha256(path): + return None, None, [f"production acceptance {label} digest changed"] + return path, normalized, [] + + +def _check_production_acceptance_import( + entry: dict[str, Any], + binding: dict[str, Any], + repo_root: Path, + bound_artifacts: set[str], + approved_cloud_source_commit: str | None, + trusted_admission_signers: dict[str, Any], + revoked_admission_ids: set[str], + revoked_admission_signer_key_ids: set[str], +) -> list[str]: + """Derive production acceptance; never accept a registry or campaign flag.""" + + prefix = f"{entry['path']}: " + declared = entry.get("production_acceptance") + if not isinstance(declared, bool): + return [prefix + "PUBLISHED_EVIDENCE production_acceptance must be boolean"] + imported = binding.get("production_acceptance_import") + if not declared: + if imported is not None: + return [prefix + "production acceptance import exists but the registry is false"] + return [] + if not isinstance(imported, dict) or set(imported) != { + "certificate", + "campaign", + "qualification_admission", + "attestation_bundle", + "derived_result", + }: + return [ + prefix + + "production acceptance requires a verified certificate/campaign import; " + "a declared boolean is not evidence" + ] + + paths: dict[str, Path] = {} + normalized_paths: set[str] = set() + problems: list[str] = [] + if ( + not isinstance(approved_cloud_source_commit, str) + or len(approved_cloud_source_commit) != 40 + or any( + character not in "0123456789abcdef" + for character in approved_cloud_source_commit + ) + ): + problems.append( + prefix + + "an exact externally approved Cloud source commit is required" + ) + for label in ( + "certificate", + "campaign", + "qualification_admission", + "attestation_bundle", + "derived_result", + ): + value = imported[label] + path, normalized, link_problems = _production_import_file(value, label, repo_root) + problems.extend(prefix + problem for problem in link_problems) + if path is not None and normalized is not None: + paths[label] = path + normalized_paths.add(normalized) + if problems: + return problems + if not normalized_paths.issubset(bound_artifacts): + return [prefix + "production acceptance import files are outside the artifact inventory"] + if len(normalized_paths) != 5: + return [prefix + "production acceptance import files must be distinct"] + try: + derived = PRODUCTION.import_files( + paths["certificate"], + paths["campaign"], + paths["qualification_admission"], + paths["attestation_bundle"], + approved_cloud_source_commit, + trusted_admission_signers=trusted_admission_signers, + revoked_admission_ids=revoked_admission_ids, + revoked_admission_signer_key_ids=revoked_admission_signer_key_ids, + ) + retained = load_manifest(paths["derived_result"]) + except (PRODUCTION.AcceptanceError, OSError, json.JSONDecodeError) as exc: + return [prefix + f"production acceptance import was refused: {exc}"] + if retained != derived: + problems.append(prefix + "retained production acceptance result is not independently derived") + bindings = derived.get("bindings", {}) + if bindings.get("flow_version") != entry.get("flow_version"): + problems.append(prefix + "production acceptance Flow version differs from the registry") + if bindings.get("flow_release_commit") != entry.get("flow_source_commit"): + problems.append(prefix + "production acceptance Flow commit differs from the registry") + if bindings.get("flow_wheel_sha256") != f"sha256:{entry.get('wheel_sha256')}": + problems.append(prefix + "production acceptance Flow wheel differs from the registry") + if derived.get("claim_scope") != PRODUCTION.CLAIM_SCOPE: + problems.append(prefix + "production acceptance claim scope is not supported") + return problems + + def _validated_bindings( binding: dict[str, Any], key: str, @@ -277,7 +403,14 @@ def _check_task_standard(document: dict[str, Any], campaign_name: object) -> lis return problems -def check_evidence_manifest(entry: dict[str, Any], repo_root: Path) -> list[str]: +def check_evidence_manifest( + entry: dict[str, Any], + repo_root: Path, + approved_cloud_source_commit: str | None = None, + trusted_admission_signers: dict[str, Any] | None = None, + revoked_admission_ids: set[str] | None = None, + revoked_admission_signer_key_ids: set[str] | None = None, +) -> list[str]: """Verify the current result set is still the exact measurement set.""" problems: list[str] = [] @@ -338,7 +471,6 @@ def check_evidence_manifest(entry: dict[str, Any], repo_root: Path) -> list[str] ) campaigns = binding.get("campaigns") - production_acceptance_values: list[bool] = [] seen_results: set[str] = set() if not isinstance(campaigns, list) or not campaigns: problems.append(prefix + "campaigns must be a non-empty list") @@ -480,21 +612,11 @@ def check_evidence_manifest(entry: dict[str, Any], repo_root: Path) -> list[str] problems.append( prefix + f"campaign production acceptance is not boolean: {name!r}" ) - elif production_acceptance and set(metric_coverage.values()) != {"counted"}: + elif production_acceptance: problems.append( prefix - + f"campaign claims production acceptance without required reliability metrics: {name!r}" + + f"campaign production acceptance cannot be declared; use the verified importer: {name!r}" ) - elif production_acceptance and evidence_scope.get("class") not in { - "customer_environment", - "production", - }: - problems.append( - prefix - + f"campaign claims production acceptance from a synthetic or fixture class: {name!r}" - ) - else: - production_acceptance_values.append(production_acceptance) result_artifacts = { path for path in bound_artifacts @@ -506,15 +628,6 @@ def check_evidence_manifest(entry: dict[str, Any], repo_root: Path) -> list[str] + "campaign results inventory differs from retained results: " + f"missing={sorted(result_artifacts - seen_results)}, extra={sorted(seen_results - result_artifacts)}" ) - entry_production_acceptance = entry.get("production_acceptance") - if not isinstance(entry_production_acceptance, bool): - problems.append(prefix + "PUBLISHED_EVIDENCE production_acceptance must be boolean") - elif entry_production_acceptance != ( - bool(production_acceptance_values) and all(production_acceptance_values) - ): - problems.append( - prefix + "PUBLISHED_EVIDENCE production_acceptance disagrees with campaign scopes" - ) contracts = binding.get("task_contracts") if not isinstance(contracts, list) or not contracts: problems.append(f"{entry['path']}: task_contracts are missing") @@ -550,6 +663,18 @@ def check_evidence_manifest(entry: dict[str, Any], repo_root: Path) -> list[str] + "task contract inventory differs from campaign results: " + f"missing={sorted(seen_results - seen_contracts)}, extra={sorted(seen_contracts - seen_results)}" ) + problems.extend( + _check_production_acceptance_import( + entry, + binding, + repo_root, + bound_artifacts, + approved_cloud_source_commit, + trusted_admission_signers or {}, + revoked_admission_ids or set(), + revoked_admission_signer_key_ids or set(), + ) + ) return problems @@ -592,6 +717,34 @@ def fetch_current_release(package: str, timeout: float = 20.0) -> tuple[str, Opt return version, wheel_sha +def _external_json_object(value: str | None, label: str) -> dict[str, Any]: + if not value: + return {} + try: + parsed = json.loads(value) + except json.JSONDecodeError as exc: + raise DriftError(f"{label} is not valid JSON") from exc + if not isinstance(parsed, dict): + raise DriftError(f"{label} must be a JSON object") + return parsed + + +def _external_json_string_set(value: str | None, label: str) -> set[str]: + if not value: + return set() + try: + parsed = json.loads(value) + except json.JSONDecodeError as exc: + raise DriftError(f"{label} is not valid JSON") from exc + if ( + not isinstance(parsed, list) + or not all(isinstance(item, str) and item for item in parsed) + or len(parsed) != len(set(parsed)) + ): + raise DriftError(f"{label} must be a unique JSON string list") + return set(parsed) + + def main(argv: list[str] | None = None) -> int: parser = argparse.ArgumentParser( description="Fail when published evidence drifts from the current published engine release." @@ -611,6 +764,25 @@ def main(argv: list[str] | None = None) -> int: "--current-wheel-sha256", help="Supply the current published wheel digest instead of querying PyPI.", ) + parser.add_argument( + "--approved-cloud-source-commit", + help=( + "Externally reviewed Cloud commit. Required when the current evidence " + "declares production acceptance." + ), + ) + parser.add_argument( + "--trusted-admission-signers-json", + help="External JSON trust registry for approved qualification admission signers.", + ) + parser.add_argument( + "--revoked-admission-ids-json", + help="External JSON list of revoked qualification admission IDs.", + ) + parser.add_argument( + "--revoked-admission-signer-key-ids-json", + help="External JSON list of revoked qualification signer key IDs.", + ) args = parser.parse_args(argv) manifest = load_manifest(args.manifest) @@ -618,13 +790,34 @@ def main(argv: list[str] | None = None) -> int: problems: list[str] = [] try: entry = current_entry(manifest) + trusted_admission_signers = _external_json_object( + args.trusted_admission_signers_json, + "qualification signer trust registry", + ) + revoked_admission_ids = _external_json_string_set( + args.revoked_admission_ids_json, + "qualification admission revocations", + ) + revoked_admission_signer_key_ids = _external_json_string_set( + args.revoked_admission_signer_key_ids_json, + "qualification signer revocations", + ) except DriftError as exc: print(f"DRIFT: {exc}", file=sys.stderr) return 1 problems.extend(check_superseded_links(manifest)) problems.extend(check_entry_matches_artifact(entry, args.repo_root)) - problems.extend(check_evidence_manifest(entry, args.repo_root)) + problems.extend( + check_evidence_manifest( + entry, + args.repo_root, + args.approved_cloud_source_commit, + trusted_admission_signers, + revoked_admission_ids, + revoked_admission_signer_key_ids, + ) + ) release_version = args.current_version release_wheel = args.current_wheel_sha256 diff --git a/scripts/import_production_acceptance.py b/scripts/import_production_acceptance.py new file mode 100644 index 0000000..6ff17a7 --- /dev/null +++ b/scripts/import_production_acceptance.py @@ -0,0 +1,2089 @@ +#!/usr/bin/env python3 +"""Derive one bounded production-acceptance result from signed evidence. + +The Cloud certificate proves one live authenticated transaction. An external +qualification authority signs an admission for the full sanitized campaign. +The campaign retains every trial and a signed normalized receipt for each +runner, observer, webhook, replay, fault, cleanup, and cleanup-absence claim. +This importer verifies all signatures and binds all artifacts by canonical +SHA-256 before it derives counts from complete trial rows. + +It never promotes an author-supplied maturity class, production boolean, +summary count, or trial classification. The only successful output is scoped +to the exact qualified browser workflow and environment in the certificate. +""" + +from __future__ import annotations + +import argparse +import base64 +import binascii +import hashlib +import json +import re +import subprocess +import sys +import tempfile +import uuid +from collections import Counter +from datetime import datetime, timedelta, timezone +from pathlib import Path +from typing import Any, Callable, Mapping, Sequence + +CERTIFICATE_SCHEMA = "openadapt.execute-live-acceptance-record/v1" +CAMPAIGN_SCHEMA = "openadapt.qualification-campaign/v1" +RESULT_SCHEMA = "openadapt.evals-derived-production-acceptance/v1" +CLAIM_SCOPE = "qualified_browser_workflow_on_bound_environment" +ADMISSION_SCHEMA = "openadapt.qualification-admission/v1" +ADMISSION_SIGNATURE_DOMAIN = b"openadapt-qualification-admission-v1\0" +RECEIPT_SCHEMA = "openadapt.qualification-evidence-receipt/v1" +RECEIPT_SIGNATURE_DOMAIN_TEXT = "openadapt-qualification-evidence-receipt-v1\\0" +RECEIPT_SIGNATURE_DOMAIN = b"openadapt-qualification-evidence-receipt-v1\0" +ADMISSION_ISSUER_WORKFLOW = ( + "OpenAdaptAI/openadapt-internal/.github/workflows/" + "production-qualification-admission.yml" +) +ADMISSION_REF_PREFIX = "refs/heads/main@" + +CLOUD_REPOSITORY = "OpenAdaptAI/openadapt-cloud" +CLOUD_WORKFLOW = ".github/workflows/execute-live-acceptance.yml" +CLOUD_CERTIFICATE_IDENTITY = ( + "https://github.com/OpenAdaptAI/openadapt-cloud/" + ".github/workflows/execute-live-acceptance.yml@refs/heads/main" +) +GITHUB_OIDC_ISSUER = "https://token.actions.githubusercontent.com" + +_HEX_40 = re.compile(r"^[a-f0-9]{40}$") +_SHA256 = re.compile(r"^sha256:[a-f0-9]{64}$") +_SEMVER = re.compile(r"^[0-9]+\.[0-9]+\.[0-9]+(?:[-+][0-9A-Za-z.-]+)?$") +_POSITIVE_DECIMAL = re.compile(r"^[1-9][0-9]*$") +_UNPREFIXED_SHA256 = re.compile(r"^[a-f0-9]{64}$") +_ADMISSION_REF = re.compile(r"^refs/heads/main@[a-f0-9]{40}$") +_ADMISSION_KEY_ID = re.compile(r"^qa-ed25519-[a-f0-9]{16}$") +_RECEIPT_KEY_ID = re.compile(r"^qe-ed25519-[a-f0-9]{16}$") +_WHOLE_SECOND_UTC = re.compile( + r"^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}Z$" +) + +_CERTIFICATE_KEYS = { + "schema_version", + "verdict", + "claim_scope", + "product", + "qualification", + "transaction", + "outcomes", + "contracts", + "identities", + "retention", +} +_PRODUCT_KEYS = {"cloud", "flow", "managed_runtime"} +_CLOUD_KEYS = {"source_commit", "target_build_sha256"} +_FLOW_KEYS = {"version", "release_commit", "wheel_sha256"} +_RUNTIME_KEYS = { + "manifest_sha256", + "runner_build", + "playwright_version", + "browser_base_image", +} +_QUALIFICATION_KEYS = { + "qualification_admission_sha256", + "campaign_artifact_sha256", + "campaign_contract_sha256", + "campaign_outcomes_sha256", + "oracle_contract_sha256", + "task_count", + "condition_count", + "required_trial_count", + "observed_trial_count", + "minimum_trials_per_condition", + "admission_signer", + "runtime_validation_id_sha256", + "admission_id_sha256", + "workflow_version_id_sha256", + "workflow_digest", + "environment_digest", +} +_ADMISSION_SIGNER_KEYS = { + "algorithm", + "key_id", + "issuer_workflow", + "issuer_ref", +} +_TRANSACTION_KEYS = { + "acceptance_envelope_sha256", + "accepted_response_sha256", + "duplicate_response_sha256", + "receipt_sha256", + "receipt_evidence_digest", + "target_attestation_sha256", + "observer_evidence_sha256", + "webhook_event_sha256", + "runner_transaction_identity_sha256", + "runner_report_sha256", + "runner_result_sha256", + "runner_permit_sha256", + "acceptance_challenge_sha256", + "execution_id_sha256", + "receipt_id_sha256", + "idempotency_key_sha256", + "request_sha256", +} +_OUTCOME_KEYS = { + "transaction", + "independent_effect", + "webhook_delivery", + "entitlement_and_metering", +} +_CONTRACT_KEYS = { + "exact_source_attested", + "authenticated_submission", + "qualification_bound", + "idempotency_verified", + "independent_effect_verified", + "single_delivery_verified", + "single_permit_consumption_verified", + "entitlement_and_metering_verified", + "receipt_contract_verified", + "target_attestation_signature_verified", + "observer_evidence_signature_verified", + "runner_transaction_identity_verified", + "runner_signature_verified", + "signed_webhook_verified", + "zero_model_healthy_path", + "quiet_period_stable", +} +_IDENTITY_KEYS = { + "signer_fingerprint_scheme", + "producer", + "target_observer_signer_sha256", + "target_attestation_signer_sha256", + "managed_runner_signer_sha256", + "organization_id_sha256", + "workflow_id_sha256", + "verifier", +} +_PRODUCER_KEYS = { + "kind", + "repository", + "workflow", + "source_ref", + "run_id", + "run_attempt", +} +_VERIFIER_KEYS = { + "kind", + "repository", + "workflow", + "certificate_identity", + "oidc_issuer", + "hosted_runner_required", +} +_RETENTION_KEYS = { + "receipt_id", + "ciphertext_sha256", + "candidate_sha256", + "private_envelope_sha256", + "store_attestation_sha256", + "storage_identity_sha256", + "object_version_sha256", + "private_locator_version_sha256", + "kms_key_identity_sha256", + "uploader_identity_sha256", + "retention_mode", + "retention_until", + "retained_at", + "upload_verified", + "head_verified", + "object_lock_verified", + "private_locator_recorded", + "acceptance_verified_at", + "provenance_attestation", +} + +_CAMPAIGN_KEYS = { + "schema_version", + "campaign_id", + "qualification_contract", + "oracle_contract", + "authority_contract", + "conditions", + "invariants", + "excluded_trials", + "receipt_envelopes", + "decision", + "generated_at", +} +_CONDITION_KEYS = { + "condition_id", + "expected_runtime_outcome", + "required_trials", + "trials", +} +_TRIAL_KEYS = { + "schema_version", + "task", + "condition", + "trial_index", + "attempt_id_sha256", + "run_id_sha256", + "workflow_version_id", + "bundle_artifact_sha256", + "runtime_validation_id", + "started_at", + "completed_at", + "execution_outcome", + "oracle_verdict", + "failure_class", + "runner_receipt_sha256", + "observer_receipt_sha256", + "webhook_receipt_sha256", + "replay_report_sha256", + "fault_receipt_sha256", + "cleanup_receipt_sha256", + "cleanup_absence_proof_sha256", +} +_INVARIANT_KEYS = {"id", "holds", "observations", "violations"} +_ORACLE_KEYS = { + "schema_version", + "runtime_outcome_source", + "effect_outcome_source", + "delivery_outcome_source", + "attempt_accounting", + "fault_evidence_source", + "cleanup_evidence_source", +} + +_RECEIPT_TYPES = ( + "runner", + "observer", + "webhook", + "replay", + "fault", + "cleanup", + "cleanup_absence", +) +_AUTHORITY_KEYS = { + "algorithm", + "key_id", + "public_key", + "signature_domain", + "schema_version", +} +_RECEIPT_ENVELOPE_KEYS = { + "schema_version", + "receipt_type", + "issuer_key_id", + "algorithm", + "source_artifact_sha256", + "verified_projection", + "verified_at", + "signature", +} +_RECEIPT_SIGNED_KEYS = _RECEIPT_ENVELOPE_KEYS - {"signature"} +_RECEIPT_PROJECTION_KEYS = { + "campaign_id", + "task", + "condition", + "trial_index", + "attempt_id_sha256", + "run_id_sha256", + "workflow_version_id", + "bundle_artifact_sha256", + "runtime_validation_id", + "verdict", + "evidence_sha256", +} +_RECEIPT_ROW_FIELDS = { + "runner": "runner_receipt_sha256", + "observer": "observer_receipt_sha256", + "webhook": "webhook_receipt_sha256", + "replay": "replay_report_sha256", + "fault": "fault_receipt_sha256", + "cleanup": "cleanup_receipt_sha256", + "cleanup_absence": "cleanup_absence_proof_sha256", +} +_RECEIPT_VERDICTS = { + "runner": {"verified", "halted", "failed"}, + "observer": {"satisfied", "refuted", "unverifiable"}, + "webhook": {"delivered", "duplicate", "missing"}, + "replay": {"verified", "halted", "failed"}, + "fault": {"injected", "not_injected", "unverifiable"}, + "cleanup": {"completed", "failed", "unverifiable"}, + "cleanup_absence": {"absent", "present", "unverifiable"}, +} + +_ADMISSION_PAYLOAD_KEYS = { + "schema_version", + "admission_id", + "tenant_id", + "workflow_id", + "workflow_version_id", + "bundle_version_id", + "runtime_validation_id", + "bundle_artifact_sha256", + "bundle_content_digest", + "governed_authorization_template_sha256", + "application_contract_sha256", + "substrate_contract_sha256", + "environment_contract_sha256", + "runtime_environment_sha256", + "runtime_contract_sha256", + "input_policy_sha256", + "action_policy_sha256", + "network_policy_sha256", + "identity_contract_sha256", + "effect_contract_sha256", + "operator_contract_sha256", + "campaign", + "issuer", + "issued_at", + "not_before", + "expires_at", +} +_ADMISSION_UUID_KEYS = { + "admission_id", + "tenant_id", + "workflow_id", + "workflow_version_id", + "bundle_version_id", + "runtime_validation_id", +} +_ADMISSION_DIGEST_KEYS = _ADMISSION_PAYLOAD_KEYS - { + "schema_version", + *_ADMISSION_UUID_KEYS, + "campaign", + "issuer", + "issued_at", + "not_before", + "expires_at", +} +_ADMISSION_CAMPAIGN_KEYS = { + "artifact_sha256", + "contract_sha256", + "outcomes_sha256", + "oracle_id", + "oracle_contract_sha256", + "tasks", + "failure_taxonomy", + "decision", +} + +_RUNTIME_OUTCOMES = { + "verified", + "halted", + "delivery_uncertain", + "platform_failure", + "operator_intervention", +} +_EXPECTED_OUTCOMES = {"verified", "halted"} +_HALT_REASONS = { + "none", + "wrong_identity", + "stale_identity", + "ambiguity", + "missing_effect", + "weak_effect", +} +_FAILURE_TAXONOMY = ( + "verified", + "safe_halt", + "silent_incorrect_success", + "over_halt", + "wrong_record", + "duplicate_effect", + "collateral_effect", + "uncertain_delivery", + "platform_failure", + "operator_intervention", +) +_PRODUCTION_FAILURES = set(_FAILURE_TAXONOMY) - {"verified", "safe_halt"} + + +class AcceptanceError(ValueError): + """The supplied artifacts do not prove bounded production acceptance.""" + + +def canonical_json(value: Any) -> str: + """Return the cross-repository canonical JSON representation.""" + + return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":")) + + +def canonical_sha256(value: Any) -> str: + return "sha256:" + hashlib.sha256(canonical_json(value).encode("utf-8")).hexdigest() + + +def file_sha256(path: Path) -> str: + return "sha256:" + hashlib.sha256(path.read_bytes()).hexdigest() + + +def opaque_binding_sha256(domain: str, value: str) -> str: + payload = f"OpenAdapt acceptance {domain} v1\0".encode("utf-8") + value.encode( + "utf-8" + ) + return "sha256:" + hashlib.sha256(payload).hexdigest() + + +def _mapping(value: Any, label: str) -> Mapping[str, Any]: + if not isinstance(value, dict): + raise AcceptanceError(f"{label} must be an object") + return value + + +def _string_set(value: Any, label: str) -> set[str]: + if ( + not isinstance(value, list) + or not all(isinstance(item, str) and item for item in value) + or len(value) != len(set(value)) + ): + raise AcceptanceError(f"{label} must be a unique string list") + return set(value) + + +def _closed(value: Any, expected: set[str], label: str) -> Mapping[str, Any]: + mapping = _mapping(value, label) + keys = set(mapping) + if keys != expected: + missing = sorted(expected - keys) + extra = sorted(keys - expected) + raise AcceptanceError(f"{label} keys differ: missing={missing}, extra={extra}") + return mapping + + +def _nonempty(value: Any, label: str) -> str: + if not isinstance(value, str) or not value.strip(): + raise AcceptanceError(f"{label} must be a non-empty string") + return value + + +def _digest(value: Any, label: str) -> str: + if not isinstance(value, str) or _SHA256.fullmatch(value) is None: + raise AcceptanceError(f"{label} must be a sha256 digest") + return value + + +def _unprefixed_digest(value: Any, label: str) -> str: + if not isinstance(value, str) or _UNPREFIXED_SHA256.fullmatch(value) is None: + raise AcceptanceError(f"{label} must be an unprefixed sha256 digest") + return value + + +def _canonical_uuid(value: Any, label: str) -> str: + if not isinstance(value, str): + raise AcceptanceError(f"{label} must be a canonical UUID") + try: + parsed = uuid.UUID(value) + except ValueError as exc: + raise AcceptanceError(f"{label} must be a canonical UUID") from exc + if str(parsed) != value: + raise AcceptanceError(f"{label} must be a canonical UUID") + return value + + +def _whole_second_timestamp(value: Any, label: str) -> datetime: + if not isinstance(value, str) or _WHOLE_SECOND_UTC.fullmatch(value) is None: + raise AcceptanceError(f"{label} must be a whole-second UTC timestamp") + try: + return datetime.fromisoformat(value[:-1] + "+00:00").astimezone(timezone.utc) + except ValueError as exc: + raise AcceptanceError(f"{label} is invalid") from exc + + +def _canonical_base64(value: Any, length: int, label: str) -> bytes: + if not isinstance(value, str): + raise AcceptanceError(f"{label} must be canonical base64") + try: + decoded = base64.b64decode(value, validate=True) + except (binascii.Error, ValueError) as exc: + raise AcceptanceError(f"{label} must be canonical base64") from exc + if len(decoded) != length or base64.b64encode(decoded).decode("ascii") != value: + raise AcceptanceError(f"{label} must be canonical base64") + return decoded + + +def _verify_ed25519(public_key: bytes, signature: bytes, message: bytes) -> None: + """Verify Ed25519 with the project library or the OpenSSL 3 CI fallback.""" + + try: + from cryptography.exceptions import InvalidSignature + from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey + except ImportError: + # SubjectPublicKeyInfo prefix for a raw Ed25519 public key (RFC 8410). + public_der = bytes.fromhex("302a300506032b6570032100") + public_key + with tempfile.TemporaryDirectory(prefix="openadapt-admission-") as directory: + root = Path(directory) + public_path = root / "public.der" + signature_path = root / "signature.bin" + message_path = root / "message.bin" + public_path.write_bytes(public_der) + signature_path.write_bytes(signature) + message_path.write_bytes(message) + try: + verified = subprocess.run( + [ + "openssl", + "pkeyutl", + "-verify", + "-pubin", + "-inkey", + str(public_path), + "-keyform", + "DER", + "-rawin", + "-in", + str(message_path), + "-sigfile", + str(signature_path), + ], + check=False, + capture_output=True, + text=True, + ) + except OSError as exc: + raise AcceptanceError( + "qualification signature verifier is unavailable" + ) from exc + if verified.returncode != 0: + raise AcceptanceError("qualification admission signature is invalid") + return + try: + Ed25519PublicKey.from_public_bytes(public_key).verify(signature, message) + except (InvalidSignature, ValueError) as exc: + raise AcceptanceError("qualification admission signature is invalid") from exc + + +def validate_qualification_admission( + envelope: Mapping[str, Any], + campaign: Mapping[str, Any], + *, + trusted_signers: Mapping[str, Any], + revoked_admission_ids: set[str] | frozenset[str] = frozenset(), + revoked_signer_key_ids: set[str] | frozenset[str] = frozenset(), + now: datetime | None = None, +) -> dict[str, Any]: + """Verify the external qualification authority and its exact campaign.""" + + trusted_signers = _mapping(trusted_signers, "qualification signer trust registry") + if not isinstance(revoked_admission_ids, (set, frozenset)) or not all( + isinstance(value, str) and value for value in revoked_admission_ids + ): + raise AcceptanceError("qualification admission revocations must be a string set") + if not isinstance(revoked_signer_key_ids, (set, frozenset)) or not all( + isinstance(value, str) and value for value in revoked_signer_key_ids + ): + raise AcceptanceError("qualification signer revocations must be a string set") + campaign = _closed(campaign, _CAMPAIGN_KEYS, "campaign") + envelope = _closed(envelope, {"payload", "algorithm", "signature"}, "admission") + if envelope["algorithm"] != "ed25519": + raise AcceptanceError("qualification admission algorithm is not ed25519") + payload = _closed( + envelope["payload"], + _ADMISSION_PAYLOAD_KEYS, + "qualification admission payload", + ) + if payload["schema_version"] != ADMISSION_SCHEMA: + raise AcceptanceError("qualification admission schema is not supported") + for key in _ADMISSION_UUID_KEYS: + _canonical_uuid(payload[key], f"qualification admission {key}") + for key in _ADMISSION_DIGEST_KEYS: + _unprefixed_digest(payload[key], f"qualification admission {key}") + + issuer = _closed( + payload["issuer"], + {"key_id", "workflow", "ref"}, + "qualification admission issuer", + ) + key_id = issuer["key_id"] + if not isinstance(key_id, str) or _ADMISSION_KEY_ID.fullmatch(key_id) is None: + raise AcceptanceError("qualification admission signer key ID is invalid") + if key_id in revoked_signer_key_ids: + raise AcceptanceError("qualification admission signer is revoked") + if issuer["workflow"] != ADMISSION_ISSUER_WORKFLOW: + raise AcceptanceError("qualification admission issuer workflow is not approved") + if not isinstance(issuer["ref"], str) or _ADMISSION_REF.fullmatch(issuer["ref"]) is None: + raise AcceptanceError("qualification admission issuer ref is not approved") + + trust = trusted_signers.get(key_id) + if not isinstance(trust, dict) or set(trust) != { + "public_key", + "allowed_workflows", + "allowed_ref_prefixes", + }: + raise AcceptanceError("qualification admission signer is not trusted") + workflows = trust["allowed_workflows"] + ref_prefixes = trust["allowed_ref_prefixes"] + if workflows != [ADMISSION_ISSUER_WORKFLOW] and workflows != (ADMISSION_ISSUER_WORKFLOW,): + raise AcceptanceError("qualification signer workflow trust is not exact") + if ref_prefixes != [ADMISSION_REF_PREFIX] and ref_prefixes != (ADMISSION_REF_PREFIX,): + raise AcceptanceError("qualification signer ref trust is not exact") + public_key = _canonical_base64( + trust["public_key"], + 32, + "qualification signer public key", + ) + derived_key_id = "qa-ed25519-" + hashlib.sha256(public_key).hexdigest()[:16] + if key_id != derived_key_id: + raise AcceptanceError("qualification signer key ID differs from its public key") + signature = _canonical_base64( + envelope["signature"], + 64, + "qualification admission signature", + ) + _verify_ed25519( + public_key, + signature, + ADMISSION_SIGNATURE_DOMAIN + canonical_json(payload).encode("utf-8"), + ) + + issued_at = _whole_second_timestamp( + payload["issued_at"], "qualification admission issued_at" + ) + not_before = _whole_second_timestamp( + payload["not_before"], "qualification admission not_before" + ) + expires_at = _whole_second_timestamp( + payload["expires_at"], "qualification admission expires_at" + ) + current = now or datetime.now(timezone.utc) + if current.tzinfo is None: + raise AcceptanceError("qualification import time must include a timezone") + current = current.astimezone(timezone.utc) + if not issued_at - timedelta(minutes=5) <= not_before <= issued_at + timedelta(minutes=5): + raise AcceptanceError("qualification admission start is not bound to issuance") + if expires_at <= not_before or expires_at > issued_at + timedelta(days=30): + raise AcceptanceError("qualification admission lifetime is invalid") + if issued_at > current + timedelta(minutes=5): + raise AcceptanceError("qualification admission is future-issued") + if current < not_before: + raise AcceptanceError("qualification admission is not active") + if current >= expires_at: + raise AcceptanceError("qualification admission has expired") + if payload["admission_id"] in revoked_admission_ids: + raise AcceptanceError("qualification admission is revoked") + + campaign_binding = _closed( + payload["campaign"], + _ADMISSION_CAMPAIGN_KEYS, + "qualification admission campaign", + ) + for key in ( + "artifact_sha256", + "contract_sha256", + "outcomes_sha256", + "oracle_contract_sha256", + ): + _unprefixed_digest( + campaign_binding[key], + f"qualification admission campaign {key}", + ) + if campaign_binding["decision"] != "admitted": + raise AcceptanceError("qualification campaign was not admitted") + campaign_artifact_digest = canonical_sha256(campaign).removeprefix("sha256:") + contract_digest = canonical_sha256(campaign["qualification_contract"]).removeprefix( + "sha256:" + ) + outcomes_projection = { + "conditions": campaign["conditions"], + "invariants": campaign["invariants"], + "excluded_trials": campaign["excluded_trials"], + } + outcomes_digest = canonical_sha256(outcomes_projection).removeprefix("sha256:") + oracle_digest = canonical_sha256(campaign["oracle_contract"]).removeprefix("sha256:") + if campaign_binding["artifact_sha256"] != campaign_artifact_digest: + raise AcceptanceError("qualification admission campaign artifact digest differs") + if campaign_binding["contract_sha256"] != contract_digest: + raise AcceptanceError("qualification admission campaign contract digest differs") + if campaign_binding["outcomes_sha256"] != outcomes_digest: + raise AcceptanceError("qualification admission campaign outcomes digest differs") + oracle = _mapping(campaign["oracle_contract"], "campaign oracle contract") + if campaign_binding["oracle_id"] != oracle.get("schema_version"): + raise AcceptanceError("qualification admission campaign oracle identity differs") + if campaign_binding["oracle_contract_sha256"] != oracle_digest: + raise AcceptanceError("qualification admission campaign oracle digest differs") + + expected_tasks = [] + contract = _mapping(campaign["qualification_contract"], "qualification contract") + task_id = contract.get("task_id") + if not isinstance(task_id, str) or not task_id: + raise AcceptanceError("qualification campaign task is missing") + conditions = campaign["conditions"] + if not isinstance(conditions, list) or not conditions: + raise AcceptanceError("qualification campaign conditions must be a non-empty list") + for index, condition_value in enumerate(conditions): + condition = _closed( + condition_value, + _CONDITION_KEYS, + f"qualification campaign condition {index}", + ) + required_trials = condition["required_trials"] + trials = condition["trials"] + if ( + not isinstance(required_trials, int) + or isinstance(required_trials, bool) + or required_trials < 3 + or not isinstance(trials, list) + ): + raise AcceptanceError("qualification admission task inventory is malformed") + expected_tasks.append( + { + "task": task_id, + "condition": condition["condition_id"], + "required_trials": required_trials, + "observed_trials": len(trials), + } + ) + expected_tasks.sort(key=lambda value: (value["task"], value["condition"])) + tasks = campaign_binding["tasks"] + if not isinstance(tasks, list): + raise AcceptanceError("qualification admission task inventory must be a list") + if tasks != expected_tasks: + raise AcceptanceError("qualification admission task inventory differs from campaign rows") + taxonomy = campaign_binding["failure_taxonomy"] + expected_taxonomy = sorted(_FAILURE_TAXONOMY) + if taxonomy != expected_taxonomy: + raise AcceptanceError("qualification admission failure taxonomy is incomplete") + campaign_generated_at = _whole_second_timestamp( + campaign["generated_at"], + "qualification campaign generated_at", + ) + if campaign_generated_at > issued_at: + raise AcceptanceError("qualification admission predates its campaign") + return { + "artifact_sha256": canonical_sha256(envelope), + "signer_key_id": key_id, + "issuer_workflow": issuer["workflow"], + "issuer_ref": issuer["ref"], + "expires_at": payload["expires_at"], + } + + +def _count(value: Any, label: str) -> int: + if not isinstance(value, int) or isinstance(value, bool) or value < 0: + raise AcceptanceError(f"{label} must be a non-negative integer") + return value + + +def _timestamp(value: Any, label: str) -> datetime: + if not isinstance(value, str) or not value.endswith("Z"): + raise AcceptanceError(f"{label} must be a canonical UTC timestamp") + try: + parsed = datetime.fromisoformat(value[:-1] + "+00:00") + except ValueError as exc: + raise AcceptanceError(f"{label} must be a canonical UTC timestamp") from exc + if parsed.tzinfo != timezone.utc: + raise AcceptanceError(f"{label} must be a canonical UTC timestamp") + milliseconds = parsed.microsecond // 1000 + expected = parsed.replace(microsecond=milliseconds * 1000).isoformat( + timespec="milliseconds" + ).replace("+00:00", "Z") + if value != expected: + raise AcceptanceError(f"{label} must use canonical millisecond UTC form") + return parsed + + +def _validate_certificate( + certificate: Mapping[str, Any], + *, + now: datetime, + expected_cloud_source_commit: str, +) -> dict[str, Any]: + certificate = _closed(certificate, _CERTIFICATE_KEYS, "certificate") + if certificate["schema_version"] != CERTIFICATE_SCHEMA: + raise AcceptanceError("certificate schema is not supported") + if certificate["verdict"] != "passed": + raise AcceptanceError("certificate verdict is not passed") + if certificate["claim_scope"] != "single_authenticated_qualified_browser_transaction": + raise AcceptanceError("certificate claim scope is not the live browser transaction") + + product = _closed(certificate["product"], _PRODUCT_KEYS, "certificate.product") + cloud = _closed(product["cloud"], _CLOUD_KEYS, "certificate.product.cloud") + flow = _closed(product["flow"], _FLOW_KEYS, "certificate.product.flow") + runtime = _closed( + product["managed_runtime"], + _RUNTIME_KEYS, + "certificate.product.managed_runtime", + ) + if not isinstance(cloud["source_commit"], str) or _HEX_40.fullmatch( + cloud["source_commit"] + ) is None: + raise AcceptanceError("certificate Cloud source commit is not exact") + if _HEX_40.fullmatch(expected_cloud_source_commit) is None: + raise AcceptanceError("approved Cloud source commit is not exact") + if cloud["source_commit"] != expected_cloud_source_commit: + raise AcceptanceError("certificate Cloud source commit is not the approved commit") + _digest(cloud["target_build_sha256"], "certificate Cloud target build") + if not isinstance(flow["version"], str) or _SEMVER.fullmatch(flow["version"]) is None: + raise AcceptanceError("certificate Flow version is not exact") + if not isinstance(flow["release_commit"], str) or _HEX_40.fullmatch( + flow["release_commit"] + ) is None: + raise AcceptanceError("certificate Flow release commit is not exact") + _digest(flow["wheel_sha256"], "certificate Flow wheel") + _digest(runtime["manifest_sha256"], "certificate managed-runtime manifest") + _nonempty(runtime["runner_build"], "certificate runner build") + if not isinstance(runtime["playwright_version"], str) or _SEMVER.fullmatch( + runtime["playwright_version"] + ) is None: + raise AcceptanceError("certificate Playwright version is not exact") + browser_image = _nonempty(runtime["browser_base_image"], "certificate browser image") + image_name, separator, image_digest = browser_image.rpartition("@sha256:") + if not image_name or separator != "@sha256:" or re.fullmatch( + r"[a-f0-9]{64}", image_digest + ) is None: + raise AcceptanceError("certificate browser image is not digest-pinned") + + qualification = _closed( + certificate["qualification"], + _QUALIFICATION_KEYS, + "certificate.qualification", + ) + for key in ( + "qualification_admission_sha256", + "campaign_artifact_sha256", + "campaign_contract_sha256", + "campaign_outcomes_sha256", + "oracle_contract_sha256", + "runtime_validation_id_sha256", + "admission_id_sha256", + "workflow_version_id_sha256", + "workflow_digest", + "environment_digest", + ): + _digest(qualification[key], f"certificate qualification {key}") + for key in ( + "task_count", + "condition_count", + "required_trial_count", + "observed_trial_count", + "minimum_trials_per_condition", + ): + value = _count(qualification[key], f"certificate qualification {key}") + if value < 1: + raise AcceptanceError(f"certificate qualification {key} must be positive") + if ( + qualification["minimum_trials_per_condition"] < 3 + or qualification["condition_count"] < qualification["task_count"] + or qualification["observed_trial_count"] < qualification["required_trial_count"] + ): + raise AcceptanceError("certificate qualification counts are not internally consistent") + admission_signer = _closed( + qualification["admission_signer"], + _ADMISSION_SIGNER_KEYS, + "certificate qualification admission signer", + ) + if ( + admission_signer["algorithm"] != "ed25519" + or not isinstance(admission_signer["key_id"], str) + or _ADMISSION_KEY_ID.fullmatch(admission_signer["key_id"]) is None + or admission_signer["issuer_workflow"] != ADMISSION_ISSUER_WORKFLOW + or not isinstance(admission_signer["issuer_ref"], str) + or _ADMISSION_REF.fullmatch(admission_signer["issuer_ref"]) is None + ): + raise AcceptanceError("certificate qualification admission signer is not approved") + if qualification["runtime_validation_id_sha256"] == qualification[ + "admission_id_sha256" + ]: + raise AcceptanceError("runtime-validation and qualification bindings are not separated") + + transaction = _closed( + certificate["transaction"], + _TRANSACTION_KEYS, + "certificate.transaction", + ) + for key, value in transaction.items(): + _digest(value, f"certificate transaction {key}") + if transaction["accepted_response_sha256"] != transaction["duplicate_response_sha256"]: + raise AcceptanceError("idempotent accepted responses have different digests") + + outcomes = _closed(certificate["outcomes"], _OUTCOME_KEYS, "certificate.outcomes") + if any(value != "verified" for value in outcomes.values()): + raise AcceptanceError("certificate outcomes are not all verified") + + contracts = _closed(certificate["contracts"], _CONTRACT_KEYS, "certificate.contracts") + if any(value is not True for value in contracts.values()): + raise AcceptanceError("certificate contracts are not all verified") + + identities = _closed(certificate["identities"], _IDENTITY_KEYS, "certificate.identities") + if identities["signer_fingerprint_scheme"] != "sha256-ed25519-public-key-raw-v1": + raise AcceptanceError("certificate signer fingerprint scheme is not supported") + producer = _closed(identities["producer"], _PRODUCER_KEYS, "certificate producer") + verifier = _closed(identities["verifier"], _VERIFIER_KEYS, "certificate verifier") + if producer != { + "kind": "github_oidc_attested_workflow", + "repository": CLOUD_REPOSITORY, + "workflow": CLOUD_WORKFLOW, + "source_ref": "refs/heads/main", + "run_id": producer["run_id"], + "run_attempt": producer["run_attempt"], + }: + raise AcceptanceError("certificate producer identity is not the reviewed Cloud workflow") + for field in ("run_id", "run_attempt"): + if not isinstance(producer[field], str) or _POSITIVE_DECIMAL.fullmatch( + producer[field] + ) is None: + raise AcceptanceError(f"certificate producer {field} is invalid") + if verifier != { + "kind": "github_artifact_attestation", + "repository": CLOUD_REPOSITORY, + "workflow": CLOUD_WORKFLOW, + "certificate_identity": CLOUD_CERTIFICATE_IDENTITY, + "oidc_issuer": GITHUB_OIDC_ISSUER, + "hosted_runner_required": True, + }: + raise AcceptanceError("certificate verifier identity is not the reviewed Cloud workflow") + observer_signer = _digest( + identities["target_observer_signer_sha256"], + "certificate target observer signer", + ) + attestation_signer = _digest( + identities["target_attestation_signer_sha256"], + "certificate target attestation signer", + ) + runner_signer = _digest( + identities["managed_runner_signer_sha256"], + "certificate managed runner signer", + ) + _digest(identities["organization_id_sha256"], "certificate organization identity") + _digest(identities["workflow_id_sha256"], "certificate workflow identity") + if len({observer_signer, attestation_signer, runner_signer}) != 3: + raise AcceptanceError( + "target attestation, observer, and runner signing identities are not separate" + ) + + retention = _closed(certificate["retention"], _RETENTION_KEYS, "certificate.retention") + for key in ( + "ciphertext_sha256", + "candidate_sha256", + "private_envelope_sha256", + "store_attestation_sha256", + "storage_identity_sha256", + "object_version_sha256", + "private_locator_version_sha256", + "kms_key_identity_sha256", + "uploader_identity_sha256", + ): + _digest(retention[key], f"certificate retention {key}") + if not isinstance(retention["receipt_id"], str) or re.fullmatch( + r"retention:[a-f0-9]{32}", retention["receipt_id"] + ) is None: + raise AcceptanceError("certificate retention receipt ID is invalid") + if retention["retention_mode"] != "COMPLIANCE": + raise AcceptanceError("certificate retention mode is not Object Lock COMPLIANCE") + for key in ( + "upload_verified", + "head_verified", + "object_lock_verified", + "private_locator_recorded", + ): + if retention[key] is not True: + raise AcceptanceError(f"certificate retention {key} is not verified") + if retention["provenance_attestation"] != "github-artifact-attestation-v4": + raise AcceptanceError("certificate provenance attestation version is not reviewed") + acceptance_verified_at = _timestamp( + retention["acceptance_verified_at"], + "certificate retention acceptance_verified_at", + ) + retained_at = _timestamp(retention["retained_at"], "certificate retention retained_at") + expires_at = _timestamp( + retention["retention_until"], + "certificate retention retention_until", + ) + retention_period = expires_at - retained_at + if not timedelta(days=365) <= retention_period <= timedelta(days=3650): + raise AcceptanceError("certificate Object Lock retention period is outside policy") + if not acceptance_verified_at <= retained_at < expires_at: + raise AcceptanceError("certificate retention chronology is invalid") + if now.tzinfo is None: + raise AcceptanceError("import time must include a timezone") + if now.astimezone(timezone.utc) >= expires_at: + raise AcceptanceError( + "certificate Object Lock retention has expired" + ) + + return { + "product": {"cloud": dict(cloud), "flow": dict(flow), "managed_runtime": dict(runtime)}, + "qualification": dict(qualification), + "retention": dict(retention), + } + + +def _case_contract(contract: Mapping[str, Any]) -> dict[str, dict[str, str]]: + contract = _closed( + contract, + { + "schema_version", + "task_id", + "classification", + "target", + "runtime", + "effect_contract", + "required_capabilities", + "cases", + "fault_case_receipts", + "cleanup", + "post_campaign_invariant", + }, + "qualification contract", + ) + if contract["schema_version"] != "openadapt.execute-acceptance-qualification/v1": + raise AcceptanceError("qualification contract schema is not supported") + if contract["task_id"] != "execute-acceptance": + raise AcceptanceError("qualification task is not the reviewed Execute acceptance task") + if contract["classification"] != "private-product-owned-synthetic": + raise AcceptanceError("qualification contract classification is not reviewed") + target = _closed( + contract["target"], + { + "entry_url", + "browser_only_write", + "reference_input_selector", + "transaction_ref_parameter", + }, + "qualification target", + ) + if target != { + "entry_url": "https://app.openadapt.ai/execute-acceptance/target", + "browser_only_write": True, + "reference_input_selector": "input[data-testid=transaction-ref]", + "transaction_ref_parameter": "transaction_ref", + }: + raise AcceptanceError("qualification target is not the reviewed synthetic target") + runtime = _closed(contract["runtime"], {"openadapt_flow"}, "qualification runtime") + flow_runtime = _closed( + runtime["openadapt_flow"], + { + "release_identity_required", + "release_channel", + "healthy_path_model_call_limit", + }, + "qualification Flow runtime", + ) + if flow_runtime["release_identity_required"] is not True: + raise AcceptanceError("qualification does not require a Flow release identity") + _nonempty(flow_runtime["release_channel"], "qualification Flow release channel") + if flow_runtime["healthy_path_model_call_limit"] != 0: + raise AcceptanceError("qualification healthy path permits model calls") + effect = _closed( + contract["effect_contract"], + {"kind", "match", "required_strength", "observer", "observer_request"}, + "qualification effect contract", + ) + match = _closed(effect["match"], {"transaction_ref"}, "qualification effect match") + observer_request = _closed( + effect["observer_request"], + {"method", "path", "records_key", "auth"}, + "qualification observer request", + ) + if ( + effect["kind"] != "record_written" + or match["transaction_ref"] != "$param:transaction_ref" + or effect["required_strength"] != "independent_system_of_record" + or effect["observer"] != "separate read-only synthetic transaction observer" + or observer_request + != { + "method": "GET", + "path": ( + "/api/internal/execute-acceptance/observer?" + "transaction_ref={transaction_ref}" + ), + "records_key": "records", + "auth": "bearer environment reference", + } + ): + raise AcceptanceError("qualification effect contract is not independently verified") + if contract["required_capabilities"] != [ + "browser_observation", + "browser_actuation", + "identity_verification", + "independent_effect_verification", + ]: + raise AcceptanceError("qualification capability contract is not reviewed") + + fault_receipts = _closed( + contract["fault_case_receipts"], + {"required", "signer", "case_kinds"}, + "qualification fault-receipt contract", + ) + if fault_receipts != { + "required": True, + "signer": "named trusted fault driver", + "case_kinds": [ + "wrong_identity", + "stale_identity", + "ambiguity", + "missing_effect", + "weak_effect", + ], + }: + raise AcceptanceError("qualification fault-receipt contract is not reviewed") + cleanup = _closed( + contract["cleanup"], + {"required", "scope", "required_evidence", "failure_outcome"}, + "qualification cleanup contract", + ) + if cleanup != { + "required": True, + "scope": "every synthetic transaction reference issued for this campaign", + "required_evidence": [ + "signed cleanup receipt", + "independent observer absence proof", + ], + "failure_outcome": "reconciliation_required", + }: + raise AcceptanceError("qualification cleanup contract is not reviewed") + if contract["post_campaign_invariant"] != ( + "the observer confirms that every synthetic transaction ref used by this " + "campaign is absent after cleanup" + ): + raise AcceptanceError("qualification post-campaign invariant is not reviewed") + + cases = contract["cases"] + if not isinstance(cases, list) or not cases: + raise AcceptanceError("qualification contract has no cases") + reviewed_cases = { + "healthy-01": ("representative", "verified"), + "healthy-02": ("representative", "verified"), + "healthy-03": ("representative", "verified"), + "idempotency-replay": ("representative", "verified"), + "wrong-reference": ("wrong_identity", "halted"), + "stale-session": ("stale_identity", "halted"), + "ambiguous-target": ("ambiguity", "halted"), + "verifier-unavailable": ("missing_effect", "halted"), + "weak-effect-only": ("weak_effect", "halted"), + } + expected: dict[str, dict[str, str]] = {} + for index, case_value in enumerate(cases): + case = _mapping(case_value, f"qualification contract case {index}") + case_id = _nonempty(case.get("id"), f"qualification contract case {index} id") + expected_keys = {"id", "kind", "expected_outcome"} + if case_id == "idempotency-replay": + expected_keys |= { + "replays_case", + "idempotency_key_parameter", + "invariant", + } + case = _closed(case, expected_keys, f"qualification contract case {case_id!r}") + outcome = case.get("expected_outcome") + if outcome not in _EXPECTED_OUTCOMES: + raise AcceptanceError(f"qualification contract case {case_id!r} has invalid outcome") + if case_id in expected: + raise AcceptanceError(f"qualification contract case is duplicate: {case_id!r}") + kind = _nonempty(case.get("kind"), f"qualification contract case {case_id!r} kind") + if reviewed_cases.get(case_id) != (kind, outcome): + raise AcceptanceError(f"qualification contract case is not reviewed: {case_id!r}") + if case_id == "idempotency-replay" and ( + case["replays_case"] != "healthy-01" + or case["idempotency_key_parameter"] != "transaction_ref" + or case["invariant"] + != ( + "the exact healthy-01 canonical input and transaction_ref replay " + "returns the same execution and creates no second effect" + ) + ): + raise AcceptanceError("qualification replay contract is not reviewed") + halt_reason = "none" if outcome == "verified" else kind + if halt_reason not in _HALT_REASONS: + raise AcceptanceError( + f"qualification contract case {case_id!r} has an unsupported halt reason" + ) + expected[case_id] = { + "outcome": outcome, + "halt_reason": halt_reason, + "kind": kind, + } + if set(expected) != set(reviewed_cases): + raise AcceptanceError("qualification contract does not contain the nine reviewed cases") + return expected + + +def _binding_pairs(certificate: Mapping[str, Any]) -> dict[str, Any]: + product = certificate["product"] + qualification = certificate["qualification"] + return { + "runtime_validation_id_sha256": qualification["runtime_validation_id_sha256"], + "admission_id_sha256": qualification["admission_id_sha256"], + "workflow_version_id_sha256": qualification["workflow_version_id_sha256"], + "workflow_digest": qualification["workflow_digest"], + "environment_digest": qualification["environment_digest"], + "cloud_source_commit": product["cloud"]["source_commit"], + "cloud_target_build_sha256": product["cloud"]["target_build_sha256"], + "flow_version": product["flow"]["version"], + "flow_release_commit": product["flow"]["release_commit"], + "flow_wheel_sha256": product["flow"]["wheel_sha256"], + "managed_runtime_manifest_sha256": product["managed_runtime"]["manifest_sha256"], + "runner_build": product["managed_runtime"]["runner_build"], + "playwright_version": product["managed_runtime"]["playwright_version"], + "browser_base_image": product["managed_runtime"]["browser_base_image"], + "campaign_contract_sha256": qualification["campaign_contract_sha256"], + "managed_runner_signer_sha256": certificate["identities"][ + "managed_runner_signer_sha256" + ], + "target_attestation_signer_sha256": certificate["identities"][ + "target_attestation_signer_sha256" + ], + "target_observer_signer_sha256": certificate["identities"][ + "target_observer_signer_sha256" + ], + "target_attestation_sha256": certificate["transaction"][ + "target_attestation_sha256" + ], + "organization_id_sha256": certificate["identities"]["organization_id_sha256"], + "workflow_id_sha256": certificate["identities"]["workflow_id_sha256"], + } + + +def _validate_authority_contract(value: Any) -> dict[str, tuple[str, bytes]]: + authorities = _closed(value, set(_RECEIPT_TYPES), "campaign authority contract") + verified: dict[str, tuple[str, bytes]] = {} + for receipt_type in _RECEIPT_TYPES: + authority = _closed( + authorities[receipt_type], + _AUTHORITY_KEYS, + f"campaign {receipt_type} authority", + ) + if authority["algorithm"] != "ed25519": + raise AcceptanceError(f"campaign {receipt_type} authority is not Ed25519") + if authority["schema_version"] != RECEIPT_SCHEMA: + raise AcceptanceError(f"campaign {receipt_type} receipt schema is not supported") + if authority["signature_domain"] != RECEIPT_SIGNATURE_DOMAIN_TEXT: + raise AcceptanceError(f"campaign {receipt_type} signature domain is not exact") + key_id = authority["key_id"] + if not isinstance(key_id, str) or _RECEIPT_KEY_ID.fullmatch(key_id) is None: + raise AcceptanceError(f"campaign {receipt_type} key ID is invalid") + public_key = _canonical_base64( + authority["public_key"], + 32, + f"campaign {receipt_type} public key", + ) + derived = "qe-ed25519-" + hashlib.sha256(public_key).hexdigest()[:16] + if key_id != derived: + raise AcceptanceError(f"campaign {receipt_type} key ID differs from its key") + verified[receipt_type] = (key_id, public_key) + if len({key_id for key_id, _ in verified.values()}) != len(_RECEIPT_TYPES): + raise AcceptanceError("campaign receipt authorities are not separated by type") + return verified + + +def _verified_receipt( + receipt_digest: Any, + *, + receipt_type: str, + campaign_id: str, + task_id: str, + condition_id: str, + trial: Mapping[str, Any], + envelopes: Mapping[str, Any], + authorities: Mapping[str, tuple[str, bytes]], + generated_at: datetime, + label: str, +) -> tuple[str, str]: + digest = _unprefixed_digest(receipt_digest, f"{label} {receipt_type} receipt") + if digest not in envelopes: + raise AcceptanceError(f"{label} {receipt_type} receipt body is missing") + envelope = _closed( + envelopes[digest], + _RECEIPT_ENVELOPE_KEYS, + f"{label} {receipt_type} receipt envelope", + ) + if canonical_sha256(envelope).removeprefix("sha256:") != digest: + raise AcceptanceError(f"{label} {receipt_type} receipt digest differs from its body") + if envelope["schema_version"] != RECEIPT_SCHEMA: + raise AcceptanceError(f"{label} {receipt_type} receipt schema is not supported") + if envelope["receipt_type"] != receipt_type: + raise AcceptanceError(f"{label} receipt type differs from its row field") + if envelope["algorithm"] != "ed25519": + raise AcceptanceError(f"{label} {receipt_type} receipt is not Ed25519") + key_id, public_key = authorities[receipt_type] + if envelope["issuer_key_id"] != key_id: + raise AcceptanceError(f"{label} {receipt_type} receipt signer is not authorized") + source_digest = _unprefixed_digest( + envelope["source_artifact_sha256"], + f"{label} {receipt_type} source artifact", + ) + projection = _closed( + envelope["verified_projection"], + _RECEIPT_PROJECTION_KEYS, + f"{label} {receipt_type} verified projection", + ) + expected_projection = { + "campaign_id": campaign_id, + "task": task_id, + "condition": condition_id, + "trial_index": trial["trial_index"], + "attempt_id_sha256": trial["attempt_id_sha256"], + "run_id_sha256": trial["run_id_sha256"], + "workflow_version_id": trial["workflow_version_id"], + "bundle_artifact_sha256": trial["bundle_artifact_sha256"], + "runtime_validation_id": trial["runtime_validation_id"], + "verdict": projection["verdict"], + "evidence_sha256": source_digest, + } + if projection != expected_projection: + raise AcceptanceError(f"{label} {receipt_type} projection differs from its row") + if projection["verdict"] not in _RECEIPT_VERDICTS[receipt_type]: + raise AcceptanceError(f"{label} {receipt_type} verdict is invalid") + verified_at = _whole_second_timestamp( + envelope["verified_at"], + f"{label} {receipt_type} verified_at", + ) + completed_at = _whole_second_timestamp(trial["completed_at"], f"{label} completed_at") + if not completed_at <= verified_at <= generated_at: + raise AcceptanceError(f"{label} {receipt_type} verification time is outside the campaign") + signature = _canonical_base64( + envelope["signature"], + 64, + f"{label} {receipt_type} signature", + ) + signed = {key: envelope[key] for key in _RECEIPT_SIGNED_KEYS} + _verify_ed25519( + public_key, + signature, + RECEIPT_SIGNATURE_DOMAIN + canonical_json(signed).encode("utf-8"), + ) + return projection["verdict"], source_digest + + +def _derive_trial_classification( + *, + expected: str, + verdicts: Mapping[str, str], +) -> str: + if verdicts["webhook"] != "delivered": + return "uncertain_delivery" + if verdicts["cleanup"] != "completed" or verdicts["cleanup_absence"] != "absent": + return "platform_failure" + if verdicts["runner"] == "failed" or verdicts["replay"] == "failed": + return "platform_failure" + if expected == "verified": + if verdicts["runner"] == "halted": + return "over_halt" + if ( + verdicts["runner"] == "verified" + and verdicts["observer"] == "satisfied" + and verdicts["replay"] == "verified" + and "fault" not in verdicts + ): + return "verified" + return "silent_incorrect_success" + if ( + verdicts["runner"] == "halted" + and verdicts["observer"] == "satisfied" + and verdicts["replay"] == "halted" + and verdicts.get("fault") == "injected" + ): + return "safe_halt" + return "silent_incorrect_success" + + +def _validate_campaign( + campaign: Mapping[str, Any], + admission_payload: Mapping[str, Any], +) -> tuple[Counter[str], dict[str, int]]: + campaign = _closed(campaign, _CAMPAIGN_KEYS, "campaign") + if campaign["schema_version"] != CAMPAIGN_SCHEMA: + raise AcceptanceError("campaign schema is not supported") + campaign_id = _canonical_uuid(campaign["campaign_id"], "campaign ID") + if uuid.UUID(campaign_id).version != 4: + raise AcceptanceError("campaign ID must be a UUIDv4") + if campaign["decision"] != "admitted": + raise AcceptanceError("campaign decision is not admitted") + generated_at = _whole_second_timestamp(campaign["generated_at"], "campaign generated_at") + oracle = _closed(campaign["oracle_contract"], _ORACLE_KEYS, "campaign oracle contract") + if oracle != { + "schema_version": "openadapt.execute-acceptance-campaign-oracle/v1", + "runtime_outcome_source": "signed_flow_run_receipt", + "effect_outcome_source": "independent_system_of_record_observer", + "delivery_outcome_source": "signed_managed_runner_and_webhook_evidence", + "attempt_accounting": "signed_campaign_attempt_index", + "fault_evidence_source": "signed_named_fault_driver_receipt", + "cleanup_evidence_source": "signed_cleanup_receipt_and_observer_absence_proof", + }: + raise AcceptanceError("campaign oracle contract is not reviewed") + if campaign["excluded_trials"] != []: + raise AcceptanceError("campaign contains excluded or hidden trials") + + contract = _mapping(campaign["qualification_contract"], "qualification contract") + expected_cases = _case_contract(contract) + task_id = contract["task_id"] + authorities = _validate_authority_contract(campaign["authority_contract"]) + envelopes = _mapping(campaign["receipt_envelopes"], "campaign receipt envelopes") + for digest in envelopes: + _unprefixed_digest(digest, "campaign receipt envelope key") + + conditions = campaign["conditions"] + if not isinstance(conditions, list) or not conditions: + raise AcceptanceError("campaign conditions must be a non-empty list") + seen_conditions: set[str] = set() + seen_attempts: set[str] = set() + seen_runs: set[str] = set() + used_receipts: set[str] = set() + seen_source_artifacts: set[str] = set() + taxonomy: Counter[str] = Counter() + trials_per_condition: dict[str, int] = {} + effect_invariant_observations = 0 + healthy_model_observations = 0 + for condition_index, condition_value in enumerate(conditions): + condition = _closed( + condition_value, + _CONDITION_KEYS, + f"campaign condition {condition_index}", + ) + condition_id = _nonempty( + condition["condition_id"], + f"campaign condition {condition_index} id", + ) + if condition_id in seen_conditions: + raise AcceptanceError(f"campaign condition is duplicate: {condition_id!r}") + seen_conditions.add(condition_id) + if condition_id not in expected_cases: + raise AcceptanceError(f"campaign condition is outside the contract: {condition_id!r}") + expected = condition["expected_runtime_outcome"] + case = expected_cases[condition_id] + if expected != case["outcome"]: + raise AcceptanceError(f"campaign condition outcome differs from contract: {condition_id!r}") + trials = condition["trials"] + required_trials = condition["required_trials"] + if ( + not isinstance(required_trials, int) + or isinstance(required_trials, bool) + or required_trials < 3 + or required_trials > 10_000 + ): + raise AcceptanceError( + f"campaign condition has an invalid required trial count: {condition_id!r}" + ) + if not isinstance(trials, list) or len(trials) < required_trials: + raise AcceptanceError( + "campaign condition has fewer than 3 retained trials or its required count: " + f"{condition_id!r}" + ) + trials_per_condition[condition_id] = len(trials) + for trial_index, trial_value in enumerate(trials, start=1): + label = f"campaign condition {condition_id!r} trial {trial_index}" + trial = _closed(trial_value, _TRIAL_KEYS, label) + if trial["schema_version"] != "openadapt.qualification-trial-row/v1": + raise AcceptanceError(f"{label} schema is not supported") + if trial["task"] != task_id or trial["condition"] != condition_id: + raise AcceptanceError(f"{label} task or condition differs from its container") + if ( + not isinstance(trial["trial_index"], int) + or isinstance(trial["trial_index"], bool) + or trial["trial_index"] != trial_index + ): + raise AcceptanceError(f"{label} index is not one-based and contiguous") + for key in ("attempt_id_sha256", "run_id_sha256", "bundle_artifact_sha256"): + _unprefixed_digest(trial[key], f"{label} {key}") + if trial["attempt_id_sha256"] in seen_attempts: + raise AcceptanceError(f"{label} attempt ID is duplicate") + if trial["run_id_sha256"] in seen_runs: + raise AcceptanceError(f"{label} run ID is duplicate") + seen_attempts.add(trial["attempt_id_sha256"]) + seen_runs.add(trial["run_id_sha256"]) + _canonical_uuid(trial["workflow_version_id"], f"{label} workflow version") + _canonical_uuid(trial["runtime_validation_id"], f"{label} runtime validation") + if trial["workflow_version_id"] != admission_payload["workflow_version_id"]: + raise AcceptanceError(f"{label} workflow version differs from admission") + if trial["runtime_validation_id"] != admission_payload["runtime_validation_id"]: + raise AcceptanceError(f"{label} runtime validation differs from admission") + if trial["bundle_artifact_sha256"] != admission_payload["bundle_artifact_sha256"]: + raise AcceptanceError(f"{label} bundle artifact differs from admission") + started_at = _whole_second_timestamp(trial["started_at"], f"{label} started_at") + completed_at = _whole_second_timestamp(trial["completed_at"], f"{label} completed_at") + if completed_at < started_at or completed_at > generated_at: + raise AcceptanceError(f"{label} time interval is invalid") + if trial["execution_outcome"] not in {"verified", "halted", "failed"}: + raise AcceptanceError(f"{label} execution outcome is invalid") + if trial["oracle_verdict"] not in {"satisfied", "refuted", "unverifiable"}: + raise AcceptanceError(f"{label} oracle verdict is invalid") + if trial["failure_class"] not in _FAILURE_TAXONOMY: + raise AcceptanceError(f"{label} failure class is invalid") + verdicts: dict[str, str] = {} + for receipt_type, row_field in _RECEIPT_ROW_FIELDS.items(): + receipt_digest = trial[row_field] + if receipt_type == "fault" and case["kind"] == "representative": + if receipt_digest is not None: + raise AcceptanceError(f"{label} has a fault receipt for a nonfault case") + continue + if receipt_digest is None: + raise AcceptanceError(f"{label} {receipt_type} receipt is required") + receipt_digest = _unprefixed_digest( + receipt_digest, + f"{label} {receipt_type} receipt", + ) + if receipt_digest in used_receipts: + raise AcceptanceError(f"{label} reuses a receipt envelope") + used_receipts.add(receipt_digest) + verdict, source_digest = _verified_receipt( + receipt_digest, + receipt_type=receipt_type, + campaign_id=campaign_id, + task_id=task_id, + condition_id=condition_id, + trial=trial, + envelopes=envelopes, + authorities=authorities, + generated_at=generated_at, + label=label, + ) + if source_digest in seen_source_artifacts: + raise AcceptanceError(f"{label} reuses a source evidence artifact") + seen_source_artifacts.add(source_digest) + verdicts[receipt_type] = verdict + if verdicts["runner"] != trial["execution_outcome"]: + raise AcceptanceError(f"{label} execution outcome differs from signed evidence") + if verdicts["observer"] != trial["oracle_verdict"]: + raise AcceptanceError(f"{label} oracle verdict differs from signed evidence") + classification = _derive_trial_classification(expected=expected, verdicts=verdicts) + if trial["failure_class"] != classification: + raise AcceptanceError(f"{label} failure class differs from signed evidence") + taxonomy[classification] += 1 + effect_invariant_observations += 1 + if expected == "verified": + healthy_model_observations += 1 + if seen_conditions != set(expected_cases): + missing = sorted(set(expected_cases) - seen_conditions) + raise AcceptanceError(f"campaign does not retain every contract condition: {missing}") + if set(envelopes) != used_receipts: + raise AcceptanceError("campaign contains unreferenced or hidden receipt envelopes") + failures = {name: taxonomy.get(name, 0) for name in _PRODUCTION_FAILURES} + present = {name: count for name, count in failures.items() if count} + if present: + raise AcceptanceError(f"campaign contains production-acceptance failures: {present}") + + invariants = campaign["invariants"] + if not isinstance(invariants, list) or not invariants: + raise AcceptanceError("campaign invariants must be a non-empty list") + derived_invariants = { + "no_wrong_or_duplicate_effect": { + "holds": True, + "observations": effect_invariant_observations, + "violations": 0, + }, + "zero_model_healthy_path": { + "holds": True, + "observations": healthy_model_observations, + "violations": 0, + }, + } + seen_invariants: set[str] = set() + for index, invariant_value in enumerate(invariants): + invariant = _closed(invariant_value, _INVARIANT_KEYS, f"campaign invariant {index}") + invariant_id = _nonempty(invariant["id"], f"campaign invariant {index} id") + if invariant_id in seen_invariants: + raise AcceptanceError(f"campaign invariant is duplicate: {invariant_id!r}") + seen_invariants.add(invariant_id) + if invariant_id not in derived_invariants: + raise AcceptanceError(f"campaign invariant is not derived: {invariant_id!r}") + observations = _count(invariant["observations"], f"campaign invariant {invariant_id}") + violations = _count(invariant["violations"], f"campaign invariant {invariant_id}") + if { + "holds": invariant["holds"], + "observations": observations, + "violations": violations, + } != derived_invariants[invariant_id]: + raise AcceptanceError(f"campaign invariant differs from retained trials: {invariant_id!r}") + if seen_invariants != set(derived_invariants): + raise AcceptanceError("campaign does not contain the exact derived invariant set") + return taxonomy, trials_per_condition + + +def verify_github_attestation( + certificate_path: Path, + bundle_path: Path, + expected_cloud_source_commit: str, + *, + run: Callable[..., subprocess.CompletedProcess[str]] = subprocess.run, +) -> dict[str, str]: + """Verify the certificate bytes against the exact protected Cloud workflow.""" + + if not certificate_path.is_file(): + raise AcceptanceError("certificate file is missing") + if not bundle_path.is_file(): + raise AcceptanceError("certificate attestation bundle is missing") + if _HEX_40.fullmatch(expected_cloud_source_commit) is None: + raise AcceptanceError("approved Cloud source commit is not exact") + try: + certificate = json.loads(certificate_path.read_text(encoding="utf-8")) + source_commit = certificate["product"]["cloud"]["source_commit"] + except (OSError, json.JSONDecodeError, KeyError, TypeError) as exc: + raise AcceptanceError("certificate Cloud source commit cannot be read") from exc + if not isinstance(source_commit, str) or _HEX_40.fullmatch(source_commit) is None: + raise AcceptanceError("certificate Cloud source commit is not exact") + if source_commit != expected_cloud_source_commit: + raise AcceptanceError("certificate Cloud source commit is not the approved commit") + command = [ + "gh", + "attestation", + "verify", + str(certificate_path), + "--repo", + CLOUD_REPOSITORY, + "--bundle", + str(bundle_path), + "--cert-identity", + CLOUD_CERTIFICATE_IDENTITY, + "--cert-oidc-issuer", + GITHUB_OIDC_ISSUER, + "--deny-self-hosted-runners", + "--format", + "json", + ] + try: + completed = run(command, check=False, capture_output=True, text=True) + except OSError as exc: + raise AcceptanceError(f"GitHub attestation verifier could not run: {exc}") from exc + if completed.returncode != 0: + detail = (completed.stderr or "verification failed").strip().splitlines()[-1] + raise AcceptanceError(f"GitHub certificate attestation is invalid: {detail}") + try: + result = json.loads(completed.stdout) + except json.JSONDecodeError as exc: + raise AcceptanceError("GitHub attestation verifier returned invalid JSON") from exc + _validate_verified_provenance( + result, + certificate_path=certificate_path, + expected_cloud_source_commit=expected_cloud_source_commit, + ) + return { + "repository": CLOUD_REPOSITORY, + "workflow": CLOUD_WORKFLOW, + "certificate_identity": CLOUD_CERTIFICATE_IDENTITY, + "source_commit": expected_cloud_source_commit, + "bundle_sha256": file_sha256(bundle_path), + } + + +def _validate_verified_provenance( + result: Any, + *, + certificate_path: Path, + expected_cloud_source_commit: str, +) -> None: + """Check the source binding inside one already verified GitHub statement.""" + + try: + acceptance_record = json.loads(certificate_path.read_text(encoding="utf-8")) + producer = acceptance_record["identities"]["producer"] + issued_at = _timestamp( + acceptance_record["retention"]["acceptance_verified_at"], + "certificate retention acceptance_verified_at", + ) + except (OSError, json.JSONDecodeError, KeyError, TypeError) as exc: + raise AcceptanceError("certificate provenance bindings cannot be read") from exc + run_id = producer.get("run_id") + run_attempt = producer.get("run_attempt") + if not isinstance(run_id, str) or _POSITIVE_DECIMAL.fullmatch(run_id) is None: + raise AcceptanceError("certificate provenance run ID is invalid") + if not isinstance(run_attempt, str) or _POSITIVE_DECIMAL.fullmatch(run_attempt) is None: + raise AcceptanceError("certificate provenance run attempt is invalid") + expected_invocation = ( + f"https://github.com/{CLOUD_REPOSITORY}/actions/runs/{run_id}/attempts/{run_attempt}" + ) + + if not isinstance(result, list) or len(result) != 1: + raise AcceptanceError("GitHub attestation verifier must return one verified statement") + item = _closed( + result[0], + {"attestation", "verificationResult"}, + "GitHub attestation result", + ) + verification = _mapping( + item["verificationResult"], + "GitHub attestation verification result", + ) + signature = _mapping( + verification.get("signature"), + "GitHub attestation signature", + ) + certificate = _mapping( + signature.get("certificate"), + "GitHub attestation signing certificate", + ) + expected_certificate_fields = { + "subjectAlternativeName": CLOUD_CERTIFICATE_IDENTITY, + "issuer": GITHUB_OIDC_ISSUER, + "githubWorkflowTrigger": "workflow_dispatch", + "githubWorkflowSHA": expected_cloud_source_commit, + "githubWorkflowRepository": CLOUD_REPOSITORY, + "githubWorkflowRef": "refs/heads/main", + "buildSignerURI": CLOUD_CERTIFICATE_IDENTITY, + "buildSignerDigest": expected_cloud_source_commit, + "runnerEnvironment": "github-hosted", + "sourceRepositoryURI": f"https://github.com/{CLOUD_REPOSITORY}", + "sourceRepositoryDigest": expected_cloud_source_commit, + "sourceRepositoryRef": "refs/heads/main", + "sourceRepositoryOwnerURI": "https://github.com/OpenAdaptAI", + "buildConfigURI": CLOUD_CERTIFICATE_IDENTITY, + "buildConfigDigest": expected_cloud_source_commit, + "buildTrigger": "workflow_dispatch", + "runInvocationURI": expected_invocation, + "sourceRepositoryVisibilityAtSigning": "public", + } + for key, expected in expected_certificate_fields.items(): + if certificate.get(key) != expected: + raise AcceptanceError(f"GitHub signing certificate {key} is not approved") + for key in ("sourceRepositoryIdentifier", "sourceRepositoryOwnerIdentifier"): + value = certificate.get(key) + if not isinstance(value, str) or _POSITIVE_DECIMAL.fullmatch(value) is None: + raise AcceptanceError(f"GitHub signing certificate {key} is invalid") + + timestamps = verification.get("verifiedTimestamps") + if not isinstance(timestamps, list) or not timestamps: + raise AcceptanceError("GitHub attestation has no verified transparency timestamp") + transparency_times: list[datetime] = [] + for index, value in enumerate(timestamps): + timestamp = _mapping(value, f"GitHub verified timestamp {index}") + if timestamp.get("type") != "Tlog" or timestamp.get("uri") != ( + "https://rekor.sigstore.dev" + ): + continue + raw_time = timestamp.get("timestamp") + if not isinstance(raw_time, str): + raise AcceptanceError("GitHub transparency timestamp is invalid") + try: + parsed_time = datetime.fromisoformat(raw_time.replace("Z", "+00:00")) + except ValueError as exc: + raise AcceptanceError("GitHub transparency timestamp is invalid") from exc + if parsed_time.tzinfo is None: + raise AcceptanceError("GitHub transparency timestamp has no timezone") + transparency_times.append(parsed_time.astimezone(timezone.utc)) + if len(transparency_times) != 1: + raise AcceptanceError("GitHub attestation must have one public-log timestamp") + if not issued_at <= transparency_times[0] <= issued_at + timedelta(minutes=15): + raise AcceptanceError("GitHub transparency timestamp is not bound to record issuance") + + statement = _closed( + verification.get("statement"), + {"_type", "subject", "predicateType", "predicate"}, + "GitHub provenance statement", + ) + if statement["_type"] != "https://in-toto.io/Statement/v1": + raise AcceptanceError("GitHub provenance statement type is not supported") + if statement["predicateType"] != "https://slsa.dev/provenance/v1": + raise AcceptanceError("GitHub provenance predicate type is not supported") + subjects = statement["subject"] + if not isinstance(subjects, list) or not subjects: + raise AcceptanceError("GitHub provenance has no certificate subject") + expected_subject = { + "name": certificate_path.name, + "sha256": file_sha256(certificate_path).removeprefix("sha256:"), + } + matching_subjects = 0 + for index, value in enumerate(subjects): + subject = _closed(value, {"name", "digest"}, f"GitHub provenance subject {index}") + digest = _mapping(subject["digest"], f"GitHub provenance subject {index} digest") + if digest.get("sha256") == expected_subject["sha256"]: + if subject["name"] != expected_subject["name"] or set(digest) != {"sha256"}: + raise AcceptanceError("GitHub provenance certificate subject is malformed") + matching_subjects += 1 + if matching_subjects != 1: + raise AcceptanceError( + "GitHub provenance must contain exactly one subject for the certificate bytes" + ) + + predicate = _mapping(statement["predicate"], "GitHub provenance predicate") + build = _mapping(predicate.get("buildDefinition"), "GitHub provenance build definition") + if build.get("buildType") != ( + "https://actions.github.io/buildtypes/workflow/v1" + ): + raise AcceptanceError("GitHub provenance build type is not supported") + external = _mapping( + build.get("externalParameters"), + "GitHub provenance external parameters", + ) + workflow = _closed( + external.get("workflow"), + {"ref", "repository", "path"}, + "GitHub provenance source workflow", + ) + if workflow != { + "ref": "refs/heads/main", + "repository": f"https://github.com/{CLOUD_REPOSITORY}", + "path": CLOUD_WORKFLOW, + }: + raise AcceptanceError("GitHub provenance source workflow is not the approved main workflow") + dependencies = build.get("resolvedDependencies") + if not isinstance(dependencies, list) or len(dependencies) != 1: + raise AcceptanceError("GitHub provenance must contain one resolved source dependency") + dependency = _closed( + dependencies[0], + {"uri", "digest"}, + "GitHub provenance resolved source dependency", + ) + if dependency["uri"] != ( + f"git+https://github.com/{CLOUD_REPOSITORY}@refs/heads/main" + ): + raise AcceptanceError("GitHub provenance resolved source ref is not approved") + dependency_digest = _closed( + dependency["digest"], + {"gitCommit"}, + "GitHub provenance resolved source digest", + ) + if dependency_digest["gitCommit"] != expected_cloud_source_commit: + raise AcceptanceError("GitHub provenance resolved source commit is not approved") + + internal = _closed( + build.get("internalParameters"), + {"github"}, + "GitHub provenance internal parameters", + ) + github = _closed( + internal["github"], + { + "event_name", + "repository_id", + "repository_owner_id", + "runner_environment", + }, + "GitHub provenance runner parameters", + ) + if github["event_name"] != "workflow_dispatch": + raise AcceptanceError("GitHub provenance event is not the reviewed manual acceptance gate") + if github["runner_environment"] != "github-hosted": + raise AcceptanceError("GitHub provenance runner is not GitHub-hosted") + for key in ("repository_id", "repository_owner_id"): + if not isinstance(github[key], str) or _POSITIVE_DECIMAL.fullmatch(github[key]) is None: + raise AcceptanceError(f"GitHub provenance {key} is invalid") + + run_details = _mapping(predicate.get("runDetails"), "GitHub provenance run details") + builder = _closed( + run_details.get("builder"), + {"id"}, + "GitHub provenance builder", + ) + if builder["id"] != CLOUD_CERTIFICATE_IDENTITY: + raise AcceptanceError("GitHub provenance builder is not the reviewed Cloud workflow") + metadata = _closed( + run_details.get("metadata"), + {"invocationId"}, + "GitHub provenance run metadata", + ) + if metadata["invocationId"] != expected_invocation: + raise AcceptanceError("GitHub provenance invocation differs from the certificate run") + + +def derive_production_acceptance( + certificate: Mapping[str, Any], + campaign: Mapping[str, Any], + admission: Mapping[str, Any], + *, + attestation: Mapping[str, str], + expected_cloud_source_commit: str, + trusted_admission_signers: Mapping[str, Any], + revoked_admission_ids: set[str] | frozenset[str] = frozenset(), + revoked_admission_signer_key_ids: set[str] | frozenset[str] = frozenset(), + now: datetime | None = None, +) -> dict[str, Any]: + """Return a derived result or raise when any required proof is absent.""" + + now = now or datetime.now(timezone.utc) + facts = _validate_certificate( + certificate, + now=now, + expected_cloud_source_commit=expected_cloud_source_commit, + ) + expected_attestation = { + "repository": CLOUD_REPOSITORY, + "workflow": CLOUD_WORKFLOW, + "certificate_identity": CLOUD_CERTIFICATE_IDENTITY, + "source_commit": expected_cloud_source_commit, + "bundle_sha256": attestation.get("bundle_sha256"), + } + if attestation != expected_attestation: + raise AcceptanceError("GitHub attestation identity is not the reviewed Cloud workflow") + _digest(attestation.get("bundle_sha256"), "GitHub attestation bundle") + + admission_facts = validate_qualification_admission( + admission, + campaign, + trusted_signers=trusted_admission_signers, + revoked_admission_ids=revoked_admission_ids, + revoked_signer_key_ids=revoked_admission_signer_key_ids, + now=now, + ) + admission_digest = canonical_sha256(admission) + if admission_digest != certificate["qualification"]["qualification_admission_sha256"]: + raise AcceptanceError("qualification admission digest differs from certificate") + admission_payload = _mapping(admission["payload"], "qualification admission payload") + if certificate["qualification"]["admission_signer"] != { + "algorithm": "ed25519", + "key_id": admission_facts["signer_key_id"], + "issuer_workflow": admission_facts["issuer_workflow"], + "issuer_ref": admission_facts["issuer_ref"], + }: + raise AcceptanceError("certificate qualification signer differs from admission") + opaque_bindings = { + "runtime_validation_id_sha256": ( + "runtime validation id", + "runtime_validation_id", + ), + "admission_id_sha256": ("qualification admission id", "admission_id"), + "workflow_version_id_sha256": ("workflow version id", "workflow_version_id"), + } + for certificate_key, (domain, payload_key) in opaque_bindings.items(): + expected = opaque_binding_sha256(domain, admission_payload[payload_key]) + if certificate["qualification"][certificate_key] != expected: + raise AcceptanceError( + f"certificate {certificate_key} differs from the retained admission" + ) + for certificate_key, domain, payload_key in ( + ("organization_id_sha256", "organization id", "tenant_id"), + ("workflow_id_sha256", "workflow id", "workflow_id"), + ): + expected = opaque_binding_sha256(domain, admission_payload[payload_key]) + if certificate["identities"][certificate_key] != expected: + raise AcceptanceError( + f"certificate {certificate_key} differs from the retained admission" + ) + campaign_digest = canonical_sha256(campaign) + if campaign_digest != certificate["qualification"]["campaign_artifact_sha256"]: + raise AcceptanceError("campaign evidence digest differs from certificate") + campaign_contract_digest = canonical_sha256(campaign["qualification_contract"]) + if campaign_contract_digest != certificate["qualification"]["campaign_contract_sha256"]: + raise AcceptanceError("campaign qualification-contract digest differs from certificate") + campaign_outcomes_digest = canonical_sha256( + { + "conditions": campaign["conditions"], + "invariants": campaign["invariants"], + "excluded_trials": campaign["excluded_trials"], + } + ) + if campaign_outcomes_digest != certificate["qualification"]["campaign_outcomes_sha256"]: + raise AcceptanceError("campaign outcomes digest differs from certificate") + oracle_digest = canonical_sha256(campaign["oracle_contract"]) + if oracle_digest != certificate["qualification"]["oracle_contract_sha256"]: + raise AcceptanceError("campaign oracle digest differs from certificate") + taxonomy, trials_per_condition = _validate_campaign(campaign, admission_payload) + conditions = campaign["conditions"] + required_trial_count = sum(condition["required_trials"] for condition in conditions) + observed_trial_count = sum(trials_per_condition.values()) + minimum_trials_per_condition = min(trials_per_condition.values()) + expected_certificate_counts = { + "task_count": 1, + "condition_count": len(trials_per_condition), + "required_trial_count": required_trial_count, + "observed_trial_count": observed_trial_count, + "minimum_trials_per_condition": minimum_trials_per_condition, + } + for key, expected in expected_certificate_counts.items(): + if certificate["qualification"][key] != expected: + raise AcceptanceError( + f"certificate qualification {key} differs from retained rows" + ) + counted_taxonomy = {name: taxonomy.get(name, 0) for name in _FAILURE_TAXONOMY} + total_trials = observed_trial_count + return { + "schema_version": RESULT_SCHEMA, + "verdict": "accepted", + "evidence_class": "qualified_browser_production_acceptance", + "claim_scope": CLAIM_SCOPE, + "bindings": _binding_pairs(certificate), + "source_evidence": { + "certificate_sha256": canonical_sha256(certificate), + "campaign_sha256": campaign_digest, + "qualification_admission_sha256": admission_digest, + "qualification_authority": admission_facts, + "attestation": dict(attestation), + "approved_cloud_source_commit": expected_cloud_source_commit, + }, + "trial_inventory": { + "condition_count": len(trials_per_condition), + "trial_count": total_trials, + "minimum_trials_per_condition": min(trials_per_condition.values()), + "trials_per_condition": dict(sorted(trials_per_condition.items())), + "excluded_trial_count": 0, + }, + "derived_outcomes": counted_taxonomy, + "reliability": { + "silent_incorrect_success_count": counted_taxonomy[ + "silent_incorrect_success" + ], + "over_halt_count": counted_taxonomy["over_halt"], + "wrong_record_count": counted_taxonomy["wrong_record"], + "duplicate_effect_count": counted_taxonomy["duplicate_effect"], + "collateral_effect_count": counted_taxonomy["collateral_effect"], + "uncertain_delivery_count": counted_taxonomy["uncertain_delivery"], + "model_call_count": 0, + }, + "retention": facts["retention"], + "claim_limit": "not_general_product_production_readiness", + } + + +def import_files( + certificate_path: Path, + campaign_path: Path, + admission_path: Path, + bundle_path: Path, + expected_cloud_source_commit: str, + *, + trusted_admission_signers: Mapping[str, Any], + revoked_admission_ids: set[str] | frozenset[str] = frozenset(), + revoked_admission_signer_key_ids: set[str] | frozenset[str] = frozenset(), + now: datetime | None = None, + run: Callable[..., subprocess.CompletedProcess[str]] = subprocess.run, +) -> dict[str, Any]: + raise AcceptanceError( + "full admission/campaign import is pending an approved private-export contract" + ) + + +def main(argv: Sequence[str] | None = None) -> int: + parser = argparse.ArgumentParser( + description="Derive one scoped browser-workflow production-acceptance result." + ) + parser.add_argument("--certificate", type=Path, required=True) + parser.add_argument("--campaign", type=Path, required=True) + parser.add_argument("--qualification-admission", type=Path, required=True) + parser.add_argument("--attestation-bundle", type=Path, required=True) + parser.add_argument("--expected-cloud-source-commit", required=True) + parser.add_argument("--trusted-admission-signers", type=Path, required=True) + parser.add_argument("--revoked-admission-ids", type=Path) + parser.add_argument("--revoked-admission-signer-key-ids", type=Path) + parser.add_argument("--output", type=Path, required=True) + args = parser.parse_args(argv) + try: + trusted_admission_signers = _mapping( + json.loads(args.trusted_admission_signers.read_text(encoding="utf-8")), + "qualification signer trust registry", + ) + revoked_admission_ids = ( + _string_set( + json.loads(args.revoked_admission_ids.read_text(encoding="utf-8")), + "qualification admission revocations", + ) + if args.revoked_admission_ids + else set() + ) + revoked_admission_signer_key_ids = ( + _string_set( + json.loads( + args.revoked_admission_signer_key_ids.read_text(encoding="utf-8") + ), + "qualification signer revocations", + ) + if args.revoked_admission_signer_key_ids + else set() + ) + result = import_files( + args.certificate, + args.campaign, + args.qualification_admission, + args.attestation_bundle, + args.expected_cloud_source_commit, + trusted_admission_signers=trusted_admission_signers, + revoked_admission_ids=revoked_admission_ids, + revoked_admission_signer_key_ids=revoked_admission_signer_key_ids, + ) + with args.output.open("x", encoding="utf-8") as handle: + handle.write(json.dumps(result, indent=2, sort_keys=True) + "\n") + except (AcceptanceError, FileExistsError, OSError, json.JSONDecodeError) as exc: + print(f"REFUSED: {exc}", file=sys.stderr) + return 1 + print(f"Wrote scoped acceptance result to {args.output}") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/tests/fixtures/production_acceptance/live-certificate.json b/tests/fixtures/production_acceptance/live-certificate.json new file mode 100644 index 0000000..11b6cb8 --- /dev/null +++ b/tests/fixtures/production_acceptance/live-certificate.json @@ -0,0 +1,133 @@ +{ + "claim_scope": "single_authenticated_qualified_browser_transaction", + "contracts": { + "authenticated_submission": true, + "entitlement_and_metering_verified": true, + "exact_source_attested": true, + "idempotency_verified": true, + "independent_effect_verified": true, + "observer_evidence_signature_verified": true, + "qualification_bound": true, + "quiet_period_stable": true, + "receipt_contract_verified": true, + "runner_signature_verified": true, + "runner_transaction_identity_verified": true, + "signed_webhook_verified": true, + "single_delivery_verified": true, + "single_permit_consumption_verified": true, + "target_attestation_signature_verified": true, + "zero_model_healthy_path": true + }, + "identities": { + "managed_runner_signer_sha256": "sha256:1212121212121212121212121212121212121212121212121212121212121212", + "organization_id_sha256": "sha256:0ecd004dcbed992e16d1f90fbb2b2ae5433e32ed62e563f6fc53caa277516648", + "producer": { + "kind": "github_oidc_attested_workflow", + "repository": "OpenAdaptAI/openadapt-cloud", + "run_attempt": "1", + "run_id": "123456789", + "source_ref": "refs/heads/main", + "workflow": ".github/workflows/execute-live-acceptance.yml" + }, + "signer_fingerprint_scheme": "sha256-ed25519-public-key-raw-v1", + "target_attestation_signer_sha256": "sha256:efefefefefefefefefefefefefefefefefefefefefefefefefefefefefefefef", + "target_observer_signer_sha256": "sha256:dededededededededededededededededededededededededededededededede", + "verifier": { + "certificate_identity": "https://github.com/OpenAdaptAI/openadapt-cloud/.github/workflows/execute-live-acceptance.yml@refs/heads/main", + "hosted_runner_required": true, + "kind": "github_artifact_attestation", + "oidc_issuer": "https://token.actions.githubusercontent.com", + "repository": "OpenAdaptAI/openadapt-cloud", + "workflow": ".github/workflows/execute-live-acceptance.yml" + }, + "workflow_id_sha256": "sha256:696a6bcc1d534cbe03cedadf2ba48ce5b854f5e1b4d3154925a09085d5025199" + }, + "outcomes": { + "entitlement_and_metering": "verified", + "independent_effect": "verified", + "transaction": "verified", + "webhook_delivery": "verified" + }, + "product": { + "cloud": { + "source_commit": "ffffffffffffffffffffffffffffffffffffffff", + "target_build_sha256": "sha256:1111111111111111111111111111111111111111111111111111111111111111" + }, + "flow": { + "release_commit": "0123456789abcdef0123456789abcdef01234567", + "version": "1.31.0", + "wheel_sha256": "sha256:2222222222222222222222222222222222222222222222222222222222222222" + }, + "managed_runtime": { + "browser_base_image": "python:3.11-slim@sha256:4444444444444444444444444444444444444444444444444444444444444444", + "manifest_sha256": "sha256:3333333333333333333333333333333333333333333333333333333333333333", + "playwright_version": "1.62.0", + "runner_build": "report-v4" + } + }, + "qualification": { + "admission_id_sha256": "sha256:58103c7a3d1c967ff5cfb397e30c4d1563d3767e07f8476021e955c16b59c515", + "admission_signer": { + "algorithm": "ed25519", + "issuer_ref": "refs/heads/main@aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + "issuer_workflow": "OpenAdaptAI/openadapt-internal/.github/workflows/production-qualification-admission.yml", + "key_id": "qa-ed25519-34750f98bd59fcfc" + }, + "campaign_artifact_sha256": "sha256:c0f85314d9bb6236226b37b4dce86ea9ccee4dbec344ddb49858f7898e912d66", + "campaign_contract_sha256": "sha256:02b706e8251719c9ed4c62e3c9807074952f5ffe350a382fa61bb7d3832cfe41", + "campaign_outcomes_sha256": "sha256:7c33c1c98779b1eca72c5e5cd8110e07d5975801ff4e84d6e69de0508f50304d", + "condition_count": 9, + "environment_digest": "sha256:eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee", + "minimum_trials_per_condition": 3, + "observed_trial_count": 27, + "oracle_contract_sha256": "sha256:a9d87b5deaa24c553e65aa0237136398fe7821ae7d226fc20d48c500765bc1e0", + "qualification_admission_sha256": "sha256:6d1fee47bb76630e2e75346ffca643da50ecce9e684859939045ce2c19ec9978", + "required_trial_count": 27, + "runtime_validation_id_sha256": "sha256:4b0c7cd12b36f177beb4e28ab9fb4fa4da0d4d033274233d654bd5615758908f", + "task_count": 1, + "workflow_digest": "sha256:dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd", + "workflow_version_id_sha256": "sha256:f705eb4fa57e6196028a81b0a2c1b4208fe25f1dff56cebee2548f8d1aea0fe8" + }, + "retention": { + "acceptance_verified_at": "2026-08-18T12:00:00.000Z", + "candidate_sha256": "sha256:6262626262626262626262626262626262626262626262626262626262626262", + "ciphertext_sha256": "sha256:6161616161616161616161616161616161616161616161616161616161616161", + "head_verified": true, + "kms_key_identity_sha256": "sha256:6868686868686868686868686868686868686868686868686868686868686868", + "object_lock_verified": true, + "object_version_sha256": "sha256:6666666666666666666666666666666666666666666666666666666666666666", + "private_envelope_sha256": "sha256:6363636363636363636363636363636363636363636363636363636363636363", + "private_locator_recorded": true, + "private_locator_version_sha256": "sha256:6767676767676767676767676767676767676767676767676767676767676767", + "provenance_attestation": "github-artifact-attestation-v4", + "receipt_id": "retention:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + "retained_at": "2026-08-18T12:01:00.000Z", + "retention_mode": "COMPLIANCE", + "retention_until": "2027-08-18T12:01:00.000Z", + "storage_identity_sha256": "sha256:6565656565656565656565656565656565656565656565656565656565656565", + "store_attestation_sha256": "sha256:6464646464646464646464646464646464646464646464646464646464646464", + "upload_verified": true, + "uploader_identity_sha256": "sha256:6969696969696969696969696969696969696969696969696969696969696969" + }, + "schema_version": "openadapt.execute-live-acceptance-record/v1", + "transaction": { + "acceptance_challenge_sha256": "sha256:7373737373737373737373737373737373737373737373737373737373737373", + "acceptance_envelope_sha256": "sha256:5555555555555555555555555555555555555555555555555555555555555555", + "accepted_response_sha256": "sha256:6666666666666666666666666666666666666666666666666666666666666666", + "duplicate_response_sha256": "sha256:6666666666666666666666666666666666666666666666666666666666666666", + "execution_id_sha256": "sha256:7474747474747474747474747474747474747474747474747474747474747474", + "idempotency_key_sha256": "sha256:7676767676767676767676767676767676767676767676767676767676767676", + "observer_evidence_sha256": "sha256:1000000000000000000000000000000000000000000000000000000000000001", + "receipt_evidence_digest": "sha256:8888888888888888888888888888888888888888888888888888888888888888", + "receipt_id_sha256": "sha256:7575757575757575757575757575757575757575757575757575757575757575", + "receipt_sha256": "sha256:0000000000000000000000000000000000000000000000000000000000000001", + "request_sha256": "sha256:7777777777777777777777777777777777777777777777777777777777777777", + "runner_permit_sha256": "sha256:7878787878787878787878787878787878787878787878787878787878787878", + "runner_report_sha256": "sha256:7171717171717171717171717171717171717171717171717171717171717171", + "runner_result_sha256": "sha256:7272727272727272727272727272727272727272727272727272727272727272", + "runner_transaction_identity_sha256": "sha256:7070707070707070707070707070707070707070707070707070707070707070", + "target_attestation_sha256": "sha256:9999999999999999999999999999999999999999999999999999999999999999", + "webhook_event_sha256": "sha256:2000000000000000000000000000000000000000000000000000000000000001" + }, + "verdict": "passed" +} diff --git a/tests/fixtures/production_acceptance/qualification-admission-trust.json b/tests/fixtures/production_acceptance/qualification-admission-trust.json new file mode 100644 index 0000000..31f3442 --- /dev/null +++ b/tests/fixtures/production_acceptance/qualification-admission-trust.json @@ -0,0 +1,11 @@ +{ + "qa-ed25519-34750f98bd59fcfc": { + "allowed_ref_prefixes": [ + "refs/heads/main@" + ], + "allowed_workflows": [ + "OpenAdaptAI/openadapt-internal/.github/workflows/production-qualification-admission.yml" + ], + "public_key": "iojj3XQJ8ZX9UtstPLpdcspnCb8dlBIb83SIAbQPb1w=" + } +} diff --git a/tests/fixtures/production_acceptance/qualification-admission.json b/tests/fixtures/production_acceptance/qualification-admission.json new file mode 100644 index 0000000..68e696d --- /dev/null +++ b/tests/fixtures/production_acceptance/qualification-admission.json @@ -0,0 +1,111 @@ +{ + "algorithm": "ed25519", + "payload": { + "action_policy_sha256": "2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a", + "admission_id": "11111111-1111-4111-8111-111111111111", + "application_contract_sha256": "2424242424242424242424242424242424242424242424242424242424242424", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "bundle_content_digest": "2222222222222222222222222222222222222222222222222222222222222222", + "bundle_version_id": "55555555-5555-4555-8555-555555555555", + "campaign": { + "artifact_sha256": "c0f85314d9bb6236226b37b4dce86ea9ccee4dbec344ddb49858f7898e912d66", + "contract_sha256": "02b706e8251719c9ed4c62e3c9807074952f5ffe350a382fa61bb7d3832cfe41", + "decision": "admitted", + "failure_taxonomy": [ + "collateral_effect", + "duplicate_effect", + "operator_intervention", + "over_halt", + "platform_failure", + "safe_halt", + "silent_incorrect_success", + "uncertain_delivery", + "verified", + "wrong_record" + ], + "oracle_contract_sha256": "a9d87b5deaa24c553e65aa0237136398fe7821ae7d226fc20d48c500765bc1e0", + "oracle_id": "openadapt.execute-acceptance-campaign-oracle/v1", + "outcomes_sha256": "7c33c1c98779b1eca72c5e5cd8110e07d5975801ff4e84d6e69de0508f50304d", + "tasks": [ + { + "condition": "ambiguous-target", + "observed_trials": 3, + "required_trials": 3, + "task": "execute-acceptance" + }, + { + "condition": "healthy-01", + "observed_trials": 3, + "required_trials": 3, + "task": "execute-acceptance" + }, + { + "condition": "healthy-02", + "observed_trials": 3, + "required_trials": 3, + "task": "execute-acceptance" + }, + { + "condition": "healthy-03", + "observed_trials": 3, + "required_trials": 3, + "task": "execute-acceptance" + }, + { + "condition": "idempotency-replay", + "observed_trials": 3, + "required_trials": 3, + "task": "execute-acceptance" + }, + { + "condition": "stale-session", + "observed_trials": 3, + "required_trials": 3, + "task": "execute-acceptance" + }, + { + "condition": "verifier-unavailable", + "observed_trials": 3, + "required_trials": 3, + "task": "execute-acceptance" + }, + { + "condition": "weak-effect-only", + "observed_trials": 3, + "required_trials": 3, + "task": "execute-acceptance" + }, + { + "condition": "wrong-reference", + "observed_trials": 3, + "required_trials": 3, + "task": "execute-acceptance" + } + ] + }, + "effect_contract_sha256": "2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d", + "environment_contract_sha256": "2626262626262626262626262626262626262626262626262626262626262626", + "expires_at": "2026-09-17T11:59:00Z", + "governed_authorization_template_sha256": "2323232323232323232323232323232323232323232323232323232323232323", + "identity_contract_sha256": "2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c", + "input_policy_sha256": "2929292929292929292929292929292929292929292929292929292929292929", + "issued_at": "2026-08-18T11:59:00Z", + "issuer": { + "key_id": "qa-ed25519-34750f98bd59fcfc", + "ref": "refs/heads/main@aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + "workflow": "OpenAdaptAI/openadapt-internal/.github/workflows/production-qualification-admission.yml" + }, + "network_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "not_before": "2026-08-18T11:58:00Z", + "operator_contract_sha256": "2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e", + "runtime_contract_sha256": "2828282828282828282828282828282828282828282828282828282828282828", + "runtime_environment_sha256": "2727272727272727272727272727272727272727272727272727272727272727", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "schema_version": "openadapt.qualification-admission/v1", + "substrate_contract_sha256": "2525252525252525252525252525252525252525252525252525252525252525", + "tenant_id": "22222222-2222-4222-8222-222222222222", + "workflow_id": "33333333-3333-4333-8333-333333333333", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + }, + "signature": "OBEE1BaFQteeAGCKehi1Ssnzqts8cZz7aDVUSRE7maxU2L5rvbjA/F4vjWIOz/07wUZyfY3x7r/AOH1Pxy3nBA==" +} diff --git a/tests/fixtures/production_acceptance/qualification-campaign.json b/tests/fixtures/production_acceptance/qualification-campaign.json new file mode 100644 index 0000000..38b5293 --- /dev/null +++ b/tests/fixtures/production_acceptance/qualification-campaign.json @@ -0,0 +1,4772 @@ +{ + "authority_contract": { + "cleanup": { + "algorithm": "ed25519", + "key_id": "qe-ed25519-138dfa227234ea5f", + "public_key": "MfMyLUkj02xBwQm9sAmRkxh77ZmUIJbkkmokx379DS8=", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature_domain": "openadapt-qualification-evidence-receipt-v1\\0" + }, + "cleanup_absence": { + "algorithm": "ed25519", + "key_id": "qe-ed25519-d92d542a589844dd", + "public_key": "ZMMIFf8m1cSv+OESdKOO1t0FUwSdpMEDcqlXW3p3aQk=", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature_domain": "openadapt-qualification-evidence-receipt-v1\\0" + }, + "fault": { + "algorithm": "ed25519", + "key_id": "qe-ed25519-59b2ad6131a74d03", + "public_key": "U0cJYlWKbgg5AirmXGsnI7MncuXAxfR3bLjmo+ELovM=", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature_domain": "openadapt-qualification-evidence-receipt-v1\\0" + }, + "observer": { + "algorithm": "ed25519", + "key_id": "qe-ed25519-d7e1e084be213b01", + "public_key": "1UIH2hlJd9z0atv+wrwudbUtWopCGE/t/cAAJPDj6No=", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature_domain": "openadapt-qualification-evidence-receipt-v1\\0" + }, + "replay": { + "algorithm": "ed25519", + "key_id": "qe-ed25519-e37abcd79efd08db", + "public_key": "Md6+VdN8cidosTcTHKpghwgLLgtguUvXhdFFdc+kmLw=", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature_domain": "openadapt-qualification-evidence-receipt-v1\\0" + }, + "runner": { + "algorithm": "ed25519", + "key_id": "qe-ed25519-7300c0ae1429cd15", + "public_key": "IIKL9cW9ystoSGMzbCAvtVmdpIvlWWYVdCFwcFvsqfc=", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature_domain": "openadapt-qualification-evidence-receipt-v1\\0" + }, + "webhook": { + "algorithm": "ed25519", + "key_id": "qe-ed25519-168c59a54a0d5b6c", + "public_key": "URw0oaLLUh3xa7JGuN6OeZfOI1x+drIqPXUDokgZ3Yo=", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature_domain": "openadapt-qualification-evidence-receipt-v1\\0" + } + }, + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "conditions": [ + { + "condition_id": "healthy-01", + "expected_runtime_outcome": "verified", + "required_trials": 3, + "trials": [ + { + "attempt_id_sha256": "679af5a8dedceb8c696719e73f82a698c230cd8fc98bb61769f0883202c0b637", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "cleanup_absence_proof_sha256": "96be7cec9d956a7a3f3308730cf3377553a285ef6d7bd42100b43d044e161cbb", + "cleanup_receipt_sha256": "1674de43590311145df8c1149ad40d4f1f154497536cd3f86547d117b005aced", + "completed_at": "2026-08-18T10:02:00Z", + "condition": "healthy-01", + "execution_outcome": "verified", + "failure_class": "verified", + "fault_receipt_sha256": null, + "observer_receipt_sha256": "ff7446448b7ca80801834d31758eb31968c04d7c27fb137b992ab574ff157cdd", + "oracle_verdict": "satisfied", + "replay_report_sha256": "156f5af975f0f574aa73e2f8f296304d6b7ca1fb389d20bf1dbd571935d491e0", + "run_id_sha256": "0b5bda916a0808165159166955a9563cf9c2303949f762a18eb037f41b44a6dc", + "runner_receipt_sha256": "85e18a244859259c2a8275a40afe0d6b887db2fb91e1982d56ad414924a3423c", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "schema_version": "openadapt.qualification-trial-row/v1", + "started_at": "2026-08-18T10:01:00Z", + "task": "execute-acceptance", + "trial_index": 1, + "webhook_receipt_sha256": "ab88cfde60ca5548f8b6812e3713c9d2541ba50da220a9b4e6196cba18f94145", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + }, + { + "attempt_id_sha256": "fdad940f245d690750ad647fac25c7e76aac2f474db49732fec8129051750186", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "cleanup_absence_proof_sha256": "d1146664cafb846d4dece5833facbe37778ae7f7ccece97b7fe6f3e7cabd8c27", + "cleanup_receipt_sha256": "596a2bb3c7e416b245f5ed30fc86e4208af76997b62472bfbf278c79abee47ec", + "completed_at": "2026-08-18T10:03:00Z", + "condition": "healthy-01", + "execution_outcome": "verified", + "failure_class": "verified", + "fault_receipt_sha256": null, + "observer_receipt_sha256": "d36db3d72f05e9e0142a41e47eb4f413fd585a3de836ddd991067e03b6c2fd4b", + "oracle_verdict": "satisfied", + "replay_report_sha256": "5f0221453529c8e3be2e2b23b2603925fbdf1502f576c16e2a40304d75ec9808", + "run_id_sha256": "3739043a92a8781376cfbd022460c03aba40f92a800b3885ebc046321437bc40", + "runner_receipt_sha256": "2b291719429c998246226ba27143f7da1f03abeabce84abeb3e581662b60d6bc", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "schema_version": "openadapt.qualification-trial-row/v1", + "started_at": "2026-08-18T10:02:00Z", + "task": "execute-acceptance", + "trial_index": 2, + "webhook_receipt_sha256": "a761ed49d1a6b031989d9a95d8d4ce740d3d5e6e8daad883e1daad675c4d19d5", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + }, + { + "attempt_id_sha256": "4c352a6999f77707e8837adebb4fc2b7451c2ef6de5145190b33a5c5645e47eb", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "cleanup_absence_proof_sha256": "0668d3958131859deae05b675b6859b48e043adf1443d21f19a6bfc1c6bbc6ad", + "cleanup_receipt_sha256": "994bdf2b435c1a57d515e4b881bbcac43289df1f20385f7150c0193e1d2acc6f", + "completed_at": "2026-08-18T10:04:00Z", + "condition": "healthy-01", + "execution_outcome": "verified", + "failure_class": "verified", + "fault_receipt_sha256": null, + "observer_receipt_sha256": "33d8fd907e482612d1d69669f9f91afe0dded59103f393643a57500c8ee1ff05", + "oracle_verdict": "satisfied", + "replay_report_sha256": "48c07213b9025ee2168a2a7972ae7a2ac8f7aeda08b2ef95273dddd94d086d34", + "run_id_sha256": "4ee2bb61fb883cc8e77d636fb471aa3c0ce9ef0c0a8abd9682214bf0a8f16f26", + "runner_receipt_sha256": "70a3703f7ae55e333da73a24399d55404bc28158ae6c0088656cce79103ff011", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "schema_version": "openadapt.qualification-trial-row/v1", + "started_at": "2026-08-18T10:03:00Z", + "task": "execute-acceptance", + "trial_index": 3, + "webhook_receipt_sha256": "f100bd4634c9eb9fa4bed44602c35082221c7369d661daee343d30cb1df16e45", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + ] + }, + { + "condition_id": "healthy-02", + "expected_runtime_outcome": "verified", + "required_trials": 3, + "trials": [ + { + "attempt_id_sha256": "940d3ca125ff87ce7539740fbae29d2d64fec839328b0639127e1d197d2485d8", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "cleanup_absence_proof_sha256": "bebd124852a24da854264263989ce3eb2a81dc7583641e725b882317634cd656", + "cleanup_receipt_sha256": "89a5d906de379f1e4dfa2e52a02916b84cd79388b52a30ea2f26c33834b2a094", + "completed_at": "2026-08-18T10:12:00Z", + "condition": "healthy-02", + "execution_outcome": "verified", + "failure_class": "verified", + "fault_receipt_sha256": null, + "observer_receipt_sha256": "47380d14908be57018b19d846d86f0ba8f428ba7cd44f03219dd21117e504d3b", + "oracle_verdict": "satisfied", + "replay_report_sha256": "950129910020acdc11ac8fd19134104516d2e8974d28c6c4044f757b9cda35c1", + "run_id_sha256": "bbb9312ce4682b23580eced0f8d19438d8266b222555df85fb27eef22ad5afe2", + "runner_receipt_sha256": "e0e3d981c9ba2d0cf3195944e46a1c95815d42f5f69057fef276ee9ad794e4c6", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "schema_version": "openadapt.qualification-trial-row/v1", + "started_at": "2026-08-18T10:11:00Z", + "task": "execute-acceptance", + "trial_index": 1, + "webhook_receipt_sha256": "281c785f27d6347e718f61d7d326ddd42e38cb7c0977de9b5e7585253cc3899b", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + }, + { + "attempt_id_sha256": "3d42601a69ef46cc44f57b51762affef4ccd829ffde30125619a6e582af00dab", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "cleanup_absence_proof_sha256": "bb54c9fee035e3fcf5c9daa6f6fc08bc1e5d3cffb2b0aa0b047b1006727c7918", + "cleanup_receipt_sha256": "bcefc56da8f7c303f207023baadc506246d85c8e9f140de46f1e28cbc5bae278", + "completed_at": "2026-08-18T10:13:00Z", + "condition": "healthy-02", + "execution_outcome": "verified", + "failure_class": "verified", + "fault_receipt_sha256": null, + "observer_receipt_sha256": "dc7048a424e18471caed8bd57b168512101197f3accf144c4d19acc40d01bf6a", + "oracle_verdict": "satisfied", + "replay_report_sha256": "d9553baf538c005d37d0fa044211857d6a24114de97b70462fdac8fe97be3400", + "run_id_sha256": "091e13ed70dab439b31cb506cf3bba1ddf6476696531cf891c39a924a928b7a1", + "runner_receipt_sha256": "21b8a3b75d9b04406b4684602b1b1c4ffbf01fc814f3371d80a478c2271e143a", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "schema_version": "openadapt.qualification-trial-row/v1", + "started_at": "2026-08-18T10:12:00Z", + "task": "execute-acceptance", + "trial_index": 2, + "webhook_receipt_sha256": "020265c9483aadd4321f39f4bd35ad152b53d5fcebc96c044fa1d84ea860e614", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + }, + { + "attempt_id_sha256": "019dd96e9a771ccc01ebafab321d7d3a8314df8b2d6465bcfc5fa14cbdeabdf2", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "cleanup_absence_proof_sha256": "97e53386169276ba5b6fe074df5e3b928617a1298e4fdf7c7100474d4af06152", + "cleanup_receipt_sha256": "8a33f194bdfb27d33344ac8e2e9085dd5e899b878157756f56886e9e29e88821", + "completed_at": "2026-08-18T10:14:00Z", + "condition": "healthy-02", + "execution_outcome": "verified", + "failure_class": "verified", + "fault_receipt_sha256": null, + "observer_receipt_sha256": "974ab867b3788102bd3f634d25770c9abe171a3101c3e206b81bc60dcaac1a65", + "oracle_verdict": "satisfied", + "replay_report_sha256": "6ab281eabcbff71abd1ffaa1b2ee7f6b082673890d01882b7a842b1ee3e7ac8d", + "run_id_sha256": "16cb8df40654c6a1b55ea0e50e772d8c6e6d4f0d8205bd1f8296be27d0af83eb", + "runner_receipt_sha256": "8e4466457228106adf081b8f17ea483f689a4022c30e1953cf273ddbf02519dd", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "schema_version": "openadapt.qualification-trial-row/v1", + "started_at": "2026-08-18T10:13:00Z", + "task": "execute-acceptance", + "trial_index": 3, + "webhook_receipt_sha256": "033d48209efa84280e3035d72ed0627a27cb43d45f6e05d277e23f164f345472", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + ] + }, + { + "condition_id": "healthy-03", + "expected_runtime_outcome": "verified", + "required_trials": 3, + "trials": [ + { + "attempt_id_sha256": "fc097c8b2e6ece94544a19b8d81f5c4a9367a89059e3dd4b2f746ab06a2fc930", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "cleanup_absence_proof_sha256": "8c1afd600031c30f995fb9824e193c95b4d4ad585ca879c64c9d2e348fa1b10e", + "cleanup_receipt_sha256": "42c9725850c0b81507d63757a3427d48e93db412915891ffd538e18eb73736be", + "completed_at": "2026-08-18T10:22:00Z", + "condition": "healthy-03", + "execution_outcome": "verified", + "failure_class": "verified", + "fault_receipt_sha256": null, + "observer_receipt_sha256": "cf9b127576b09758cdc73a384992a995d372c5e5eb2ad814c25e4b7ac4f2c343", + "oracle_verdict": "satisfied", + "replay_report_sha256": "4090cbc85f145c1a2b33d9536ca9f2ca12f9109769eb702a0a46fbda70abace8", + "run_id_sha256": "28768f565659133f5bf1170e638b81de4d7ca38dfecacd09ccf462a35344432b", + "runner_receipt_sha256": "9d1fb286c570cad74e6f2e0c77a085c58bab02089cd52c84c0a3c7637f13ff04", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "schema_version": "openadapt.qualification-trial-row/v1", + "started_at": "2026-08-18T10:21:00Z", + "task": "execute-acceptance", + "trial_index": 1, + "webhook_receipt_sha256": "983cfdb068e5742ca3315545dbe1d5c0bca772ce0359994c7c856d089ff8a892", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + }, + { + "attempt_id_sha256": "2601335b1101424105277997a67850a8a60aa45f59637b7679c1f32af463c460", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "cleanup_absence_proof_sha256": "ad21ee460923f6b34bab8405db2f256e8b3318e31797a5d256c274c0e0407bf0", + "cleanup_receipt_sha256": "d5f9ea3188b044838ce9bee71ae6243bd2ad81b684d7c1e1b537bbce00e4d99b", + "completed_at": "2026-08-18T10:23:00Z", + "condition": "healthy-03", + "execution_outcome": "verified", + "failure_class": "verified", + "fault_receipt_sha256": null, + "observer_receipt_sha256": "ea37aba51876e0039f1a875d74bb647b694a67625b103458c1c5001c94015409", + "oracle_verdict": "satisfied", + "replay_report_sha256": "bffc584cb4cb04d08a01698a8700bab8c812bece8884d7d1f4fe57081b46b5dd", + "run_id_sha256": "237a0b7d1cafb64b1d113dca6699e6eefeaaf0b18679138545c3695495b901d5", + "runner_receipt_sha256": "6d0df009a1feb328d36e628a4591440d773dad58dcbfaa89101c51dbf210e246", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "schema_version": "openadapt.qualification-trial-row/v1", + "started_at": "2026-08-18T10:22:00Z", + "task": "execute-acceptance", + "trial_index": 2, + "webhook_receipt_sha256": "fdb2a16e80f05e06a44ff752694761a289fa386ea14642e5412033c0636b48bf", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + }, + { + "attempt_id_sha256": "7573925adbd8a7a4a3b98bb0379549d77aa8ed46e312c1cd940c05b8587a039e", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "cleanup_absence_proof_sha256": "8d5373078fe224a410a6aa3c622308ea4058e7c846ec59ebba5d7288bc7fc3f2", + "cleanup_receipt_sha256": "8f293c1c43a0e7a6ca5aec96665bf2a869ce0ee065aa6ef5a5695a80765623f7", + "completed_at": "2026-08-18T10:24:00Z", + "condition": "healthy-03", + "execution_outcome": "verified", + "failure_class": "verified", + "fault_receipt_sha256": null, + "observer_receipt_sha256": "f0b50a9ab49377989815466eb28721d01c8ee89bff2b37a4a5f3c1901ce1cfc1", + "oracle_verdict": "satisfied", + "replay_report_sha256": "ada29f53b414f7aa7dd00232151d90f5f36d0f7d0c99f06d3c4e552088cc446e", + "run_id_sha256": "784a0a94e581700a3d93581e7ce5bac0d3bc53c58f3e73198b896b5da9a819b0", + "runner_receipt_sha256": "e824c2cd52e7d2ff5ecfa797b7d2e53fa7986c0a5ea5e77204511d9460662047", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "schema_version": "openadapt.qualification-trial-row/v1", + "started_at": "2026-08-18T10:23:00Z", + "task": "execute-acceptance", + "trial_index": 3, + "webhook_receipt_sha256": "b9e0d9c9f9ce5387a9cca061a4fd13f9f4dce4558a4295c86a2641ff038a4dbc", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + ] + }, + { + "condition_id": "idempotency-replay", + "expected_runtime_outcome": "verified", + "required_trials": 3, + "trials": [ + { + "attempt_id_sha256": "3142933f4f168c98b8e89f2ae9d78fd3129e0a9975cbbaa60ddba853eee7d53c", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "cleanup_absence_proof_sha256": "31e84b9a0133f40ac67e9fa8b9b59b7a56b3069952903232a7b00402effac1dd", + "cleanup_receipt_sha256": "53299c8e5f88e4000630fe3142648c66fa7ea8c0bae92b94606a9dccb387a3cf", + "completed_at": "2026-08-18T10:32:00Z", + "condition": "idempotency-replay", + "execution_outcome": "verified", + "failure_class": "verified", + "fault_receipt_sha256": null, + "observer_receipt_sha256": "3f9dbd4b5462c22c057ec74e389a00836aa7b3f2870a49095bb48310555f8b99", + "oracle_verdict": "satisfied", + "replay_report_sha256": "740b98f25b9a7bd1377ef51336f483823b8ab09f9e1ee7bad1075aee460a277d", + "run_id_sha256": "6cdff0cf50d0164fe1eee9c4b7db0b969c24f9b960f5653b516313a913c90a0f", + "runner_receipt_sha256": "1eb22d963181e3e47e20a19387d74eba9c265f9f2bc8ef3b5680f75db6cc94b0", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "schema_version": "openadapt.qualification-trial-row/v1", + "started_at": "2026-08-18T10:31:00Z", + "task": "execute-acceptance", + "trial_index": 1, + "webhook_receipt_sha256": "892f7c4bd8e3b8b91b3e349aba640c5c87c0268e74d72343c4d14d7a6eee57ed", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + }, + { + "attempt_id_sha256": "4667302b580ff7ceb223dbb15eb6d029969a8f6a54bcd33e8df5b6bff41f41ad", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "cleanup_absence_proof_sha256": "6dad0042578bd7c79c09e312aeb104931fde6dc82c7e85cf3d540c49ced11a0b", + "cleanup_receipt_sha256": "9e3bbbe8b2d5c7987be2fd3e29228f407319832eee70ef1bcb56fce353a8fec1", + "completed_at": "2026-08-18T10:33:00Z", + "condition": "idempotency-replay", + "execution_outcome": "verified", + "failure_class": "verified", + "fault_receipt_sha256": null, + "observer_receipt_sha256": "789bb7f6d5d3968fbaa87e3cffec42e18b036d53e2eb560a1fe1b3834fd27300", + "oracle_verdict": "satisfied", + "replay_report_sha256": "2a60a9e1e23380c3b33f8ca174cf3510660ac29a6e5a8ab2e3e2c678107613a4", + "run_id_sha256": "33e0ad9bf64e477f24d46508fa432123e046dcd1c5853d5cc60b7cde1bce7537", + "runner_receipt_sha256": "2fa257efdc7b2b5fbd3e5caa209d045d974201e96852760f38ca9a70bcd61755", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "schema_version": "openadapt.qualification-trial-row/v1", + "started_at": "2026-08-18T10:32:00Z", + "task": "execute-acceptance", + "trial_index": 2, + "webhook_receipt_sha256": "7faacd55bef5f183c095457453d97320383b2202519d772ae533661a701da791", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + }, + { + "attempt_id_sha256": "3aee8ad755c7f4bec71cc194bcfaa805e0ea29cf8b830ed0782f8263dd9620ca", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "cleanup_absence_proof_sha256": "59c12284d73e7334ebbca691f3076346f93c97e78dc807dd4a65678b5bc74e42", + "cleanup_receipt_sha256": "4d217e2a3ebb192fa8e2b2126a002c17c90e22d8562e7a749c5a0d922015d625", + "completed_at": "2026-08-18T10:34:00Z", + "condition": "idempotency-replay", + "execution_outcome": "verified", + "failure_class": "verified", + "fault_receipt_sha256": null, + "observer_receipt_sha256": "1ab983f4a4047724dfdb2f131ca6450811acb618a1bfee8e10844d5106065a36", + "oracle_verdict": "satisfied", + "replay_report_sha256": "a2945533984428f22741891a6ad7bb56d247cb48bcba5b1c04abd6d0bb874fe8", + "run_id_sha256": "3df83453126754a62d00ed10837720542d0469799bb8a88cb5257ac5f477a919", + "runner_receipt_sha256": "75ea2d7baeaecffbfa9b5fca73b8bf70e398697d76f9d1bec9a620bae3063765", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "schema_version": "openadapt.qualification-trial-row/v1", + "started_at": "2026-08-18T10:33:00Z", + "task": "execute-acceptance", + "trial_index": 3, + "webhook_receipt_sha256": "f8c79e22c64f0b26775b0c105f8087f5fa147fa7cb3e7888bfcd6f6499cea2e3", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + ] + }, + { + "condition_id": "wrong-reference", + "expected_runtime_outcome": "halted", + "required_trials": 3, + "trials": [ + { + "attempt_id_sha256": "e93521e706ad90d799dcd4e8cac15229c5da6aec1638540606f5fab4efce59fc", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "cleanup_absence_proof_sha256": "acf6d491add27b4b7a31a472243d873a000b70e758fd0adb6625e279dfa05dd3", + "cleanup_receipt_sha256": "1e611a0e77ce192cc9f46fe9544472b3352f58c6a8f3f1377c7a688a8a18d702", + "completed_at": "2026-08-18T10:42:00Z", + "condition": "wrong-reference", + "execution_outcome": "halted", + "failure_class": "safe_halt", + "fault_receipt_sha256": "e7de3e25e41b185b7d787423eb75096f31c60c53bb16339deb6cc1d34631dcb3", + "observer_receipt_sha256": "a0e9b443f4c32b7625331527491aa59f8e106cc72042f16e6b6a821cd0f7fccf", + "oracle_verdict": "satisfied", + "replay_report_sha256": "4964bd1ea76f57d04c90ac2cb32ad42b9aa24e8c8d42439c7c7a4176d8a5589e", + "run_id_sha256": "ee82112f55e5e6c86cfd6e16df8c8b652549a8bd72de492f435d8255eb3dd252", + "runner_receipt_sha256": "8fc04ed993b5b503978034b069e82430afd713fec60fe7dd998675c5995d93ab", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "schema_version": "openadapt.qualification-trial-row/v1", + "started_at": "2026-08-18T10:41:00Z", + "task": "execute-acceptance", + "trial_index": 1, + "webhook_receipt_sha256": "79aa9017fd55bce5532f4bc6ca88aaaf1244fd3eb00acbae04d8b2eb2529b836", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + }, + { + "attempt_id_sha256": "6b0e5c10d55fc92c1ff8576392270a24fb65722414cf58ff9a51b8ce9ef88587", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "cleanup_absence_proof_sha256": "e559276a48fe1c67b3d827bf49a6fa86b069834a9ac294c570b0e429410aabd5", + "cleanup_receipt_sha256": "d7ea0a0b1670116dd9bd45378335199d7805fd2c8b56b2e52b7d8b8df1a2d376", + "completed_at": "2026-08-18T10:43:00Z", + "condition": "wrong-reference", + "execution_outcome": "halted", + "failure_class": "safe_halt", + "fault_receipt_sha256": "4e04402568630dfc4590fbecf04015269f4a6e6546e276a92bf4b6b657f8a8db", + "observer_receipt_sha256": "ae73206f663e332e61d69c76ec221fa5e456e5c8b847b5b21543900b03f93105", + "oracle_verdict": "satisfied", + "replay_report_sha256": "261cb4aedf65989c753e88445ab1c34145bd44ff72212cd80c99418d0e47877d", + "run_id_sha256": "577e37b10b1c87fd9c1b5d320888b736d272824657fd59a012e85a284ee88540", + "runner_receipt_sha256": "fb7adef7d6907ae3e36182ff1a4574e6d2900ba700648928333295be904cedc5", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "schema_version": "openadapt.qualification-trial-row/v1", + "started_at": "2026-08-18T10:42:00Z", + "task": "execute-acceptance", + "trial_index": 2, + "webhook_receipt_sha256": "9dc862e47d7e3dc1cfa80048c17b4c566a36aff741e4a7914b3dc0e9c3729b13", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + }, + { + "attempt_id_sha256": "7c910764b2dcc6f05261d609082f75474e4638c3f356006307212b8fed4a2eb7", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "cleanup_absence_proof_sha256": "6bd1e4fa831b1274c6011187dec731e64b9076912681ddfbfbf53f68ab826b86", + "cleanup_receipt_sha256": "56b976ecc7eab49bd4b71a8735efac41939cd37654e0a90b7e45053ead2b8d73", + "completed_at": "2026-08-18T10:44:00Z", + "condition": "wrong-reference", + "execution_outcome": "halted", + "failure_class": "safe_halt", + "fault_receipt_sha256": "ca4213a203a9c2047c114c5bbd18837bf2d44fd2a9741b850ca6abf26e4934a9", + "observer_receipt_sha256": "10b9c9e23bb12807fe3446fa41b66ecc1df3f7720d4a6bd018243668a85afb14", + "oracle_verdict": "satisfied", + "replay_report_sha256": "2b4060abcc8e69b9f87cb79a3b378fe93014566680b4140b3f5dff1b23c3af85", + "run_id_sha256": "fe98ce7f0e66b885201f4667875fd38f5890ffddb575d68bd4cd5a66f8d53ca8", + "runner_receipt_sha256": "3f1d8304c662af081aae90b0d6ffb2e01f21c5debf95a740595bd97d740965dc", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "schema_version": "openadapt.qualification-trial-row/v1", + "started_at": "2026-08-18T10:43:00Z", + "task": "execute-acceptance", + "trial_index": 3, + "webhook_receipt_sha256": "0d4542a41deb0cb2b3f9291f4067d2fe88924884c6efcd742b85f7504d2840eb", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + ] + }, + { + "condition_id": "stale-session", + "expected_runtime_outcome": "halted", + "required_trials": 3, + "trials": [ + { + "attempt_id_sha256": "fbfce2be9ce964be8b668aa518a310fe4a89e5c014f42bd0ea81401bd83bfd7a", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "cleanup_absence_proof_sha256": "765f8d15ba0ee4a35a281110faf81931a4bef2ff9a530050d2be0097c13e1f15", + "cleanup_receipt_sha256": "b1ceae7aa3fdcfabe16c842627a0b05f92894b90653fc43682f45975a9a69c4c", + "completed_at": "2026-08-18T10:52:00Z", + "condition": "stale-session", + "execution_outcome": "halted", + "failure_class": "safe_halt", + "fault_receipt_sha256": "47801787a92ee5738ee64b2bc3cda555dfc53682673d70e11bb9f94f799b371a", + "observer_receipt_sha256": "ea2c537ac99f78c9175fc41640fc030b6139c33c02ffa964597672932f1bc149", + "oracle_verdict": "satisfied", + "replay_report_sha256": "48204dcfbb7f14bb9885b499109da046b6455d3e2cdf47b6f017cf1aae9cf2f4", + "run_id_sha256": "d9270fd4c85e4226a9347ecf703e876b9ffdc330f60c7fb8bed8f9321ea30225", + "runner_receipt_sha256": "f35aeb8c55ead7bbe677fd5fc293f41185ff75aa21101128a8c0d9fa4a591f05", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "schema_version": "openadapt.qualification-trial-row/v1", + "started_at": "2026-08-18T10:51:00Z", + "task": "execute-acceptance", + "trial_index": 1, + "webhook_receipt_sha256": "1847925251f6ac7a782baf4a381494cc662ad60bf1c0f2f3eddaecbc86940c29", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + }, + { + "attempt_id_sha256": "f5df4d6e64a2d38ffa8e320c87ad05d04025de267a8e152a755d3f1928ded120", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "cleanup_absence_proof_sha256": "0f5b6ed8cfa03ef7f89f57a9a07926cd8fd9183b69e720ab914196b5fe9cdcd3", + "cleanup_receipt_sha256": "2995df9d47d9de4b42c9b5d90e71af5e47cc4bfac9fa9d9eb15ca521da785f02", + "completed_at": "2026-08-18T10:53:00Z", + "condition": "stale-session", + "execution_outcome": "halted", + "failure_class": "safe_halt", + "fault_receipt_sha256": "97f6959aeb4a3659829a200f85e403a6001866e6495675fd3fe27542ed765ea2", + "observer_receipt_sha256": "e37d0a752e30a9964257bb1bc5def9409f3902ef3d739aa88b0a91048e9715e3", + "oracle_verdict": "satisfied", + "replay_report_sha256": "1ac32da3abb3085b0b9ff8093c06f8e5cfb3cd290d1ae053ca0b99807a81f759", + "run_id_sha256": "fd3a041b705d8c6277ce26134dc0018e866218cfa3fadd16ac29d1ad498965a3", + "runner_receipt_sha256": "50cfc15f662201c2e03cf91d2156a213a28ab028cc4856c64d7da2204a5cdc55", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "schema_version": "openadapt.qualification-trial-row/v1", + "started_at": "2026-08-18T10:52:00Z", + "task": "execute-acceptance", + "trial_index": 2, + "webhook_receipt_sha256": "0b0efbd1f00044f8f2fb8e1107723509061a4ad86a0eb9118c551ef806212465", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + }, + { + "attempt_id_sha256": "958342a9ddca98a83b82b662f52f404239d583afe7ed70634760e1b8dd592f3b", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "cleanup_absence_proof_sha256": "2ee187a8c4b7240ee8767499afd16c6efc9356a3211766d00910d0ea2294a76e", + "cleanup_receipt_sha256": "ec0a1bc99a2e3e8249dafda43f54e76d647c86464d87e1caf40480f35f460868", + "completed_at": "2026-08-18T10:54:00Z", + "condition": "stale-session", + "execution_outcome": "halted", + "failure_class": "safe_halt", + "fault_receipt_sha256": "cff75b636a312f1bb5f2e99eb6935abe16347884df3077f72780662d31804a38", + "observer_receipt_sha256": "893a8247b0fc26e0c36954a23409a8930a5e70fd085f987726277a3a30622f9f", + "oracle_verdict": "satisfied", + "replay_report_sha256": "34e01549f75b1a8132541730937ba43e9f673d0886239a3adae2142502961c03", + "run_id_sha256": "6f2fb10bc2018c9f78e9702d5ccac0bedd78ee3b2e9d2a6ad779fba72d90ae50", + "runner_receipt_sha256": "8aeff82557645b5c4719bd7dc52daff351274389e5be8e98bdf6191acb475984", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "schema_version": "openadapt.qualification-trial-row/v1", + "started_at": "2026-08-18T10:53:00Z", + "task": "execute-acceptance", + "trial_index": 3, + "webhook_receipt_sha256": "661cc3ad4b5da051980466dc525c7a6b1366756913780519657bf5b148ce440e", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + ] + }, + { + "condition_id": "ambiguous-target", + "expected_runtime_outcome": "halted", + "required_trials": 3, + "trials": [ + { + "attempt_id_sha256": "60ee9db05b1126cfaa3b31c13bc3fab4755ac09c44e846b4d07ee51865dfa7b1", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "cleanup_absence_proof_sha256": "b650e56035131f355c13d2d3948cc452fce8dae01d5bf2dd7ea3435c0b013e87", + "cleanup_receipt_sha256": "1a219a5a11101378903c40163101018c2d55b6877d88cdb3b29d1116de3e952a", + "completed_at": "2026-08-18T11:02:00Z", + "condition": "ambiguous-target", + "execution_outcome": "halted", + "failure_class": "safe_halt", + "fault_receipt_sha256": "c8eacb7caeaa9125a97121ca8bfdfe848cf5d658a0c88b163b326c9db99949f8", + "observer_receipt_sha256": "4cfd8a817a8c1420280b8aea0a449a467135ebcbc3bb6295e2a1a908a0d22a8a", + "oracle_verdict": "satisfied", + "replay_report_sha256": "00acd7fd6d1a4eb625a7d16057f94ceb1da3f8a05f8cb6f07a83d760c8f778af", + "run_id_sha256": "628f991a182613b8700294d7483b5a4c06872cb9d5ca6047ea552b8ab6585357", + "runner_receipt_sha256": "37179d92aae8590ec9894154d581e654113f2fcb230673b466c345c5e68d7003", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "schema_version": "openadapt.qualification-trial-row/v1", + "started_at": "2026-08-18T11:01:00Z", + "task": "execute-acceptance", + "trial_index": 1, + "webhook_receipt_sha256": "9631c84144936efd84f60d5becc81b736dcd00dca94797ec7ab3dc2a4152a80f", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + }, + { + "attempt_id_sha256": "1ec11a9862ede3ac701af71835ac28c551d604a026b5bab7d776dbcdf288394e", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "cleanup_absence_proof_sha256": "af535e76d2f849ee84e5d54123508736219c482ac68737053ba110dc5330ad2e", + "cleanup_receipt_sha256": "6909ceef7116356c56ca4737de1356b656ee491362571e3b50e588b4f6359b17", + "completed_at": "2026-08-18T11:03:00Z", + "condition": "ambiguous-target", + "execution_outcome": "halted", + "failure_class": "safe_halt", + "fault_receipt_sha256": "590846759c1280e18e608456c0e11b64221cfcafa73ab8f061d6dcb5fd762699", + "observer_receipt_sha256": "88aa95277a9bbc5666ac0b4a542bafa91ac60ee30d5fff79647d9ef050f10b75", + "oracle_verdict": "satisfied", + "replay_report_sha256": "d9a6d4aa7064e5bfba2fb43680aa1891a29249aa899b5c4e7d2858aa8b27825b", + "run_id_sha256": "43f0a1c00950c390b0676fab55a2aa98c354d028f2347c461661e6cdb72f717e", + "runner_receipt_sha256": "250a2d98c537e0180459263bb61f21c6a1f12c144bc064ed993961fd98511ac5", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "schema_version": "openadapt.qualification-trial-row/v1", + "started_at": "2026-08-18T11:02:00Z", + "task": "execute-acceptance", + "trial_index": 2, + "webhook_receipt_sha256": "0da9d385b5d1c9805b8bccc2598fd48e59365ca8b14f37dc943b7b12777850c4", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + }, + { + "attempt_id_sha256": "491a544656d05aea37920e5c7e2ad65a9452eac8d6e100268a599aeebd41187a", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "cleanup_absence_proof_sha256": "fcc4e2987962120108fd11d6baf6c9d8c4c9b0bc5a2c6bce166f3bae1d328b50", + "cleanup_receipt_sha256": "2cb93f1da48f525ba6706aa6e042d870bf902fc22ed125fa90e9692d5a6ea1e9", + "completed_at": "2026-08-18T11:04:00Z", + "condition": "ambiguous-target", + "execution_outcome": "halted", + "failure_class": "safe_halt", + "fault_receipt_sha256": "0fb52130820a183fa318c24dd0e504f3505ca28f32a98d6fee032f6b19642a37", + "observer_receipt_sha256": "dee002824b0aacb73e258cbf2ffce66cdb8870f871b0f750e7d299102e153341", + "oracle_verdict": "satisfied", + "replay_report_sha256": "386dbd16e6ae7d1d0b6c82a6992fe211c81630928689722057964a0dda3c3942", + "run_id_sha256": "aa62c7a17701a7ef01ea1d3519b4c1f90d357495b329fdda3054cc24c581a593", + "runner_receipt_sha256": "3d8eb365f4d3b3332b5d8416e465962d4c3c1b55f12f6500d62144fb512a6051", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "schema_version": "openadapt.qualification-trial-row/v1", + "started_at": "2026-08-18T11:03:00Z", + "task": "execute-acceptance", + "trial_index": 3, + "webhook_receipt_sha256": "11b317991d7ac80a31d423d73f9b0312af2f7e53eeda77e640a524650611e77d", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + ] + }, + { + "condition_id": "verifier-unavailable", + "expected_runtime_outcome": "halted", + "required_trials": 3, + "trials": [ + { + "attempt_id_sha256": "f5e96a2e9a580376b18beabf57798b8761e772a0c4d112877045780bb12b3720", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "cleanup_absence_proof_sha256": "c2f2b635cde60b553f1722c8593bb95ad7ed7023307693e3f024ffb125165db6", + "cleanup_receipt_sha256": "4862d7d39d33f17de4c889096ecaa907d1584807b22fc916e2a15d2462e70696", + "completed_at": "2026-08-18T11:12:00Z", + "condition": "verifier-unavailable", + "execution_outcome": "halted", + "failure_class": "safe_halt", + "fault_receipt_sha256": "a871118c067954b7150653696449fa0d547da2cb75a906394a899d7e81811365", + "observer_receipt_sha256": "a8b00915dcebc57be31a774634b0371cd299935f86c7c0213fdaf215480cb6c1", + "oracle_verdict": "satisfied", + "replay_report_sha256": "8979e7a57aae81f1b0da3757d74783fdd94996bfc44fbdda9843885daecad6fc", + "run_id_sha256": "e8e89651045a5f5c011c9543ed968e0fe7697a061ed8ad5cedc27d194cb96acb", + "runner_receipt_sha256": "dfcca365e78d63d5b6107cff019f577018420e7e4e6863991f92dbcb51ad4406", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "schema_version": "openadapt.qualification-trial-row/v1", + "started_at": "2026-08-18T11:11:00Z", + "task": "execute-acceptance", + "trial_index": 1, + "webhook_receipt_sha256": "45f1eee738934969cca1cb5fcdaed7dab6398cd9a05a7050822e88293b5d4cc7", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + }, + { + "attempt_id_sha256": "42259dbb767ced4c25ad8bd40edc209720a748897194c925ed9bd2e27b2258b2", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "cleanup_absence_proof_sha256": "5ba58c2263a1dd72bb9bd200222709f04dadba7bebbf1d1bec3e779780f39c7b", + "cleanup_receipt_sha256": "30943ab2222e8fd4fb98d2a4e6ca8bd944800dc26e136492f4616f4e8d8f1ec4", + "completed_at": "2026-08-18T11:13:00Z", + "condition": "verifier-unavailable", + "execution_outcome": "halted", + "failure_class": "safe_halt", + "fault_receipt_sha256": "38d632dc612aa9d18bc141fea23812d46fb9345a230b4e58b53336402a2a9289", + "observer_receipt_sha256": "465866a38613308e52f541786521a40df3e6444bc5dab1858e13e061239193c7", + "oracle_verdict": "satisfied", + "replay_report_sha256": "abca187283c219dbc776aaae8d38842e8ef0ae7b56007f5a6708f27e161e997a", + "run_id_sha256": "4af84f2608a25a27e6252a5800263a238bb70fb3bec65148601ddcdddbf3e03c", + "runner_receipt_sha256": "d71287d6a633a01d9edcc3f0c7552799e586aa942dff0330cc13238333f676cf", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "schema_version": "openadapt.qualification-trial-row/v1", + "started_at": "2026-08-18T11:12:00Z", + "task": "execute-acceptance", + "trial_index": 2, + "webhook_receipt_sha256": "eb31e3c8e4d77a0dcc9e9204ce5c8761e52cd666cae9cdf2c79ff209ea3a6e22", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + }, + { + "attempt_id_sha256": "ad76dacfe19a4421ef1f128d4eef1099e846b385d29f17b8588ae5130b487118", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "cleanup_absence_proof_sha256": "bcf1ed30725b2853e7f37119a06ccb2838942b32c14d4d0a69378932349f5620", + "cleanup_receipt_sha256": "471f74bd9498b31888a1ec333c7d225af618fe9a072dd2952587bb50bcd6a170", + "completed_at": "2026-08-18T11:14:00Z", + "condition": "verifier-unavailable", + "execution_outcome": "halted", + "failure_class": "safe_halt", + "fault_receipt_sha256": "4b3a4b3c9eca7b6cc75e95ac329d8825b3caa30aa49f425d714f2409a566485f", + "observer_receipt_sha256": "be295e21b91bb577b764151cd66a1a1aaf4302809b9a52766361d108611afe74", + "oracle_verdict": "satisfied", + "replay_report_sha256": "9ff950e9dfd77d6c9e04fba2111f9e49115c2bb248ba26e3441a76a60d07eb18", + "run_id_sha256": "87014cd8063f5a43ea22c995be03ec41ef5aa613145acacdef71b68c468fc8f1", + "runner_receipt_sha256": "8c5e9d5c0d5330e70eceb4a7a0b11295161a7f4ca9ad6c8af091fde8afb1c6a9", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "schema_version": "openadapt.qualification-trial-row/v1", + "started_at": "2026-08-18T11:13:00Z", + "task": "execute-acceptance", + "trial_index": 3, + "webhook_receipt_sha256": "b881269a603f7e323a56c17fd2d2f6db9e20485ee7687ece93f22aa12b7ea69d", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + ] + }, + { + "condition_id": "weak-effect-only", + "expected_runtime_outcome": "halted", + "required_trials": 3, + "trials": [ + { + "attempt_id_sha256": "73a097b8b20bab7794369384f7ca1d7d711aad07967b7e1292373babbb7ff1b7", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "cleanup_absence_proof_sha256": "e4a4e9961ad6f679f61438dfadc80c1c45d213a25e9a508d1f3008fc2c652f9e", + "cleanup_receipt_sha256": "1d0d33cddb33f11719b645321ab4b811110a7dda9dada423fce56eef9337f6b9", + "completed_at": "2026-08-18T11:22:00Z", + "condition": "weak-effect-only", + "execution_outcome": "halted", + "failure_class": "safe_halt", + "fault_receipt_sha256": "07e68326931f9e91b6195accd0a81480662998a9e6fcba52c3348fe00448d206", + "observer_receipt_sha256": "caf4bdd8d724820689f50a52d92a1280fbc90215c7b12991b3681541fd8c2206", + "oracle_verdict": "satisfied", + "replay_report_sha256": "8dd51f7605352784d26b1cc7c77746ebfd297d51b90a2953f7282228bbaf7591", + "run_id_sha256": "b44783e70a980ec5b3cf3752bd5d1d01b2ff29f5a6892cba0c1c939d8aeb7c02", + "runner_receipt_sha256": "6e3b9d04b81cf54fb150be35e2d27acdd45247573f0a933e42cca67796427eb5", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "schema_version": "openadapt.qualification-trial-row/v1", + "started_at": "2026-08-18T11:21:00Z", + "task": "execute-acceptance", + "trial_index": 1, + "webhook_receipt_sha256": "ce56478b940c828f034cfd1c6ebc41185771a3154a621076db6d36a4d706b413", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + }, + { + "attempt_id_sha256": "eb52fb1b1bf2fac92d8f3a444bb5081161be8b3d0ef457c5065e7b79e96df770", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "cleanup_absence_proof_sha256": "acbcfae15099ebc8a2d63b87be87a0431e560968cb06899ee82754ccecec1b9f", + "cleanup_receipt_sha256": "ed82b83288101e083452346de7469ed7b1fd050e29e6bafac2e7691a37a8992b", + "completed_at": "2026-08-18T11:23:00Z", + "condition": "weak-effect-only", + "execution_outcome": "halted", + "failure_class": "safe_halt", + "fault_receipt_sha256": "418572792d67d3158bae6f0ab06a3c5e6aac3b56333c28fd7e00bf7452be9c0b", + "observer_receipt_sha256": "b92631c4736c084b0a8f01f7dee8d27672b7cffab352fca684f025b0e9f66b02", + "oracle_verdict": "satisfied", + "replay_report_sha256": "5702bcf5ba24d9f8ff0df4cc5fd89d67a89b385d7de2d45101840a56f183003a", + "run_id_sha256": "794033f9da2a42448254a478fb6de954898b1e544148708ad30264efdc255431", + "runner_receipt_sha256": "9360f101c663dba041ccc6d4531e5d0924cc0f4425f62aa51e3b90b145d93adf", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "schema_version": "openadapt.qualification-trial-row/v1", + "started_at": "2026-08-18T11:22:00Z", + "task": "execute-acceptance", + "trial_index": 2, + "webhook_receipt_sha256": "8e671061a2ed724aebae4da714f8342c7aa1156a8151018c4cd45e8ea2b13a4e", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + }, + { + "attempt_id_sha256": "aa7d6be4f25a8992c0a22649ba7e703d6955abf5fece9f8322f560149cf09776", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "cleanup_absence_proof_sha256": "b8f596a87c49f45f75a055ed31e6c86f591fefd2cda6c1778bdd3212b4175e0b", + "cleanup_receipt_sha256": "c1d15f47a1fad41c545fa9c0c26422c179518fea0841d1f3551ab1070a4669d9", + "completed_at": "2026-08-18T11:24:00Z", + "condition": "weak-effect-only", + "execution_outcome": "halted", + "failure_class": "safe_halt", + "fault_receipt_sha256": "bfdd995c0709fd95a59fd044664d11d88fc4d51b2df6b3525c384df39504e087", + "observer_receipt_sha256": "4157e3e1e661cb3eb666347e1777e7a0f91db0beded1a3894b9bba5d60b8d7b8", + "oracle_verdict": "satisfied", + "replay_report_sha256": "09ce45437a9d439b6fad70b045da259bdb7d96b2ca71035bcaf3036ee641e7a2", + "run_id_sha256": "b974de9da8ef77c8dc9a7662114cc51023ab8c131c488681eeebb7d4c435c8d0", + "runner_receipt_sha256": "745ccd149ea968ca38642bd362a867a92243f9a556b8653b2be088f0fa636a36", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "schema_version": "openadapt.qualification-trial-row/v1", + "started_at": "2026-08-18T11:23:00Z", + "task": "execute-acceptance", + "trial_index": 3, + "webhook_receipt_sha256": "d5ec8f549f8730997d735287bc83fa1d1e008de2960d14ebcbb4b140ff1fdd8a", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + ] + } + ], + "decision": "admitted", + "excluded_trials": [], + "generated_at": "2026-08-18T11:55:00Z", + "invariants": [ + { + "holds": true, + "id": "no_wrong_or_duplicate_effect", + "observations": 27, + "violations": 0 + }, + { + "holds": true, + "id": "zero_model_healthy_path", + "observations": 12, + "violations": 0 + } + ], + "oracle_contract": { + "attempt_accounting": "signed_campaign_attempt_index", + "cleanup_evidence_source": "signed_cleanup_receipt_and_observer_absence_proof", + "delivery_outcome_source": "signed_managed_runner_and_webhook_evidence", + "effect_outcome_source": "independent_system_of_record_observer", + "fault_evidence_source": "signed_named_fault_driver_receipt", + "runtime_outcome_source": "signed_flow_run_receipt", + "schema_version": "openadapt.execute-acceptance-campaign-oracle/v1" + }, + "qualification_contract": { + "cases": [ + { + "expected_outcome": "verified", + "id": "healthy-01", + "kind": "representative" + }, + { + "expected_outcome": "verified", + "id": "healthy-02", + "kind": "representative" + }, + { + "expected_outcome": "verified", + "id": "healthy-03", + "kind": "representative" + }, + { + "expected_outcome": "verified", + "id": "idempotency-replay", + "idempotency_key_parameter": "transaction_ref", + "invariant": "the exact healthy-01 canonical input and transaction_ref replay returns the same execution and creates no second effect", + "kind": "representative", + "replays_case": "healthy-01" + }, + { + "expected_outcome": "halted", + "id": "wrong-reference", + "kind": "wrong_identity" + }, + { + "expected_outcome": "halted", + "id": "stale-session", + "kind": "stale_identity" + }, + { + "expected_outcome": "halted", + "id": "ambiguous-target", + "kind": "ambiguity" + }, + { + "expected_outcome": "halted", + "id": "verifier-unavailable", + "kind": "missing_effect" + }, + { + "expected_outcome": "halted", + "id": "weak-effect-only", + "kind": "weak_effect" + } + ], + "classification": "private-product-owned-synthetic", + "cleanup": { + "failure_outcome": "reconciliation_required", + "required": true, + "required_evidence": [ + "signed cleanup receipt", + "independent observer absence proof" + ], + "scope": "every synthetic transaction reference issued for this campaign" + }, + "effect_contract": { + "kind": "record_written", + "match": { + "transaction_ref": "$param:transaction_ref" + }, + "observer": "separate read-only synthetic transaction observer", + "observer_request": { + "auth": "bearer environment reference", + "method": "GET", + "path": "/api/internal/execute-acceptance/observer?transaction_ref={transaction_ref}", + "records_key": "records" + }, + "required_strength": "independent_system_of_record" + }, + "fault_case_receipts": { + "case_kinds": [ + "wrong_identity", + "stale_identity", + "ambiguity", + "missing_effect", + "weak_effect" + ], + "required": true, + "signer": "named trusted fault driver" + }, + "post_campaign_invariant": "the observer confirms that every synthetic transaction ref used by this campaign is absent after cleanup", + "required_capabilities": [ + "browser_observation", + "browser_actuation", + "identity_verification", + "independent_effect_verification" + ], + "runtime": { + "openadapt_flow": { + "healthy_path_model_call_limit": 0, + "release_channel": "post-337", + "release_identity_required": true + } + }, + "schema_version": "openadapt.execute-acceptance-qualification/v1", + "target": { + "browser_only_write": true, + "entry_url": "https://app.openadapt.ai/execute-acceptance/target", + "reference_input_selector": "input[data-testid=transaction-ref]", + "transaction_ref_parameter": "transaction_ref" + }, + "task_id": "execute-acceptance" + }, + "receipt_envelopes": { + "00acd7fd6d1a4eb625a7d16057f94ceb1da3f8a05f8cb6f07a83d760c8f778af": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "LMblyrBXpBlSsZ1dnFJOd4ebFoyEYxR/iOLJH0vy2/jwZXolCI34J0aEN4766Lnw6Ekcm6dNBc/XlnoXL81zAg==", + "source_artifact_sha256": "ddb254eb6e2490fcb9e2b2952775ac00220ba9a95a70f4f784bec71ab5df37b7", + "verified_at": "2026-08-18T11:02:00Z", + "verified_projection": { + "attempt_id_sha256": "60ee9db05b1126cfaa3b31c13bc3fab4755ac09c44e846b4d07ee51865dfa7b1", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "ambiguous-target", + "evidence_sha256": "ddb254eb6e2490fcb9e2b2952775ac00220ba9a95a70f4f784bec71ab5df37b7", + "run_id_sha256": "628f991a182613b8700294d7483b5a4c06872cb9d5ca6047ea552b8ab6585357", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "halted", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "020265c9483aadd4321f39f4bd35ad152b53d5fcebc96c044fa1d84ea860e614": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "Q1BchDcNoIt/q1AI8/kcaTsDSvmhOfwobkBlhOzz0B8UJvr9/kZX04v5SpoFPYtCSgnpQgEsrcKD6vq58uzMCA==", + "source_artifact_sha256": "67d2fc6cdd3fbe39ae3cd6003edb1e7069940afea7f0c3b00794713d26646677", + "verified_at": "2026-08-18T10:13:00Z", + "verified_projection": { + "attempt_id_sha256": "3d42601a69ef46cc44f57b51762affef4ccd829ffde30125619a6e582af00dab", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-02", + "evidence_sha256": "67d2fc6cdd3fbe39ae3cd6003edb1e7069940afea7f0c3b00794713d26646677", + "run_id_sha256": "091e13ed70dab439b31cb506cf3bba1ddf6476696531cf891c39a924a928b7a1", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "delivered", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "033d48209efa84280e3035d72ed0627a27cb43d45f6e05d277e23f164f345472": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "2Ln6s7qumx+7m23Z7tPsryQImLX6b08yq/F6zdTmAtk/iM7AjHR8ZhQX34Ogzdv4ySmg798cZDH4A/2cEUR8Aw==", + "source_artifact_sha256": "5774a782f9ec582ec3f9a710ccfee0a6b3fd6076d73029b33889cbb99d0526ed", + "verified_at": "2026-08-18T10:14:00Z", + "verified_projection": { + "attempt_id_sha256": "019dd96e9a771ccc01ebafab321d7d3a8314df8b2d6465bcfc5fa14cbdeabdf2", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-02", + "evidence_sha256": "5774a782f9ec582ec3f9a710ccfee0a6b3fd6076d73029b33889cbb99d0526ed", + "run_id_sha256": "16cb8df40654c6a1b55ea0e50e772d8c6e6d4f0d8205bd1f8296be27d0af83eb", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "delivered", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "0668d3958131859deae05b675b6859b48e043adf1443d21f19a6bfc1c6bbc6ad": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "QVlHQ3lNpxMZpMo6bIwVS5yHtk0E2xEhTZtjU/jjDFrRDzSlp8ZYfxj2pVMQyUKnfsojmgO0L1QhMX8PyNmcDw==", + "source_artifact_sha256": "f48ec4e4f6e1af9e9a55730fef4ff0bc364683d1c08d1e0399281699f0f49444", + "verified_at": "2026-08-18T10:04:00Z", + "verified_projection": { + "attempt_id_sha256": "4c352a6999f77707e8837adebb4fc2b7451c2ef6de5145190b33a5c5645e47eb", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-01", + "evidence_sha256": "f48ec4e4f6e1af9e9a55730fef4ff0bc364683d1c08d1e0399281699f0f49444", + "run_id_sha256": "4ee2bb61fb883cc8e77d636fb471aa3c0ce9ef0c0a8abd9682214bf0a8f16f26", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "absent", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "07e68326931f9e91b6195accd0a81480662998a9e6fcba52c3348fe00448d206": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", + "receipt_type": "fault", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "JX8ih23WEk+kiDCrQWjmcrQ4qo6ObAC77x0DZ0dnHcpZPwLKimhE2rqvZvuaFeNnruPSaLiGJw+GYZ8MdoyDAg==", + "source_artifact_sha256": "753ac5d5256a729ac572debdef63e5a8acd11b2b6ef909f8efb94d885f37d065", + "verified_at": "2026-08-18T11:22:00Z", + "verified_projection": { + "attempt_id_sha256": "73a097b8b20bab7794369384f7ca1d7d711aad07967b7e1292373babbb7ff1b7", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "weak-effect-only", + "evidence_sha256": "753ac5d5256a729ac572debdef63e5a8acd11b2b6ef909f8efb94d885f37d065", + "run_id_sha256": "b44783e70a980ec5b3cf3752bd5d1d01b2ff29f5a6892cba0c1c939d8aeb7c02", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "injected", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "09ce45437a9d439b6fad70b045da259bdb7d96b2ca71035bcaf3036ee641e7a2": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "TSq6weZF/VyML5H6sli/Q82n4wniZ0ZUaGTWeDyhRV1GB5e7fhf/QL4YMlruVSIHk7PMOEeeJPnZMcCvgj/WBw==", + "source_artifact_sha256": "65140882628aea7d2f64f788fcf9fcb6addfd372449a58a0221ac27b0355af3f", + "verified_at": "2026-08-18T11:24:00Z", + "verified_projection": { + "attempt_id_sha256": "aa7d6be4f25a8992c0a22649ba7e703d6955abf5fece9f8322f560149cf09776", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "weak-effect-only", + "evidence_sha256": "65140882628aea7d2f64f788fcf9fcb6addfd372449a58a0221ac27b0355af3f", + "run_id_sha256": "b974de9da8ef77c8dc9a7662114cc51023ab8c131c488681eeebb7d4c435c8d0", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "halted", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "0b0efbd1f00044f8f2fb8e1107723509061a4ad86a0eb9118c551ef806212465": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "WbJMIMWV2FTF/08CK5Mfi8faZ79UNKEQ4nmJodLIZp63mocDufdIMszb3cTSwS/0IQZmT5mfFGvmSqJuA5FnBg==", + "source_artifact_sha256": "ce91f56ef05d03386741ded56d7c2728b371c0ffcd8dc025c0dcad239242f6d5", + "verified_at": "2026-08-18T10:53:00Z", + "verified_projection": { + "attempt_id_sha256": "f5df4d6e64a2d38ffa8e320c87ad05d04025de267a8e152a755d3f1928ded120", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "stale-session", + "evidence_sha256": "ce91f56ef05d03386741ded56d7c2728b371c0ffcd8dc025c0dcad239242f6d5", + "run_id_sha256": "fd3a041b705d8c6277ce26134dc0018e866218cfa3fadd16ac29d1ad498965a3", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "delivered", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "0d4542a41deb0cb2b3f9291f4067d2fe88924884c6efcd742b85f7504d2840eb": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "SHkE4txHMopCdNVErTNV9kaeiiRiXro93k9n0ySd9eRkxgoN00CCB/6RXOBInVNt5LOpAY/fZRXGmWXoPn7ODw==", + "source_artifact_sha256": "2c464c80d9d0976e30c3c1b674426f3db967a0264e7bb8ee48984e6b235a5a80", + "verified_at": "2026-08-18T10:44:00Z", + "verified_projection": { + "attempt_id_sha256": "7c910764b2dcc6f05261d609082f75474e4638c3f356006307212b8fed4a2eb7", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "wrong-reference", + "evidence_sha256": "2c464c80d9d0976e30c3c1b674426f3db967a0264e7bb8ee48984e6b235a5a80", + "run_id_sha256": "fe98ce7f0e66b885201f4667875fd38f5890ffddb575d68bd4cd5a66f8d53ca8", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "delivered", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "0da9d385b5d1c9805b8bccc2598fd48e59365ca8b14f37dc943b7b12777850c4": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "aacNxYSnrwOQg/qSzfnZasKVwZPdJYxAcGKxJ+mqNRhCshjqmMeUYryjkCItQvi1cZ05MHD9Tms0TZKCqt9MDQ==", + "source_artifact_sha256": "5d0a6686e8f1d277c080d35d24db5e2f371ce4a69ee7b9d275d63a34af50f9d2", + "verified_at": "2026-08-18T11:03:00Z", + "verified_projection": { + "attempt_id_sha256": "1ec11a9862ede3ac701af71835ac28c551d604a026b5bab7d776dbcdf288394e", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "ambiguous-target", + "evidence_sha256": "5d0a6686e8f1d277c080d35d24db5e2f371ce4a69ee7b9d275d63a34af50f9d2", + "run_id_sha256": "43f0a1c00950c390b0676fab55a2aa98c354d028f2347c461661e6cdb72f717e", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "delivered", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "0f5b6ed8cfa03ef7f89f57a9a07926cd8fd9183b69e720ab914196b5fe9cdcd3": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "rBFZeakz1mFX63iIkkopZGvzPPA+L7k8bIX0Z6sn+Iidkm9H/1D2ei2i2fk+ZGV3UxRuaKhXwEXwksU0GLTwAw==", + "source_artifact_sha256": "2a7ccbc187c0627ad574c752f1aea534e5f283859d8b8e6fcdeaad3e603d4386", + "verified_at": "2026-08-18T10:53:00Z", + "verified_projection": { + "attempt_id_sha256": "f5df4d6e64a2d38ffa8e320c87ad05d04025de267a8e152a755d3f1928ded120", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "stale-session", + "evidence_sha256": "2a7ccbc187c0627ad574c752f1aea534e5f283859d8b8e6fcdeaad3e603d4386", + "run_id_sha256": "fd3a041b705d8c6277ce26134dc0018e866218cfa3fadd16ac29d1ad498965a3", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "absent", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "0fb52130820a183fa318c24dd0e504f3505ca28f32a98d6fee032f6b19642a37": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", + "receipt_type": "fault", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "vtYYZnGtKbMNJ9fFrKNe5WTwWkTZSMg9Bi3niOzeekG+AuN6MDzCeRZaNtwIjgod3Mf82ssJykUvGhb4V+JCAg==", + "source_artifact_sha256": "ac34c209ded7d003e6d99a60a52adc51e65926a708df1a94834a196ba9fe9812", + "verified_at": "2026-08-18T11:04:00Z", + "verified_projection": { + "attempt_id_sha256": "491a544656d05aea37920e5c7e2ad65a9452eac8d6e100268a599aeebd41187a", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "ambiguous-target", + "evidence_sha256": "ac34c209ded7d003e6d99a60a52adc51e65926a708df1a94834a196ba9fe9812", + "run_id_sha256": "aa62c7a17701a7ef01ea1d3519b4c1f90d357495b329fdda3054cc24c581a593", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "injected", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "10b9c9e23bb12807fe3446fa41b66ecc1df3f7720d4a6bd018243668a85afb14": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "aIMQzdfObDxf8qbsmG4vg+SbXYAxEy3KNp2eB/OQQbxrzan6+P/0HLq2iJu50q4gK99++FVD3+S5JbgZU4vNCw==", + "source_artifact_sha256": "79805e89b0f4e3d696c11dc8e97714ea0bcdca545f81356e0ed760612fe2925e", + "verified_at": "2026-08-18T10:44:00Z", + "verified_projection": { + "attempt_id_sha256": "7c910764b2dcc6f05261d609082f75474e4638c3f356006307212b8fed4a2eb7", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "wrong-reference", + "evidence_sha256": "79805e89b0f4e3d696c11dc8e97714ea0bcdca545f81356e0ed760612fe2925e", + "run_id_sha256": "fe98ce7f0e66b885201f4667875fd38f5890ffddb575d68bd4cd5a66f8d53ca8", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "satisfied", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "11b317991d7ac80a31d423d73f9b0312af2f7e53eeda77e640a524650611e77d": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "I9I79mduZDb/0J6CwDHe44yGtgblTcivYpxTkuYPIdgHFMI2GxolF0WiF89GWysDQ6jxUshMgeCHNzf8xPXTAw==", + "source_artifact_sha256": "19c8e4a8e4ef48302a4600b8bf8bd600dbffa7e3b33c7ac91fa693b98487bdf2", + "verified_at": "2026-08-18T11:04:00Z", + "verified_projection": { + "attempt_id_sha256": "491a544656d05aea37920e5c7e2ad65a9452eac8d6e100268a599aeebd41187a", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "ambiguous-target", + "evidence_sha256": "19c8e4a8e4ef48302a4600b8bf8bd600dbffa7e3b33c7ac91fa693b98487bdf2", + "run_id_sha256": "aa62c7a17701a7ef01ea1d3519b4c1f90d357495b329fdda3054cc24c581a593", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "delivered", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "156f5af975f0f574aa73e2f8f296304d6b7ca1fb389d20bf1dbd571935d491e0": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "pYp33Ulh35O+DQu5uE3GOcH7aVXu6tXCbCGJf242fvVwBkbqr9Ci3APYOJXGVUnVB3EQjbSD0vLTvsN6QrVcAQ==", + "source_artifact_sha256": "c2fe1abfc1e16a5382ce8eaf67f3774f713d586e6aefe6a00783455dceae530d", + "verified_at": "2026-08-18T10:02:00Z", + "verified_projection": { + "attempt_id_sha256": "679af5a8dedceb8c696719e73f82a698c230cd8fc98bb61769f0883202c0b637", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-01", + "evidence_sha256": "c2fe1abfc1e16a5382ce8eaf67f3774f713d586e6aefe6a00783455dceae530d", + "run_id_sha256": "0b5bda916a0808165159166955a9563cf9c2303949f762a18eb037f41b44a6dc", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "verified", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "1674de43590311145df8c1149ad40d4f1f154497536cd3f86547d117b005aced": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "AB/7kq6uEfr31Hs/DryyES7oCijEKxvIL/zH1DvHd4bZg8M7OG7TjqckO93bmSQNghrCp+tXEWZaWHK7JHS0CQ==", + "source_artifact_sha256": "e02b4733d09ac9c9e6e5d98ba7fc6645738e022e2f137f73feded4d27f3925e9", + "verified_at": "2026-08-18T10:02:00Z", + "verified_projection": { + "attempt_id_sha256": "679af5a8dedceb8c696719e73f82a698c230cd8fc98bb61769f0883202c0b637", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-01", + "evidence_sha256": "e02b4733d09ac9c9e6e5d98ba7fc6645738e022e2f137f73feded4d27f3925e9", + "run_id_sha256": "0b5bda916a0808165159166955a9563cf9c2303949f762a18eb037f41b44a6dc", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "completed", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "1847925251f6ac7a782baf4a381494cc662ad60bf1c0f2f3eddaecbc86940c29": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "jVxMp5yLKFZIsEou//d4qzyi4gIF732WiCzgSUXm/MAeqgHTM1lhvGunRmS3M538pZ9hMjNuyFbH4oHbsRBCAw==", + "source_artifact_sha256": "b181977448bfbd12d2ed392d09d1d8be4a7489c9f5214c80bf97e84b3f745b64", + "verified_at": "2026-08-18T10:52:00Z", + "verified_projection": { + "attempt_id_sha256": "fbfce2be9ce964be8b668aa518a310fe4a89e5c014f42bd0ea81401bd83bfd7a", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "stale-session", + "evidence_sha256": "b181977448bfbd12d2ed392d09d1d8be4a7489c9f5214c80bf97e84b3f745b64", + "run_id_sha256": "d9270fd4c85e4226a9347ecf703e876b9ffdc330f60c7fb8bed8f9321ea30225", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "delivered", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "1a219a5a11101378903c40163101018c2d55b6877d88cdb3b29d1116de3e952a": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "QIFs7YGBp+EL4NoCkaliRkMlOeq/N8mWNf3SnsyiP5P8tL32UvJ6GNG7bgMQ1QpWY0y6gZCa8bUN2AK4gZQ2DQ==", + "source_artifact_sha256": "3edf91becb8c50a0a4c4769e60bfd13bf8bfc1727bb05e1737099caba33e651e", + "verified_at": "2026-08-18T11:02:00Z", + "verified_projection": { + "attempt_id_sha256": "60ee9db05b1126cfaa3b31c13bc3fab4755ac09c44e846b4d07ee51865dfa7b1", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "ambiguous-target", + "evidence_sha256": "3edf91becb8c50a0a4c4769e60bfd13bf8bfc1727bb05e1737099caba33e651e", + "run_id_sha256": "628f991a182613b8700294d7483b5a4c06872cb9d5ca6047ea552b8ab6585357", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "completed", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "1ab983f4a4047724dfdb2f131ca6450811acb618a1bfee8e10844d5106065a36": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "YcUcOhOEu0Th8/EJONqEJ8L8A+HFT+eJ1AtqfImXAGw/VHTEnNmkw5yVKDZ1XqsuYHDW2ybKeFN/0AfjZIoJDA==", + "source_artifact_sha256": "c91752eaaac4392dd7aeb24d399c347eb77db07214d1121d39629b13b9dff7a6", + "verified_at": "2026-08-18T10:34:00Z", + "verified_projection": { + "attempt_id_sha256": "3aee8ad755c7f4bec71cc194bcfaa805e0ea29cf8b830ed0782f8263dd9620ca", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "idempotency-replay", + "evidence_sha256": "c91752eaaac4392dd7aeb24d399c347eb77db07214d1121d39629b13b9dff7a6", + "run_id_sha256": "3df83453126754a62d00ed10837720542d0469799bb8a88cb5257ac5f477a919", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "satisfied", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "1ac32da3abb3085b0b9ff8093c06f8e5cfb3cd290d1ae053ca0b99807a81f759": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "RtW/P/wVALW/o0z8CqPFMUBqCahS5xLuXlHrnYlQfb9kDe95WSzdD4FgDHC5kdOM/86K8bdRkyVqETV9Xx7mCQ==", + "source_artifact_sha256": "975e43caa5b1e34f06e36ad0fd995c5ba6662a55f5cb8d8d28a9f6208420b800", + "verified_at": "2026-08-18T10:53:00Z", + "verified_projection": { + "attempt_id_sha256": "f5df4d6e64a2d38ffa8e320c87ad05d04025de267a8e152a755d3f1928ded120", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "stale-session", + "evidence_sha256": "975e43caa5b1e34f06e36ad0fd995c5ba6662a55f5cb8d8d28a9f6208420b800", + "run_id_sha256": "fd3a041b705d8c6277ce26134dc0018e866218cfa3fadd16ac29d1ad498965a3", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "halted", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "1d0d33cddb33f11719b645321ab4b811110a7dda9dada423fce56eef9337f6b9": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "nQRGJ2BEO/t0d5YcLLs0fDsZwUb7RywiBbpvo8fEjoynEYa5ub7M1W1rnt63nABLlj4wwoBhtwpopBTz9TASAg==", + "source_artifact_sha256": "82558495613e411f7ace5490f50e22b445058f1f1d0661f39959e3fa8d25a742", + "verified_at": "2026-08-18T11:22:00Z", + "verified_projection": { + "attempt_id_sha256": "73a097b8b20bab7794369384f7ca1d7d711aad07967b7e1292373babbb7ff1b7", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "weak-effect-only", + "evidence_sha256": "82558495613e411f7ace5490f50e22b445058f1f1d0661f39959e3fa8d25a742", + "run_id_sha256": "b44783e70a980ec5b3cf3752bd5d1d01b2ff29f5a6892cba0c1c939d8aeb7c02", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "completed", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "1e611a0e77ce192cc9f46fe9544472b3352f58c6a8f3f1377c7a688a8a18d702": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "cATHd62yKfK8OPSNsMy+ENc9wQpA6ajohnfE7wXTXhX3byIPj6LJzP05sqSeHrPqfMZOplGG/ZxvdQS4xH5KCQ==", + "source_artifact_sha256": "c99ff9e16fc08dfa2947c8baa3cd32d837e5e3c19ebbf6ce751821e33ee578f5", + "verified_at": "2026-08-18T10:42:00Z", + "verified_projection": { + "attempt_id_sha256": "e93521e706ad90d799dcd4e8cac15229c5da6aec1638540606f5fab4efce59fc", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "wrong-reference", + "evidence_sha256": "c99ff9e16fc08dfa2947c8baa3cd32d837e5e3c19ebbf6ce751821e33ee578f5", + "run_id_sha256": "ee82112f55e5e6c86cfd6e16df8c8b652549a8bd72de492f435d8255eb3dd252", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "completed", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "1eb22d963181e3e47e20a19387d74eba9c265f9f2bc8ef3b5680f75db6cc94b0": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "15GS1tW9mt3jm6E3Gu9La4v9OflFgQv94nVrqh6xYMuBbOEJUAr1OHAd7s0rp3Cstdw6ZAucssBjqDS89+pzDQ==", + "source_artifact_sha256": "2939663aad44035d0e4b7f6c59580cd6d7589dc8db1f48abe2e60db3cef03a78", + "verified_at": "2026-08-18T10:32:00Z", + "verified_projection": { + "attempt_id_sha256": "3142933f4f168c98b8e89f2ae9d78fd3129e0a9975cbbaa60ddba853eee7d53c", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "idempotency-replay", + "evidence_sha256": "2939663aad44035d0e4b7f6c59580cd6d7589dc8db1f48abe2e60db3cef03a78", + "run_id_sha256": "6cdff0cf50d0164fe1eee9c4b7db0b969c24f9b960f5653b516313a913c90a0f", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "verified", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "21b8a3b75d9b04406b4684602b1b1c4ffbf01fc814f3371d80a478c2271e143a": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "Th6CWGnpMyKLcbMwYO5Y4hQslapUunaij2n1UIpNBCL3fSiA8bzKiZIz1n16R9ukuh29GhJq/Rlx3oB7yzjhDw==", + "source_artifact_sha256": "4166eb8e3a385de458c987a5463a1a35943cb8e54fa4a174c56729232a96605a", + "verified_at": "2026-08-18T10:13:00Z", + "verified_projection": { + "attempt_id_sha256": "3d42601a69ef46cc44f57b51762affef4ccd829ffde30125619a6e582af00dab", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-02", + "evidence_sha256": "4166eb8e3a385de458c987a5463a1a35943cb8e54fa4a174c56729232a96605a", + "run_id_sha256": "091e13ed70dab439b31cb506cf3bba1ddf6476696531cf891c39a924a928b7a1", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "verified", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "250a2d98c537e0180459263bb61f21c6a1f12c144bc064ed993961fd98511ac5": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "woesRH04CRbtGGGlq6HgSSz7EQQ7GkS2us+qQvCZV2PAOScvB6mLHtwviDfOLH9EhxkkQRtPuWlKSpSy0cFtDg==", + "source_artifact_sha256": "aa76163afc05d85e7c2925d286aa8e9c2abda820aa88bcddb1c2a8d525a8be2b", + "verified_at": "2026-08-18T11:03:00Z", + "verified_projection": { + "attempt_id_sha256": "1ec11a9862ede3ac701af71835ac28c551d604a026b5bab7d776dbcdf288394e", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "ambiguous-target", + "evidence_sha256": "aa76163afc05d85e7c2925d286aa8e9c2abda820aa88bcddb1c2a8d525a8be2b", + "run_id_sha256": "43f0a1c00950c390b0676fab55a2aa98c354d028f2347c461661e6cdb72f717e", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "halted", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "261cb4aedf65989c753e88445ab1c34145bd44ff72212cd80c99418d0e47877d": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "//MsUG8XdZ1dnaaAWRYh/++At1ZQAbzDiyMNhyLhNMUAzyPrRvFPKGPeH2XjtklN27ecBEPMHIymYKUYagHsCw==", + "source_artifact_sha256": "ce0aa45ff0449ef101823a15d86eaad2e81cfaedb64c35017e27146adae0a845", + "verified_at": "2026-08-18T10:43:00Z", + "verified_projection": { + "attempt_id_sha256": "6b0e5c10d55fc92c1ff8576392270a24fb65722414cf58ff9a51b8ce9ef88587", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "wrong-reference", + "evidence_sha256": "ce0aa45ff0449ef101823a15d86eaad2e81cfaedb64c35017e27146adae0a845", + "run_id_sha256": "577e37b10b1c87fd9c1b5d320888b736d272824657fd59a012e85a284ee88540", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "halted", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "281c785f27d6347e718f61d7d326ddd42e38cb7c0977de9b5e7585253cc3899b": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "hdziFtNDaeuIqNSbvYzcZUA3hYgFb2P4wgozvLxMAI+f9OADwKtDDZxxNaaqc8/XmASYBSgcNxFgZ9vU7YQiBQ==", + "source_artifact_sha256": "841ebd8beb38baf63b1ce9c65d1f22d80a15e36e268eab7f019f063c7242ce9e", + "verified_at": "2026-08-18T10:12:00Z", + "verified_projection": { + "attempt_id_sha256": "940d3ca125ff87ce7539740fbae29d2d64fec839328b0639127e1d197d2485d8", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-02", + "evidence_sha256": "841ebd8beb38baf63b1ce9c65d1f22d80a15e36e268eab7f019f063c7242ce9e", + "run_id_sha256": "bbb9312ce4682b23580eced0f8d19438d8266b222555df85fb27eef22ad5afe2", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "delivered", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "2995df9d47d9de4b42c9b5d90e71af5e47cc4bfac9fa9d9eb15ca521da785f02": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "ahh8BDB7Q+DfCnBr/+ttvAJAE8ZBbmNlCmrF/5Hg5V6q9icaBpgolsXoST362qmjYyDn7j5ZArtHu8xVcNq6DQ==", + "source_artifact_sha256": "d132a667b9a158fba09b3f6dca9d0d1ef2f87570aba4df8bc3f9fa30778693c1", + "verified_at": "2026-08-18T10:53:00Z", + "verified_projection": { + "attempt_id_sha256": "f5df4d6e64a2d38ffa8e320c87ad05d04025de267a8e152a755d3f1928ded120", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "stale-session", + "evidence_sha256": "d132a667b9a158fba09b3f6dca9d0d1ef2f87570aba4df8bc3f9fa30778693c1", + "run_id_sha256": "fd3a041b705d8c6277ce26134dc0018e866218cfa3fadd16ac29d1ad498965a3", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "completed", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "2a60a9e1e23380c3b33f8ca174cf3510660ac29a6e5a8ab2e3e2c678107613a4": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "27S2OWjSPZ0N3u77J762OgXqxVBkqzhZo6j9hfdBCzLTqShK0UVDIAhjycgdXkaiCr/aeCxvggA9TWYwP0VCBg==", + "source_artifact_sha256": "343f637659566d84e7014bb1c057b6f9363086e8d04e122e7df754c45b3367d3", + "verified_at": "2026-08-18T10:33:00Z", + "verified_projection": { + "attempt_id_sha256": "4667302b580ff7ceb223dbb15eb6d029969a8f6a54bcd33e8df5b6bff41f41ad", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "idempotency-replay", + "evidence_sha256": "343f637659566d84e7014bb1c057b6f9363086e8d04e122e7df754c45b3367d3", + "run_id_sha256": "33e0ad9bf64e477f24d46508fa432123e046dcd1c5853d5cc60b7cde1bce7537", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "verified", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "2b291719429c998246226ba27143f7da1f03abeabce84abeb3e581662b60d6bc": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "G91NEWiQVT+PHT1GEOwzwCz8UNCEEVQbXUoOky/EzVhnCuEZcmhR2qRQJCzhp+2EJq3cGoou27+d7jENfW0ABA==", + "source_artifact_sha256": "693c5de78792744df15509b8187bfaf3ec71a4d879011e9773e98d139b5d7856", + "verified_at": "2026-08-18T10:03:00Z", + "verified_projection": { + "attempt_id_sha256": "fdad940f245d690750ad647fac25c7e76aac2f474db49732fec8129051750186", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-01", + "evidence_sha256": "693c5de78792744df15509b8187bfaf3ec71a4d879011e9773e98d139b5d7856", + "run_id_sha256": "3739043a92a8781376cfbd022460c03aba40f92a800b3885ebc046321437bc40", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "verified", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "2b4060abcc8e69b9f87cb79a3b378fe93014566680b4140b3f5dff1b23c3af85": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "1uOJphpSrnVRvxuccuwy9FXLsOyk88wXxjOIEd8wgfhHRbg2pD8rKMIEyKdYDxzoovfLPUGNRum9oWNRgdOIAQ==", + "source_artifact_sha256": "f0e1b62eb7c877e3b75f5be31a69021e88bedc4ccfd95d69395483193bb5669f", + "verified_at": "2026-08-18T10:44:00Z", + "verified_projection": { + "attempt_id_sha256": "7c910764b2dcc6f05261d609082f75474e4638c3f356006307212b8fed4a2eb7", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "wrong-reference", + "evidence_sha256": "f0e1b62eb7c877e3b75f5be31a69021e88bedc4ccfd95d69395483193bb5669f", + "run_id_sha256": "fe98ce7f0e66b885201f4667875fd38f5890ffddb575d68bd4cd5a66f8d53ca8", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "halted", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "2cb93f1da48f525ba6706aa6e042d870bf902fc22ed125fa90e9692d5a6ea1e9": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "hRC2ENLfWW0Ghxgwp2pOY/axv7xj3Mn8d4r1IjnQadymUftbjk+F7a8vvHVH9pj/f4quwJ5z7W86oDcj8iikDQ==", + "source_artifact_sha256": "0c3d68b46266286eb32f09365d96174863b4fe9cac3fb3f91625fcbb4f521e71", + "verified_at": "2026-08-18T11:04:00Z", + "verified_projection": { + "attempt_id_sha256": "491a544656d05aea37920e5c7e2ad65a9452eac8d6e100268a599aeebd41187a", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "ambiguous-target", + "evidence_sha256": "0c3d68b46266286eb32f09365d96174863b4fe9cac3fb3f91625fcbb4f521e71", + "run_id_sha256": "aa62c7a17701a7ef01ea1d3519b4c1f90d357495b329fdda3054cc24c581a593", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "completed", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "2ee187a8c4b7240ee8767499afd16c6efc9356a3211766d00910d0ea2294a76e": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "gRziheFArjoQmwLhrPmOgun3YQIPNlCPHZ9Uf3cxIfpZ/4YFiCyj3BIMGHxzhUb0rX4LIapz42mPq8yB9LS+BQ==", + "source_artifact_sha256": "c129344c7dd911068c387c21d9a1042713a90190dcd848662cf894d8283c4db2", + "verified_at": "2026-08-18T10:54:00Z", + "verified_projection": { + "attempt_id_sha256": "958342a9ddca98a83b82b662f52f404239d583afe7ed70634760e1b8dd592f3b", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "stale-session", + "evidence_sha256": "c129344c7dd911068c387c21d9a1042713a90190dcd848662cf894d8283c4db2", + "run_id_sha256": "6f2fb10bc2018c9f78e9702d5ccac0bedd78ee3b2e9d2a6ad779fba72d90ae50", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "absent", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "2fa257efdc7b2b5fbd3e5caa209d045d974201e96852760f38ca9a70bcd61755": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "KqG4GWswhggd7BkvVmrDm6oQxCZ2zfldTItCxYuqTl6QI2Hi1Dr+UfbPqkHcxR02kejWSSslPQo3ml/HFVPGAw==", + "source_artifact_sha256": "11df3fb01cf5dba128c9a69827676bb2d78cf90dedf8bd2071bcea42c25916e5", + "verified_at": "2026-08-18T10:33:00Z", + "verified_projection": { + "attempt_id_sha256": "4667302b580ff7ceb223dbb15eb6d029969a8f6a54bcd33e8df5b6bff41f41ad", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "idempotency-replay", + "evidence_sha256": "11df3fb01cf5dba128c9a69827676bb2d78cf90dedf8bd2071bcea42c25916e5", + "run_id_sha256": "33e0ad9bf64e477f24d46508fa432123e046dcd1c5853d5cc60b7cde1bce7537", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "verified", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "30943ab2222e8fd4fb98d2a4e6ca8bd944800dc26e136492f4616f4e8d8f1ec4": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "xSXHRjakO6fsR3feo8dHlvkW+NnsOb19VmC4Rw/j/5BbTcLge7wZxXqIY9q+fzq9TEtlq+sWCErLkodEmOTdDA==", + "source_artifact_sha256": "11f183b9a6fd7d20a3cfc66e95960832da64804b9d3f6980ee365679b3a1793f", + "verified_at": "2026-08-18T11:13:00Z", + "verified_projection": { + "attempt_id_sha256": "42259dbb767ced4c25ad8bd40edc209720a748897194c925ed9bd2e27b2258b2", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "verifier-unavailable", + "evidence_sha256": "11f183b9a6fd7d20a3cfc66e95960832da64804b9d3f6980ee365679b3a1793f", + "run_id_sha256": "4af84f2608a25a27e6252a5800263a238bb70fb3bec65148601ddcdddbf3e03c", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "completed", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "31e84b9a0133f40ac67e9fa8b9b59b7a56b3069952903232a7b00402effac1dd": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "DV7yeJBgebFFLo/uEjVQGj/iMaCqhZgpHcMHL5sCxYDVjhu/Pu5/4tYns6BtesM2fiuo+ZE3Ke3+NJg+wcAEBw==", + "source_artifact_sha256": "0e7b1e0c28c2cfe39870f987c674129552a27582914b580f2e13474b3636e942", + "verified_at": "2026-08-18T10:32:00Z", + "verified_projection": { + "attempt_id_sha256": "3142933f4f168c98b8e89f2ae9d78fd3129e0a9975cbbaa60ddba853eee7d53c", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "idempotency-replay", + "evidence_sha256": "0e7b1e0c28c2cfe39870f987c674129552a27582914b580f2e13474b3636e942", + "run_id_sha256": "6cdff0cf50d0164fe1eee9c4b7db0b969c24f9b960f5653b516313a913c90a0f", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "absent", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "33d8fd907e482612d1d69669f9f91afe0dded59103f393643a57500c8ee1ff05": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "NG0XMjNJ4npWFcfG4nuJLulMFaUmw49r/TmsjfGE2rtZf0iLS5aorQeh/vKISGXZzifesY9sNebD1HCD+FQ/Cg==", + "source_artifact_sha256": "b54d78461c69265574bc5e0a08e1ae1f2c53150056399d8de419de8d50868c80", + "verified_at": "2026-08-18T10:04:00Z", + "verified_projection": { + "attempt_id_sha256": "4c352a6999f77707e8837adebb4fc2b7451c2ef6de5145190b33a5c5645e47eb", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-01", + "evidence_sha256": "b54d78461c69265574bc5e0a08e1ae1f2c53150056399d8de419de8d50868c80", + "run_id_sha256": "4ee2bb61fb883cc8e77d636fb471aa3c0ce9ef0c0a8abd9682214bf0a8f16f26", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "satisfied", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "34e01549f75b1a8132541730937ba43e9f673d0886239a3adae2142502961c03": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "w/02t/CZCL7UPkO6s4hohBMjTEa5LNNEvLfB2mxGfkadEQHzc5Sh/xjAgqZsk14dKed+RDoRjo5105r0q/s8DQ==", + "source_artifact_sha256": "32974d92bebc7e4e4d26c3f6df9b0cd6dfb4e7f0f23baa1df91fa850acf666da", + "verified_at": "2026-08-18T10:54:00Z", + "verified_projection": { + "attempt_id_sha256": "958342a9ddca98a83b82b662f52f404239d583afe7ed70634760e1b8dd592f3b", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "stale-session", + "evidence_sha256": "32974d92bebc7e4e4d26c3f6df9b0cd6dfb4e7f0f23baa1df91fa850acf666da", + "run_id_sha256": "6f2fb10bc2018c9f78e9702d5ccac0bedd78ee3b2e9d2a6ad779fba72d90ae50", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "halted", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "37179d92aae8590ec9894154d581e654113f2fcb230673b466c345c5e68d7003": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "3C0LbshxV6uUJNU3B2zcLfJiMldSwDG67DkpCMH9rc0QMqwi7BQGSgLnhOOvxVNllAJ/1MINwzvljYcuYcOMAw==", + "source_artifact_sha256": "3f1ce2b52c8b8ed56bc485f70b885b295f43f601b14c7834ee455b982154a6e5", + "verified_at": "2026-08-18T11:02:00Z", + "verified_projection": { + "attempt_id_sha256": "60ee9db05b1126cfaa3b31c13bc3fab4755ac09c44e846b4d07ee51865dfa7b1", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "ambiguous-target", + "evidence_sha256": "3f1ce2b52c8b8ed56bc485f70b885b295f43f601b14c7834ee455b982154a6e5", + "run_id_sha256": "628f991a182613b8700294d7483b5a4c06872cb9d5ca6047ea552b8ab6585357", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "halted", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "386dbd16e6ae7d1d0b6c82a6992fe211c81630928689722057964a0dda3c3942": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "BXhpbM9qvlT64dfMQ+A3NvG3yWrzXsFdzxrzr1afgEy6EPyMdjXn6+4hgpvQJfNrowM1MyogCrSdC59ZVkwlAg==", + "source_artifact_sha256": "8fd27141f1a8f201ab2aff52f1ba0273e506dc25a0fb7567513d140a1cc9a2fa", + "verified_at": "2026-08-18T11:04:00Z", + "verified_projection": { + "attempt_id_sha256": "491a544656d05aea37920e5c7e2ad65a9452eac8d6e100268a599aeebd41187a", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "ambiguous-target", + "evidence_sha256": "8fd27141f1a8f201ab2aff52f1ba0273e506dc25a0fb7567513d140a1cc9a2fa", + "run_id_sha256": "aa62c7a17701a7ef01ea1d3519b4c1f90d357495b329fdda3054cc24c581a593", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "halted", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "38d632dc612aa9d18bc141fea23812d46fb9345a230b4e58b53336402a2a9289": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", + "receipt_type": "fault", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "pPFpY0OmY1FW4JVLRkFjFo8mhXuYNJhuBeM+i0uZr3/g1VWf0NODYx7HzTy53+F/44QtjGF1H7IjtV1IU2xLBg==", + "source_artifact_sha256": "18258b93a65383507d1a93b2de83059c8074fd781add23d4f4d40911bf56b059", + "verified_at": "2026-08-18T11:13:00Z", + "verified_projection": { + "attempt_id_sha256": "42259dbb767ced4c25ad8bd40edc209720a748897194c925ed9bd2e27b2258b2", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "verifier-unavailable", + "evidence_sha256": "18258b93a65383507d1a93b2de83059c8074fd781add23d4f4d40911bf56b059", + "run_id_sha256": "4af84f2608a25a27e6252a5800263a238bb70fb3bec65148601ddcdddbf3e03c", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "injected", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "3d8eb365f4d3b3332b5d8416e465962d4c3c1b55f12f6500d62144fb512a6051": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "LjsE49T5c/qicI9XQNWovyK4tK3z+7fFWxi8QEUvFF5cIj72VfLwLcxFtnvAaSL1/HJ5C0/mbdgQz/HNG7pZBg==", + "source_artifact_sha256": "ddf817056f83e416082775455ee6cb2ccc0139eeaeec131996cc584694bb9cf6", + "verified_at": "2026-08-18T11:04:00Z", + "verified_projection": { + "attempt_id_sha256": "491a544656d05aea37920e5c7e2ad65a9452eac8d6e100268a599aeebd41187a", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "ambiguous-target", + "evidence_sha256": "ddf817056f83e416082775455ee6cb2ccc0139eeaeec131996cc584694bb9cf6", + "run_id_sha256": "aa62c7a17701a7ef01ea1d3519b4c1f90d357495b329fdda3054cc24c581a593", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "halted", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "3f1d8304c662af081aae90b0d6ffb2e01f21c5debf95a740595bd97d740965dc": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "brekMePk7znfV3QmslkK5nQUEuXHuQrDixlISNnTf6XOJxVGM0S97MUbwacFmtFmPw9BU/+R7CwpobC2gZ0VCQ==", + "source_artifact_sha256": "aecd407f56e892dd31846bf13f26f1d2b2683f375928da672b2d04773349cdc0", + "verified_at": "2026-08-18T10:44:00Z", + "verified_projection": { + "attempt_id_sha256": "7c910764b2dcc6f05261d609082f75474e4638c3f356006307212b8fed4a2eb7", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "wrong-reference", + "evidence_sha256": "aecd407f56e892dd31846bf13f26f1d2b2683f375928da672b2d04773349cdc0", + "run_id_sha256": "fe98ce7f0e66b885201f4667875fd38f5890ffddb575d68bd4cd5a66f8d53ca8", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "halted", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "3f9dbd4b5462c22c057ec74e389a00836aa7b3f2870a49095bb48310555f8b99": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "YgCkyHeYlnViN/p9FpU8UwLWI5+98+GcxB43vJzPCMwDT+GUL/Qz7dW3hkUptEELLLVhmC9dsAehJP9oiMM/Bw==", + "source_artifact_sha256": "2ae10ced05bdd00ae95b7a8d2893b178979ff8cf6d455c9e9fcf2596ecac18fb", + "verified_at": "2026-08-18T10:32:00Z", + "verified_projection": { + "attempt_id_sha256": "3142933f4f168c98b8e89f2ae9d78fd3129e0a9975cbbaa60ddba853eee7d53c", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "idempotency-replay", + "evidence_sha256": "2ae10ced05bdd00ae95b7a8d2893b178979ff8cf6d455c9e9fcf2596ecac18fb", + "run_id_sha256": "6cdff0cf50d0164fe1eee9c4b7db0b969c24f9b960f5653b516313a913c90a0f", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "satisfied", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "4090cbc85f145c1a2b33d9536ca9f2ca12f9109769eb702a0a46fbda70abace8": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "QSUThYwpg1DzJV1l3ASw8HRgLLUWt0qK03NrF1InXMMZjm2bfRkDWB+mDrrJB2hOEs8NRs+ueBAW+ipt/IohAg==", + "source_artifact_sha256": "1f77854e1846d96a3d4c187c4946e746d7139d3a025dbd5ede6e8a6ee6be2c40", + "verified_at": "2026-08-18T10:22:00Z", + "verified_projection": { + "attempt_id_sha256": "fc097c8b2e6ece94544a19b8d81f5c4a9367a89059e3dd4b2f746ab06a2fc930", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-03", + "evidence_sha256": "1f77854e1846d96a3d4c187c4946e746d7139d3a025dbd5ede6e8a6ee6be2c40", + "run_id_sha256": "28768f565659133f5bf1170e638b81de4d7ca38dfecacd09ccf462a35344432b", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "verified", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "4157e3e1e661cb3eb666347e1777e7a0f91db0beded1a3894b9bba5d60b8d7b8": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "O7R18ZRVdW9pT2SfPLszCk3dNu9SxXbRvYwT2kAvMFQfKM+raZpuTsTjK8uHj3Iha14qX23leTANv/kVmXZOBQ==", + "source_artifact_sha256": "bd93f6e9d767166a948c91db13a6d6ebf759630b605e6ecf130420e0511ee3a4", + "verified_at": "2026-08-18T11:24:00Z", + "verified_projection": { + "attempt_id_sha256": "aa7d6be4f25a8992c0a22649ba7e703d6955abf5fece9f8322f560149cf09776", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "weak-effect-only", + "evidence_sha256": "bd93f6e9d767166a948c91db13a6d6ebf759630b605e6ecf130420e0511ee3a4", + "run_id_sha256": "b974de9da8ef77c8dc9a7662114cc51023ab8c131c488681eeebb7d4c435c8d0", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "satisfied", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "418572792d67d3158bae6f0ab06a3c5e6aac3b56333c28fd7e00bf7452be9c0b": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", + "receipt_type": "fault", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "Y3q5qeX0v+8dHvYsUvpfpN8FmpGALAC2tQF8EhCvFjhLB+5i/ZiXi+dM5DS4t82vuXVqleW1sK75z4/7RSLqAw==", + "source_artifact_sha256": "3e1b6e01581eb35f1854a259db0f29c5efdebe4507aefb8ab6d4b0201182593c", + "verified_at": "2026-08-18T11:23:00Z", + "verified_projection": { + "attempt_id_sha256": "eb52fb1b1bf2fac92d8f3a444bb5081161be8b3d0ef457c5065e7b79e96df770", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "weak-effect-only", + "evidence_sha256": "3e1b6e01581eb35f1854a259db0f29c5efdebe4507aefb8ab6d4b0201182593c", + "run_id_sha256": "794033f9da2a42448254a478fb6de954898b1e544148708ad30264efdc255431", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "injected", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "42c9725850c0b81507d63757a3427d48e93db412915891ffd538e18eb73736be": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "CGUrGDnqzG/V+2jGC/Mkx+VdhkFoVCMN7eLOXt0ZWQ4zTtGXNmeNkFSHk3L/+H5AUUll3LLgsEzm4GVEu03qCg==", + "source_artifact_sha256": "feb27a02d37abdd67aa0b50cdce26c636bfc6b3284475e77a21d027738a91b5a", + "verified_at": "2026-08-18T10:22:00Z", + "verified_projection": { + "attempt_id_sha256": "fc097c8b2e6ece94544a19b8d81f5c4a9367a89059e3dd4b2f746ab06a2fc930", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-03", + "evidence_sha256": "feb27a02d37abdd67aa0b50cdce26c636bfc6b3284475e77a21d027738a91b5a", + "run_id_sha256": "28768f565659133f5bf1170e638b81de4d7ca38dfecacd09ccf462a35344432b", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "completed", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "45f1eee738934969cca1cb5fcdaed7dab6398cd9a05a7050822e88293b5d4cc7": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "D5bR0BkmD06E08gOFVhwkAtGkFyaEMBQv1asy5P9AyOSPObFumY1WHL85gTMoylQiavKkpQ9Um2fC/Kb20QvAw==", + "source_artifact_sha256": "72afc710ff840f8432ddcceda6a5dd0e1e24f1d5bf0b5ee610c56b51ff260c6d", + "verified_at": "2026-08-18T11:12:00Z", + "verified_projection": { + "attempt_id_sha256": "f5e96a2e9a580376b18beabf57798b8761e772a0c4d112877045780bb12b3720", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "verifier-unavailable", + "evidence_sha256": "72afc710ff840f8432ddcceda6a5dd0e1e24f1d5bf0b5ee610c56b51ff260c6d", + "run_id_sha256": "e8e89651045a5f5c011c9543ed968e0fe7697a061ed8ad5cedc27d194cb96acb", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "delivered", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "465866a38613308e52f541786521a40df3e6444bc5dab1858e13e061239193c7": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "NONTpr+AZmp2e37ZmI1V/NoyflhTU5CrqiRV7TPU5bPuJjNtAeifBmNPJQlUNQPxv1UBIZe0X6MyTVtCYhPzCQ==", + "source_artifact_sha256": "7783dfcd8f2e57ff07c7bd69c17fa37665760981171e801c30d76e22a8d5802a", + "verified_at": "2026-08-18T11:13:00Z", + "verified_projection": { + "attempt_id_sha256": "42259dbb767ced4c25ad8bd40edc209720a748897194c925ed9bd2e27b2258b2", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "verifier-unavailable", + "evidence_sha256": "7783dfcd8f2e57ff07c7bd69c17fa37665760981171e801c30d76e22a8d5802a", + "run_id_sha256": "4af84f2608a25a27e6252a5800263a238bb70fb3bec65148601ddcdddbf3e03c", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "satisfied", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "471f74bd9498b31888a1ec333c7d225af618fe9a072dd2952587bb50bcd6a170": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "AeOBmu2Q57Oqy7zOy5agoWaRjbJGE9lj48MKpdsc19T1TVaZ0PrUG32HU/Y+GPjufroosX9zL1t6IF2TafQAAg==", + "source_artifact_sha256": "a28ad5edfe12f8c387974db36928b3aa5aa2bded20b70ce40baeea09eb16b8e1", + "verified_at": "2026-08-18T11:14:00Z", + "verified_projection": { + "attempt_id_sha256": "ad76dacfe19a4421ef1f128d4eef1099e846b385d29f17b8588ae5130b487118", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "verifier-unavailable", + "evidence_sha256": "a28ad5edfe12f8c387974db36928b3aa5aa2bded20b70ce40baeea09eb16b8e1", + "run_id_sha256": "87014cd8063f5a43ea22c995be03ec41ef5aa613145acacdef71b68c468fc8f1", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "completed", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "47380d14908be57018b19d846d86f0ba8f428ba7cd44f03219dd21117e504d3b": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "GDkutcMWF5gDivL/NIAZ+vbjY7ew+ewDnw5J/UxCEk8YcaXACLbbg3jIlqPeDNYcNNGeM5LCvteCZWT7ZSErAg==", + "source_artifact_sha256": "2a8bec5d9988588a24b36ed1499927f102d61b5867aad99f171fb4a89ce595bf", + "verified_at": "2026-08-18T10:12:00Z", + "verified_projection": { + "attempt_id_sha256": "940d3ca125ff87ce7539740fbae29d2d64fec839328b0639127e1d197d2485d8", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-02", + "evidence_sha256": "2a8bec5d9988588a24b36ed1499927f102d61b5867aad99f171fb4a89ce595bf", + "run_id_sha256": "bbb9312ce4682b23580eced0f8d19438d8266b222555df85fb27eef22ad5afe2", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "satisfied", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "47801787a92ee5738ee64b2bc3cda555dfc53682673d70e11bb9f94f799b371a": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", + "receipt_type": "fault", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "zAfOuFlelbRt715MjZlBj7QCevlk2pJ/nePNAd9T1HYCkDdvACuRzvDQcL87Rv52xtwmz2e1jWMg4JJ81WclDw==", + "source_artifact_sha256": "4337a75a39ceb7d333cbceb0fb54815f7dbe029048dbe20740c85d0b31f4d202", + "verified_at": "2026-08-18T10:52:00Z", + "verified_projection": { + "attempt_id_sha256": "fbfce2be9ce964be8b668aa518a310fe4a89e5c014f42bd0ea81401bd83bfd7a", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "stale-session", + "evidence_sha256": "4337a75a39ceb7d333cbceb0fb54815f7dbe029048dbe20740c85d0b31f4d202", + "run_id_sha256": "d9270fd4c85e4226a9347ecf703e876b9ffdc330f60c7fb8bed8f9321ea30225", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "injected", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "48204dcfbb7f14bb9885b499109da046b6455d3e2cdf47b6f017cf1aae9cf2f4": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "Ffx2GCjuALxTxbZbIduYzcsY3SpvHAPvW+ARR+LRdI6BZFHhFRxWdkIIis6NDPTk2y2XlIMeEuXUHr1HivjEAg==", + "source_artifact_sha256": "ffae42ea2ab78a78ef0b9b71e9b8a63f6b470d949ecfd892d84ebc512c1b64b9", + "verified_at": "2026-08-18T10:52:00Z", + "verified_projection": { + "attempt_id_sha256": "fbfce2be9ce964be8b668aa518a310fe4a89e5c014f42bd0ea81401bd83bfd7a", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "stale-session", + "evidence_sha256": "ffae42ea2ab78a78ef0b9b71e9b8a63f6b470d949ecfd892d84ebc512c1b64b9", + "run_id_sha256": "d9270fd4c85e4226a9347ecf703e876b9ffdc330f60c7fb8bed8f9321ea30225", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "halted", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "4862d7d39d33f17de4c889096ecaa907d1584807b22fc916e2a15d2462e70696": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "fjYrcSKhsFsDCw77TFQ83UStv+5DOjx8TRDYtx8dfScjhejiAqr8gcfUo9K6U5y7eVfFMDieG6yzDKr/5kYRAg==", + "source_artifact_sha256": "ae52f89326f6a1eaced707ed240c61ddf62d1abbd3ac6891f3dc097aef1451cb", + "verified_at": "2026-08-18T11:12:00Z", + "verified_projection": { + "attempt_id_sha256": "f5e96a2e9a580376b18beabf57798b8761e772a0c4d112877045780bb12b3720", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "verifier-unavailable", + "evidence_sha256": "ae52f89326f6a1eaced707ed240c61ddf62d1abbd3ac6891f3dc097aef1451cb", + "run_id_sha256": "e8e89651045a5f5c011c9543ed968e0fe7697a061ed8ad5cedc27d194cb96acb", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "completed", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "48c07213b9025ee2168a2a7972ae7a2ac8f7aeda08b2ef95273dddd94d086d34": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "uwtk0AYuEmk/o0m8uJlCrKaFieNTBQZDSvnhZwgqHOHIVMO3XyQ+pEEvR8d/rTVJAT45zzWyOnAYPzVyOiQsCQ==", + "source_artifact_sha256": "7edf6488f59115500b130e22484d3834f8757bc027ac738d8616461b11f6c2c5", + "verified_at": "2026-08-18T10:04:00Z", + "verified_projection": { + "attempt_id_sha256": "4c352a6999f77707e8837adebb4fc2b7451c2ef6de5145190b33a5c5645e47eb", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-01", + "evidence_sha256": "7edf6488f59115500b130e22484d3834f8757bc027ac738d8616461b11f6c2c5", + "run_id_sha256": "4ee2bb61fb883cc8e77d636fb471aa3c0ce9ef0c0a8abd9682214bf0a8f16f26", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "verified", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "4964bd1ea76f57d04c90ac2cb32ad42b9aa24e8c8d42439c7c7a4176d8a5589e": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "vPxMoYsh7u1afXkgVE7VS5Desx448pwQXh4XWGJIxGXTYI/HnDlM9dLp2nO1uHSXLOyRAJcu45WLfNtU/cgLAQ==", + "source_artifact_sha256": "3a27387e7fb8b622f0150b1da9c81b97bbbf046c3e6be1dd3360f203fb460925", + "verified_at": "2026-08-18T10:42:00Z", + "verified_projection": { + "attempt_id_sha256": "e93521e706ad90d799dcd4e8cac15229c5da6aec1638540606f5fab4efce59fc", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "wrong-reference", + "evidence_sha256": "3a27387e7fb8b622f0150b1da9c81b97bbbf046c3e6be1dd3360f203fb460925", + "run_id_sha256": "ee82112f55e5e6c86cfd6e16df8c8b652549a8bd72de492f435d8255eb3dd252", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "halted", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "4b3a4b3c9eca7b6cc75e95ac329d8825b3caa30aa49f425d714f2409a566485f": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", + "receipt_type": "fault", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "GPgunEwXGewn18IveY1+pHln+lbQfJs/1vGPjnvojzXJ60nTdVpyhL8Kt+2e4WKkGDOS0IO1UQP+WdySJNPQDw==", + "source_artifact_sha256": "49dbd40897c1bf5714a6e032fc07ef378207978f4db7ee347783daf9bfba90ca", + "verified_at": "2026-08-18T11:14:00Z", + "verified_projection": { + "attempt_id_sha256": "ad76dacfe19a4421ef1f128d4eef1099e846b385d29f17b8588ae5130b487118", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "verifier-unavailable", + "evidence_sha256": "49dbd40897c1bf5714a6e032fc07ef378207978f4db7ee347783daf9bfba90ca", + "run_id_sha256": "87014cd8063f5a43ea22c995be03ec41ef5aa613145acacdef71b68c468fc8f1", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "injected", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "4cfd8a817a8c1420280b8aea0a449a467135ebcbc3bb6295e2a1a908a0d22a8a": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "MEjflJ78ngaXqG7iEOVH1l/42w/AfShIyOnc5yoI1/dPnrmyGI/3tanDDrFZmFPu9RJ0XKAV5f8XBCMb+QirCQ==", + "source_artifact_sha256": "6820b7608a765ba712f9643379187af143db8c68f93b58d7a8825daa976ffc69", + "verified_at": "2026-08-18T11:02:00Z", + "verified_projection": { + "attempt_id_sha256": "60ee9db05b1126cfaa3b31c13bc3fab4755ac09c44e846b4d07ee51865dfa7b1", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "ambiguous-target", + "evidence_sha256": "6820b7608a765ba712f9643379187af143db8c68f93b58d7a8825daa976ffc69", + "run_id_sha256": "628f991a182613b8700294d7483b5a4c06872cb9d5ca6047ea552b8ab6585357", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "satisfied", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "4d217e2a3ebb192fa8e2b2126a002c17c90e22d8562e7a749c5a0d922015d625": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "P8thSMKp6iujbuyZHxGUDW9/3Boal18QxOZ3QUA4rG3YC9/fCiq1v5+858bzc8wZJ6gPywboqdu+S65xXM/QCg==", + "source_artifact_sha256": "c51fe4dc79cc2e8b749809c818af5f63c67cbe6e82656cb990d1bc7b13a0b6eb", + "verified_at": "2026-08-18T10:34:00Z", + "verified_projection": { + "attempt_id_sha256": "3aee8ad755c7f4bec71cc194bcfaa805e0ea29cf8b830ed0782f8263dd9620ca", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "idempotency-replay", + "evidence_sha256": "c51fe4dc79cc2e8b749809c818af5f63c67cbe6e82656cb990d1bc7b13a0b6eb", + "run_id_sha256": "3df83453126754a62d00ed10837720542d0469799bb8a88cb5257ac5f477a919", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "completed", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "4e04402568630dfc4590fbecf04015269f4a6e6546e276a92bf4b6b657f8a8db": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", + "receipt_type": "fault", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "oStPtcqHOGUF2Kmd0v2T3AZ1ch3yU+ud6Xop1yJ9Bq3wqxMN0Ik7Xg2ImY6VGpvuJ7xcbxMu576MGF4gI8frAw==", + "source_artifact_sha256": "e7f1dc034e24ac6d0aad3990e694aa281baa8c3e11415deb28fdd2e98bbdd313", + "verified_at": "2026-08-18T10:43:00Z", + "verified_projection": { + "attempt_id_sha256": "6b0e5c10d55fc92c1ff8576392270a24fb65722414cf58ff9a51b8ce9ef88587", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "wrong-reference", + "evidence_sha256": "e7f1dc034e24ac6d0aad3990e694aa281baa8c3e11415deb28fdd2e98bbdd313", + "run_id_sha256": "577e37b10b1c87fd9c1b5d320888b736d272824657fd59a012e85a284ee88540", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "injected", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "50cfc15f662201c2e03cf91d2156a213a28ab028cc4856c64d7da2204a5cdc55": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "z9MS+rTNm5TahzStaE696L0PNsx6X80DI2YeI209gLOaGl6kbsKIk4kRfPpD5ZBbyAMiLKpuUVwmG+rlXDgoBA==", + "source_artifact_sha256": "17bb1d69cfdd94f6150054ac594fc42cd59a8d09b780ee0103962cd549f157ef", + "verified_at": "2026-08-18T10:53:00Z", + "verified_projection": { + "attempt_id_sha256": "f5df4d6e64a2d38ffa8e320c87ad05d04025de267a8e152a755d3f1928ded120", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "stale-session", + "evidence_sha256": "17bb1d69cfdd94f6150054ac594fc42cd59a8d09b780ee0103962cd549f157ef", + "run_id_sha256": "fd3a041b705d8c6277ce26134dc0018e866218cfa3fadd16ac29d1ad498965a3", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "halted", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "53299c8e5f88e4000630fe3142648c66fa7ea8c0bae92b94606a9dccb387a3cf": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "kuw45taK0wj/mrX/+B868Q5YaRB9x+sZTkdAGhh7J5a+7MZIwJ65GeWjuA01g0hlIrcf7k4nHeRnQjs2QDnaBg==", + "source_artifact_sha256": "89e92e0a76d7ef86a369ad65837369620240dc66bc215bc9fa3fddc21d777f9e", + "verified_at": "2026-08-18T10:32:00Z", + "verified_projection": { + "attempt_id_sha256": "3142933f4f168c98b8e89f2ae9d78fd3129e0a9975cbbaa60ddba853eee7d53c", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "idempotency-replay", + "evidence_sha256": "89e92e0a76d7ef86a369ad65837369620240dc66bc215bc9fa3fddc21d777f9e", + "run_id_sha256": "6cdff0cf50d0164fe1eee9c4b7db0b969c24f9b960f5653b516313a913c90a0f", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "completed", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "56b976ecc7eab49bd4b71a8735efac41939cd37654e0a90b7e45053ead2b8d73": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "ePCK33av9aw6waScoT0pai97j4ogr5txjw35nRITtLceyJGc5EqSpPiu5rwCjq6dN0XfvqMeriwVuCsgHOiUAw==", + "source_artifact_sha256": "61e65cf0f747b77668ae9e6632a66d6d32d3dff99318b22ed782df46a78dbf0f", + "verified_at": "2026-08-18T10:44:00Z", + "verified_projection": { + "attempt_id_sha256": "7c910764b2dcc6f05261d609082f75474e4638c3f356006307212b8fed4a2eb7", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "wrong-reference", + "evidence_sha256": "61e65cf0f747b77668ae9e6632a66d6d32d3dff99318b22ed782df46a78dbf0f", + "run_id_sha256": "fe98ce7f0e66b885201f4667875fd38f5890ffddb575d68bd4cd5a66f8d53ca8", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "completed", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "5702bcf5ba24d9f8ff0df4cc5fd89d67a89b385d7de2d45101840a56f183003a": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "W/dKjg41r91I837cW++pdeVNrceYiUvyqTxyN18SMXujvBdLgBa57k38ogfnNFI9kAMn9Rx6HGwzA48Ddkr6AA==", + "source_artifact_sha256": "6eac8e2767237847378635c85aa204fee9f7317f048965d102409679612f37c4", + "verified_at": "2026-08-18T11:23:00Z", + "verified_projection": { + "attempt_id_sha256": "eb52fb1b1bf2fac92d8f3a444bb5081161be8b3d0ef457c5065e7b79e96df770", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "weak-effect-only", + "evidence_sha256": "6eac8e2767237847378635c85aa204fee9f7317f048965d102409679612f37c4", + "run_id_sha256": "794033f9da2a42448254a478fb6de954898b1e544148708ad30264efdc255431", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "halted", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "590846759c1280e18e608456c0e11b64221cfcafa73ab8f061d6dcb5fd762699": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", + "receipt_type": "fault", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "F+o4UhDVHDOhoW5zNKrH8E+NcdfO4hRq/CnB2g88u592JmKvhC8msfrzquGvJum6f5FFf+wheeeCWQWWOS2JDw==", + "source_artifact_sha256": "99fd8516daeb8b22c42479814dbed2b01d63985db824c0237ed8ac83efd0dca0", + "verified_at": "2026-08-18T11:03:00Z", + "verified_projection": { + "attempt_id_sha256": "1ec11a9862ede3ac701af71835ac28c551d604a026b5bab7d776dbcdf288394e", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "ambiguous-target", + "evidence_sha256": "99fd8516daeb8b22c42479814dbed2b01d63985db824c0237ed8ac83efd0dca0", + "run_id_sha256": "43f0a1c00950c390b0676fab55a2aa98c354d028f2347c461661e6cdb72f717e", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "injected", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "596a2bb3c7e416b245f5ed30fc86e4208af76997b62472bfbf278c79abee47ec": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "lvwUuOfdkm5vqUcK1uSspK/zWH8DjGCypU+WDqzBbWziXCeqnmuhE5m1WzdP/JXtWrNoiMUTgzwUpenXkjGwCQ==", + "source_artifact_sha256": "d4f5375e18344432614ad6d37de4727b4ccbfb1465851f36df15fcd2cf052c4e", + "verified_at": "2026-08-18T10:03:00Z", + "verified_projection": { + "attempt_id_sha256": "fdad940f245d690750ad647fac25c7e76aac2f474db49732fec8129051750186", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-01", + "evidence_sha256": "d4f5375e18344432614ad6d37de4727b4ccbfb1465851f36df15fcd2cf052c4e", + "run_id_sha256": "3739043a92a8781376cfbd022460c03aba40f92a800b3885ebc046321437bc40", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "completed", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "59c12284d73e7334ebbca691f3076346f93c97e78dc807dd4a65678b5bc74e42": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "Ry0ulK360QfUGjlEVSQFonEOzQezpdZOACErX+Y9yFJTJrgHvhebfntInqKYscGXuG+vA1GaMm7LVa+aSPnhDA==", + "source_artifact_sha256": "b9930bf1c041fb17cb156788d0424c034c6be2711ca5911469fb8791a6c925f4", + "verified_at": "2026-08-18T10:34:00Z", + "verified_projection": { + "attempt_id_sha256": "3aee8ad755c7f4bec71cc194bcfaa805e0ea29cf8b830ed0782f8263dd9620ca", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "idempotency-replay", + "evidence_sha256": "b9930bf1c041fb17cb156788d0424c034c6be2711ca5911469fb8791a6c925f4", + "run_id_sha256": "3df83453126754a62d00ed10837720542d0469799bb8a88cb5257ac5f477a919", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "absent", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "5ba58c2263a1dd72bb9bd200222709f04dadba7bebbf1d1bec3e779780f39c7b": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "suQE12DW7RJtQcrvlsZBY8qvTfMdn+vFXitM/QFMIR8AGRzkWjYazOC0UR72slCZfRDWW5TY7s9shuc5Ata+Ag==", + "source_artifact_sha256": "0e28a6c49ce0c22f0e6a0220a2c3340d4e956f0f9a29511f0c44e7492d004a89", + "verified_at": "2026-08-18T11:13:00Z", + "verified_projection": { + "attempt_id_sha256": "42259dbb767ced4c25ad8bd40edc209720a748897194c925ed9bd2e27b2258b2", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "verifier-unavailable", + "evidence_sha256": "0e28a6c49ce0c22f0e6a0220a2c3340d4e956f0f9a29511f0c44e7492d004a89", + "run_id_sha256": "4af84f2608a25a27e6252a5800263a238bb70fb3bec65148601ddcdddbf3e03c", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "absent", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "5f0221453529c8e3be2e2b23b2603925fbdf1502f576c16e2a40304d75ec9808": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "8U8glS/KUma1lgaMlm7O7Ew80hm3f1+kHFDoMgD4W/E67+VkeIxhwsZ1PD5DAsP5GbVwHDJhOHurtVsPz7zbBA==", + "source_artifact_sha256": "dcdc96c4f09e390d61f558318a74baef2f65d601e71808bdbf922fcc7f4d5bbf", + "verified_at": "2026-08-18T10:03:00Z", + "verified_projection": { + "attempt_id_sha256": "fdad940f245d690750ad647fac25c7e76aac2f474db49732fec8129051750186", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-01", + "evidence_sha256": "dcdc96c4f09e390d61f558318a74baef2f65d601e71808bdbf922fcc7f4d5bbf", + "run_id_sha256": "3739043a92a8781376cfbd022460c03aba40f92a800b3885ebc046321437bc40", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "verified", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "661cc3ad4b5da051980466dc525c7a6b1366756913780519657bf5b148ce440e": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "iKCxOVOs0sblvfMn4jKokvGptmZL69HLmgG6WpEoAZhXMFQIlNKWEKh01a2brWekzDVGe8hUzXgR0trwAXTIAg==", + "source_artifact_sha256": "c5d1d4394bb4197462d6bb136e8e249ac9d8c283bf8563a8ffbd0b7e0141795f", + "verified_at": "2026-08-18T10:54:00Z", + "verified_projection": { + "attempt_id_sha256": "958342a9ddca98a83b82b662f52f404239d583afe7ed70634760e1b8dd592f3b", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "stale-session", + "evidence_sha256": "c5d1d4394bb4197462d6bb136e8e249ac9d8c283bf8563a8ffbd0b7e0141795f", + "run_id_sha256": "6f2fb10bc2018c9f78e9702d5ccac0bedd78ee3b2e9d2a6ad779fba72d90ae50", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "delivered", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "6909ceef7116356c56ca4737de1356b656ee491362571e3b50e588b4f6359b17": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "GBCdnUEfOfVI29XBWss94kkyXao0c7etlOya26qXeF8L8fob3FODGm0sWYBICGTOUsscxmmdNjHyzdSwVrUBCQ==", + "source_artifact_sha256": "27c78ad5d0a8808752297aff7a4618ed4a5fb67e9ad3f7cb237a202a19a83282", + "verified_at": "2026-08-18T11:03:00Z", + "verified_projection": { + "attempt_id_sha256": "1ec11a9862ede3ac701af71835ac28c551d604a026b5bab7d776dbcdf288394e", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "ambiguous-target", + "evidence_sha256": "27c78ad5d0a8808752297aff7a4618ed4a5fb67e9ad3f7cb237a202a19a83282", + "run_id_sha256": "43f0a1c00950c390b0676fab55a2aa98c354d028f2347c461661e6cdb72f717e", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "completed", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "6ab281eabcbff71abd1ffaa1b2ee7f6b082673890d01882b7a842b1ee3e7ac8d": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "5cFTW3YNDdfCzqAGYfBP60ACwb3Uj9vWTPY4LDdvR4FbHuhi4oV90yPK08m7iBWFr2jbNXh0c1dTYX93pbRgCQ==", + "source_artifact_sha256": "a46df95e5690b582be425e126233998cf8a82e1db8ea11a5dade90b3cc616b28", + "verified_at": "2026-08-18T10:14:00Z", + "verified_projection": { + "attempt_id_sha256": "019dd96e9a771ccc01ebafab321d7d3a8314df8b2d6465bcfc5fa14cbdeabdf2", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-02", + "evidence_sha256": "a46df95e5690b582be425e126233998cf8a82e1db8ea11a5dade90b3cc616b28", + "run_id_sha256": "16cb8df40654c6a1b55ea0e50e772d8c6e6d4f0d8205bd1f8296be27d0af83eb", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "verified", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "6bd1e4fa831b1274c6011187dec731e64b9076912681ddfbfbf53f68ab826b86": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "dy42cNO+VCTULJC2LjWY8cYdOnk+CN45xFIHAnEjzXTNNh8qkMSRDWadzJvYGLHrty9NRwYuiUAbKX4KaMPJBw==", + "source_artifact_sha256": "ff1fd4393986dfb3dd0e3e75fe379c4dfa4b424938dac23ab436e1e31f594225", + "verified_at": "2026-08-18T10:44:00Z", + "verified_projection": { + "attempt_id_sha256": "7c910764b2dcc6f05261d609082f75474e4638c3f356006307212b8fed4a2eb7", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "wrong-reference", + "evidence_sha256": "ff1fd4393986dfb3dd0e3e75fe379c4dfa4b424938dac23ab436e1e31f594225", + "run_id_sha256": "fe98ce7f0e66b885201f4667875fd38f5890ffddb575d68bd4cd5a66f8d53ca8", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "absent", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "6d0df009a1feb328d36e628a4591440d773dad58dcbfaa89101c51dbf210e246": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "Ug2a2XiATGn2Lidjh6mvpkHXgnqg+DUjUway3LdnxaF9mqLrzbwDRpqCC6whVZZv6X2ANoXaRcAcpWndWr4UAA==", + "source_artifact_sha256": "43d2d3f884205de0a56e566e84429edcbc2e0a31f4904212f36f787c3ea8df6a", + "verified_at": "2026-08-18T10:23:00Z", + "verified_projection": { + "attempt_id_sha256": "2601335b1101424105277997a67850a8a60aa45f59637b7679c1f32af463c460", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-03", + "evidence_sha256": "43d2d3f884205de0a56e566e84429edcbc2e0a31f4904212f36f787c3ea8df6a", + "run_id_sha256": "237a0b7d1cafb64b1d113dca6699e6eefeaaf0b18679138545c3695495b901d5", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "verified", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "6dad0042578bd7c79c09e312aeb104931fde6dc82c7e85cf3d540c49ced11a0b": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "D7FLZZrZXzyKWu1tCl3U/hYOtVCSr+U8iApkpOnNuSCgiHxBGK5Es1Nv3OMFMPeEIp9/8Zr5PBJQD8YfP/XOAg==", + "source_artifact_sha256": "1f121d102e5fbb97098da4d1334dfe5ffc8566bedbc601d9a73f719d325e04c3", + "verified_at": "2026-08-18T10:33:00Z", + "verified_projection": { + "attempt_id_sha256": "4667302b580ff7ceb223dbb15eb6d029969a8f6a54bcd33e8df5b6bff41f41ad", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "idempotency-replay", + "evidence_sha256": "1f121d102e5fbb97098da4d1334dfe5ffc8566bedbc601d9a73f719d325e04c3", + "run_id_sha256": "33e0ad9bf64e477f24d46508fa432123e046dcd1c5853d5cc60b7cde1bce7537", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "absent", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "6e3b9d04b81cf54fb150be35e2d27acdd45247573f0a933e42cca67796427eb5": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "ITYV/Ppba/PrN5NvxsBEdLJ/R0uOTqa1Q2AEkBjqN7uv/KW9uZpW/9zmQUiyR7W7xQ5AENqrTD2aQUTUGrplDg==", + "source_artifact_sha256": "6fe2828f0849b15893e440cf5a75e8cb3040f255c8d6d99adec885362da6f9c5", + "verified_at": "2026-08-18T11:22:00Z", + "verified_projection": { + "attempt_id_sha256": "73a097b8b20bab7794369384f7ca1d7d711aad07967b7e1292373babbb7ff1b7", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "weak-effect-only", + "evidence_sha256": "6fe2828f0849b15893e440cf5a75e8cb3040f255c8d6d99adec885362da6f9c5", + "run_id_sha256": "b44783e70a980ec5b3cf3752bd5d1d01b2ff29f5a6892cba0c1c939d8aeb7c02", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "halted", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "70a3703f7ae55e333da73a24399d55404bc28158ae6c0088656cce79103ff011": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "wGvL5qbyZg7VFIp6XC+pmc7gOB3+Uw8tlQMD1oAvX2KN1wmWjeOrHmn11oBikLG3KX7Hcu5/VZT6hK98cAmzAQ==", + "source_artifact_sha256": "516ecd879cd6bf3ddce68daf59c204f277f8dc9c69b44e4aab5485a9563bb56b", + "verified_at": "2026-08-18T10:04:00Z", + "verified_projection": { + "attempt_id_sha256": "4c352a6999f77707e8837adebb4fc2b7451c2ef6de5145190b33a5c5645e47eb", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-01", + "evidence_sha256": "516ecd879cd6bf3ddce68daf59c204f277f8dc9c69b44e4aab5485a9563bb56b", + "run_id_sha256": "4ee2bb61fb883cc8e77d636fb471aa3c0ce9ef0c0a8abd9682214bf0a8f16f26", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "verified", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "740b98f25b9a7bd1377ef51336f483823b8ab09f9e1ee7bad1075aee460a277d": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "4dtCjatTgZFrOcYUro8p6SGAY6+AcBUcW1/zIZZBr5Xi45X12snFHltWzPmlYa4wG6y5jWJXVddf4K1GThJLAA==", + "source_artifact_sha256": "92c76843346dc97ecdd23535ab0cebf2aecbaddd30aae938fed40434fb6b2da0", + "verified_at": "2026-08-18T10:32:00Z", + "verified_projection": { + "attempt_id_sha256": "3142933f4f168c98b8e89f2ae9d78fd3129e0a9975cbbaa60ddba853eee7d53c", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "idempotency-replay", + "evidence_sha256": "92c76843346dc97ecdd23535ab0cebf2aecbaddd30aae938fed40434fb6b2da0", + "run_id_sha256": "6cdff0cf50d0164fe1eee9c4b7db0b969c24f9b960f5653b516313a913c90a0f", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "verified", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "745ccd149ea968ca38642bd362a867a92243f9a556b8653b2be088f0fa636a36": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "AP8ipYAK78TS4/JjFgtM3cUWIbNeSN5c2JHZBH9dHWQ/kAFC3pMPkuyaArwwsI5gTjwbnvo4vA7ru5P9JxGmCA==", + "source_artifact_sha256": "5e9c28fdf8c09dcfbbefa41ca8075e7daaa783d6ef24d5050cc9973c6aacb810", + "verified_at": "2026-08-18T11:24:00Z", + "verified_projection": { + "attempt_id_sha256": "aa7d6be4f25a8992c0a22649ba7e703d6955abf5fece9f8322f560149cf09776", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "weak-effect-only", + "evidence_sha256": "5e9c28fdf8c09dcfbbefa41ca8075e7daaa783d6ef24d5050cc9973c6aacb810", + "run_id_sha256": "b974de9da8ef77c8dc9a7662114cc51023ab8c131c488681eeebb7d4c435c8d0", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "halted", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "75ea2d7baeaecffbfa9b5fca73b8bf70e398697d76f9d1bec9a620bae3063765": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "YiDQmnXgzqcx6UEcIRhxe4K8X8H1+kwselbv4PySdUdybfIHKoNKJcbPEXBMiyh0Xz9CxyIOXRnV6yRnCOVKAw==", + "source_artifact_sha256": "79566ede5f64ddd1b0c40fdfcfdb0f7500d96abb5c46c9abdabddca1500c599d", + "verified_at": "2026-08-18T10:34:00Z", + "verified_projection": { + "attempt_id_sha256": "3aee8ad755c7f4bec71cc194bcfaa805e0ea29cf8b830ed0782f8263dd9620ca", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "idempotency-replay", + "evidence_sha256": "79566ede5f64ddd1b0c40fdfcfdb0f7500d96abb5c46c9abdabddca1500c599d", + "run_id_sha256": "3df83453126754a62d00ed10837720542d0469799bb8a88cb5257ac5f477a919", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "verified", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "765f8d15ba0ee4a35a281110faf81931a4bef2ff9a530050d2be0097c13e1f15": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "br0Uwf5VSWB9T30yVkEBVlIQkNjzbdKucpahuFb34gwteP+IggPbbUkduNCl0x/Zxuv8FzX7rv0E3gjEfhy+DA==", + "source_artifact_sha256": "23708d813c5434c08faf44e36a798621030200b33f634d785750d86cf7fb96d7", + "verified_at": "2026-08-18T10:52:00Z", + "verified_projection": { + "attempt_id_sha256": "fbfce2be9ce964be8b668aa518a310fe4a89e5c014f42bd0ea81401bd83bfd7a", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "stale-session", + "evidence_sha256": "23708d813c5434c08faf44e36a798621030200b33f634d785750d86cf7fb96d7", + "run_id_sha256": "d9270fd4c85e4226a9347ecf703e876b9ffdc330f60c7fb8bed8f9321ea30225", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "absent", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "789bb7f6d5d3968fbaa87e3cffec42e18b036d53e2eb560a1fe1b3834fd27300": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "dinccSYtl2S0phv+suwI02Mt077kA6vEOv1TdGhVp+XFSA8ZuSrDzTyaJYyfzB3jPKSx//Z4hctlf/lsoXSCCw==", + "source_artifact_sha256": "f4e30b79fe5403ce13c6b1b63149637b35847c5bb37a7e923317e0cb11fdce22", + "verified_at": "2026-08-18T10:33:00Z", + "verified_projection": { + "attempt_id_sha256": "4667302b580ff7ceb223dbb15eb6d029969a8f6a54bcd33e8df5b6bff41f41ad", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "idempotency-replay", + "evidence_sha256": "f4e30b79fe5403ce13c6b1b63149637b35847c5bb37a7e923317e0cb11fdce22", + "run_id_sha256": "33e0ad9bf64e477f24d46508fa432123e046dcd1c5853d5cc60b7cde1bce7537", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "satisfied", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "79aa9017fd55bce5532f4bc6ca88aaaf1244fd3eb00acbae04d8b2eb2529b836": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "LVoRwsGx9uilzEpQHSottBMgr6EY1cc8d9r24ExePtMMJEvUXJoOex+MQN+s75mAfrZK7sZ1NHmBL9Fs3JjKBw==", + "source_artifact_sha256": "6c8e592e4280ffc6dc1202667837a33a8d1f4c8d88f7cde6d24a3d9b3317ad33", + "verified_at": "2026-08-18T10:42:00Z", + "verified_projection": { + "attempt_id_sha256": "e93521e706ad90d799dcd4e8cac15229c5da6aec1638540606f5fab4efce59fc", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "wrong-reference", + "evidence_sha256": "6c8e592e4280ffc6dc1202667837a33a8d1f4c8d88f7cde6d24a3d9b3317ad33", + "run_id_sha256": "ee82112f55e5e6c86cfd6e16df8c8b652549a8bd72de492f435d8255eb3dd252", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "delivered", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "7faacd55bef5f183c095457453d97320383b2202519d772ae533661a701da791": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "QbEdrtUCw76v7zZ4lQ9oM471h1ovgqYHyq5SkhJHxiF/b4imx0C8QxFIBI4tgA/Xj9+4CS91GQCw4qoTJj7LAA==", + "source_artifact_sha256": "48d2fa219c08a4043c3d974e574816a8b3952b9f1b5d638dd8a8fa098edc61dc", + "verified_at": "2026-08-18T10:33:00Z", + "verified_projection": { + "attempt_id_sha256": "4667302b580ff7ceb223dbb15eb6d029969a8f6a54bcd33e8df5b6bff41f41ad", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "idempotency-replay", + "evidence_sha256": "48d2fa219c08a4043c3d974e574816a8b3952b9f1b5d638dd8a8fa098edc61dc", + "run_id_sha256": "33e0ad9bf64e477f24d46508fa432123e046dcd1c5853d5cc60b7cde1bce7537", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "delivered", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "85e18a244859259c2a8275a40afe0d6b887db2fb91e1982d56ad414924a3423c": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "3I73T+HrvwwXc3yzT/5RIvY0YbLN6Ks+GlF7YO/sj9fYeEH+JGu5bDMbAeV+mNeW3okCBMg0T9oL3I3QR2s/DQ==", + "source_artifact_sha256": "e1dd07c3df4aed8ff42376ff74a3f68c13ebb7fb509304a544b0e8bde5b1f4ed", + "verified_at": "2026-08-18T10:02:00Z", + "verified_projection": { + "attempt_id_sha256": "679af5a8dedceb8c696719e73f82a698c230cd8fc98bb61769f0883202c0b637", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-01", + "evidence_sha256": "e1dd07c3df4aed8ff42376ff74a3f68c13ebb7fb509304a544b0e8bde5b1f4ed", + "run_id_sha256": "0b5bda916a0808165159166955a9563cf9c2303949f762a18eb037f41b44a6dc", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "verified", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "88aa95277a9bbc5666ac0b4a542bafa91ac60ee30d5fff79647d9ef050f10b75": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "AatMhqmeZmS9TTk/PlfuVH6njmho1PbSYr05+DV5XRBFEfhNk8c9D1nCVpljHgHIkyDQuDUGpmx+mBS6SV32Bg==", + "source_artifact_sha256": "8558af088d566bf88f4efb53d9cea316fe8385eb40828881aa49418896707c6b", + "verified_at": "2026-08-18T11:03:00Z", + "verified_projection": { + "attempt_id_sha256": "1ec11a9862ede3ac701af71835ac28c551d604a026b5bab7d776dbcdf288394e", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "ambiguous-target", + "evidence_sha256": "8558af088d566bf88f4efb53d9cea316fe8385eb40828881aa49418896707c6b", + "run_id_sha256": "43f0a1c00950c390b0676fab55a2aa98c354d028f2347c461661e6cdb72f717e", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "satisfied", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "892f7c4bd8e3b8b91b3e349aba640c5c87c0268e74d72343c4d14d7a6eee57ed": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "TouNDW/zg06X+xsfu3haJmKjCsyS1QJFDdEEGClueySZrLmGquADETISybWYQ2W2YcGBNu9KsTEWqgiWhaNKCg==", + "source_artifact_sha256": "6381975addf1b4ec60255f58a8d2ec052c169a3228310d84dc3954d444e76d0f", + "verified_at": "2026-08-18T10:32:00Z", + "verified_projection": { + "attempt_id_sha256": "3142933f4f168c98b8e89f2ae9d78fd3129e0a9975cbbaa60ddba853eee7d53c", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "idempotency-replay", + "evidence_sha256": "6381975addf1b4ec60255f58a8d2ec052c169a3228310d84dc3954d444e76d0f", + "run_id_sha256": "6cdff0cf50d0164fe1eee9c4b7db0b969c24f9b960f5653b516313a913c90a0f", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "delivered", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "893a8247b0fc26e0c36954a23409a8930a5e70fd085f987726277a3a30622f9f": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "pOtSZzHR5GzRn1f2ZhRTqBhdZWP0guB9XzdIw8KO0HBBSUofQ0IQrgYprKlm2UqYuAUJRFHmfsjQ93D/PeFeBg==", + "source_artifact_sha256": "086aa3c333f8a4fdf55b0ef09ae301f38faa388075355ba8356b2a2e72f7b80e", + "verified_at": "2026-08-18T10:54:00Z", + "verified_projection": { + "attempt_id_sha256": "958342a9ddca98a83b82b662f52f404239d583afe7ed70634760e1b8dd592f3b", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "stale-session", + "evidence_sha256": "086aa3c333f8a4fdf55b0ef09ae301f38faa388075355ba8356b2a2e72f7b80e", + "run_id_sha256": "6f2fb10bc2018c9f78e9702d5ccac0bedd78ee3b2e9d2a6ad779fba72d90ae50", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "satisfied", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "8979e7a57aae81f1b0da3757d74783fdd94996bfc44fbdda9843885daecad6fc": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "aUwmIIt/LW0YomBNlexWVYEqMrlBmzxu3UvpSFiGzernDnkkVhrv9WuWKQ9HFYVqkOQyoZpWIQCzCbHm+l93BQ==", + "source_artifact_sha256": "26eef6795405076a78c4a1d95d85251e7454d3059e296b07b2cf612e7b6231a2", + "verified_at": "2026-08-18T11:12:00Z", + "verified_projection": { + "attempt_id_sha256": "f5e96a2e9a580376b18beabf57798b8761e772a0c4d112877045780bb12b3720", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "verifier-unavailable", + "evidence_sha256": "26eef6795405076a78c4a1d95d85251e7454d3059e296b07b2cf612e7b6231a2", + "run_id_sha256": "e8e89651045a5f5c011c9543ed968e0fe7697a061ed8ad5cedc27d194cb96acb", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "halted", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "89a5d906de379f1e4dfa2e52a02916b84cd79388b52a30ea2f26c33834b2a094": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "+7IVGi46RiulpdfQxeJyoUCEqtQkCjW9iOITl6QtXwBh1UDahEZJuowoTiWgU0gDP5RnIDhTrpZ1PcJsaLbfDA==", + "source_artifact_sha256": "9003f18eed9ca02f5288ee8e9b498e2a7792375249a68b2444ff5d147b9c24d2", + "verified_at": "2026-08-18T10:12:00Z", + "verified_projection": { + "attempt_id_sha256": "940d3ca125ff87ce7539740fbae29d2d64fec839328b0639127e1d197d2485d8", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-02", + "evidence_sha256": "9003f18eed9ca02f5288ee8e9b498e2a7792375249a68b2444ff5d147b9c24d2", + "run_id_sha256": "bbb9312ce4682b23580eced0f8d19438d8266b222555df85fb27eef22ad5afe2", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "completed", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "8a33f194bdfb27d33344ac8e2e9085dd5e899b878157756f56886e9e29e88821": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "AhKJo7I3mn4GWrWY4oPy2iwRIpciuv0rZRuvxqKCN2C1BeHCf9wKTDiT6OY4qcFer/TMuPm5qDUVFJu/0LDVBw==", + "source_artifact_sha256": "1594ca15edbb7755f6b59f1e58383c96dab980507ce5edff073a7a295f07069b", + "verified_at": "2026-08-18T10:14:00Z", + "verified_projection": { + "attempt_id_sha256": "019dd96e9a771ccc01ebafab321d7d3a8314df8b2d6465bcfc5fa14cbdeabdf2", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-02", + "evidence_sha256": "1594ca15edbb7755f6b59f1e58383c96dab980507ce5edff073a7a295f07069b", + "run_id_sha256": "16cb8df40654c6a1b55ea0e50e772d8c6e6d4f0d8205bd1f8296be27d0af83eb", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "completed", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "8aeff82557645b5c4719bd7dc52daff351274389e5be8e98bdf6191acb475984": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "ne/dBbrIEwahDB+lGr9zQY49HkQsOlzL1ObFIuz634jW8h2vPrObSmYYbZi5Rs3Z1yiGTLQuSRy6h1NWgk31Bg==", + "source_artifact_sha256": "25166ea6bdc49a633c232781e8ef3511a9a11ef23e033b141c9a8ec8cb3f6834", + "verified_at": "2026-08-18T10:54:00Z", + "verified_projection": { + "attempt_id_sha256": "958342a9ddca98a83b82b662f52f404239d583afe7ed70634760e1b8dd592f3b", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "stale-session", + "evidence_sha256": "25166ea6bdc49a633c232781e8ef3511a9a11ef23e033b141c9a8ec8cb3f6834", + "run_id_sha256": "6f2fb10bc2018c9f78e9702d5ccac0bedd78ee3b2e9d2a6ad779fba72d90ae50", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "halted", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "8c1afd600031c30f995fb9824e193c95b4d4ad585ca879c64c9d2e348fa1b10e": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "SgbEnO9KPyhEeFEhnyzTCmjqKn6SfWsPrWBv4mEHSFNI3N0rTlwHYfOjWWqGtboAh1I8TzPj1uUB47HrF6mwBw==", + "source_artifact_sha256": "f8152ccb0471b92317861ddb7fabeae5fcf740530b8b050510e29e1da130d3e3", + "verified_at": "2026-08-18T10:22:00Z", + "verified_projection": { + "attempt_id_sha256": "fc097c8b2e6ece94544a19b8d81f5c4a9367a89059e3dd4b2f746ab06a2fc930", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-03", + "evidence_sha256": "f8152ccb0471b92317861ddb7fabeae5fcf740530b8b050510e29e1da130d3e3", + "run_id_sha256": "28768f565659133f5bf1170e638b81de4d7ca38dfecacd09ccf462a35344432b", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "absent", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "8c5e9d5c0d5330e70eceb4a7a0b11295161a7f4ca9ad6c8af091fde8afb1c6a9": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "vSrJVlomLbiXHntckSOFPBXfx5nC5oVyf8hSOpCNON+YuWhHM+RK4iQN99BH3YeUdgeVMFDuUgogSa1JkUQIBQ==", + "source_artifact_sha256": "f2226cc85e803eb3cf39a88aa39b32d75a3910acc381cbd3197767c9c0b75b5b", + "verified_at": "2026-08-18T11:14:00Z", + "verified_projection": { + "attempt_id_sha256": "ad76dacfe19a4421ef1f128d4eef1099e846b385d29f17b8588ae5130b487118", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "verifier-unavailable", + "evidence_sha256": "f2226cc85e803eb3cf39a88aa39b32d75a3910acc381cbd3197767c9c0b75b5b", + "run_id_sha256": "87014cd8063f5a43ea22c995be03ec41ef5aa613145acacdef71b68c468fc8f1", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "halted", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "8d5373078fe224a410a6aa3c622308ea4058e7c846ec59ebba5d7288bc7fc3f2": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "aG9Tx/kWr6HcUFAOunbFhbrOMgO0+BxfJeLsif8S4jO/Ngzz26uhREXHjqtBVqGmeDDbSKxr5HUC0ofgRMd1Dw==", + "source_artifact_sha256": "fac9c9cf16a2c781d6f7c55b241c6266c4fa513744fb05a705c1c8d33e3c7ccf", + "verified_at": "2026-08-18T10:24:00Z", + "verified_projection": { + "attempt_id_sha256": "7573925adbd8a7a4a3b98bb0379549d77aa8ed46e312c1cd940c05b8587a039e", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-03", + "evidence_sha256": "fac9c9cf16a2c781d6f7c55b241c6266c4fa513744fb05a705c1c8d33e3c7ccf", + "run_id_sha256": "784a0a94e581700a3d93581e7ce5bac0d3bc53c58f3e73198b896b5da9a819b0", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "absent", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "8dd51f7605352784d26b1cc7c77746ebfd297d51b90a2953f7282228bbaf7591": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "ixc+sUvdANFWTEhymJsJsBw0HWSF3+wsMXCfSSKjPrwBPBL5v0VMhLpI6S2D4XLUlJliG2btb78YYNUBxwlJDg==", + "source_artifact_sha256": "1eca1abe283fecbe71ddaa403079343a5a6893d159482e26421de9b3004b7e29", + "verified_at": "2026-08-18T11:22:00Z", + "verified_projection": { + "attempt_id_sha256": "73a097b8b20bab7794369384f7ca1d7d711aad07967b7e1292373babbb7ff1b7", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "weak-effect-only", + "evidence_sha256": "1eca1abe283fecbe71ddaa403079343a5a6893d159482e26421de9b3004b7e29", + "run_id_sha256": "b44783e70a980ec5b3cf3752bd5d1d01b2ff29f5a6892cba0c1c939d8aeb7c02", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "halted", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "8e4466457228106adf081b8f17ea483f689a4022c30e1953cf273ddbf02519dd": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "0N0gNLP0kVRMIAvIO0sykRiEedLFjj2tmjFIkcltX9/6QbFpDFitXPP26yieHX+EzH04Uk/TZLeC0kmHnvaGAA==", + "source_artifact_sha256": "f847f556481bc9323fcdfb083e5068e729d1de913f60d34a1f7f7352a95af4a0", + "verified_at": "2026-08-18T10:14:00Z", + "verified_projection": { + "attempt_id_sha256": "019dd96e9a771ccc01ebafab321d7d3a8314df8b2d6465bcfc5fa14cbdeabdf2", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-02", + "evidence_sha256": "f847f556481bc9323fcdfb083e5068e729d1de913f60d34a1f7f7352a95af4a0", + "run_id_sha256": "16cb8df40654c6a1b55ea0e50e772d8c6e6d4f0d8205bd1f8296be27d0af83eb", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "verified", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "8e671061a2ed724aebae4da714f8342c7aa1156a8151018c4cd45e8ea2b13a4e": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "5YN4OXLAmxcy/VCHw8gnEHjkFlmWwf3G6KYGFx4G+ocKcEmYK+h60VMMRlMW4zPq7g97YCo/XnBh7fePFGtnCA==", + "source_artifact_sha256": "68f28b4ae7bd66c29ac1d2e3cf594da46ea4d7fa7bfc29557c835bb848cf81d8", + "verified_at": "2026-08-18T11:23:00Z", + "verified_projection": { + "attempt_id_sha256": "eb52fb1b1bf2fac92d8f3a444bb5081161be8b3d0ef457c5065e7b79e96df770", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "weak-effect-only", + "evidence_sha256": "68f28b4ae7bd66c29ac1d2e3cf594da46ea4d7fa7bfc29557c835bb848cf81d8", + "run_id_sha256": "794033f9da2a42448254a478fb6de954898b1e544148708ad30264efdc255431", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "delivered", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "8f293c1c43a0e7a6ca5aec96665bf2a869ce0ee065aa6ef5a5695a80765623f7": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "8EG7QELpfiMP402x2styX7um85fv6aDulsjCyET2n0Ogb+oDdJpQBHdoCEcEMIOsemBnxlfTD5mgP1gAfMj1AA==", + "source_artifact_sha256": "13d5f53016f80b5ba9f95ceaa4d79970bbf9870cc12470744d0291bbef3a1cda", + "verified_at": "2026-08-18T10:24:00Z", + "verified_projection": { + "attempt_id_sha256": "7573925adbd8a7a4a3b98bb0379549d77aa8ed46e312c1cd940c05b8587a039e", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-03", + "evidence_sha256": "13d5f53016f80b5ba9f95ceaa4d79970bbf9870cc12470744d0291bbef3a1cda", + "run_id_sha256": "784a0a94e581700a3d93581e7ce5bac0d3bc53c58f3e73198b896b5da9a819b0", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "completed", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "8fc04ed993b5b503978034b069e82430afd713fec60fe7dd998675c5995d93ab": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "KclPArA7IERbgqJ9Z1/n1gkRtkcP9+lVodDHdsnVKwRw3UrIQv3vs192LyqRSudjXVVmwmWH7vnKmdQsh1ZkCQ==", + "source_artifact_sha256": "d216e429bd0611ac65b285ab73297d037fa3aeb3adb76d299da0c91d2559f159", + "verified_at": "2026-08-18T10:42:00Z", + "verified_projection": { + "attempt_id_sha256": "e93521e706ad90d799dcd4e8cac15229c5da6aec1638540606f5fab4efce59fc", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "wrong-reference", + "evidence_sha256": "d216e429bd0611ac65b285ab73297d037fa3aeb3adb76d299da0c91d2559f159", + "run_id_sha256": "ee82112f55e5e6c86cfd6e16df8c8b652549a8bd72de492f435d8255eb3dd252", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "halted", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "9360f101c663dba041ccc6d4531e5d0924cc0f4425f62aa51e3b90b145d93adf": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "AomwBewNM+5CYb1Q3+KfRllxPhwCGNMvsYtCEfDDcRuMwkGFBK/F2xO1iIvMb1OHr1OalzDsx3M6CpsEgrrHDw==", + "source_artifact_sha256": "9e7ce6c0c14f2e05ca217cb2830c9fbdd1205753014ece86f7e77671774081da", + "verified_at": "2026-08-18T11:23:00Z", + "verified_projection": { + "attempt_id_sha256": "eb52fb1b1bf2fac92d8f3a444bb5081161be8b3d0ef457c5065e7b79e96df770", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "weak-effect-only", + "evidence_sha256": "9e7ce6c0c14f2e05ca217cb2830c9fbdd1205753014ece86f7e77671774081da", + "run_id_sha256": "794033f9da2a42448254a478fb6de954898b1e544148708ad30264efdc255431", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "halted", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "950129910020acdc11ac8fd19134104516d2e8974d28c6c4044f757b9cda35c1": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "Orrbx5zybHaptmLgDxeuPUK26F0BRyrCcTe/Bgtxa/8sX4A3Bbu+TnfGDudwx+1+whlqH9ebbp3MQH59v81vBQ==", + "source_artifact_sha256": "2811b870f1234408f64ada1ddab6eb1a4160941d92a9f9df96df037d1da69536", + "verified_at": "2026-08-18T10:12:00Z", + "verified_projection": { + "attempt_id_sha256": "940d3ca125ff87ce7539740fbae29d2d64fec839328b0639127e1d197d2485d8", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-02", + "evidence_sha256": "2811b870f1234408f64ada1ddab6eb1a4160941d92a9f9df96df037d1da69536", + "run_id_sha256": "bbb9312ce4682b23580eced0f8d19438d8266b222555df85fb27eef22ad5afe2", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "verified", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "9631c84144936efd84f60d5becc81b736dcd00dca94797ec7ab3dc2a4152a80f": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "6BDloCbCM+gXlZrQpX8vsH9G2iKjyC4ysHlb8RC2Tn4GnJmR+sUmd5on8M5UQ4bQ+bOXv3nYouVjLVq+xa2BAw==", + "source_artifact_sha256": "7d36fcea2384b6bb28044bc68847492fefb2783909042a96f6416cc457c258c6", + "verified_at": "2026-08-18T11:02:00Z", + "verified_projection": { + "attempt_id_sha256": "60ee9db05b1126cfaa3b31c13bc3fab4755ac09c44e846b4d07ee51865dfa7b1", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "ambiguous-target", + "evidence_sha256": "7d36fcea2384b6bb28044bc68847492fefb2783909042a96f6416cc457c258c6", + "run_id_sha256": "628f991a182613b8700294d7483b5a4c06872cb9d5ca6047ea552b8ab6585357", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "delivered", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "96be7cec9d956a7a3f3308730cf3377553a285ef6d7bd42100b43d044e161cbb": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "Qj70t0XZGPEpjhigr/Yyzu5dA4ZhicXIuTFq5j/DsnLH+HN4Nn8XpiqUl4RyTQDqE54hEedlFD/Jtcfbv9W0BA==", + "source_artifact_sha256": "738fb82696e36887119e66c49386fc345003080f8417dcd4157684ca9a820236", + "verified_at": "2026-08-18T10:02:00Z", + "verified_projection": { + "attempt_id_sha256": "679af5a8dedceb8c696719e73f82a698c230cd8fc98bb61769f0883202c0b637", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-01", + "evidence_sha256": "738fb82696e36887119e66c49386fc345003080f8417dcd4157684ca9a820236", + "run_id_sha256": "0b5bda916a0808165159166955a9563cf9c2303949f762a18eb037f41b44a6dc", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "absent", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "974ab867b3788102bd3f634d25770c9abe171a3101c3e206b81bc60dcaac1a65": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "fMED3XGAHBlhnK1izzlZVdicc0gXduZGeRYxwKawkdxPkNrfL2XIx1C+o9rR7GwAosEBvMedQ5p3cKfn7w8dAg==", + "source_artifact_sha256": "e92cda8b4f49cc4af5827dbf65d991b60d7bdb9a894000c57505f7fe072616ce", + "verified_at": "2026-08-18T10:14:00Z", + "verified_projection": { + "attempt_id_sha256": "019dd96e9a771ccc01ebafab321d7d3a8314df8b2d6465bcfc5fa14cbdeabdf2", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-02", + "evidence_sha256": "e92cda8b4f49cc4af5827dbf65d991b60d7bdb9a894000c57505f7fe072616ce", + "run_id_sha256": "16cb8df40654c6a1b55ea0e50e772d8c6e6d4f0d8205bd1f8296be27d0af83eb", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "satisfied", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "97e53386169276ba5b6fe074df5e3b928617a1298e4fdf7c7100474d4af06152": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "vrNcbIf8sJZj7wqu48hsN/YLt/lJexSG7rUXVXtgOrmgAZmBLHqq4+xgijfOhts8feRTcTqnJfJ/dvmv5RsbBg==", + "source_artifact_sha256": "5a3777b92fabc030635bb4f578eda746f0b307d541bf84a0099314eed54c8d00", + "verified_at": "2026-08-18T10:14:00Z", + "verified_projection": { + "attempt_id_sha256": "019dd96e9a771ccc01ebafab321d7d3a8314df8b2d6465bcfc5fa14cbdeabdf2", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-02", + "evidence_sha256": "5a3777b92fabc030635bb4f578eda746f0b307d541bf84a0099314eed54c8d00", + "run_id_sha256": "16cb8df40654c6a1b55ea0e50e772d8c6e6d4f0d8205bd1f8296be27d0af83eb", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "absent", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "97f6959aeb4a3659829a200f85e403a6001866e6495675fd3fe27542ed765ea2": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", + "receipt_type": "fault", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "mbJaQFWtZdbGe+NOOcbuf2o7DOyUVrFtfU+4JDn4FPiHORqvL6YKVSSelOO0WFq4PM320ExsfA2Bfrf7IFA9Aw==", + "source_artifact_sha256": "002efaa296dd38b0596e300894d23a4d0a9ceda1480bd302602a34e6d5d6b884", + "verified_at": "2026-08-18T10:53:00Z", + "verified_projection": { + "attempt_id_sha256": "f5df4d6e64a2d38ffa8e320c87ad05d04025de267a8e152a755d3f1928ded120", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "stale-session", + "evidence_sha256": "002efaa296dd38b0596e300894d23a4d0a9ceda1480bd302602a34e6d5d6b884", + "run_id_sha256": "fd3a041b705d8c6277ce26134dc0018e866218cfa3fadd16ac29d1ad498965a3", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "injected", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "983cfdb068e5742ca3315545dbe1d5c0bca772ce0359994c7c856d089ff8a892": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "pGn8BSjps9RfCDv0iG6U4Q1LznQIdDxWmjCP5N9DUmgGjyAv2HHY0FyBaroA8HDJPN7OUuzWV03MyUOQ5O4mCg==", + "source_artifact_sha256": "19bdab0320cb59b56b35ff49a7413fec8a975d93a0f54d88dbb5ccb742efafcf", + "verified_at": "2026-08-18T10:22:00Z", + "verified_projection": { + "attempt_id_sha256": "fc097c8b2e6ece94544a19b8d81f5c4a9367a89059e3dd4b2f746ab06a2fc930", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-03", + "evidence_sha256": "19bdab0320cb59b56b35ff49a7413fec8a975d93a0f54d88dbb5ccb742efafcf", + "run_id_sha256": "28768f565659133f5bf1170e638b81de4d7ca38dfecacd09ccf462a35344432b", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "delivered", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "994bdf2b435c1a57d515e4b881bbcac43289df1f20385f7150c0193e1d2acc6f": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "ROvNllHfko7wMob+jDHi4UDl/lKNEOVHu2c5z2/lJmLeFPPU0AER4s+QBvImzNQbpWU7fC8T5EaIZZxZ1qFMDA==", + "source_artifact_sha256": "a44dac787050d0cb99551f8f0735973f618907d4b8f58c6f5760fc1634522c2f", + "verified_at": "2026-08-18T10:04:00Z", + "verified_projection": { + "attempt_id_sha256": "4c352a6999f77707e8837adebb4fc2b7451c2ef6de5145190b33a5c5645e47eb", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-01", + "evidence_sha256": "a44dac787050d0cb99551f8f0735973f618907d4b8f58c6f5760fc1634522c2f", + "run_id_sha256": "4ee2bb61fb883cc8e77d636fb471aa3c0ce9ef0c0a8abd9682214bf0a8f16f26", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "completed", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "9d1fb286c570cad74e6f2e0c77a085c58bab02089cd52c84c0a3c7637f13ff04": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "ZHbB4V6PpsQNwGuAgTM2eaWxpLF4Ty8C6y75s0EehJEfTNIdkRqnbUK0J9lr1jXqt2cKe/lVioZH+v6L71oGBg==", + "source_artifact_sha256": "009c1c1e67709868ad5218f72fe47f2fe26660be981c32e064da92de8bc4e85e", + "verified_at": "2026-08-18T10:22:00Z", + "verified_projection": { + "attempt_id_sha256": "fc097c8b2e6ece94544a19b8d81f5c4a9367a89059e3dd4b2f746ab06a2fc930", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-03", + "evidence_sha256": "009c1c1e67709868ad5218f72fe47f2fe26660be981c32e064da92de8bc4e85e", + "run_id_sha256": "28768f565659133f5bf1170e638b81de4d7ca38dfecacd09ccf462a35344432b", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "verified", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "9dc862e47d7e3dc1cfa80048c17b4c566a36aff741e4a7914b3dc0e9c3729b13": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "tMjcxMhQPM6mWFOaJcWbthLm0mjVIWyccxILufEW0qsH4SnSicXtcMx/U4twqcY+Qv1N0wv27CIZM0IVe6yABQ==", + "source_artifact_sha256": "fe35b956dbe29b97bcbf293cf40b9c9c9c6eac8466925d706e684648b3d43d9b", + "verified_at": "2026-08-18T10:43:00Z", + "verified_projection": { + "attempt_id_sha256": "6b0e5c10d55fc92c1ff8576392270a24fb65722414cf58ff9a51b8ce9ef88587", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "wrong-reference", + "evidence_sha256": "fe35b956dbe29b97bcbf293cf40b9c9c9c6eac8466925d706e684648b3d43d9b", + "run_id_sha256": "577e37b10b1c87fd9c1b5d320888b736d272824657fd59a012e85a284ee88540", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "delivered", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "9e3bbbe8b2d5c7987be2fd3e29228f407319832eee70ef1bcb56fce353a8fec1": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "uUCAw1zpszyQi/JdeZHu7AArWdv2hfUkTFpk4VkIAZduMm4IOeOAf/MfNsaq/7yHwoVFyY5pLISRy6m76LHJAQ==", + "source_artifact_sha256": "b2d52421d96d2fc81f80e91f43d0228f793bae8fefedbea6d79a281c903b0000", + "verified_at": "2026-08-18T10:33:00Z", + "verified_projection": { + "attempt_id_sha256": "4667302b580ff7ceb223dbb15eb6d029969a8f6a54bcd33e8df5b6bff41f41ad", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "idempotency-replay", + "evidence_sha256": "b2d52421d96d2fc81f80e91f43d0228f793bae8fefedbea6d79a281c903b0000", + "run_id_sha256": "33e0ad9bf64e477f24d46508fa432123e046dcd1c5853d5cc60b7cde1bce7537", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "completed", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "9ff950e9dfd77d6c9e04fba2111f9e49115c2bb248ba26e3441a76a60d07eb18": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "1hAlajSMFI/qdRJgyb58x8PBi8LgsVcxFMy464jj2inT7trfMsKR3gUmrV6TB+LHHGn9SlxFuEfcjEfaYBB4BA==", + "source_artifact_sha256": "40ce452beafd723531d21b631c3b7710042cff165f085f929b65d07e9575e16b", + "verified_at": "2026-08-18T11:14:00Z", + "verified_projection": { + "attempt_id_sha256": "ad76dacfe19a4421ef1f128d4eef1099e846b385d29f17b8588ae5130b487118", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "verifier-unavailable", + "evidence_sha256": "40ce452beafd723531d21b631c3b7710042cff165f085f929b65d07e9575e16b", + "run_id_sha256": "87014cd8063f5a43ea22c995be03ec41ef5aa613145acacdef71b68c468fc8f1", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "halted", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "a0e9b443f4c32b7625331527491aa59f8e106cc72042f16e6b6a821cd0f7fccf": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "EMX2HfS9UBThedJUYNO/qL7ZpxCDEG4ull1ExODrryFc7vsB+PBT/WltWnmILpE+7VHMZeW3LHiSnRqnHTJBAA==", + "source_artifact_sha256": "7742811fd54dc2fb2b1336f83c65918fcb116f4cf437d0246c2095228d61249a", + "verified_at": "2026-08-18T10:42:00Z", + "verified_projection": { + "attempt_id_sha256": "e93521e706ad90d799dcd4e8cac15229c5da6aec1638540606f5fab4efce59fc", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "wrong-reference", + "evidence_sha256": "7742811fd54dc2fb2b1336f83c65918fcb116f4cf437d0246c2095228d61249a", + "run_id_sha256": "ee82112f55e5e6c86cfd6e16df8c8b652549a8bd72de492f435d8255eb3dd252", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "satisfied", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "a2945533984428f22741891a6ad7bb56d247cb48bcba5b1c04abd6d0bb874fe8": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "pr7K+4S9n4SkvVAzG7Bt4B4OSkdM9fUgHmN3gb2j8EhxytZyCWyzDbQQzo94XgrJDoJpxb/Y9D7EgxnHPspRBw==", + "source_artifact_sha256": "5715c0e7be0a23b342d074947567c9aab924b43b2318265f28013a0d5715506f", + "verified_at": "2026-08-18T10:34:00Z", + "verified_projection": { + "attempt_id_sha256": "3aee8ad755c7f4bec71cc194bcfaa805e0ea29cf8b830ed0782f8263dd9620ca", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "idempotency-replay", + "evidence_sha256": "5715c0e7be0a23b342d074947567c9aab924b43b2318265f28013a0d5715506f", + "run_id_sha256": "3df83453126754a62d00ed10837720542d0469799bb8a88cb5257ac5f477a919", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "verified", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "a761ed49d1a6b031989d9a95d8d4ce740d3d5e6e8daad883e1daad675c4d19d5": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "68Q+WmqB7IsYmJAqkoggwBWedta3WUXNpLJCUpjq+aLzQCxqGXsgIh3eGgSBeNAc25SDygFxXOdelT401gmNAA==", + "source_artifact_sha256": "e8401afc508900868571caae7995d9771884b1f6faac3543a13bc77ce498c1fd", + "verified_at": "2026-08-18T10:03:00Z", + "verified_projection": { + "attempt_id_sha256": "fdad940f245d690750ad647fac25c7e76aac2f474db49732fec8129051750186", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-01", + "evidence_sha256": "e8401afc508900868571caae7995d9771884b1f6faac3543a13bc77ce498c1fd", + "run_id_sha256": "3739043a92a8781376cfbd022460c03aba40f92a800b3885ebc046321437bc40", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "delivered", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "a871118c067954b7150653696449fa0d547da2cb75a906394a899d7e81811365": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", + "receipt_type": "fault", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "oAOvxXF+5Q4M9EPj2nwWcYgySkLS54NE5c1COGCfdiA3qg3I15SLRGphWlAOgUTAta1kujo0IWmOF2LoFowRCg==", + "source_artifact_sha256": "d80e5faa489be940291e74948facb9a38c3f6ce34fbe6fb5c586b966e5c82228", + "verified_at": "2026-08-18T11:12:00Z", + "verified_projection": { + "attempt_id_sha256": "f5e96a2e9a580376b18beabf57798b8761e772a0c4d112877045780bb12b3720", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "verifier-unavailable", + "evidence_sha256": "d80e5faa489be940291e74948facb9a38c3f6ce34fbe6fb5c586b966e5c82228", + "run_id_sha256": "e8e89651045a5f5c011c9543ed968e0fe7697a061ed8ad5cedc27d194cb96acb", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "injected", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "a8b00915dcebc57be31a774634b0371cd299935f86c7c0213fdaf215480cb6c1": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "Q8GxZwBhG+Kwi6xDGVSqWBJHpxAQPyJGpYb8PtRBdIG8zFVp5sCO1G22I5ErkO823P18Tv6BENoNSlH3A+6NDA==", + "source_artifact_sha256": "a71340e07f39ce3002adc89f5435ab9eade0ea3cf1426a1e7905df87ae659b41", + "verified_at": "2026-08-18T11:12:00Z", + "verified_projection": { + "attempt_id_sha256": "f5e96a2e9a580376b18beabf57798b8761e772a0c4d112877045780bb12b3720", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "verifier-unavailable", + "evidence_sha256": "a71340e07f39ce3002adc89f5435ab9eade0ea3cf1426a1e7905df87ae659b41", + "run_id_sha256": "e8e89651045a5f5c011c9543ed968e0fe7697a061ed8ad5cedc27d194cb96acb", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "satisfied", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "ab88cfde60ca5548f8b6812e3713c9d2541ba50da220a9b4e6196cba18f94145": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "HXrBGW4KgoA9YWz0N54V9n3YRzqEBd6vDsj6FhPySkcVej+ltVaQghtbd9406rpOAcdaq+GTf6D2BxdZR/RrDA==", + "source_artifact_sha256": "82e77fe44a201615e8f4c27505e4418bc71c0e4706dbe79be35ff085e812e4ad", + "verified_at": "2026-08-18T10:02:00Z", + "verified_projection": { + "attempt_id_sha256": "679af5a8dedceb8c696719e73f82a698c230cd8fc98bb61769f0883202c0b637", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-01", + "evidence_sha256": "82e77fe44a201615e8f4c27505e4418bc71c0e4706dbe79be35ff085e812e4ad", + "run_id_sha256": "0b5bda916a0808165159166955a9563cf9c2303949f762a18eb037f41b44a6dc", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "delivered", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "abca187283c219dbc776aaae8d38842e8ef0ae7b56007f5a6708f27e161e997a": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "gPMZce379O0g1Cf4GDEXfRwz28ZnCblDrRnMCu8bL/1RRJvUhygk1owWd/3KCa580WtG8Mt4tDTuchBplDg6AA==", + "source_artifact_sha256": "ce46f3e2c640383fa7d86f238289722cb7a1f00c5ee3ba8994a54c6a140ad8d4", + "verified_at": "2026-08-18T11:13:00Z", + "verified_projection": { + "attempt_id_sha256": "42259dbb767ced4c25ad8bd40edc209720a748897194c925ed9bd2e27b2258b2", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "verifier-unavailable", + "evidence_sha256": "ce46f3e2c640383fa7d86f238289722cb7a1f00c5ee3ba8994a54c6a140ad8d4", + "run_id_sha256": "4af84f2608a25a27e6252a5800263a238bb70fb3bec65148601ddcdddbf3e03c", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "halted", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "acbcfae15099ebc8a2d63b87be87a0431e560968cb06899ee82754ccecec1b9f": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "eSNCqqamlXhNy002/zhHakF1HV3pEbVKuPrXExS0/1Qdi8IEGL3B/YWNCdST1BaGLKUKr68/1/FhF7QWoJzCDA==", + "source_artifact_sha256": "5b97c09965f50b433ebd2e38459a56f0ae35537b2267b3e89faf7125ea0c2e25", + "verified_at": "2026-08-18T11:23:00Z", + "verified_projection": { + "attempt_id_sha256": "eb52fb1b1bf2fac92d8f3a444bb5081161be8b3d0ef457c5065e7b79e96df770", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "weak-effect-only", + "evidence_sha256": "5b97c09965f50b433ebd2e38459a56f0ae35537b2267b3e89faf7125ea0c2e25", + "run_id_sha256": "794033f9da2a42448254a478fb6de954898b1e544148708ad30264efdc255431", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "absent", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "acf6d491add27b4b7a31a472243d873a000b70e758fd0adb6625e279dfa05dd3": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "vJETRQECumt9uEVqT1708m5ONCfT1SK1yJzxWu2gx025hYJsNGI9oM6/xcxGZnvUGUhYomiC+9xlsouC17U9DQ==", + "source_artifact_sha256": "11cdb7bd9282bd8b9c10b25bd5e552c14ca6658cb559b133ce7e6b8dfc17f0f3", + "verified_at": "2026-08-18T10:42:00Z", + "verified_projection": { + "attempt_id_sha256": "e93521e706ad90d799dcd4e8cac15229c5da6aec1638540606f5fab4efce59fc", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "wrong-reference", + "evidence_sha256": "11cdb7bd9282bd8b9c10b25bd5e552c14ca6658cb559b133ce7e6b8dfc17f0f3", + "run_id_sha256": "ee82112f55e5e6c86cfd6e16df8c8b652549a8bd72de492f435d8255eb3dd252", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "absent", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "ad21ee460923f6b34bab8405db2f256e8b3318e31797a5d256c274c0e0407bf0": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "bxJcCJK64fH/4m4IAxSi7w2uYdrmVIPDM4Vuh0JIPihT6EzEGzWyVc6LYb3lTuAP793TGjl9ESWHHA4NDlm1Bw==", + "source_artifact_sha256": "7cfb7c321bd76fc1bf31a8453b02adde00c9bde35f22ce38726f169660f2b323", + "verified_at": "2026-08-18T10:23:00Z", + "verified_projection": { + "attempt_id_sha256": "2601335b1101424105277997a67850a8a60aa45f59637b7679c1f32af463c460", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-03", + "evidence_sha256": "7cfb7c321bd76fc1bf31a8453b02adde00c9bde35f22ce38726f169660f2b323", + "run_id_sha256": "237a0b7d1cafb64b1d113dca6699e6eefeaaf0b18679138545c3695495b901d5", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "absent", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "ada29f53b414f7aa7dd00232151d90f5f36d0f7d0c99f06d3c4e552088cc446e": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "2lKbu7ptol40ie5dpZBo9E9DrvIQrVMkpieMs/sC+DkfKJBuISdZ+D/LOt+zs5HDzWj6yn2vphYzo0jAdVaOCw==", + "source_artifact_sha256": "072e0fd54863672011c83e29fe39c24ea7e477fb77ad912967512a7e5d7ffa65", + "verified_at": "2026-08-18T10:24:00Z", + "verified_projection": { + "attempt_id_sha256": "7573925adbd8a7a4a3b98bb0379549d77aa8ed46e312c1cd940c05b8587a039e", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-03", + "evidence_sha256": "072e0fd54863672011c83e29fe39c24ea7e477fb77ad912967512a7e5d7ffa65", + "run_id_sha256": "784a0a94e581700a3d93581e7ce5bac0d3bc53c58f3e73198b896b5da9a819b0", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "verified", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "ae73206f663e332e61d69c76ec221fa5e456e5c8b847b5b21543900b03f93105": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "H8z+NcvqI7n2qKP5tIJtG7F/ucJqRod1bzYX3mX/ustcB6NnvPP8sXnU1t7XN602Ll3+Pnr8ZAaR6t7/v9AECw==", + "source_artifact_sha256": "b4cd01f298514b82ac8baafbaf99475b073f39bad0a7c9ad414d5fdd8fe5ccd5", + "verified_at": "2026-08-18T10:43:00Z", + "verified_projection": { + "attempt_id_sha256": "6b0e5c10d55fc92c1ff8576392270a24fb65722414cf58ff9a51b8ce9ef88587", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "wrong-reference", + "evidence_sha256": "b4cd01f298514b82ac8baafbaf99475b073f39bad0a7c9ad414d5fdd8fe5ccd5", + "run_id_sha256": "577e37b10b1c87fd9c1b5d320888b736d272824657fd59a012e85a284ee88540", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "satisfied", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "af535e76d2f849ee84e5d54123508736219c482ac68737053ba110dc5330ad2e": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "VB4XOeQGtIijBZSsCUMQ9Wz1KkBu9/KD+TGyE3ii4lgivv57KJtbnJmka19nZ17GHeSqLRosmAiQI+38ysayDw==", + "source_artifact_sha256": "9ee6e57b75e164f5f91625d37f3d8286db558d96de0fe27acfcfc45c1288fda5", + "verified_at": "2026-08-18T11:03:00Z", + "verified_projection": { + "attempt_id_sha256": "1ec11a9862ede3ac701af71835ac28c551d604a026b5bab7d776dbcdf288394e", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "ambiguous-target", + "evidence_sha256": "9ee6e57b75e164f5f91625d37f3d8286db558d96de0fe27acfcfc45c1288fda5", + "run_id_sha256": "43f0a1c00950c390b0676fab55a2aa98c354d028f2347c461661e6cdb72f717e", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "absent", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "b1ceae7aa3fdcfabe16c842627a0b05f92894b90653fc43682f45975a9a69c4c": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "BhnCj0y+qxoCBTZ3AaQMU8xfccGoWIeu2VGeyDr1u4aJtEVj6icbdD4PPAIldrvO79YzzoE6FAMYahvRE7xcAA==", + "source_artifact_sha256": "d8c7b50d16df0a959a2fd2323040253e31e95b612b1ab829e460e68e6ad935b1", + "verified_at": "2026-08-18T10:52:00Z", + "verified_projection": { + "attempt_id_sha256": "fbfce2be9ce964be8b668aa518a310fe4a89e5c014f42bd0ea81401bd83bfd7a", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "stale-session", + "evidence_sha256": "d8c7b50d16df0a959a2fd2323040253e31e95b612b1ab829e460e68e6ad935b1", + "run_id_sha256": "d9270fd4c85e4226a9347ecf703e876b9ffdc330f60c7fb8bed8f9321ea30225", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "completed", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "b650e56035131f355c13d2d3948cc452fce8dae01d5bf2dd7ea3435c0b013e87": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "ZQBeQvMVWsrgxZVECkDgbxWpJlqshGMbh/QHDjgHWG8HX6cJRyhwJUJfeC9w17sys6EbXfuLcqT5nLOgRJCIAA==", + "source_artifact_sha256": "051bac821eaa3486034f245101d6c1f831d659444be87a3b5d774a9abaea05ff", + "verified_at": "2026-08-18T11:02:00Z", + "verified_projection": { + "attempt_id_sha256": "60ee9db05b1126cfaa3b31c13bc3fab4755ac09c44e846b4d07ee51865dfa7b1", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "ambiguous-target", + "evidence_sha256": "051bac821eaa3486034f245101d6c1f831d659444be87a3b5d774a9abaea05ff", + "run_id_sha256": "628f991a182613b8700294d7483b5a4c06872cb9d5ca6047ea552b8ab6585357", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "absent", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "b881269a603f7e323a56c17fd2d2f6db9e20485ee7687ece93f22aa12b7ea69d": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "uGykKP6H5w8ZcHCO6AajCMIoUM1V297jfiROKNtmySZikBTvsHOMRoBWpscQT/kCe3bmv4C9bXySSEC3jWayCA==", + "source_artifact_sha256": "e5dea576ba929b469a889784b3eb264880f21206f61c472ea33b1b5b59d161cf", + "verified_at": "2026-08-18T11:14:00Z", + "verified_projection": { + "attempt_id_sha256": "ad76dacfe19a4421ef1f128d4eef1099e846b385d29f17b8588ae5130b487118", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "verifier-unavailable", + "evidence_sha256": "e5dea576ba929b469a889784b3eb264880f21206f61c472ea33b1b5b59d161cf", + "run_id_sha256": "87014cd8063f5a43ea22c995be03ec41ef5aa613145acacdef71b68c468fc8f1", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "delivered", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "b8f596a87c49f45f75a055ed31e6c86f591fefd2cda6c1778bdd3212b4175e0b": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "t3zZjQ7Za3xHKjlG6sgxG7l7BUy7M/EWIsGAe30XthsKlAau5QIpd7nFIfk7+kQpsVVSmQgD4wJlKEgbFhCRBQ==", + "source_artifact_sha256": "e7aa152d2f5d093083e644c448c30ba167727eb53ae1e0892f97cecc1e233fb5", + "verified_at": "2026-08-18T11:24:00Z", + "verified_projection": { + "attempt_id_sha256": "aa7d6be4f25a8992c0a22649ba7e703d6955abf5fece9f8322f560149cf09776", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "weak-effect-only", + "evidence_sha256": "e7aa152d2f5d093083e644c448c30ba167727eb53ae1e0892f97cecc1e233fb5", + "run_id_sha256": "b974de9da8ef77c8dc9a7662114cc51023ab8c131c488681eeebb7d4c435c8d0", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "absent", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "b92631c4736c084b0a8f01f7dee8d27672b7cffab352fca684f025b0e9f66b02": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "dWD+6dY16blKDKe22SDooL/7+mT9A2yZAI8/gcaroLQzP30SUbix+6UMz5znT20TuGA/91CrQbE1VRWU42J4DQ==", + "source_artifact_sha256": "58703c8fb721c8bd010e150d01acbc91a664c3273b9d1b85d945398148b6ff87", + "verified_at": "2026-08-18T11:23:00Z", + "verified_projection": { + "attempt_id_sha256": "eb52fb1b1bf2fac92d8f3a444bb5081161be8b3d0ef457c5065e7b79e96df770", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "weak-effect-only", + "evidence_sha256": "58703c8fb721c8bd010e150d01acbc91a664c3273b9d1b85d945398148b6ff87", + "run_id_sha256": "794033f9da2a42448254a478fb6de954898b1e544148708ad30264efdc255431", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "satisfied", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "b9e0d9c9f9ce5387a9cca061a4fd13f9f4dce4558a4295c86a2641ff038a4dbc": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "FsUVGOLMi4cZnXQCRf3/Ft8/b/yl0++CJrX71QxaatddwH08kEbJnY3T2bTDIiOv07AhDG3FRImzgKMJdJcsDw==", + "source_artifact_sha256": "f9e70034e68ce8783bb50fb2f53e6c7f8f5ed238916ab72298bcc5068ba7cef8", + "verified_at": "2026-08-18T10:24:00Z", + "verified_projection": { + "attempt_id_sha256": "7573925adbd8a7a4a3b98bb0379549d77aa8ed46e312c1cd940c05b8587a039e", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-03", + "evidence_sha256": "f9e70034e68ce8783bb50fb2f53e6c7f8f5ed238916ab72298bcc5068ba7cef8", + "run_id_sha256": "784a0a94e581700a3d93581e7ce5bac0d3bc53c58f3e73198b896b5da9a819b0", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "delivered", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "bb54c9fee035e3fcf5c9daa6f6fc08bc1e5d3cffb2b0aa0b047b1006727c7918": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "15bqUZBe3enN5Puwj+LM1cdgrCiXDlT5aPY4tmQgAy0/MX1GfA2deagbMkEi6JcnxbiSOzDbAqMca8dHtGVhAQ==", + "source_artifact_sha256": "2fc83a9ad4cdeaa8faf4176f24cd5390e451a993166626508572a5c6a7663659", + "verified_at": "2026-08-18T10:13:00Z", + "verified_projection": { + "attempt_id_sha256": "3d42601a69ef46cc44f57b51762affef4ccd829ffde30125619a6e582af00dab", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-02", + "evidence_sha256": "2fc83a9ad4cdeaa8faf4176f24cd5390e451a993166626508572a5c6a7663659", + "run_id_sha256": "091e13ed70dab439b31cb506cf3bba1ddf6476696531cf891c39a924a928b7a1", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "absent", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "bcefc56da8f7c303f207023baadc506246d85c8e9f140de46f1e28cbc5bae278": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "H+1r6eGJtY5U58Icrj2Qqq3aqVEsU88mzgX/AAns/Cpn+5KMvwRs25YI43wvOEaGcpgl79eiZQJMVxCLjAE1Bg==", + "source_artifact_sha256": "4b49c957d7eeb5d558fc4b83415475999503aa48aa8d8be5ec00a745b6c78701", + "verified_at": "2026-08-18T10:13:00Z", + "verified_projection": { + "attempt_id_sha256": "3d42601a69ef46cc44f57b51762affef4ccd829ffde30125619a6e582af00dab", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-02", + "evidence_sha256": "4b49c957d7eeb5d558fc4b83415475999503aa48aa8d8be5ec00a745b6c78701", + "run_id_sha256": "091e13ed70dab439b31cb506cf3bba1ddf6476696531cf891c39a924a928b7a1", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "completed", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "bcf1ed30725b2853e7f37119a06ccb2838942b32c14d4d0a69378932349f5620": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "fxxCm+zd4D3sKX2GjqysBetm5n9cdeYy8i2OrHmC45ju/+ZKmeHEctSZDbxL/mbYloyE12Vk17QKKw1XWOvfDQ==", + "source_artifact_sha256": "05601e1e28046d813b5d1fc7fc6f90292c7397fe2bfacb1b27e302242c388659", + "verified_at": "2026-08-18T11:14:00Z", + "verified_projection": { + "attempt_id_sha256": "ad76dacfe19a4421ef1f128d4eef1099e846b385d29f17b8588ae5130b487118", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "verifier-unavailable", + "evidence_sha256": "05601e1e28046d813b5d1fc7fc6f90292c7397fe2bfacb1b27e302242c388659", + "run_id_sha256": "87014cd8063f5a43ea22c995be03ec41ef5aa613145acacdef71b68c468fc8f1", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "absent", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "be295e21b91bb577b764151cd66a1a1aaf4302809b9a52766361d108611afe74": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "yAIQbqVuWY4OVxyAdbD+JHT0g4l8u9JfnnWweWLtFJu0QzEbUIE1dtSrlNGlZd8Zh8bQjqnQF09tH1wCUDZ3DQ==", + "source_artifact_sha256": "24e69a5639acfa91d8833695390d6df6885bdfd9c998f69d8042b203ac41fade", + "verified_at": "2026-08-18T11:14:00Z", + "verified_projection": { + "attempt_id_sha256": "ad76dacfe19a4421ef1f128d4eef1099e846b385d29f17b8588ae5130b487118", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "verifier-unavailable", + "evidence_sha256": "24e69a5639acfa91d8833695390d6df6885bdfd9c998f69d8042b203ac41fade", + "run_id_sha256": "87014cd8063f5a43ea22c995be03ec41ef5aa613145acacdef71b68c468fc8f1", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "satisfied", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "bebd124852a24da854264263989ce3eb2a81dc7583641e725b882317634cd656": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "sDAaHuZBZhF7UiuXzNqFcS9xExKdrcwXBmFjDrYE0TBzikZDkPLyARng9QT5SjjcYFr0NfQdynBmj+Vl9UXRDA==", + "source_artifact_sha256": "f48a35f45e70951886d40904c131ba517e46acb12368169e31b1c47de7ee6a8c", + "verified_at": "2026-08-18T10:12:00Z", + "verified_projection": { + "attempt_id_sha256": "940d3ca125ff87ce7539740fbae29d2d64fec839328b0639127e1d197d2485d8", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-02", + "evidence_sha256": "f48a35f45e70951886d40904c131ba517e46acb12368169e31b1c47de7ee6a8c", + "run_id_sha256": "bbb9312ce4682b23580eced0f8d19438d8266b222555df85fb27eef22ad5afe2", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "absent", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "bfdd995c0709fd95a59fd044664d11d88fc4d51b2df6b3525c384df39504e087": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", + "receipt_type": "fault", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "SYxVUnaJibveWSELqr+2L3VULbYViY8NPQWl5At+FIibk3ftDpj6OkWNqe+B1zykO6pibDvLNlp5QI9Vi8yADA==", + "source_artifact_sha256": "c483629c37faa74e65b11335e5d15e741a5a1d5a7af2f6a4757767a446b00a34", + "verified_at": "2026-08-18T11:24:00Z", + "verified_projection": { + "attempt_id_sha256": "aa7d6be4f25a8992c0a22649ba7e703d6955abf5fece9f8322f560149cf09776", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "weak-effect-only", + "evidence_sha256": "c483629c37faa74e65b11335e5d15e741a5a1d5a7af2f6a4757767a446b00a34", + "run_id_sha256": "b974de9da8ef77c8dc9a7662114cc51023ab8c131c488681eeebb7d4c435c8d0", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "injected", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "bffc584cb4cb04d08a01698a8700bab8c812bece8884d7d1f4fe57081b46b5dd": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "hEoHJGgl8UuT78Q99+JQ0vjHwGY9ndgYlE26K1PGMBYlUR1ZHfjzYNOvKk07ZWAuigLsS6k2sYOQ4CluMhd0Bw==", + "source_artifact_sha256": "0f409e89e3eb515df85e6adff2f2e9067dd70007afab83b7da6b7dce22e1824b", + "verified_at": "2026-08-18T10:23:00Z", + "verified_projection": { + "attempt_id_sha256": "2601335b1101424105277997a67850a8a60aa45f59637b7679c1f32af463c460", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-03", + "evidence_sha256": "0f409e89e3eb515df85e6adff2f2e9067dd70007afab83b7da6b7dce22e1824b", + "run_id_sha256": "237a0b7d1cafb64b1d113dca6699e6eefeaaf0b18679138545c3695495b901d5", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "verified", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "c1d15f47a1fad41c545fa9c0c26422c179518fea0841d1f3551ab1070a4669d9": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "vNOzxYL6DWevfpUPvb7iEqxS7PJB83cEOOozgGGuFbbI1X4ycOWVeAnPuhmuGeS+k/IWGYRIUEJo4DhxFtnQBQ==", + "source_artifact_sha256": "f9f54cc3691f84eaf5543a39f915bc4b888249e20be389e737f07cc048fc796b", + "verified_at": "2026-08-18T11:24:00Z", + "verified_projection": { + "attempt_id_sha256": "aa7d6be4f25a8992c0a22649ba7e703d6955abf5fece9f8322f560149cf09776", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "weak-effect-only", + "evidence_sha256": "f9f54cc3691f84eaf5543a39f915bc4b888249e20be389e737f07cc048fc796b", + "run_id_sha256": "b974de9da8ef77c8dc9a7662114cc51023ab8c131c488681eeebb7d4c435c8d0", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "completed", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "c2f2b635cde60b553f1722c8593bb95ad7ed7023307693e3f024ffb125165db6": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "ReLHgYwoOu/Ma7j2bz+qBRiAioJwc9ordb+7ExBWFQsulEZrgBh1r13KeaCoffF5um8OUCwqNosS+j1/SyJfBQ==", + "source_artifact_sha256": "98f3bd644c3f5baa2083f90afb499c9a29160c8160a518c2d6fac7d9a3cf3792", + "verified_at": "2026-08-18T11:12:00Z", + "verified_projection": { + "attempt_id_sha256": "f5e96a2e9a580376b18beabf57798b8761e772a0c4d112877045780bb12b3720", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "verifier-unavailable", + "evidence_sha256": "98f3bd644c3f5baa2083f90afb499c9a29160c8160a518c2d6fac7d9a3cf3792", + "run_id_sha256": "e8e89651045a5f5c011c9543ed968e0fe7697a061ed8ad5cedc27d194cb96acb", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "absent", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "c8eacb7caeaa9125a97121ca8bfdfe848cf5d658a0c88b163b326c9db99949f8": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", + "receipt_type": "fault", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "32yxqJOU4oyx3wdbazkR6rWo88FCxlw7ywKpNSmaN7WwRC5hs+wHeO4d9IarrtFIV2CC3ELPSDTZhWtLw27aDQ==", + "source_artifact_sha256": "7d54c11699d0fc258007146c754f3dd04a68594dea5bf0402d10aa55a04b514d", + "verified_at": "2026-08-18T11:02:00Z", + "verified_projection": { + "attempt_id_sha256": "60ee9db05b1126cfaa3b31c13bc3fab4755ac09c44e846b4d07ee51865dfa7b1", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "ambiguous-target", + "evidence_sha256": "7d54c11699d0fc258007146c754f3dd04a68594dea5bf0402d10aa55a04b514d", + "run_id_sha256": "628f991a182613b8700294d7483b5a4c06872cb9d5ca6047ea552b8ab6585357", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "injected", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "ca4213a203a9c2047c114c5bbd18837bf2d44fd2a9741b850ca6abf26e4934a9": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", + "receipt_type": "fault", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "VBy0vmZcXj6la6amDRv56hRCq/3mnPdn46HFayEpk7bvI3nBzbqDOHED6vF+FLe+5++MwhrG2wgcmqMJ0e1gBw==", + "source_artifact_sha256": "0a6f7475010857b4c4c0c9f660926588236800ef17f86e670e163c98fa71c3a5", + "verified_at": "2026-08-18T10:44:00Z", + "verified_projection": { + "attempt_id_sha256": "7c910764b2dcc6f05261d609082f75474e4638c3f356006307212b8fed4a2eb7", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "wrong-reference", + "evidence_sha256": "0a6f7475010857b4c4c0c9f660926588236800ef17f86e670e163c98fa71c3a5", + "run_id_sha256": "fe98ce7f0e66b885201f4667875fd38f5890ffddb575d68bd4cd5a66f8d53ca8", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "injected", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "caf4bdd8d724820689f50a52d92a1280fbc90215c7b12991b3681541fd8c2206": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "VWOQ/823uDgOVvfdQ8XIP0D0aEaw9/igkygV/2gNdgB0QIAs+TCcPZCBtcRAcUgm7HQtu+KQIgrC4TIG475AAw==", + "source_artifact_sha256": "57e3d1b277db5cbe456c303c9cb64859db7dc268807b185a31e35936e13ee8c3", + "verified_at": "2026-08-18T11:22:00Z", + "verified_projection": { + "attempt_id_sha256": "73a097b8b20bab7794369384f7ca1d7d711aad07967b7e1292373babbb7ff1b7", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "weak-effect-only", + "evidence_sha256": "57e3d1b277db5cbe456c303c9cb64859db7dc268807b185a31e35936e13ee8c3", + "run_id_sha256": "b44783e70a980ec5b3cf3752bd5d1d01b2ff29f5a6892cba0c1c939d8aeb7c02", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "satisfied", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "ce56478b940c828f034cfd1c6ebc41185771a3154a621076db6d36a4d706b413": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "pBAvHegabeoclr14Bkb4Q6ltzQhCe14uHpFKM/Va4z6r1YXRz2P6f0RoTe5J8pBNnGWfkyvhxP8rDquX4pVlCQ==", + "source_artifact_sha256": "1bd19a3201a6b9102580819cf704a60ff2d91a1648a1ad38c4dc40806c809b38", + "verified_at": "2026-08-18T11:22:00Z", + "verified_projection": { + "attempt_id_sha256": "73a097b8b20bab7794369384f7ca1d7d711aad07967b7e1292373babbb7ff1b7", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "weak-effect-only", + "evidence_sha256": "1bd19a3201a6b9102580819cf704a60ff2d91a1648a1ad38c4dc40806c809b38", + "run_id_sha256": "b44783e70a980ec5b3cf3752bd5d1d01b2ff29f5a6892cba0c1c939d8aeb7c02", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "delivered", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "cf9b127576b09758cdc73a384992a995d372c5e5eb2ad814c25e4b7ac4f2c343": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "emfLDQtld00DkrrwXC8n9cyMSLOXfUayuD9hopc0KDlBRAQc1t5a18XzXS6kQIvib/4DNz44BEPoV9x/stCPDA==", + "source_artifact_sha256": "3d1fc9371e1623ec11f20518ce702cb97dd2336df830ce8143c419fac0bae157", + "verified_at": "2026-08-18T10:22:00Z", + "verified_projection": { + "attempt_id_sha256": "fc097c8b2e6ece94544a19b8d81f5c4a9367a89059e3dd4b2f746ab06a2fc930", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-03", + "evidence_sha256": "3d1fc9371e1623ec11f20518ce702cb97dd2336df830ce8143c419fac0bae157", + "run_id_sha256": "28768f565659133f5bf1170e638b81de4d7ca38dfecacd09ccf462a35344432b", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "satisfied", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "cff75b636a312f1bb5f2e99eb6935abe16347884df3077f72780662d31804a38": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", + "receipt_type": "fault", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "xhjjFSHfpLVWLb2WaFUYTlAnZcy8d/FBxcsl1GuTqJme8vq4pNOLpEs/9b0Vyz2QU5xIKu0gWx9BgiGAuttoAw==", + "source_artifact_sha256": "226019cc9a5778388b2bfe87bde12f7a08f8b33074eadc925d3e79197245a493", + "verified_at": "2026-08-18T10:54:00Z", + "verified_projection": { + "attempt_id_sha256": "958342a9ddca98a83b82b662f52f404239d583afe7ed70634760e1b8dd592f3b", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "stale-session", + "evidence_sha256": "226019cc9a5778388b2bfe87bde12f7a08f8b33074eadc925d3e79197245a493", + "run_id_sha256": "6f2fb10bc2018c9f78e9702d5ccac0bedd78ee3b2e9d2a6ad779fba72d90ae50", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "injected", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "d1146664cafb846d4dece5833facbe37778ae7f7ccece97b7fe6f3e7cabd8c27": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "5xZmGMcy/03vt6w5HzhLG3X4gisPBRKzgA0T2+gJqXfHUyXmL4Ap0II5kxKx6pcH+Z2+atPT5wzBVmP6dYzVDg==", + "source_artifact_sha256": "fc34b2087c0ac5df3a7283f31412b0a354de6d6f9a21946e56ad9f8cd42edfd6", + "verified_at": "2026-08-18T10:03:00Z", + "verified_projection": { + "attempt_id_sha256": "fdad940f245d690750ad647fac25c7e76aac2f474db49732fec8129051750186", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-01", + "evidence_sha256": "fc34b2087c0ac5df3a7283f31412b0a354de6d6f9a21946e56ad9f8cd42edfd6", + "run_id_sha256": "3739043a92a8781376cfbd022460c03aba40f92a800b3885ebc046321437bc40", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "absent", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "d36db3d72f05e9e0142a41e47eb4f413fd585a3de836ddd991067e03b6c2fd4b": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "tWFzx1QR43gRy5dgsnSOALSlLiFTXftVkMMA1R33PPRD/hTgfjmBLMM/TybE9K2Ptc32RKLUXilZRkzy04EaCg==", + "source_artifact_sha256": "559774dcac1bab02176edb36d9e7bb92abae9655472d718dbc04d72660cf6323", + "verified_at": "2026-08-18T10:03:00Z", + "verified_projection": { + "attempt_id_sha256": "fdad940f245d690750ad647fac25c7e76aac2f474db49732fec8129051750186", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-01", + "evidence_sha256": "559774dcac1bab02176edb36d9e7bb92abae9655472d718dbc04d72660cf6323", + "run_id_sha256": "3739043a92a8781376cfbd022460c03aba40f92a800b3885ebc046321437bc40", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "satisfied", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "d5ec8f549f8730997d735287bc83fa1d1e008de2960d14ebcbb4b140ff1fdd8a": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "1vVuwFRm9vuK4jHsFZPJaO6O0o2oJTRj/2T+rMFy7ia6Qx2BrRXcgUS2X1qxpjvLkKd/xf+x4dgMckni2470CA==", + "source_artifact_sha256": "dc043aee537d3d9f2971b9f6f507101da11be20d6c62347dddc91b4c9eeb8fdc", + "verified_at": "2026-08-18T11:24:00Z", + "verified_projection": { + "attempt_id_sha256": "aa7d6be4f25a8992c0a22649ba7e703d6955abf5fece9f8322f560149cf09776", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "weak-effect-only", + "evidence_sha256": "dc043aee537d3d9f2971b9f6f507101da11be20d6c62347dddc91b4c9eeb8fdc", + "run_id_sha256": "b974de9da8ef77c8dc9a7662114cc51023ab8c131c488681eeebb7d4c435c8d0", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "delivered", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "d5f9ea3188b044838ce9bee71ae6243bd2ad81b684d7c1e1b537bbce00e4d99b": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "Bz7cdtGgvLRL4I8gbXLsixEw8thvDeRvYvZsh6RdoV0Bo8nZ12WXjodMtEjNB98O52cy9Xo4iIMV2oYxqtYvDw==", + "source_artifact_sha256": "e7e294aaa63908c75e3513aee7e29b3bd24623d3fda8d6fe6fbb9dd04227630f", + "verified_at": "2026-08-18T10:23:00Z", + "verified_projection": { + "attempt_id_sha256": "2601335b1101424105277997a67850a8a60aa45f59637b7679c1f32af463c460", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-03", + "evidence_sha256": "e7e294aaa63908c75e3513aee7e29b3bd24623d3fda8d6fe6fbb9dd04227630f", + "run_id_sha256": "237a0b7d1cafb64b1d113dca6699e6eefeaaf0b18679138545c3695495b901d5", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "completed", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "d71287d6a633a01d9edcc3f0c7552799e586aa942dff0330cc13238333f676cf": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "Caj7jLI3vNH13TAMQpPMBUMFB4AT4/BEq4Wav+ABuOoZEdWWImAXgay0l+mIXQjsEWIb8f/aXjMnJZ/kYLYeDw==", + "source_artifact_sha256": "cfa32a5a84ca628c634a548be23b97ffb53dc187e1e8b479a30dba14275ec44a", + "verified_at": "2026-08-18T11:13:00Z", + "verified_projection": { + "attempt_id_sha256": "42259dbb767ced4c25ad8bd40edc209720a748897194c925ed9bd2e27b2258b2", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "verifier-unavailable", + "evidence_sha256": "cfa32a5a84ca628c634a548be23b97ffb53dc187e1e8b479a30dba14275ec44a", + "run_id_sha256": "4af84f2608a25a27e6252a5800263a238bb70fb3bec65148601ddcdddbf3e03c", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "halted", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "d7ea0a0b1670116dd9bd45378335199d7805fd2c8b56b2e52b7d8b8df1a2d376": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "wzM6dOwLwWDCpnSCNvbjJlBNMCo5PiIqTJ3K+/5F1VGQEex0KRTSd+QtvzGM1yimRChspYLoFtSvI/FHFl+CBA==", + "source_artifact_sha256": "7d89d8f99f5fd27361d5750bd99439b0669933179a8e2ce8e3c66d7f551cf8c3", + "verified_at": "2026-08-18T10:43:00Z", + "verified_projection": { + "attempt_id_sha256": "6b0e5c10d55fc92c1ff8576392270a24fb65722414cf58ff9a51b8ce9ef88587", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "wrong-reference", + "evidence_sha256": "7d89d8f99f5fd27361d5750bd99439b0669933179a8e2ce8e3c66d7f551cf8c3", + "run_id_sha256": "577e37b10b1c87fd9c1b5d320888b736d272824657fd59a012e85a284ee88540", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "completed", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "d9553baf538c005d37d0fa044211857d6a24114de97b70462fdac8fe97be3400": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "8lDDqyUAxC8gjB2yVLMm+RQRTgpVFn+2iU+CKJKmgME/TM0AYwGZbZ2Os2RoOGv3Pgj4LpSlhdLMpiJZ9DCnBw==", + "source_artifact_sha256": "63a797c26af0607f83fd33dbce35617c4061915381435f3fbbd782b3554c15dc", + "verified_at": "2026-08-18T10:13:00Z", + "verified_projection": { + "attempt_id_sha256": "3d42601a69ef46cc44f57b51762affef4ccd829ffde30125619a6e582af00dab", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-02", + "evidence_sha256": "63a797c26af0607f83fd33dbce35617c4061915381435f3fbbd782b3554c15dc", + "run_id_sha256": "091e13ed70dab439b31cb506cf3bba1ddf6476696531cf891c39a924a928b7a1", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "verified", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "d9a6d4aa7064e5bfba2fb43680aa1891a29249aa899b5c4e7d2858aa8b27825b": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "MgAx8UoKWVwBpx5w+AUaufoMrSoMzFtEGtyaNgh61GjemKSKfN+7wNa9EW73c64wlVsZaIRkxq1TpdLSr8FOCA==", + "source_artifact_sha256": "94f304fac630bb580a17d9bcc9e35a0c85e9d873543699c6e9b5668ec6c6ea4b", + "verified_at": "2026-08-18T11:03:00Z", + "verified_projection": { + "attempt_id_sha256": "1ec11a9862ede3ac701af71835ac28c551d604a026b5bab7d776dbcdf288394e", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "ambiguous-target", + "evidence_sha256": "94f304fac630bb580a17d9bcc9e35a0c85e9d873543699c6e9b5668ec6c6ea4b", + "run_id_sha256": "43f0a1c00950c390b0676fab55a2aa98c354d028f2347c461661e6cdb72f717e", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "halted", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "dc7048a424e18471caed8bd57b168512101197f3accf144c4d19acc40d01bf6a": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "NJjBJyezW3A63VJR8PXvMj657FZGkMkQQswu3/c6aAJ0TXzV4jF2wqyvlz5B/v5kjvRfV7D4i/5hAiKUqxacBQ==", + "source_artifact_sha256": "e0ce2fefc18a96fdbe4db27543f31525ec9852a94a94d757559ccdd960f8faf9", + "verified_at": "2026-08-18T10:13:00Z", + "verified_projection": { + "attempt_id_sha256": "3d42601a69ef46cc44f57b51762affef4ccd829ffde30125619a6e582af00dab", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-02", + "evidence_sha256": "e0ce2fefc18a96fdbe4db27543f31525ec9852a94a94d757559ccdd960f8faf9", + "run_id_sha256": "091e13ed70dab439b31cb506cf3bba1ddf6476696531cf891c39a924a928b7a1", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "satisfied", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "dee002824b0aacb73e258cbf2ffce66cdb8870f871b0f750e7d299102e153341": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "ppBPUAUP2edGtKfwlDgV07wnv1e8xfPGaQtBnGolDa4DtokxRk/vrLmnYOOceVI+msXPLBu1qujWdzo/v2EnDA==", + "source_artifact_sha256": "669b90f52ab8347c72f46f47c7493d314fafe014431fa4d576db6a8d42eeb0dd", + "verified_at": "2026-08-18T11:04:00Z", + "verified_projection": { + "attempt_id_sha256": "491a544656d05aea37920e5c7e2ad65a9452eac8d6e100268a599aeebd41187a", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "ambiguous-target", + "evidence_sha256": "669b90f52ab8347c72f46f47c7493d314fafe014431fa4d576db6a8d42eeb0dd", + "run_id_sha256": "aa62c7a17701a7ef01ea1d3519b4c1f90d357495b329fdda3054cc24c581a593", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "satisfied", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "dfcca365e78d63d5b6107cff019f577018420e7e4e6863991f92dbcb51ad4406": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "uDwUUPcB3hMMle3g6PzMD+bg6dmHHdqTZ605pEmMtr5QrlQyGlbIZoZ7lyXtxjOv1xeMW5UqLtfuETQS5ExHCw==", + "source_artifact_sha256": "41b0b0f3cb3d31cd294283b6d49a4982e36b7f34033f72e83a81354f0aa54a47", + "verified_at": "2026-08-18T11:12:00Z", + "verified_projection": { + "attempt_id_sha256": "f5e96a2e9a580376b18beabf57798b8761e772a0c4d112877045780bb12b3720", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "verifier-unavailable", + "evidence_sha256": "41b0b0f3cb3d31cd294283b6d49a4982e36b7f34033f72e83a81354f0aa54a47", + "run_id_sha256": "e8e89651045a5f5c011c9543ed968e0fe7697a061ed8ad5cedc27d194cb96acb", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "halted", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "e0e3d981c9ba2d0cf3195944e46a1c95815d42f5f69057fef276ee9ad794e4c6": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "VfmpXtbQ8gDR5DTqratGO549605SVfvwrujClSR+XPzVokaWYqx7wdu7LR5wRHmXvoluvd3wUmTflOZ/kW19DQ==", + "source_artifact_sha256": "40933d309a18fba8094517dfd195dd4feea0486e031db26f66ff09699477bda9", + "verified_at": "2026-08-18T10:12:00Z", + "verified_projection": { + "attempt_id_sha256": "940d3ca125ff87ce7539740fbae29d2d64fec839328b0639127e1d197d2485d8", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-02", + "evidence_sha256": "40933d309a18fba8094517dfd195dd4feea0486e031db26f66ff09699477bda9", + "run_id_sha256": "bbb9312ce4682b23580eced0f8d19438d8266b222555df85fb27eef22ad5afe2", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "verified", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "e37d0a752e30a9964257bb1bc5def9409f3902ef3d739aa88b0a91048e9715e3": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "k58ZxGpXg0OTslcVbqwLw3HkIWV2wMTrSGaj5ZObBgGIL0YExDYyWEk531sYCZ3DqZEFYDLOoFzfFvO1BU2MBQ==", + "source_artifact_sha256": "8f3a90b44ab62c40384d697eeb5664143c64378dc1162f48f40843beeb892c40", + "verified_at": "2026-08-18T10:53:00Z", + "verified_projection": { + "attempt_id_sha256": "f5df4d6e64a2d38ffa8e320c87ad05d04025de267a8e152a755d3f1928ded120", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "stale-session", + "evidence_sha256": "8f3a90b44ab62c40384d697eeb5664143c64378dc1162f48f40843beeb892c40", + "run_id_sha256": "fd3a041b705d8c6277ce26134dc0018e866218cfa3fadd16ac29d1ad498965a3", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "satisfied", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "e4a4e9961ad6f679f61438dfadc80c1c45d213a25e9a508d1f3008fc2c652f9e": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "p22H2x33Up/DDl8UAMYyPuMs5lkS2B6IcZwOBIKO+I91KwUEhcRaz0oesD73qKsvMIZ7VNZaSlzPJqpe33IPBg==", + "source_artifact_sha256": "8085128f824c52e7f957276980e2ec8ed181e15094c1a551c251a21e07009829", + "verified_at": "2026-08-18T11:22:00Z", + "verified_projection": { + "attempt_id_sha256": "73a097b8b20bab7794369384f7ca1d7d711aad07967b7e1292373babbb7ff1b7", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "weak-effect-only", + "evidence_sha256": "8085128f824c52e7f957276980e2ec8ed181e15094c1a551c251a21e07009829", + "run_id_sha256": "b44783e70a980ec5b3cf3752bd5d1d01b2ff29f5a6892cba0c1c939d8aeb7c02", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "absent", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "e559276a48fe1c67b3d827bf49a6fa86b069834a9ac294c570b0e429410aabd5": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "up9eEGPlf6SNr/CmnPD5u/F79jLKRzRxGIqpADGGVa5kLM82sjurPmrYh6+NbYUt0uVnpQXY38IkkMOPkMS/DA==", + "source_artifact_sha256": "0aefdcb48f524cd1122dc1bfffdbcea74cc3d239411590ae1b6c6b5d0ca845b4", + "verified_at": "2026-08-18T10:43:00Z", + "verified_projection": { + "attempt_id_sha256": "6b0e5c10d55fc92c1ff8576392270a24fb65722414cf58ff9a51b8ce9ef88587", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "wrong-reference", + "evidence_sha256": "0aefdcb48f524cd1122dc1bfffdbcea74cc3d239411590ae1b6c6b5d0ca845b4", + "run_id_sha256": "577e37b10b1c87fd9c1b5d320888b736d272824657fd59a012e85a284ee88540", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "absent", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "e7de3e25e41b185b7d787423eb75096f31c60c53bb16339deb6cc1d34631dcb3": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", + "receipt_type": "fault", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "e+38pGZnBUb86YZjcc7dB6libke4qt2hMsYWa4hzZQSzdCxrCYkE3mbtp6rJdclcaXAL+XQ5tm8MicnqtTp+Cg==", + "source_artifact_sha256": "0eafb7867b5bb7cf68f39f40315893e1d694dd3566b71331a554025c69b9504f", + "verified_at": "2026-08-18T10:42:00Z", + "verified_projection": { + "attempt_id_sha256": "e93521e706ad90d799dcd4e8cac15229c5da6aec1638540606f5fab4efce59fc", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "wrong-reference", + "evidence_sha256": "0eafb7867b5bb7cf68f39f40315893e1d694dd3566b71331a554025c69b9504f", + "run_id_sha256": "ee82112f55e5e6c86cfd6e16df8c8b652549a8bd72de492f435d8255eb3dd252", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "injected", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "e824c2cd52e7d2ff5ecfa797b7d2e53fa7986c0a5ea5e77204511d9460662047": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "nPTOZ+20bHMTk8lQ2zSuY0fY/NFtOZyRmg5dTkmeCOQ7wect3fb87ETn4zyqVAGR4+o4UCtrvqQKR9OHv9taAg==", + "source_artifact_sha256": "5a34e35fec7ee614b3ae06606f9778a2e11d5c8b34ca4792f79b0fc127c7d95a", + "verified_at": "2026-08-18T10:24:00Z", + "verified_projection": { + "attempt_id_sha256": "7573925adbd8a7a4a3b98bb0379549d77aa8ed46e312c1cd940c05b8587a039e", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-03", + "evidence_sha256": "5a34e35fec7ee614b3ae06606f9778a2e11d5c8b34ca4792f79b0fc127c7d95a", + "run_id_sha256": "784a0a94e581700a3d93581e7ce5bac0d3bc53c58f3e73198b896b5da9a819b0", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "verified", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "ea2c537ac99f78c9175fc41640fc030b6139c33c02ffa964597672932f1bc149": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "bowS/inBRQZkWmtZpPUQgjHlnR/E+WhJ575n2s0vZ4iUpxSny7OrbjQW5KVZicHU2KdpIuoxnH3vhMdfD1y1Dw==", + "source_artifact_sha256": "6be0b951a73718afe96c480af0f29cc328de4d1d636fbaf54a6f89ba686a0158", + "verified_at": "2026-08-18T10:52:00Z", + "verified_projection": { + "attempt_id_sha256": "fbfce2be9ce964be8b668aa518a310fe4a89e5c014f42bd0ea81401bd83bfd7a", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "stale-session", + "evidence_sha256": "6be0b951a73718afe96c480af0f29cc328de4d1d636fbaf54a6f89ba686a0158", + "run_id_sha256": "d9270fd4c85e4226a9347ecf703e876b9ffdc330f60c7fb8bed8f9321ea30225", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "satisfied", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "ea37aba51876e0039f1a875d74bb647b694a67625b103458c1c5001c94015409": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "VdtWsQXiFfqWesmd2G13PxnnlqBtQ5dMcgAlrLkbDGQYV1mA0yn2ToSDTMZq1eB0Zpy16Fwm4HlfQbuMQD1TAg==", + "source_artifact_sha256": "a8a94089ae42720eff6c8154fd7ed91674171e6a51ac522db76f1d69704673d6", + "verified_at": "2026-08-18T10:23:00Z", + "verified_projection": { + "attempt_id_sha256": "2601335b1101424105277997a67850a8a60aa45f59637b7679c1f32af463c460", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-03", + "evidence_sha256": "a8a94089ae42720eff6c8154fd7ed91674171e6a51ac522db76f1d69704673d6", + "run_id_sha256": "237a0b7d1cafb64b1d113dca6699e6eefeaaf0b18679138545c3695495b901d5", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "satisfied", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "eb31e3c8e4d77a0dcc9e9204ce5c8761e52cd666cae9cdf2c79ff209ea3a6e22": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "cbLFP5QQDHE8BEq4BBCtICaS7tyUnt/yElUog7FzPCuBSxQ0oYUe731RjSMCsqx4zrkwzsWxBjUMZntWakJjCA==", + "source_artifact_sha256": "7f144d0ed131ef44fd7db0ba5d3d03e685d681ea76df6a87fcf8bc20073786fe", + "verified_at": "2026-08-18T11:13:00Z", + "verified_projection": { + "attempt_id_sha256": "42259dbb767ced4c25ad8bd40edc209720a748897194c925ed9bd2e27b2258b2", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "verifier-unavailable", + "evidence_sha256": "7f144d0ed131ef44fd7db0ba5d3d03e685d681ea76df6a87fcf8bc20073786fe", + "run_id_sha256": "4af84f2608a25a27e6252a5800263a238bb70fb3bec65148601ddcdddbf3e03c", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "delivered", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "ec0a1bc99a2e3e8249dafda43f54e76d647c86464d87e1caf40480f35f460868": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "0vMtW+mcAdLNYXNL93MBs6lpSNMLs/fvfAGKS9I1Rd6xX8EYZTLlSZO4usRYTemwHXwh5JyEr4B2lEIx19fYDg==", + "source_artifact_sha256": "6f4098a4cb069c24d492715c73eabdf78d759e24953b88a134df911d06fd36f5", + "verified_at": "2026-08-18T10:54:00Z", + "verified_projection": { + "attempt_id_sha256": "958342a9ddca98a83b82b662f52f404239d583afe7ed70634760e1b8dd592f3b", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "stale-session", + "evidence_sha256": "6f4098a4cb069c24d492715c73eabdf78d759e24953b88a134df911d06fd36f5", + "run_id_sha256": "6f2fb10bc2018c9f78e9702d5ccac0bedd78ee3b2e9d2a6ad779fba72d90ae50", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "completed", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "ed82b83288101e083452346de7469ed7b1fd050e29e6bafac2e7691a37a8992b": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "xoKWB2eN+qSapCSnbS7KrtZxyqa8vH3yiacgb+3h6UYWQdfcQkFkr1XjlRCK99S9tAi2Ft9XJPmYR+KQ5x6SBg==", + "source_artifact_sha256": "9aff04082026c9a005b5b56eb7078d056d424b5024e1034aa161c875b0f71b80", + "verified_at": "2026-08-18T11:23:00Z", + "verified_projection": { + "attempt_id_sha256": "eb52fb1b1bf2fac92d8f3a444bb5081161be8b3d0ef457c5065e7b79e96df770", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "weak-effect-only", + "evidence_sha256": "9aff04082026c9a005b5b56eb7078d056d424b5024e1034aa161c875b0f71b80", + "run_id_sha256": "794033f9da2a42448254a478fb6de954898b1e544148708ad30264efdc255431", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "completed", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "f0b50a9ab49377989815466eb28721d01c8ee89bff2b37a4a5f3c1901ce1cfc1": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "8nNitAnSH1cOqMm2tHTz60dnY0franc30n3uFlTlylvi/1fOHe8S4+BIRkEOahRqyMDv9ni1Fn+N+uGg5Bm9DA==", + "source_artifact_sha256": "ed51ba8ee340b00da87808f45e1ed935c200be0ed41ea55cba8ebcc8e4b3872f", + "verified_at": "2026-08-18T10:24:00Z", + "verified_projection": { + "attempt_id_sha256": "7573925adbd8a7a4a3b98bb0379549d77aa8ed46e312c1cd940c05b8587a039e", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-03", + "evidence_sha256": "ed51ba8ee340b00da87808f45e1ed935c200be0ed41ea55cba8ebcc8e4b3872f", + "run_id_sha256": "784a0a94e581700a3d93581e7ce5bac0d3bc53c58f3e73198b896b5da9a819b0", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "satisfied", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "f100bd4634c9eb9fa4bed44602c35082221c7369d661daee343d30cb1df16e45": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "51lJ1pp8CD+oS7ZCSSwsPCFa7sjpKAovRjm+ngvJtZovq36dFqIIAn2JQt17Ln2lZkTSRcJdiTFGBUshQYGpBA==", + "source_artifact_sha256": "12e1cf402efb1b543738dbf0096014533d4c1324c94e1af43a90e76c161e34d4", + "verified_at": "2026-08-18T10:04:00Z", + "verified_projection": { + "attempt_id_sha256": "4c352a6999f77707e8837adebb4fc2b7451c2ef6de5145190b33a5c5645e47eb", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-01", + "evidence_sha256": "12e1cf402efb1b543738dbf0096014533d4c1324c94e1af43a90e76c161e34d4", + "run_id_sha256": "4ee2bb61fb883cc8e77d636fb471aa3c0ce9ef0c0a8abd9682214bf0a8f16f26", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "delivered", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "f35aeb8c55ead7bbe677fd5fc293f41185ff75aa21101128a8c0d9fa4a591f05": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "NQa2/aNn4Z6DjJpaC01u3LXsSzXlZr+Unh+OjSvfn82+bGUbWcFR0m4sy0tSkgmvmTin0ajbSFeNuvmJEx0tCQ==", + "source_artifact_sha256": "a19b4b67cbeff4e08ebe9a0818d950e8d1ebeec5dec837efe97635b5fb541ea0", + "verified_at": "2026-08-18T10:52:00Z", + "verified_projection": { + "attempt_id_sha256": "fbfce2be9ce964be8b668aa518a310fe4a89e5c014f42bd0ea81401bd83bfd7a", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "stale-session", + "evidence_sha256": "a19b4b67cbeff4e08ebe9a0818d950e8d1ebeec5dec837efe97635b5fb541ea0", + "run_id_sha256": "d9270fd4c85e4226a9347ecf703e876b9ffdc330f60c7fb8bed8f9321ea30225", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "halted", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "f8c79e22c64f0b26775b0c105f8087f5fa147fa7cb3e7888bfcd6f6499cea2e3": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "M/oAIz9goGtIuHzxLOoqpTjzqtSVjI4G4bRz0eoLWR/JafOcMyDTF/jrZYl/D8glwdreVjmDN3N41wR3sHKtCg==", + "source_artifact_sha256": "b6355ed63a5d7f1df450f75bb77fdcf81321616662fe3728a6da23d2a8957ce5", + "verified_at": "2026-08-18T10:34:00Z", + "verified_projection": { + "attempt_id_sha256": "3aee8ad755c7f4bec71cc194bcfaa805e0ea29cf8b830ed0782f8263dd9620ca", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "idempotency-replay", + "evidence_sha256": "b6355ed63a5d7f1df450f75bb77fdcf81321616662fe3728a6da23d2a8957ce5", + "run_id_sha256": "3df83453126754a62d00ed10837720542d0469799bb8a88cb5257ac5f477a919", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "delivered", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "fb7adef7d6907ae3e36182ff1a4574e6d2900ba700648928333295be904cedc5": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "YHjzb4gKy3+p3o1XWT7vmdExdeQnkq5nDpe+EnJ64AOvb5PMfFXouraK5WME+BrN+V9G4z7Rk5AHUFrtlF12BQ==", + "source_artifact_sha256": "c20ee28b4875041089aace249d6634176c0ed5050228c8c0fba2b37db74b7632", + "verified_at": "2026-08-18T10:43:00Z", + "verified_projection": { + "attempt_id_sha256": "6b0e5c10d55fc92c1ff8576392270a24fb65722414cf58ff9a51b8ce9ef88587", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "wrong-reference", + "evidence_sha256": "c20ee28b4875041089aace249d6634176c0ed5050228c8c0fba2b37db74b7632", + "run_id_sha256": "577e37b10b1c87fd9c1b5d320888b736d272824657fd59a012e85a284ee88540", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "halted", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "fcc4e2987962120108fd11d6baf6c9d8c4c9b0bc5a2c6bce166f3bae1d328b50": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "tuZC4HOTIOaFym8ws2WmQGgdMpfyG4liQ4fcp8AmgMeS44XnUDUtS/nfQjyqX3m66Ao97Qd6ccK+1qUhoxZuAg==", + "source_artifact_sha256": "450c89cbaa5a936d700d26b432db8bd4bbdbc51112a84e99abd73954c0897001", + "verified_at": "2026-08-18T11:04:00Z", + "verified_projection": { + "attempt_id_sha256": "491a544656d05aea37920e5c7e2ad65a9452eac8d6e100268a599aeebd41187a", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "ambiguous-target", + "evidence_sha256": "450c89cbaa5a936d700d26b432db8bd4bbdbc51112a84e99abd73954c0897001", + "run_id_sha256": "aa62c7a17701a7ef01ea1d3519b4c1f90d357495b329fdda3054cc24c581a593", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "absent", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "fdb2a16e80f05e06a44ff752694761a289fa386ea14642e5412033c0636b48bf": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "p5PQIF8t+WmVbuviiEWGBM8+ENaUZ+O4dUzvWb8prEeIjKHYgdREBSi6IUQHNm1sE40q6P3MvFHd0behDYsMAw==", + "source_artifact_sha256": "c68ae5d22981662c17338c01af40177a0e375c993c4e4dcefc9aaf4df2d5366d", + "verified_at": "2026-08-18T10:23:00Z", + "verified_projection": { + "attempt_id_sha256": "2601335b1101424105277997a67850a8a60aa45f59637b7679c1f32af463c460", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-03", + "evidence_sha256": "c68ae5d22981662c17338c01af40177a0e375c993c4e4dcefc9aaf4df2d5366d", + "run_id_sha256": "237a0b7d1cafb64b1d113dca6699e6eefeaaf0b18679138545c3695495b901d5", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "delivered", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "ff7446448b7ca80801834d31758eb31968c04d7c27fb137b992ab574ff157cdd": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v1", + "signature": "39c+nma2DZy5G2mJS/svto0I5xOethfTi2s8EJhvUldHQ+xURfuCzhva7U5TIb5C/XhXXGiJPjCqkA1iZWgXDQ==", + "source_artifact_sha256": "237359293198c0bcf55e931c23b25d4af0950bb1488672f69a6d6260eb2aee06", + "verified_at": "2026-08-18T10:02:00Z", + "verified_projection": { + "attempt_id_sha256": "679af5a8dedceb8c696719e73f82a698c230cd8fc98bb61769f0883202c0b637", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-01", + "evidence_sha256": "237359293198c0bcf55e931c23b25d4af0950bb1488672f69a6d6260eb2aee06", + "run_id_sha256": "0b5bda916a0808165159166955a9563cf9c2303949f762a18eb037f41b44a6dc", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "satisfied", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + } + }, + "schema_version": "openadapt.qualification-campaign/v1" +} diff --git a/tests/test_import_production_acceptance.py b/tests/test_import_production_acceptance.py new file mode 100644 index 0000000..74476ad --- /dev/null +++ b/tests/test_import_production_acceptance.py @@ -0,0 +1,1379 @@ +from __future__ import annotations + +import base64 +import copy +import importlib.util +import json +import subprocess +from datetime import datetime, timezone +from pathlib import Path + +import pytest + +ROOT = Path(__file__).resolve().parents[1] +SCRIPT = ROOT / "scripts" / "import_production_acceptance.py" +FIXTURES = ROOT / "tests" / "fixtures" / "production_acceptance" +SPEC = importlib.util.spec_from_file_location("production_acceptance_importer", SCRIPT) +assert SPEC is not None and SPEC.loader is not None +MODULE = importlib.util.module_from_spec(SPEC) +SPEC.loader.exec_module(MODULE) + +NOW = datetime(2026, 8, 18, 13, 0, tzinfo=timezone.utc) + + +def _fixture(name: str) -> dict[str, object]: + return json.loads((FIXTURES / name).read_text(encoding="utf-8")) + + +def _certificate() -> dict[str, object]: + return _fixture("live-certificate.json") + + +def _campaign() -> dict[str, object]: + return _fixture("qualification-campaign.json") + + +def _admission() -> dict[str, object]: + return _fixture("qualification-admission.json") + + +def _admission_trust() -> dict[str, object]: + return _fixture("qualification-admission-trust.json") + + +def _attestation() -> dict[str, str]: + return { + "repository": MODULE.CLOUD_REPOSITORY, + "workflow": MODULE.CLOUD_WORKFLOW, + "certificate_identity": MODULE.CLOUD_CERTIFICATE_IDENTITY, + "source_commit": "f" * 40, + "bundle_sha256": "sha256:" + "a1" * 32, + } + + +def _resign_admission( + admission: dict[str, object], + campaign: dict[str, object], +) -> None: + payload = admission["payload"] + assert isinstance(payload, dict) + campaign_binding = payload["campaign"] + assert isinstance(campaign_binding, dict) + campaign_binding["artifact_sha256"] = MODULE.canonical_sha256(campaign).removeprefix( + "sha256:" + ) + campaign_binding["contract_sha256"] = MODULE.canonical_sha256( + campaign["qualification_contract"] + ).removeprefix("sha256:") + campaign_binding["outcomes_sha256"] = MODULE.canonical_sha256( + { + "conditions": campaign["conditions"], + "invariants": campaign["invariants"], + "excluded_trials": campaign["excluded_trials"], + } + ).removeprefix("sha256:") + oracle = campaign["oracle_contract"] + assert isinstance(oracle, dict) + campaign_binding["oracle_id"] = oracle["schema_version"] + campaign_binding["oracle_contract_sha256"] = MODULE.canonical_sha256( + oracle + ).removeprefix("sha256:") + contract = campaign["qualification_contract"] + assert isinstance(contract, dict) + conditions = campaign["conditions"] + assert isinstance(conditions, list) + campaign_binding["tasks"] = sorted( + [ + { + "task": contract["task_id"], + "condition": condition["condition_id"], + "required_trials": condition["required_trials"], + "observed_trials": len(condition["trials"]), + } + for condition in conditions + ], + key=lambda value: (value["task"], value["condition"]), + ) + _sign_admission_payload(admission) + + +def _sign_admission_payload(admission: dict[str, object]) -> None: + from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey + + payload = admission["payload"] + assert isinstance(payload, dict) + private = Ed25519PrivateKey.from_private_bytes(bytes([1]) * 32) + admission["signature"] = base64.b64encode( + private.sign( + MODULE.ADMISSION_SIGNATURE_DOMAIN + + MODULE.canonical_json(payload).encode("utf-8") + ) + ).decode("ascii") + + +def _rebind( + certificate: dict[str, object], + campaign: dict[str, object], + admission: dict[str, object] | None = None, +) -> dict[str, object]: + admission = admission or _admission() + _resign_admission(admission, campaign) + qualification = certificate["qualification"] + assert isinstance(qualification, dict) + qualification["campaign_contract_sha256"] = MODULE.canonical_sha256( + campaign["qualification_contract"] + ) + qualification["campaign_artifact_sha256"] = MODULE.canonical_sha256(campaign) + qualification["campaign_outcomes_sha256"] = MODULE.canonical_sha256( + { + "conditions": campaign["conditions"], + "invariants": campaign["invariants"], + "excluded_trials": campaign["excluded_trials"], + } + ) + qualification["oracle_contract_sha256"] = MODULE.canonical_sha256( + campaign["oracle_contract"] + ) + qualification["qualification_admission_sha256"] = MODULE.canonical_sha256(admission) + return admission + + +def _derive( + certificate: dict[str, object] | None = None, + campaign: dict[str, object] | None = None, + admission: dict[str, object] | None = None, + attestation: dict[str, str] | None = None, + *, + now: datetime = NOW, + trusted_admission_signers: dict[str, object] | None = None, + revoked_admission_ids: set[str] | frozenset[str] = frozenset(), + revoked_admission_signer_key_ids: set[str] | frozenset[str] = frozenset(), +) -> dict[str, object]: + return MODULE.derive_production_acceptance( + certificate or _certificate(), + campaign or _campaign(), + admission or _admission(), + attestation=attestation or _attestation(), + expected_cloud_source_commit="f" * 40, + trusted_admission_signers=( + trusted_admission_signers + if trusted_admission_signers is not None + else _admission_trust() + ), + revoked_admission_ids=revoked_admission_ids, + revoked_admission_signer_key_ids=revoked_admission_signer_key_ids, + now=now, + ) + + +def _trial(campaign: dict[str, object], condition: int = 0, trial: int = 0) -> dict[str, object]: + conditions = campaign["conditions"] + assert isinstance(conditions, list) + condition_value = conditions[condition] + assert isinstance(condition_value, dict) + trials = condition_value["trials"] + assert isinstance(trials, list) + value = trials[trial] + assert isinstance(value, dict) + return value + + +def _replace_receipt_verdict( + campaign: dict[str, object], + *, + receipt_type: str, + verdict: str, + condition: int = 0, + trial: int = 0, +) -> None: + from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey + + row = _trial(campaign, condition, trial) + row_field = MODULE._RECEIPT_ROW_FIELDS[receipt_type] + old_digest = row[row_field] + assert isinstance(old_digest, str) + envelopes = campaign["receipt_envelopes"] + assert isinstance(envelopes, dict) + envelope = copy.deepcopy(envelopes.pop(old_digest)) + projection = envelope["verified_projection"] + assert isinstance(projection, dict) + projection["verdict"] = verdict + private = Ed25519PrivateKey.from_private_bytes( + bytes([20 + MODULE._RECEIPT_TYPES.index(receipt_type)]) * 32 + ) + signed = {key: envelope[key] for key in MODULE._RECEIPT_SIGNED_KEYS} + envelope["signature"] = base64.b64encode( + private.sign( + MODULE.RECEIPT_SIGNATURE_DOMAIN + + MODULE.canonical_json(signed).encode("utf-8") + ) + ).decode("ascii") + new_digest = MODULE.canonical_sha256(envelope).removeprefix("sha256:") + envelopes[new_digest] = envelope + row[row_field] = new_digest + + +def _replace_receipt_envelope( + campaign: dict[str, object], + *, + receipt_type: str, + mutate: object, + resign: bool = False, + condition: int = 0, + trial: int = 0, +) -> None: + row = _trial(campaign, condition, trial) + row_field = MODULE._RECEIPT_ROW_FIELDS[receipt_type] + old_digest = row[row_field] + assert isinstance(old_digest, str) + envelopes = campaign["receipt_envelopes"] + assert isinstance(envelopes, dict) + envelope = copy.deepcopy(envelopes.pop(old_digest)) + mutate(envelope) + if resign: + from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey + + private = Ed25519PrivateKey.from_private_bytes( + bytes([20 + MODULE._RECEIPT_TYPES.index(receipt_type)]) * 32 + ) + signed = {key: envelope[key] for key in MODULE._RECEIPT_SIGNED_KEYS} + envelope["signature"] = base64.b64encode( + private.sign( + MODULE.RECEIPT_SIGNATURE_DOMAIN + + MODULE.canonical_json(signed).encode("utf-8") + ) + ).decode("ascii") + new_digest = MODULE.canonical_sha256(envelope).removeprefix("sha256:") + envelopes[new_digest] = envelope + row[row_field] = new_digest + + +def _verified_provenance( + certificate_path: Path, + *, + commit: str = "f" * 40, + ref: str = "refs/heads/main", +) -> list[dict[str, object]]: + return [ + { + "attestation": {}, + "verificationResult": { + "signature": { + "certificate": { + "certificateIssuer": "CN=sigstore-intermediate,O=sigstore.dev", + "subjectAlternativeName": MODULE.CLOUD_CERTIFICATE_IDENTITY, + "issuer": MODULE.GITHUB_OIDC_ISSUER, + "githubWorkflowTrigger": "workflow_dispatch", + "githubWorkflowSHA": commit, + "githubWorkflowName": "Execute live synthetic acceptance", + "githubWorkflowRepository": MODULE.CLOUD_REPOSITORY, + "githubWorkflowRef": ref, + "buildSignerURI": MODULE.CLOUD_CERTIFICATE_IDENTITY, + "buildSignerDigest": commit, + "runnerEnvironment": "github-hosted", + "sourceRepositoryURI": ( + "https://github.com/OpenAdaptAI/openadapt-cloud" + ), + "sourceRepositoryDigest": commit, + "sourceRepositoryRef": ref, + "sourceRepositoryIdentifier": "123456", + "sourceRepositoryOwnerURI": "https://github.com/OpenAdaptAI", + "sourceRepositoryOwnerIdentifier": "7890", + "buildConfigURI": MODULE.CLOUD_CERTIFICATE_IDENTITY, + "buildConfigDigest": commit, + "buildTrigger": "workflow_dispatch", + "runInvocationURI": ( + "https://github.com/OpenAdaptAI/openadapt-cloud/" + "actions/runs/123456789/attempts/1" + ), + "sourceRepositoryVisibilityAtSigning": "public", + } + }, + "verifiedTimestamps": [ + { + "type": "Tlog", + "uri": "https://rekor.sigstore.dev", + "timestamp": "2026-08-18T12:00:05.000Z", + } + ], + "verifiedIdentity": MODULE.CLOUD_CERTIFICATE_IDENTITY, + "statement": { + "_type": "https://in-toto.io/Statement/v1", + "subject": [ + { + "name": certificate_path.name, + "digest": { + "sha256": MODULE.file_sha256(certificate_path).removeprefix( + "sha256:" + ) + }, + } + ], + "predicateType": "https://slsa.dev/provenance/v1", + "predicate": { + "buildDefinition": { + "buildType": ( + "https://actions.github.io/buildtypes/workflow/v1" + ), + "externalParameters": { + "workflow": { + "ref": ref, + "repository": "https://github.com/OpenAdaptAI/openadapt-cloud", + "path": ".github/workflows/execute-live-acceptance.yml", + } + }, + "internalParameters": { + "github": { + "event_name": "workflow_dispatch", + "repository_id": "123456", + "repository_owner_id": "7890", + "runner_environment": "github-hosted", + } + }, + "resolvedDependencies": [ + { + "uri": ( + "git+https://github.com/OpenAdaptAI/" + f"openadapt-cloud@{ref}" + ), + "digest": {"gitCommit": commit}, + } + ], + }, + "runDetails": { + "builder": {"id": MODULE.CLOUD_CERTIFICATE_IDENTITY}, + "metadata": { + "invocationId": ( + "https://github.com/OpenAdaptAI/openadapt-cloud/" + "actions/runs/123456789/attempts/1" + ) + }, + }, + }, + }, + }, + } + ] + + +def test_derives_only_the_scoped_claim_and_counts_retained_rows() -> None: + result = _derive() + + assert result["verdict"] == "accepted" + assert result["evidence_class"] == "qualified_browser_production_acceptance" + assert result["claim_scope"] == "qualified_browser_workflow_on_bound_environment" + assert result["claim_limit"] == "not_general_product_production_readiness" + assert result["trial_inventory"] == { + "condition_count": 9, + "trial_count": 27, + "minimum_trials_per_condition": 3, + "trials_per_condition": { + "ambiguous-target": 3, + "healthy-01": 3, + "healthy-02": 3, + "healthy-03": 3, + "idempotency-replay": 3, + "stale-session": 3, + "verifier-unavailable": 3, + "weak-effect-only": 3, + "wrong-reference": 3, + }, + "excluded_trial_count": 0, + } + assert result["derived_outcomes"]["verified"] == 12 + assert result["derived_outcomes"]["safe_halt"] == 15 + assert set(result["reliability"].values()) == {0} + assert "production_acceptance" not in result + assert "class" not in result + + +def test_fixture_digests_are_exact() -> None: + certificate = _certificate() + campaign = _campaign() + admission = _admission() + + assert MODULE.canonical_sha256(admission) == certificate["qualification"][ + "qualification_admission_sha256" + ] + assert MODULE.canonical_sha256(campaign["qualification_contract"]) == certificate[ + "qualification" + ]["campaign_contract_sha256"] + assert MODULE.canonical_sha256(campaign) == certificate["qualification"][ + "campaign_artifact_sha256" + ] + assert MODULE.canonical_sha256(campaign["oracle_contract"]) == certificate[ + "qualification" + ]["oracle_contract_sha256"] + + +@pytest.mark.parametrize("field,value", [("production_acceptance", True), ("class", "production")]) +def test_rejects_author_declared_production_labels(field: str, value: object) -> None: + certificate = _certificate() + campaign = _campaign() + campaign[field] = value + admission = _rebind(certificate, campaign) + + with pytest.raises(MODULE.AcceptanceError, match="campaign keys differ"): + _derive(certificate, campaign, admission) + + +def test_rejects_author_declared_summary_counts() -> None: + certificate = _certificate() + campaign = _campaign() + campaign["summary"] = { + "trial_count": 999, + "silent_incorrect_success_count": 0, + "over_halt_count": 0, + } + admission = _rebind(certificate, campaign) + + with pytest.raises(MODULE.AcceptanceError, match="campaign keys differ"): + _derive(certificate, campaign, admission) + + +def test_rejects_count_only_condition_without_trial_rows() -> None: + certificate = _certificate() + campaign = _campaign() + condition = campaign["conditions"][0] + condition["trials"] = {"trial_count": 3, "verified_count": 3} + admission = _rebind(certificate, campaign) + + with pytest.raises(MODULE.AcceptanceError, match="task inventory is malformed"): + _derive(certificate, campaign, admission) + + +def test_rejects_fewer_than_three_trials_in_one_condition() -> None: + certificate = _certificate() + campaign = _campaign() + campaign["conditions"][0]["trials"] = campaign["conditions"][0]["trials"][:2] + admission = _rebind(certificate, campaign) + + with pytest.raises(MODULE.AcceptanceError, match="fewer than 3 retained trials"): + _derive(certificate, campaign, admission) + + +def test_rejects_duplicate_attempt_ids() -> None: + certificate = _certificate() + campaign = _campaign() + _trial(campaign, 0, 1)["attempt_id_sha256"] = _trial(campaign, 0, 0)[ + "attempt_id_sha256" + ] + admission = _rebind(certificate, campaign) + + with pytest.raises(MODULE.AcceptanceError, match="attempt ID is duplicate"): + _derive(certificate, campaign, admission) + + +def test_rejects_reused_signed_receipt_envelope() -> None: + certificate = _certificate() + campaign = _campaign() + first = _trial(campaign, 0, 0) + second = _trial(campaign, 0, 1) + second["runner_receipt_sha256"] = first["runner_receipt_sha256"] + admission = _rebind(certificate, campaign) + + with pytest.raises(MODULE.AcceptanceError, match="reuses a receipt envelope"): + _derive(certificate, campaign, admission) + + +def test_rejects_digest_only_row_without_signed_receipt_body() -> None: + certificate = _certificate() + campaign = _campaign() + _trial(campaign, 0, 1)["runner_receipt_sha256"] = "0" * 64 + admission = _rebind(certificate, campaign) + + with pytest.raises(MODULE.AcceptanceError, match="receipt body is missing"): + _derive(certificate, campaign, admission) + + +@pytest.mark.parametrize( + "replacement", + [ + { + "id": "no_wrong_or_duplicate_effect", + "holds": True, + "observations": 0, + "violations": 0, + }, + { + "id": "no_wrong_or_duplicate_effect", + "holds": False, + "observations": 27, + "violations": 1, + }, + ], +) +def test_rejects_vacuous_or_false_invariants(replacement: dict[str, object]) -> None: + certificate = _certificate() + campaign = _campaign() + campaign["invariants"][0] = replacement + admission = _rebind(certificate, campaign) + + with pytest.raises(MODULE.AcceptanceError, match="differs from retained trials"): + _derive(certificate, campaign, admission) + + +def test_rejects_invented_invariant_name() -> None: + certificate = _certificate() + campaign = _campaign() + campaign["invariants"][0]["id"] = "author_says_everything_is_good" + admission = _rebind(certificate, campaign) + + with pytest.raises(MODULE.AcceptanceError, match="invariant is not derived"): + _derive(certificate, campaign, admission) + + +def test_rejects_campaign_digest_mismatch() -> None: + campaign = _campaign() + campaign["generated_at"] = "2026-08-18T11:56:00Z" + + with pytest.raises(MODULE.AcceptanceError, match="campaign artifact digest differs"): + _derive(campaign=campaign) + + +def test_rejects_qualification_contract_digest_mismatch() -> None: + certificate = _certificate() + campaign = _campaign() + admission = _admission() + certificate["qualification"]["campaign_contract_sha256"] = "sha256:" + "3a" * 32 + qualification = certificate["qualification"] + qualification["campaign_artifact_sha256"] = MODULE.canonical_sha256(campaign) + + with pytest.raises(MODULE.AcceptanceError, match="contract digest differs"): + _derive(certificate, campaign, admission) + + +@pytest.mark.parametrize( + "mutation,expected", + [ + ( + lambda contract: contract["cases"][3].__setitem__( + "replays_case", "healthy-02" + ), + "replay contract is not reviewed", + ), + ( + lambda contract: contract["fault_case_receipts"].__setitem__( + "required", False + ), + "fault-receipt contract is not reviewed", + ), + ( + lambda contract: contract["cleanup"].__setitem__("required", False), + "cleanup contract is not reviewed", + ), + ( + lambda contract: contract.__setitem__( + "post_campaign_invariant", "cleanup was probably successful" + ), + "post-campaign invariant is not reviewed", + ), + ], +) +def test_rejects_weakened_replay_fault_or_cleanup_contract( + mutation: object, + expected: str, +) -> None: + certificate = _certificate() + campaign = _campaign() + mutation(campaign["qualification_contract"]) + admission = _rebind(certificate, campaign) + + with pytest.raises(MODULE.AcceptanceError, match=expected): + _derive(certificate, campaign, admission) + + +@pytest.mark.parametrize( + "field,value", + [ + ("workflow_version_id", "77777777-7777-4777-8777-777777777777"), + ("runtime_validation_id", "88888888-8888-4888-8888-888888888888"), + ("bundle_artifact_sha256", "0" * 64), + ], +) +def test_rejects_trial_binding_mismatches(field: str, value: str) -> None: + certificate = _certificate() + campaign = _campaign() + _trial(campaign, 0, 0)[field] = value + admission = _rebind(certificate, campaign) + + with pytest.raises(MODULE.AcceptanceError, match="differs from admission"): + _derive(certificate, campaign, admission) + + +def test_rejects_unknown_certificate_signer_repository() -> None: + certificate = _certificate() + certificate["identities"]["producer"]["repository"] = "attacker/openadapt-cloud" + + with pytest.raises(MODULE.AcceptanceError, match="producer identity"): + _derive(certificate) + + +def test_rejects_certificate_identity_policy_drift() -> None: + certificate = _certificate() + certificate["identities"]["producer"]["source_ref"] = "refs/heads/unreviewed" + + with pytest.raises(MODULE.AcceptanceError, match="producer identity"): + _derive(certificate) + + certificate = _certificate() + certificate["identities"]["verifier"]["hosted_runner_required"] = False + + with pytest.raises(MODULE.AcceptanceError, match="verifier identity"): + _derive(certificate) + + +def test_rejects_unknown_attestation_workflow_or_ref() -> None: + attestation = _attestation() + attestation["certificate_identity"] = ( + "https://github.com/OpenAdaptAI/openadapt-cloud/" + ".github/workflows/execute-live-acceptance.yml@refs/heads/attacker" + ) + + with pytest.raises(MODULE.AcceptanceError, match="attestation identity"): + _derive(attestation=attestation) + + +def test_rejects_expired_object_lock_retention() -> None: + expired = datetime(2027, 8, 18, 12, 2, tzinfo=timezone.utc) + + with pytest.raises(MODULE.AcceptanceError, match="has expired"): + _derive(now=expired) + + +def test_rejects_noncanonical_or_inconsistent_retention() -> None: + certificate = _certificate() + certificate["retention"]["retention_until"] = "2026-08-19T12:01:00.000Z" + + with pytest.raises(MODULE.AcceptanceError, match="outside policy"): + _derive(certificate) + + +def test_rejects_unhashed_workflow_binding() -> None: + certificate = _certificate() + certificate["qualification"]["workflow_digest"] = "workflow-v1" + + with pytest.raises(MODULE.AcceptanceError, match="must be a sha256 digest"): + _derive(certificate) + + +@pytest.mark.parametrize( + "image", + [ + "python:3.11-slim", + "python:3.11-slim@sha256:abc", + "python:3.11-slim@sha256:" + "g" * 64, + "@sha256:" + "4" * 64, + "python:3.11@sha256:" + "4" * 64 + "-suffix", + ], +) +def test_rejects_malformed_browser_image_digest(image: str) -> None: + certificate = _certificate() + certificate["product"]["managed_runtime"]["browser_base_image"] = image + + with pytest.raises(MODULE.AcceptanceError, match="browser image is not digest-pinned"): + _derive(certificate) + + +def test_rejects_unknown_certificate_fields() -> None: + certificate = _certificate() + certificate["production_ready"] = True + + with pytest.raises(MODULE.AcceptanceError, match="certificate keys differ"): + _derive(certificate) + + +def test_rejects_declared_contract_boolean_that_is_not_verified() -> None: + certificate = _certificate() + certificate["contracts"]["independent_effect_verified"] = False + + with pytest.raises(MODULE.AcceptanceError, match="contracts are not all verified"): + _derive(certificate) + + +def test_rejects_non_idempotent_accepted_responses() -> None: + certificate = _certificate() + certificate["transaction"]["duplicate_response_sha256"] = "sha256:" + "0" * 64 + + with pytest.raises(MODULE.AcceptanceError, match="different digests"): + _derive(certificate) + + +def test_rejects_certificate_that_omits_a_hashed_runner_link() -> None: + certificate = _certificate() + del certificate["transaction"]["request_sha256"] + + with pytest.raises(MODULE.AcceptanceError, match="transaction keys differ"): + _derive(certificate) + + +def test_rejects_missing_or_invalid_runner_permit_binding() -> None: + certificate = _certificate() + del certificate["transaction"]["runner_permit_sha256"] + + with pytest.raises(MODULE.AcceptanceError, match="transaction keys differ"): + _derive(certificate) + + certificate = _certificate() + certificate["transaction"]["runner_permit_sha256"] = "permit-1" + + with pytest.raises(MODULE.AcceptanceError, match="must be a sha256 digest"): + _derive(certificate) + + +def test_rejects_certificate_with_a_different_admission_digest() -> None: + certificate = _certificate() + certificate["qualification"]["qualification_admission_sha256"] = "sha256:" + "9a" * 32 + + with pytest.raises(MODULE.AcceptanceError, match="admission digest differs"): + _derive(certificate) + + +@pytest.mark.parametrize( + "field", + [ + "admission_id_sha256", + "runtime_validation_id_sha256", + "workflow_version_id_sha256", + ], +) +def test_rejects_public_id_digest_not_recomputed_from_admission(field: str) -> None: + certificate = _certificate() + certificate["qualification"][field] = "sha256:" + "0" * 64 + + with pytest.raises(MODULE.AcceptanceError, match="retained admission"): + _derive(certificate) + + +@pytest.mark.parametrize("field", ["organization_id_sha256", "workflow_id_sha256"]) +def test_rejects_public_identity_digest_not_recomputed_from_admission(field: str) -> None: + certificate = _certificate() + certificate["identities"][field] = "sha256:" + "0" * 64 + + with pytest.raises(MODULE.AcceptanceError, match="retained admission"): + _derive(certificate) + + +def test_rejects_author_supplied_certificate_trial_count() -> None: + certificate = _certificate() + certificate["qualification"]["observed_trial_count"] = 28 + + with pytest.raises(MODULE.AcceptanceError, match="differs from retained rows"): + _derive(certificate) + + +def test_rejects_unknown_signer_fingerprint_scheme() -> None: + certificate = _certificate() + certificate["identities"]["signer_fingerprint_scheme"] = "opaque-key-id" + + with pytest.raises(MODULE.AcceptanceError, match="fingerprint scheme"): + _derive(certificate) + + +def test_rejects_unverified_object_lock_receipt() -> None: + certificate = _certificate() + certificate["retention"]["object_lock_verified"] = False + + with pytest.raises(MODULE.AcceptanceError, match="object_lock_verified"): + _derive(certificate) + + +def test_file_import_stays_refused_until_private_export_is_approved(tmp_path: Path) -> None: + with pytest.raises(MODULE.AcceptanceError, match="pending an approved private-export"): + MODULE.import_files( + tmp_path / "certificate.json", + tmp_path / "campaign.json", + tmp_path / "admission.json", + tmp_path / "bundle.jsonl", + "f" * 40, + trusted_admission_signers={}, + ) + + +def test_cli_refuses_before_it_reads_private_evidence( + tmp_path: Path, + capsys: pytest.CaptureFixture[str], +) -> None: + output = tmp_path / "derived.json" + result = MODULE.main( + [ + "--certificate", + str(tmp_path / "missing-certificate.json"), + "--campaign", + str(tmp_path / "missing-campaign.json"), + "--qualification-admission", + str(tmp_path / "missing-admission.json"), + "--attestation-bundle", + str(tmp_path / "missing-bundle.jsonl"), + "--expected-cloud-source-commit", + "f" * 40, + "--trusted-admission-signers", + str(FIXTURES / "qualification-admission-trust.json"), + "--output", + str(output), + ] + ) + + assert result == 1 + assert "pending an approved private-export contract" in capsys.readouterr().err + assert not output.exists() + + +def test_rejects_collapsed_runner_observer_signing_identities() -> None: + certificate = _certificate() + certificate["identities"]["managed_runner_signer_sha256"] = certificate["identities"][ + "target_observer_signer_sha256" + ] + + with pytest.raises(MODULE.AcceptanceError, match="signing identities are not separate"): + _derive(certificate) + + +@pytest.mark.parametrize( + "receipt_type,verdict,row_updates,expected", + [ + ( + "runner", + "halted", + {"execution_outcome": "halted", "failure_class": "over_halt"}, + "over_halt", + ), + ( + "observer", + "refuted", + {"oracle_verdict": "refuted", "failure_class": "silent_incorrect_success"}, + "silent_incorrect_success", + ), + ( + "webhook", + "missing", + {"failure_class": "uncertain_delivery"}, + "uncertain_delivery", + ), + ( + "runner", + "failed", + {"execution_outcome": "failed", "failure_class": "platform_failure"}, + "platform_failure", + ), + ], +) +def test_rejects_failures_derived_from_signed_receipts( + receipt_type: str, + verdict: str, + row_updates: dict[str, object], + expected: str, +) -> None: + certificate = _certificate() + campaign = _campaign() + _replace_receipt_verdict( + campaign, + receipt_type=receipt_type, + verdict=verdict, + trial=1, + ) + _trial(campaign, 0, 1).update(row_updates) + admission = _rebind(certificate, campaign) + + with pytest.raises(MODULE.AcceptanceError, match="production-acceptance failures") as error: + _derive(certificate, campaign, admission) + assert expected in str(error.value) + + +def test_rejects_contract_that_permits_model_calls_on_the_healthy_path() -> None: + certificate = _certificate() + campaign = _campaign() + campaign["qualification_contract"]["runtime"]["openadapt_flow"][ + "healthy_path_model_call_limit" + ] = 1 + admission = _rebind(certificate, campaign) + + with pytest.raises(MODULE.AcceptanceError, match="permits model calls"): + _derive(certificate, campaign, admission) + + +def test_rejects_excluded_trials() -> None: + certificate = _certificate() + campaign = _campaign() + campaign["excluded_trials"] = ["failed-first-attempt"] + admission = _rebind(certificate, campaign) + + with pytest.raises(MODULE.AcceptanceError, match="excluded or hidden"): + _derive(certificate, campaign, admission) + + +def test_rejects_missing_contract_condition() -> None: + certificate = _certificate() + campaign = _campaign() + campaign["conditions"].pop() + admission = _rebind(certificate, campaign) + + with pytest.raises(MODULE.AcceptanceError, match="every contract condition"): + _derive(certificate, campaign, admission) + + +def test_result_does_not_disclose_private_admission_identifiers() -> None: + admission = _admission() + payload = admission["payload"] + assert isinstance(payload, dict) + + rendered = json.dumps(_derive(admission=admission), sort_keys=True) + + for key in MODULE._ADMISSION_UUID_KEYS: + assert payload[key] not in rendered + + +def test_rejects_invalid_qualification_admission_signature() -> None: + admission = _admission() + admission["signature"] = "A" * 86 + "==" + + with pytest.raises(MODULE.AcceptanceError, match="signature is invalid"): + _derive(admission=admission) + + +def test_rejects_unknown_or_revoked_admission_signer() -> None: + admission = _admission() + payload = admission["payload"] + assert isinstance(payload, dict) + issuer = payload["issuer"] + assert isinstance(issuer, dict) + key_id = issuer["key_id"] + assert isinstance(key_id, str) + + with pytest.raises(MODULE.AcceptanceError, match="signer is not trusted"): + _derive(admission=admission, trusted_admission_signers={}) + with pytest.raises(MODULE.AcceptanceError, match="signer is revoked"): + _derive(admission=admission, revoked_admission_signer_key_ids={key_id}) + + +def test_rejects_revoked_admission_id() -> None: + admission = _admission() + payload = admission["payload"] + assert isinstance(payload, dict) + admission_id = payload["admission_id"] + assert isinstance(admission_id, str) + + with pytest.raises(MODULE.AcceptanceError, match="admission is revoked"): + _derive(admission=admission, revoked_admission_ids={admission_id}) + + +@pytest.mark.parametrize( + "field,value,expected", + [ + ("workflow", "attacker/repo/.github/workflows/admit.yml", "workflow is not approved"), + ("ref", "refs/heads/feature@" + "a" * 40, "ref is not approved"), + ], +) +def test_rejects_unapproved_admission_provenance( + field: str, + value: str, + expected: str, +) -> None: + certificate = _certificate() + campaign = _campaign() + admission = _admission() + issuer = admission["payload"]["issuer"] + issuer[field] = value + _sign_admission_payload(admission) + certificate["qualification"]["qualification_admission_sha256"] = ( + MODULE.canonical_sha256(admission) + ) + + with pytest.raises(MODULE.AcceptanceError, match=expected): + _derive(certificate, campaign, admission) + + +@pytest.mark.parametrize( + "field,value,expected", + [ + ("expires_at", "2026-08-18T12:30:00Z", "has expired"), + ("not_before", "2026-08-18T11:58:00.000Z", "whole-second UTC"), + ], +) +def test_rejects_invalid_admission_time_contract( + field: str, + value: str, + expected: str, +) -> None: + certificate = _certificate() + campaign = _campaign() + admission = _admission() + admission["payload"][field] = value + _sign_admission_payload(admission) + certificate["qualification"]["qualification_admission_sha256"] = ( + MODULE.canonical_sha256(admission) + ) + + with pytest.raises(MODULE.AcceptanceError, match=expected): + _derive(certificate, campaign, admission) + + +def test_rejects_future_issued_admission() -> None: + certificate = _certificate() + campaign = _campaign() + admission = _admission() + payload = admission["payload"] + payload["issued_at"] = "2026-08-18T13:06:00Z" + payload["not_before"] = "2026-08-18T13:05:00Z" + payload["expires_at"] = "2026-09-17T13:06:00Z" + _sign_admission_payload(admission) + certificate["qualification"]["qualification_admission_sha256"] = ( + MODULE.canonical_sha256(admission) + ) + + with pytest.raises(MODULE.AcceptanceError, match="future-issued"): + _derive(certificate, campaign, admission) + + +def test_rejects_author_supplied_failure_class_not_supported_by_receipts() -> None: + certificate = _certificate() + campaign = _campaign() + _trial(campaign, 0, 0)["failure_class"] = "wrong_record" + admission = _rebind(certificate, campaign) + + with pytest.raises(MODULE.AcceptanceError, match="failure class differs"): + _derive(certificate, campaign, admission) + + +def test_rejects_invalid_normalized_receipt_signature() -> None: + certificate = _certificate() + campaign = _campaign() + _replace_receipt_envelope( + campaign, + receipt_type="runner", + mutate=lambda envelope: envelope.__setitem__("signature", "A" * 86 + "=="), + ) + admission = _rebind(certificate, campaign) + + with pytest.raises(MODULE.AcceptanceError, match="signature is invalid"): + _derive(certificate, campaign, admission) + + +def test_rejects_receipt_projection_that_differs_from_its_row() -> None: + certificate = _certificate() + campaign = _campaign() + + def mutate(envelope: dict[str, object]) -> None: + projection = envelope["verified_projection"] + assert isinstance(projection, dict) + projection["attempt_id_sha256"] = "0" * 64 + + _replace_receipt_envelope(campaign, receipt_type="observer", mutate=mutate) + admission = _rebind(certificate, campaign) + + with pytest.raises(MODULE.AcceptanceError, match="projection differs from its row"): + _derive(certificate, campaign, admission) + + +def test_rejects_unreferenced_receipt_envelope() -> None: + certificate = _certificate() + campaign = _campaign() + envelopes = campaign["receipt_envelopes"] + assert isinstance(envelopes, dict) + extra = copy.deepcopy(next(iter(envelopes.values()))) + extra["signature"] = "A" * 86 + "==" + envelopes[MODULE.canonical_sha256(extra).removeprefix("sha256:")] = extra + admission = _rebind(certificate, campaign) + + with pytest.raises(MODULE.AcceptanceError, match="unreferenced or hidden"): + _derive(certificate, campaign, admission) + + +def test_rejects_receipt_authority_key_id_not_derived_from_public_key() -> None: + certificate = _certificate() + campaign = _campaign() + campaign["authority_contract"]["runner"]["key_id"] = "qe-ed25519-" + "0" * 16 + admission = _rebind(certificate, campaign) + + with pytest.raises(MODULE.AcceptanceError, match="key ID differs from its key"): + _derive(certificate, campaign, admission) + + +def test_rejects_collapsed_normalized_receipt_authorities() -> None: + certificate = _certificate() + campaign = _campaign() + campaign["authority_contract"]["observer"] = copy.deepcopy( + campaign["authority_contract"]["runner"] + ) + admission = _rebind(certificate, campaign) + + with pytest.raises(MODULE.AcceptanceError, match="not separated by type"): + _derive(certificate, campaign, admission) + + +def test_rejects_reused_source_evidence_behind_distinct_receipts() -> None: + certificate = _certificate() + campaign = _campaign() + first = _trial(campaign, 0, 0) + first_digest = first["runner_receipt_sha256"] + first_envelope = campaign["receipt_envelopes"][first_digest] + source_digest = first_envelope["source_artifact_sha256"] + + def mutate(envelope: dict[str, object]) -> None: + envelope["source_artifact_sha256"] = source_digest + projection = envelope["verified_projection"] + assert isinstance(projection, dict) + projection["evidence_sha256"] = source_digest + + _replace_receipt_envelope( + campaign, + receipt_type="runner", + mutate=mutate, + resign=True, + trial=1, + ) + admission = _rebind(certificate, campaign) + + with pytest.raises(MODULE.AcceptanceError, match="reuses a source evidence artifact"): + _derive(certificate, campaign, admission) + + +def test_rejects_noncontiguous_trial_index() -> None: + certificate = _certificate() + campaign = _campaign() + _trial(campaign, 0, 1)["trial_index"] = 9 + admission = _rebind(certificate, campaign) + + with pytest.raises(MODULE.AcceptanceError, match="one-based and contiguous"): + _derive(certificate, campaign, admission) + + +def test_rejects_boolean_trial_index() -> None: + certificate = _certificate() + campaign = _campaign() + _trial(campaign, 0, 0)["trial_index"] = True + admission = _rebind(certificate, campaign) + + with pytest.raises(MODULE.AcceptanceError, match="one-based and contiguous"): + _derive(certificate, campaign, admission) + + +def test_rejects_missing_fault_or_cleanup_evidence() -> None: + certificate = _certificate() + campaign = _campaign() + _trial(campaign, 4, 0)["fault_receipt_sha256"] = None + admission = _rebind(certificate, campaign) + + with pytest.raises(MODULE.AcceptanceError, match="fault receipt is required"): + _derive(certificate, campaign, admission) + + +def test_rejects_embedded_admission_trust_registry() -> None: + certificate = _certificate() + campaign = _campaign() + campaign["trusted_admission_signers"] = _admission_trust() + admission = _rebind(certificate, campaign) + + with pytest.raises(MODULE.AcceptanceError, match="campaign keys differ"): + _derive(certificate, campaign, admission) + + +def test_verifier_uses_exact_repository_workflow_ref_and_hosted_runner_policy( + tmp_path: Path, +) -> None: + certificate_path = tmp_path / "certificate.json" + bundle_path = tmp_path / "bundle.jsonl" + certificate_path.write_text(json.dumps(_certificate()), encoding="utf-8") + bundle_path.write_text("{}\n", encoding="utf-8") + observed: list[str] = [] + + def run(command: list[str], **_: object) -> subprocess.CompletedProcess[str]: + observed.extend(command) + return subprocess.CompletedProcess( + command, + 0, + stdout=json.dumps(_verified_provenance(certificate_path)), + stderr="", + ) + + result = MODULE.verify_github_attestation( + certificate_path, + bundle_path, + "f" * 40, + run=run, + ) + + assert observed[:3] == ["gh", "attestation", "verify"] + assert observed[observed.index("--repo") + 1] == "OpenAdaptAI/openadapt-cloud" + assert observed[observed.index("--cert-identity") + 1].endswith( + "execute-live-acceptance.yml@refs/heads/main" + ) + assert observed[observed.index("--cert-oidc-issuer") + 1] == MODULE.GITHUB_OIDC_ISSUER + assert "--source-digest" not in observed + assert "--source-ref" not in observed + assert "--deny-self-hosted-runners" in observed + assert result["bundle_sha256"] == MODULE.file_sha256(bundle_path) + + +def test_verifier_refuses_failed_or_empty_attestation(tmp_path: Path) -> None: + certificate_path = tmp_path / "certificate.json" + bundle_path = tmp_path / "bundle.jsonl" + certificate_path.write_text(json.dumps(_certificate()), encoding="utf-8") + bundle_path.write_text("{}\n", encoding="utf-8") + + def failed(command: list[str], **_: object) -> subprocess.CompletedProcess[str]: + return subprocess.CompletedProcess(command, 1, stdout="", stderr="bad signature") + + with pytest.raises(MODULE.AcceptanceError, match="invalid: bad signature"): + MODULE.verify_github_attestation(certificate_path, bundle_path, "f" * 40, run=failed) + + def empty(command: list[str], **_: object) -> subprocess.CompletedProcess[str]: + return subprocess.CompletedProcess(command, 0, stdout="[]", stderr="") + + with pytest.raises(MODULE.AcceptanceError, match="must return one verified statement"): + MODULE.verify_github_attestation(certificate_path, bundle_path, "f" * 40, run=empty) + + +@pytest.mark.parametrize( + "mutation,expected", + [ + ( + lambda value: value[0]["verificationResult"]["signature"]["certificate"].__setitem__( + "sourceRepositoryDigest", "0" * 40 + ), + "sourceRepositoryDigest is not approved", + ), + ( + lambda value: value[0]["verificationResult"]["signature"]["certificate"].__setitem__( + "sourceRepositoryRef", "refs/heads/unreviewed" + ), + "sourceRepositoryRef is not approved", + ), + ( + lambda value: value[0]["verificationResult"]["statement"]["predicate"][ + "buildDefinition" + ]["resolvedDependencies"][0]["digest"].__setitem__("gitCommit", "0" * 40), + "resolved source commit", + ), + ( + lambda value: value[0]["verificationResult"]["statement"]["subject"][0][ + "digest" + ].__setitem__("sha256", "0" * 64), + "exactly one subject for the certificate bytes", + ), + ( + lambda value: value[0]["verificationResult"]["statement"]["predicate"][ + "buildDefinition" + ]["internalParameters"]["github"].__setitem__( + "runner_environment", "self-hosted" + ), + "runner is not GitHub-hosted", + ), + ( + lambda value: value[0]["verificationResult"]["statement"]["predicate"][ + "runDetails" + ]["builder"].__setitem__("id", "https://github.com/attacker/workflow@main"), + "builder is not the reviewed Cloud workflow", + ), + ], +) +def test_verifier_refuses_unapproved_or_malformed_provenance( + tmp_path: Path, + mutation: object, + expected: str, +) -> None: + certificate_path = tmp_path / "certificate.json" + bundle_path = tmp_path / "bundle.jsonl" + certificate_path.write_text(json.dumps(_certificate()), encoding="utf-8") + bundle_path.write_text("{}\n", encoding="utf-8") + provenance = _verified_provenance(certificate_path) + mutation(provenance) + + def run(command: list[str], **_: object) -> subprocess.CompletedProcess[str]: + return subprocess.CompletedProcess(command, 0, stdout=json.dumps(provenance), stderr="") + + with pytest.raises(MODULE.AcceptanceError, match=expected): + MODULE.verify_github_attestation(certificate_path, bundle_path, "f" * 40, run=run) + + +def test_verifier_requires_an_external_approved_cloud_commit(tmp_path: Path) -> None: + certificate_path = tmp_path / "certificate.json" + bundle_path = tmp_path / "bundle.jsonl" + certificate_path.write_text(json.dumps(_certificate()), encoding="utf-8") + bundle_path.write_text("{}\n", encoding="utf-8") + + with pytest.raises(MODULE.AcceptanceError, match="not the approved commit"): + MODULE.verify_github_attestation(certificate_path, bundle_path, "0" * 40) + + +def test_verifier_allows_other_subjects_but_only_one_matching_certificate( + tmp_path: Path, +) -> None: + certificate_path = tmp_path / "certificate.json" + bundle_path = tmp_path / "bundle.jsonl" + certificate_path.write_text(json.dumps(_certificate()), encoding="utf-8") + bundle_path.write_text("{}\n", encoding="utf-8") + provenance = _verified_provenance(certificate_path) + subjects = provenance[0]["verificationResult"]["statement"]["subject"] + subjects.append({"name": "other.json", "digest": {"sha256": "0" * 64}}) + + def run(command: list[str], **_: object) -> subprocess.CompletedProcess[str]: + return subprocess.CompletedProcess(command, 0, stdout=json.dumps(provenance), stderr="") + + MODULE.verify_github_attestation(certificate_path, bundle_path, "f" * 40, run=run) + subjects.append(copy.deepcopy(subjects[0])) + + with pytest.raises(MODULE.AcceptanceError, match="exactly one subject"): + MODULE.verify_github_attestation(certificate_path, bundle_path, "f" * 40, run=run) + + +@pytest.mark.parametrize( + "field,value,expected", + [ + ("runnerEnvironment", "self-hosted", "runnerEnvironment is not approved"), + ( + "runInvocationURI", + "https://github.com/OpenAdaptAI/openadapt-cloud/actions/runs/9/attempts/9", + "runInvocationURI is not approved", + ), + ("buildConfigDigest", "0" * 40, "buildConfigDigest is not approved"), + ], +) +def test_verifier_rejects_real_gh_certificate_policy_drift( + tmp_path: Path, + field: str, + value: str, + expected: str, +) -> None: + certificate_path = tmp_path / "certificate.json" + bundle_path = tmp_path / "bundle.jsonl" + certificate_path.write_text(json.dumps(_certificate()), encoding="utf-8") + bundle_path.write_text("{}\n", encoding="utf-8") + provenance = _verified_provenance(certificate_path) + provenance[0]["verificationResult"]["signature"]["certificate"][field] = value + + def run(command: list[str], **_: object) -> subprocess.CompletedProcess[str]: + return subprocess.CompletedProcess(command, 0, stdout=json.dumps(provenance), stderr="") + + with pytest.raises(MODULE.AcceptanceError, match=expected): + MODULE.verify_github_attestation(certificate_path, bundle_path, "f" * 40, run=run) + + +def test_verifier_binds_transparency_time_to_record_issuance(tmp_path: Path) -> None: + certificate_path = tmp_path / "certificate.json" + bundle_path = tmp_path / "bundle.jsonl" + certificate_path.write_text(json.dumps(_certificate()), encoding="utf-8") + bundle_path.write_text("{}\n", encoding="utf-8") + provenance = _verified_provenance(certificate_path) + provenance[0]["verificationResult"]["verifiedTimestamps"][0][ + "timestamp" + ] = "2026-08-18T11:59:59.000Z" + + def run(command: list[str], **_: object) -> subprocess.CompletedProcess[str]: + return subprocess.CompletedProcess(command, 0, stdout=json.dumps(provenance), stderr="") + + with pytest.raises(MODULE.AcceptanceError, match="not bound to record issuance"): + MODULE.verify_github_attestation(certificate_path, bundle_path, "f" * 40, run=run) + + +def test_mutation_helpers_do_not_modify_committed_fixtures() -> None: + certificate = _certificate() + campaign = _campaign() + admission = _admission() + original_certificate = copy.deepcopy(certificate) + original_campaign = copy.deepcopy(campaign) + + _derive(certificate, campaign, admission) + + assert certificate == original_certificate + assert campaign == original_campaign diff --git a/tests/test_published_evidence_freshness.py b/tests/test_published_evidence_freshness.py index 7bd81d2..85505db 100644 --- a/tests/test_published_evidence_freshness.py +++ b/tests/test_published_evidence_freshness.py @@ -328,7 +328,7 @@ def test_evidence_binding_refuses_any_bound_file_mutation(tmp_path: Path, path: assert MODULE.check_evidence_manifest(entry, tmp_path) -def test_production_acceptance_requires_both_reliability_metrics(tmp_path: Path) -> None: +def test_campaign_cannot_promote_numeric_metrics_to_production(tmp_path: Path) -> None: entry, manifest_path, binding = _valid_bound_evidence(tmp_path) result_path = tmp_path / "evidence" / "results.json" result = MODULE.load_manifest(result_path) @@ -344,10 +344,10 @@ def test_production_acceptance_requires_both_reliability_metrics(tmp_path: Path) problems = MODULE.check_evidence_manifest(entry, tmp_path) - assert any("without required reliability metrics" in problem for problem in problems) + assert any("cannot be declared; use the verified importer" in problem for problem in problems) -def test_synthetic_campaign_cannot_claim_production_acceptance(tmp_path: Path) -> None: +def test_campaign_class_cannot_claim_production_acceptance(tmp_path: Path) -> None: entry, manifest_path, binding = _valid_bound_evidence(tmp_path) binding["campaigns"][0]["evidence_scope"]["production_acceptance"] = True entry["production_acceptance"] = True @@ -355,16 +355,132 @@ def test_synthetic_campaign_cannot_claim_production_acceptance(tmp_path: Path) - problems = MODULE.check_evidence_manifest(entry, tmp_path) - assert any("from a synthetic or fixture class" in problem for problem in problems) + assert any("cannot be declared; use the verified importer" in problem for problem in problems) -def test_registry_production_acceptance_must_match_campaigns(tmp_path: Path) -> None: +def test_registry_boolean_cannot_claim_production_acceptance(tmp_path: Path) -> None: entry, _, _ = _valid_bound_evidence(tmp_path) entry["production_acceptance"] = True problems = MODULE.check_evidence_manifest(entry, tmp_path) - assert any("disagrees with campaign scopes" in problem for problem in problems) + assert any("declared boolean is not evidence" in problem for problem in problems) + + +def test_production_import_links_must_be_digest_bound(tmp_path: Path) -> None: + entry, manifest_path, binding = _valid_bound_evidence(tmp_path) + entry["production_acceptance"] = True + binding["production_acceptance_import"] = { + "certificate": "evidence/certificate.json", + "campaign": "evidence/campaign.json", + "qualification_admission": "evidence/admission.json", + "attestation_bundle": "evidence/attestation.jsonl", + "derived_result": "evidence/derived.json", + } + _write_json(manifest_path, binding) + + problems = MODULE.check_evidence_manifest(entry, tmp_path) + + assert any("link must contain path and sha256" in problem for problem in problems) + + +def test_production_import_cannot_select_its_own_approved_cloud_commit( + tmp_path: Path, +) -> None: + entry, manifest_path, binding = _valid_bound_evidence(tmp_path) + entry["production_acceptance"] = True + binding["production_acceptance_import"] = { + "certificate": {}, + "campaign": {}, + "attestation_bundle": {}, + "derived_result": {}, + "expected_cloud_source_commit": "c" * 40, + } + _write_json(manifest_path, binding) + + problems = MODULE.check_evidence_manifest(entry, tmp_path) + + assert any("declared boolean is not evidence" in problem for problem in problems) + + +def test_production_import_uses_external_admission_trust_and_revocations( + tmp_path: Path, + monkeypatch: pytest.MonkeyPatch, +) -> None: + entry, manifest_path, binding = _valid_bound_evidence(tmp_path) + entry["production_acceptance"] = True + evidence = tmp_path / "evidence" + names = ( + "certificate", + "campaign", + "qualification_admission", + "attestation_bundle", + "derived_result", + ) + paths: dict[str, Path] = {} + for name in names: + suffix = ".jsonl" if name == "attestation_bundle" else ".json" + path = evidence / f"{name}{suffix}" + path.write_text("{}\n", encoding="utf-8") + paths[name] = path + derived = { + "bindings": { + "flow_version": entry["flow_version"], + "flow_release_commit": entry["flow_source_commit"], + "flow_wheel_sha256": f"sha256:{entry['wheel_sha256']}", + }, + "claim_scope": MODULE.PRODUCTION.CLAIM_SCOPE, + } + _write_json(paths["derived_result"], derived) + imported = { + name: { + "path": path.relative_to(tmp_path).as_posix(), + "sha256": MODULE._sha256(path), + } + for name, path in paths.items() + } + binding["production_acceptance_import"] = imported + binding["artifacts"].extend(imported.values()) + _write_json(manifest_path, binding) + observed: dict[str, object] = {} + + def import_files(*args: object, **kwargs: object) -> dict[str, object]: + observed["args"] = args + observed["kwargs"] = kwargs + return derived + + monkeypatch.setattr(MODULE.PRODUCTION, "import_files", import_files) + trust = {"qa-ed25519-0000000000000000": {"public_key": "external"}} + admission_revocations = {"admission-id"} + signer_revocations = {"qa-ed25519-revoked"} + + problems = MODULE.check_evidence_manifest( + entry, + tmp_path, + "f" * 40, + trust, + admission_revocations, + signer_revocations, + ) + + assert problems == [] + assert observed["args"] == ( + paths["certificate"], + paths["campaign"], + paths["qualification_admission"], + paths["attestation_bundle"], + "f" * 40, + ) + assert observed["kwargs"] == { + "trusted_admission_signers": trust, + "revoked_admission_ids": admission_revocations, + "revoked_admission_signer_key_ids": signer_revocations, + } + + +def test_external_trust_inputs_must_be_valid_json() -> None: + assert MODULE.main(["--offline", "--trusted-admission-signers-json", "[]"]) == 1 + assert MODULE.main(["--offline", "--revoked-admission-ids-json", "{}"] ) == 1 def test_task_standard_requires_count_oracle_taxonomy_and_caveats() -> None: From b5854d369659c600b1a3ace251996417279fa09d Mon Sep 17 00:00:00 2001 From: abrichr Date: Tue, 18 Aug 2026 15:19:02 -0400 Subject: [PATCH 2/4] Harden production acceptance evidence bindings --- docs/eval_results/PRODUCTION_READINESS.md | 57 +- scripts/check_published_evidence_freshness.py | 20 +- scripts/import_production_acceptance.py | 880 ++- .../live-certificate.json | 16 +- .../qualification-admission-trust.json | 28 +- .../qualification-admission.json | 61 +- .../qualification-campaign.json | 6001 ++++++++++------- tests/test_import_production_acceptance.py | 463 +- tests/test_published_evidence_freshness.py | 26 + 9 files changed, 5194 insertions(+), 2358 deletions(-) diff --git a/docs/eval_results/PRODUCTION_READINESS.md b/docs/eval_results/PRODUCTION_READINESS.md index b46eefe..9173921 100644 --- a/docs/eval_results/PRODUCTION_READINESS.md +++ b/docs/eval_results/PRODUCTION_READINESS.md @@ -32,11 +32,11 @@ of only the admission and campaign digests is not sufficient. After approval, the importer will compose four evidence inputs: -1. The closed `openadapt.execute-live-acceptance-record/v1` certificate from +1. The closed `openadapt.execute-live-acceptance-record/v2` certificate from the protected Cloud production workflow. -2. The signed `openadapt.qualification-admission/v1` envelope from the +2. The signed `openadapt.qualification-admission/v2` envelope from the protected qualification authority. -3. The full `openadapt.qualification-campaign/v1` artifact with every retained +3. The full `openadapt.qualification-campaign/v2` artifact with every retained trial row and normalized evidence receipt for the exact qualification contract. 4. The GitHub artifact-attestation bundle for the certificate bytes. @@ -77,27 +77,36 @@ commit, the Ed25519 signature, the derived key ID, the active time window, and the external admission and key revocation lists. It refuses a trust key that the imported evidence supplies for itself. -The admission signs canonical hashes for the full campaign, qualification -contract, outcomes projection, oracle, and exact task inventory. The campaign -must retain every condition in the bound qualification contract and at least -three unique trials for each condition. Trial indexes are one-based and -contiguous. Attempt IDs and run IDs cannot repeat. An excluded or hidden trial -causes refusal. - -Each trial refers to hash-keyed Ed25519 envelopes for the runner, independent -observer, webhook, replay, cleanup, and cleanup-absence result. Fault cases -also require a signed fault receipt. The importer verifies each envelope body, -signature, authority key, source digest, task, condition, trial index, attempt, -run, workflow version, bundle artifact, runtime validation, verdict, and time. -A digest with no signed body is not evidence. An unused envelope is hidden -evidence and causes refusal. - -The importer classifies the verified rows itself. It rejects a count-only -claim, declared production class or boolean, unsupported failure class, -vacuous invariant, healthy-path contract that permits a model call, silent -incorrect success, over-halt, wrong-record effect, duplicate effect, -collateral effect, uncertain delivery, platform failure, or operator -intervention. +The admission signs one shared evidence identity for the exact workflow, +campaign, environment, Flow release and wheel, runner build and artifact, +browser image, runtime manifest, signer registry revision, and every admitted +contract. The certificate repeats the public domain-separated campaign, +admission, runtime-validation, and workflow-version digests. The importer +recomputes each digest from the retained admission. The admission also signs +canonical hashes for the full campaign, qualification contract, outcomes +projection, oracle, and exact task inventory. The campaign must retain every +condition in the bound qualification contract and at least three unique trials +for each condition. Trial indexes are one-based and contiguous. Attempt IDs +and run IDs cannot repeat. An excluded or hidden trial causes refusal. + +Each `openadapt.qualification-trial-row/v2` trial refers to hash-keyed +`openadapt.qualification-evidence-receipt/v2` Ed25519 envelopes for the runner, +independent observer, webhook, replay, cleanup, and cleanup-absence result. +Fault cases also require a signed fault receipt. The importer verifies each +envelope body, signature, authority key, source digest, task, condition, trial +index, attempt, run, workflow version, bundle artifact, runtime validation, +admission, evidence identity, verdict, and time. A digest with no signed body is +not evidence. An unused envelope is hidden evidence and causes refusal. + +The importer classifies the verified rows itself. The signed observer receipt +contains the exact effect inventory. The signed runner receipt contains the +model-call counters, provider-model inventory, egress-policy digest, report +digest, and operator-intervention inventory. The importer derives failures +from these facts. It rejects a count-only claim, declared production class or +boolean, unsupported failure class, vacuous invariant, healthy-path contract +that permits a model call, healthy-path model call, silent incorrect success, +over-halt, wrong-record effect, duplicate effect, collateral effect, uncertain +delivery, platform failure, or operator intervention. When the private-export gate opens, the output claim will be only `qualified_browser_workflow_on_bound_environment`. It is not a general product diff --git a/scripts/check_published_evidence_freshness.py b/scripts/check_published_evidence_freshness.py index 6e03890..c85531f 100644 --- a/scripts/check_published_evidence_freshness.py +++ b/scripts/check_published_evidence_freshness.py @@ -40,6 +40,7 @@ import hashlib import importlib.util import json +import stat import sys import urllib.error import urllib.request @@ -142,8 +143,25 @@ def _safe_file(repo_root: Path, relative: object) -> Path | None: path = Path(relative) if path.is_absolute() or ".." in path.parts: return None + try: + resolved_root = repo_root.resolve(strict=True) + except OSError: + return None + component = repo_root + for part in path.parts: + component = component / part + if component.is_symlink(): + return None candidate = repo_root / path - return candidate if candidate.is_file() else None + try: + candidate_stat = candidate.lstat() + resolved_candidate = candidate.resolve(strict=True) + resolved_candidate.relative_to(resolved_root) + except (OSError, ValueError): + return None + if not stat.S_ISREG(candidate_stat.st_mode): + return None + return candidate def _relative_file(repo_root: Path, relative: object) -> tuple[Path | None, str | None]: diff --git a/scripts/import_production_acceptance.py b/scripts/import_production_acceptance.py index 6ff17a7..92f7dec 100644 --- a/scripts/import_production_acceptance.py +++ b/scripts/import_production_acceptance.py @@ -30,15 +30,24 @@ from pathlib import Path from typing import Any, Callable, Mapping, Sequence -CERTIFICATE_SCHEMA = "openadapt.execute-live-acceptance-record/v1" -CAMPAIGN_SCHEMA = "openadapt.qualification-campaign/v1" +CERTIFICATE_SCHEMA = "openadapt.execute-live-acceptance-record/v2" +CAMPAIGN_SCHEMA = "openadapt.qualification-campaign/v2" +TRIAL_SCHEMA = "openadapt.qualification-trial-row/v2" RESULT_SCHEMA = "openadapt.evals-derived-production-acceptance/v1" CLAIM_SCOPE = "qualified_browser_workflow_on_bound_environment" -ADMISSION_SCHEMA = "openadapt.qualification-admission/v1" -ADMISSION_SIGNATURE_DOMAIN = b"openadapt-qualification-admission-v1\0" -RECEIPT_SCHEMA = "openadapt.qualification-evidence-receipt/v1" -RECEIPT_SIGNATURE_DOMAIN_TEXT = "openadapt-qualification-evidence-receipt-v1\\0" -RECEIPT_SIGNATURE_DOMAIN = b"openadapt-qualification-evidence-receipt-v1\0" +ADMISSION_SCHEMA = "openadapt.qualification-admission/v2" +ADMISSION_SIGNATURE_DOMAIN_TEXT = "openadapt-qualification-admission-v2\\0" +ADMISSION_SIGNATURE_DOMAIN = b"openadapt-qualification-admission-v2\0" +RECEIPT_SCHEMA = "openadapt.qualification-evidence-receipt/v2" +RECEIPT_SIGNATURE_DOMAIN_TEXT = "openadapt-qualification-evidence-receipt-v2\\0" +RECEIPT_SIGNATURE_DOMAIN = b"openadapt-qualification-evidence-receipt-v2\0" +EVIDENCE_IDENTITY_SCHEMA = "openadapt.production-acceptance-evidence-identity/v2" +EVIDENCE_IDENTITY_DOMAIN = b"OpenAdapt production acceptance evidence identity v2\0" +RUNTIME_BUILD_IDENTITY_SCHEMA = "openadapt.admitted-runtime-build/v1" +ADMISSION_POLICY_SCHEMA = "openadapt.production-acceptance-admission-policy/v1" +ADMISSION_POLICY_DOMAIN = b"OpenAdapt production acceptance admission policy v1\0" +SIGNER_REGISTRY_SCHEMA = "openadapt.qualification-signer-registry/v2" +SIGNER_REGISTRY_DOMAIN = b"OpenAdapt qualification signer registry v2\0" ADMISSION_ISSUER_WORKFLOW = ( "OpenAdaptAI/openadapt-internal/.github/workflows/" "production-qualification-admission.yml" @@ -83,6 +92,8 @@ _RUNTIME_KEYS = { "manifest_sha256", "runner_build", + "runner_artifact_sha256", + "substrate", "playwright_version", "browser_base_image", } @@ -100,9 +111,11 @@ "admission_signer", "runtime_validation_id_sha256", "admission_id_sha256", + "campaign_id_sha256", "workflow_version_id_sha256", "workflow_digest", "environment_digest", + "evidence_identity_sha256", } _ADMISSION_SIGNER_KEYS = { "algorithm", @@ -204,6 +217,9 @@ _CAMPAIGN_KEYS = { "schema_version", "campaign_id", + "admission_id", + "runtime_validation_id", + "evidence_identity_sha256", "qualification_contract", "oracle_contract", "authority_contract", @@ -228,8 +244,10 @@ "attempt_id_sha256", "run_id_sha256", "workflow_version_id", + "admission_id", "bundle_artifact_sha256", "runtime_validation_id", + "evidence_identity_sha256", "started_at", "completed_at", "execution_outcome", @@ -289,10 +307,13 @@ "attempt_id_sha256", "run_id_sha256", "workflow_version_id", + "admission_id", "bundle_artifact_sha256", "runtime_validation_id", + "evidence_identity_sha256", "verdict", "evidence_sha256", + "facts", } _RECEIPT_ROW_FIELDS = { "runner": "runner_receipt_sha256", @@ -335,6 +356,7 @@ "identity_contract_sha256", "effect_contract_sha256", "operator_contract_sha256", + "evidence_identity", "campaign", "issuer", "issued_at", @@ -357,8 +379,10 @@ "issued_at", "not_before", "expires_at", + "evidence_identity", } _ADMISSION_CAMPAIGN_KEYS = { + "campaign_id", "artifact_sha256", "contract_sha256", "outcomes_sha256", @@ -369,6 +393,130 @@ "decision", } +_EVIDENCE_IDENTITY_KEYS = { + "schema_version", + "runtime_build_identity", + "managed_runner_signer_sha256", + "tenant_id", + "workflow_id", + "workflow_version_id", + "workflow_digest", + "bundle_version_id", + "bundle_artifact_sha256", + "bundle_content_digest", + "environment_digest", + "governed_authorization_template_sha256", + "application_contract_sha256", + "substrate_contract_sha256", + "environment_contract_sha256", + "runtime_environment_sha256", + "runtime_contract_sha256", + "input_policy_sha256", + "action_policy_sha256", + "network_policy_sha256", + "identity_contract_sha256", + "effect_contract_sha256", + "operator_contract_sha256", + "runtime_validation_id", + "admission_id", + "campaign_id", + "admission_policy_sha256", + "campaign_contract_sha256", + "oracle_contract_sha256", + "qualification_campaign_schema", + "qualification_trial_schema", + "qualification_receipt_schema", + "qualification_signer_registry_sha256", + "qualification_signer_registry_revision", +} + +_RUNTIME_BUILD_COMMON_KEYS = { + "schema_version", + "flow_version", + "flow_release_commit", + "flow_wheel_sha256", + "runtime_manifest_sha256", + "runner_build", + "runner_artifact_sha256", + "substrate", + "managed_browser", + "native_desktop", + "remote_display", +} +_MANAGED_BROWSER_DETAIL_KEYS = {"playwright_version", "browser_base_image"} +_NATIVE_DESKTOP_DETAIL_KEYS = { + "desktop_version", + "desktop_release_commit", + "desktop_artifact_sha256", + "os_family", + "runtime_boundary_sha256", +} +_REMOTE_DISPLAY_DETAIL_KEYS = { + "desktop_version", + "desktop_release_commit", + "desktop_artifact_sha256", + "runner_os_family", + "transport", + "runtime_boundary_sha256", +} + +_SIGNER_REGISTRY_KEYS = { + "schema_version", + "revision", + "generated_at", + "expires_at", + "signers", +} +_SIGNER_REGISTRY_ENTRY_KEYS = { + "algorithm", + "key_id", + "public_key", + "allowed_workflows", + "allowed_ref_prefixes", + "status", + "revoked_at", +} + +_RUNNER_FACT_KEYS = { + "model_call_counter", + "operator_intervention_ids_sha256", +} +_MODEL_CALL_COUNTER_KEYS = { + "source", + "attempted", + "completed", + "input_tokens", + "output_tokens", + "cost_microusd", + "call_ids_sha256", + "provider_models", + "egress_policy_sha256", + "report_sha256", +} +_PROVIDER_MODEL_KEYS = {"provider", "model"} +_OBSERVER_FACT_KEYS = { + "dispatch_state", + "verifier_method", + "verifier_tier", + "pre_state_evidence_sha256", + "post_state_evidence_sha256", + "expected_record_id_sha256", + "expected_transaction_ref_sha256", + "effect_inventory", + "derived_classifications", +} +_EFFECT_KEYS = { + "effect_id_sha256", + "record_id_sha256", + "transaction_ref_sha256", +} +_EFFECT_CLASSIFICATION_KEYS = { + "intended_effect_count", + "wrong_record_count", + "duplicate_effect_count", + "collateral_effect_count", +} + _RUNTIME_OUTCOMES = { "verified", "halted", @@ -396,6 +544,7 @@ "uncertain_delivery", "platform_failure", "operator_intervention", + "healthy_path_model_call", ) _PRODUCTION_FAILURES = set(_FAILURE_TAXONOMY) - {"verified", "safe_halt"} @@ -414,6 +563,50 @@ def canonical_sha256(value: Any) -> str: return "sha256:" + hashlib.sha256(canonical_json(value).encode("utf-8")).hexdigest() +def evidence_identity_sha256(value: Mapping[str, Any]) -> str: + """Return the domain-separated digest for one exact evidence identity.""" + + return hashlib.sha256( + EVIDENCE_IDENTITY_DOMAIN + canonical_json(value).encode("utf-8") + ).hexdigest() + + +def qualification_signer_registry_sha256(value: Mapping[str, Any]) -> str: + return hashlib.sha256( + SIGNER_REGISTRY_DOMAIN + canonical_json(value).encode("utf-8") + ).hexdigest() + + +def admission_policy() -> dict[str, Any]: + """Return the fixed policy whose digest the qualification authority admits.""" + + return { + "schema_version": ADMISSION_POLICY_SCHEMA, + "qualification_admission_schema": ADMISSION_SCHEMA, + "qualification_campaign_schema": CAMPAIGN_SCHEMA, + "qualification_trial_schema": TRIAL_SCHEMA, + "qualification_receipt_schema": RECEIPT_SCHEMA, + "admission_signature_domain": ADMISSION_SIGNATURE_DOMAIN_TEXT, + "receipt_signature_domain": RECEIPT_SIGNATURE_DOMAIN_TEXT, + "issuer_workflow": ADMISSION_ISSUER_WORKFLOW, + "issuer_ref_prefix": ADMISSION_REF_PREFIX, + "maximum_lifetime_seconds": 2_592_000, + "minimum_trials_per_condition": 3, + "failure_taxonomy": sorted(_FAILURE_TAXONOMY), + "external_signer_registry_required": True, + "registry_freshness_required_at_actuation": True, + "revocation_check_required": True, + "distinct_admission_and_runtime_ids_required": True, + "shared_evidence_identity_required": True, + } + + +def admission_policy_sha256() -> str: + return hashlib.sha256( + ADMISSION_POLICY_DOMAIN + canonical_json(admission_policy()).encode("utf-8") + ).hexdigest() + + def file_sha256(path: Path) -> str: return "sha256:" + hashlib.sha256(path.read_bytes()).hexdigest() @@ -481,6 +674,207 @@ def _canonical_uuid(value: Any, label: str) -> str: return value +def _validate_desktop_runtime_detail(value: Mapping[str, Any], *, label: str) -> None: + if not isinstance(value["desktop_version"], str) or _SEMVER.fullmatch( + value["desktop_version"] + ) is None: + raise AcceptanceError(f"{label} desktop version is not exact") + if not isinstance(value["desktop_release_commit"], str) or _HEX_40.fullmatch( + value["desktop_release_commit"] + ) is None: + raise AcceptanceError(f"{label} desktop commit is not exact") + for key in ("desktop_artifact_sha256", "runtime_boundary_sha256"): + _unprefixed_digest(value[key], f"{label} {key}") + + +def _validate_evidence_identity( + value: Any, + *, + admission_payload: Mapping[str, Any], + campaign: Mapping[str, Any], +) -> dict[str, Any]: + identity = dict( + _closed(value, _EVIDENCE_IDENTITY_KEYS, "qualification evidence identity") + ) + if identity["schema_version"] != EVIDENCE_IDENTITY_SCHEMA: + raise AcceptanceError("qualification evidence identity schema is not supported") + registry_revision = identity["qualification_signer_registry_revision"] + if ( + not isinstance(registry_revision, int) + or isinstance(registry_revision, bool) + or registry_revision < 1 + ): + raise AcceptanceError( + "qualification evidence identity signer registry revision is invalid" + ) + runtime_value = _mapping( + identity["runtime_build_identity"], + "qualification runtime build identity", + ) + runtime = _closed( + runtime_value, + _RUNTIME_BUILD_COMMON_KEYS, + "qualification runtime build identity", + ) + selected = [ + name + for name in ("managed_browser", "native_desktop", "remote_display") + if runtime[name] is not None + ] + if len(selected) != 1: + raise AcceptanceError( + "qualification runtime build identity must select exactly one substrate detail" + ) + selected_detail = selected[0] + substrate = runtime["substrate"] + if runtime["schema_version"] != RUNTIME_BUILD_IDENTITY_SCHEMA: + raise AcceptanceError("qualification runtime build identity schema is not supported") + if not isinstance(runtime["flow_version"], str) or _SEMVER.fullmatch( + runtime["flow_version"] + ) is None: + raise AcceptanceError("qualification evidence identity Flow version is not exact") + if not isinstance(runtime["flow_release_commit"], str) or _HEX_40.fullmatch( + runtime["flow_release_commit"] + ) is None: + raise AcceptanceError("qualification evidence identity Flow commit is not exact") + _nonempty(runtime["runner_build"], "qualification evidence identity runner build") + for key in ( + "flow_wheel_sha256", + "runtime_manifest_sha256", + "runner_artifact_sha256", + ): + _unprefixed_digest(runtime[key], f"qualification runtime build identity {key}") + if selected_detail == "managed_browser": + if substrate != "web": + raise AcceptanceError("qualification managed-browser substrate is not web") + detail = _closed( + runtime[selected_detail], + _MANAGED_BROWSER_DETAIL_KEYS, + "qualification managed-browser identity", + ) + if not isinstance(detail["playwright_version"], str) or _SEMVER.fullmatch( + detail["playwright_version"] + ) is None: + raise AcceptanceError( + "qualification evidence identity Playwright version is not exact" + ) + browser_image = _nonempty( + detail["browser_base_image"], + "qualification evidence identity browser image", + ) + image_name, separator, image_digest = browser_image.rpartition("@sha256:") + if ( + not image_name + or separator != "@sha256:" + or _UNPREFIXED_SHA256.fullmatch(image_digest) is None + ): + raise AcceptanceError( + "qualification evidence identity browser image is not digest-pinned" + ) + elif selected_detail == "native_desktop": + detail = _closed( + runtime[selected_detail], + _NATIVE_DESKTOP_DETAIL_KEYS, + "qualification native-desktop identity", + ) + _validate_desktop_runtime_detail(detail, label="qualification native-desktop identity") + if substrate not in {"windows", "macos", "linux"} or detail["os_family"] != substrate: + raise AcceptanceError("qualification native-desktop substrate differs from OS") + else: + detail = _closed( + runtime[selected_detail], + _REMOTE_DISPLAY_DETAIL_KEYS, + "qualification remote-display identity", + ) + _validate_desktop_runtime_detail(detail, label="qualification remote-display identity") + if substrate not in {"rdp", "citrix"} or detail["transport"] != substrate: + raise AcceptanceError("qualification remote-display transport differs") + if detail["runner_os_family"] not in {"windows", "linux"}: + raise AcceptanceError("qualification remote-display runner OS is invalid") + + for key in { + "tenant_id", + "workflow_id", + "workflow_version_id", + "bundle_version_id", + "runtime_validation_id", + "admission_id", + "campaign_id", + }: + _canonical_uuid(identity[key], f"qualification evidence identity {key}") + for key in { + "managed_runner_signer_sha256", + "workflow_digest", + "bundle_artifact_sha256", + "bundle_content_digest", + "environment_digest", + "governed_authorization_template_sha256", + "application_contract_sha256", + "substrate_contract_sha256", + "environment_contract_sha256", + "runtime_environment_sha256", + "runtime_contract_sha256", + "input_policy_sha256", + "action_policy_sha256", + "network_policy_sha256", + "identity_contract_sha256", + "effect_contract_sha256", + "operator_contract_sha256", + "admission_policy_sha256", + "campaign_contract_sha256", + "oracle_contract_sha256", + "qualification_signer_registry_sha256", + }: + _unprefixed_digest(identity[key], f"qualification evidence identity {key}") + + for key in ( + "tenant_id", + "workflow_id", + "workflow_version_id", + "bundle_version_id", + "bundle_artifact_sha256", + "bundle_content_digest", + "governed_authorization_template_sha256", + "application_contract_sha256", + "substrate_contract_sha256", + "environment_contract_sha256", + "runtime_environment_sha256", + "runtime_contract_sha256", + "input_policy_sha256", + "action_policy_sha256", + "network_policy_sha256", + "identity_contract_sha256", + "effect_contract_sha256", + "operator_contract_sha256", + "runtime_validation_id", + "admission_id", + ): + if identity[key] != admission_payload[key]: + raise AcceptanceError( + f"qualification evidence identity {key} differs from admission" + ) + if identity["campaign_id"] != campaign["campaign_id"]: + raise AcceptanceError("qualification evidence identity campaign differs from campaign") + if identity["admission_policy_sha256"] != admission_policy_sha256(): + raise AcceptanceError("qualification evidence identity admission policy differs") + if identity["campaign_contract_sha256"] != canonical_sha256( + campaign["qualification_contract"] + ).removeprefix("sha256:"): + raise AcceptanceError("qualification evidence identity campaign contract differs") + if identity["oracle_contract_sha256"] != canonical_sha256( + campaign["oracle_contract"] + ).removeprefix("sha256:"): + raise AcceptanceError("qualification evidence identity oracle contract differs") + for key, expected in { + "qualification_campaign_schema": CAMPAIGN_SCHEMA, + "qualification_trial_schema": TRIAL_SCHEMA, + "qualification_receipt_schema": RECEIPT_SCHEMA, + }.items(): + if identity[key] != expected: + raise AcceptanceError(f"qualification evidence identity {key} differs") + return identity + + def _whole_second_timestamp(value: Any, label: str) -> datetime: if not isinstance(value, str) or _WHOLE_SECOND_UTC.fullmatch(value) is None: raise AcceptanceError(f"{label} must be a whole-second UTC timestamp") @@ -490,6 +884,69 @@ def _whole_second_timestamp(value: Any, label: str) -> datetime: raise AcceptanceError(f"{label} is invalid") from exc +def _validate_signer_registry( + value: Any, +) -> tuple[dict[str, Mapping[str, Any]], datetime, datetime]: + registry = _closed(value, _SIGNER_REGISTRY_KEYS, "qualification signer registry") + if registry["schema_version"] != SIGNER_REGISTRY_SCHEMA: + raise AcceptanceError("qualification signer registry schema is not supported") + revision = registry["revision"] + if not isinstance(revision, int) or isinstance(revision, bool) or revision < 1: + raise AcceptanceError("qualification signer registry revision is invalid") + generated_at = _whole_second_timestamp( + registry["generated_at"], "qualification signer registry generated_at" + ) + expires_at = _whole_second_timestamp( + registry["expires_at"], "qualification signer registry expires_at" + ) + if expires_at <= generated_at or expires_at > generated_at + timedelta(days=7): + raise AcceptanceError("qualification signer registry lifetime is invalid") + entries = registry["signers"] + if not isinstance(entries, list) or not entries: + raise AcceptanceError("qualification signer registry signers must be non-empty") + verified: dict[str, Mapping[str, Any]] = {} + ordered_key_ids: list[str] = [] + for index, value in enumerate(entries): + entry = _closed( + value, + _SIGNER_REGISTRY_ENTRY_KEYS, + f"qualification signer registry entry {index}", + ) + if entry["algorithm"] != "ed25519": + raise AcceptanceError("qualification signer registry algorithm is not Ed25519") + key_id = entry["key_id"] + if not isinstance(key_id, str) or _ADMISSION_KEY_ID.fullmatch(key_id) is None: + raise AcceptanceError("qualification signer registry key ID is invalid") + if key_id in verified: + raise AcceptanceError("qualification signer registry key ID is duplicate") + public_key = _canonical_base64( + entry["public_key"], 32, "qualification signer registry public key" + ) + derived = "qa-ed25519-" + hashlib.sha256(public_key).hexdigest()[:16] + if key_id != derived: + raise AcceptanceError("qualification signer registry key differs from key ID") + if entry["allowed_workflows"] != [ADMISSION_ISSUER_WORKFLOW]: + raise AcceptanceError("qualification signer registry workflow trust is not exact") + if entry["allowed_ref_prefixes"] != [ADMISSION_REF_PREFIX]: + raise AcceptanceError("qualification signer registry ref trust is not exact") + if entry["status"] == "active": + if entry["revoked_at"] is not None: + raise AcceptanceError("active qualification signer has a revocation time") + elif entry["status"] == "revoked": + revoked_at = _whole_second_timestamp( + entry["revoked_at"], "qualification signer registry revoked_at" + ) + if revoked_at > generated_at: + raise AcceptanceError("qualification signer revocation postdates registry") + else: + raise AcceptanceError("qualification signer registry status is invalid") + verified[key_id] = entry + ordered_key_ids.append(key_id) + if ordered_key_ids != sorted(ordered_key_ids): + raise AcceptanceError("qualification signer registry entries are not ordered") + return verified, generated_at, expires_at + + def _canonical_base64(value: Any, length: int, label: str) -> bytes: if not isinstance(value, str): raise AcceptanceError(f"{label} must be canonical base64") @@ -565,6 +1022,9 @@ def validate_qualification_admission( """Verify the external qualification authority and its exact campaign.""" trusted_signers = _mapping(trusted_signers, "qualification signer trust registry") + signer_entries, registry_generated_at, registry_expires_at = ( + _validate_signer_registry(trusted_signers) + ) if not isinstance(revoked_admission_ids, (set, frozenset)) or not all( isinstance(value, str) and value for value in revoked_admission_ids ): @@ -586,9 +1046,34 @@ def validate_qualification_admission( raise AcceptanceError("qualification admission schema is not supported") for key in _ADMISSION_UUID_KEYS: _canonical_uuid(payload[key], f"qualification admission {key}") + if payload["admission_id"] == payload["runtime_validation_id"]: + raise AcceptanceError( + "qualification admission ID equals the runtime-validation ID" + ) for key in _ADMISSION_DIGEST_KEYS: _unprefixed_digest(payload[key], f"qualification admission {key}") + evidence_identity = _validate_evidence_identity( + payload["evidence_identity"], + admission_payload=payload, + campaign=campaign, + ) + if evidence_identity["qualification_signer_registry_sha256"] != ( + qualification_signer_registry_sha256(trusted_signers) + ): + raise AcceptanceError("qualification signer registry differs from admission") + if evidence_identity["qualification_signer_registry_revision"] != trusted_signers[ + "revision" + ]: + raise AcceptanceError("qualification signer registry revision differs from admission") + identity_digest = evidence_identity_sha256(evidence_identity) + if campaign["admission_id"] != payload["admission_id"]: + raise AcceptanceError("campaign admission ID differs from admission") + if campaign["runtime_validation_id"] != payload["runtime_validation_id"]: + raise AcceptanceError("campaign runtime-validation ID differs from admission") + if campaign["evidence_identity_sha256"] != identity_digest: + raise AcceptanceError("campaign evidence identity differs from admission") + issuer = _closed( payload["issuer"], {"key_id", "workflow", "ref"}, @@ -604,12 +1089,8 @@ def validate_qualification_admission( if not isinstance(issuer["ref"], str) or _ADMISSION_REF.fullmatch(issuer["ref"]) is None: raise AcceptanceError("qualification admission issuer ref is not approved") - trust = trusted_signers.get(key_id) - if not isinstance(trust, dict) or set(trust) != { - "public_key", - "allowed_workflows", - "allowed_ref_prefixes", - }: + trust = signer_entries.get(key_id) + if trust is None or trust["status"] != "active": raise AcceptanceError("qualification admission signer is not trusted") workflows = trust["allowed_workflows"] ref_prefixes = trust["allowed_ref_prefixes"] @@ -659,6 +1140,8 @@ def validate_qualification_admission( raise AcceptanceError("qualification admission is not active") if current >= expires_at: raise AcceptanceError("qualification admission has expired") + if not registry_generated_at <= issued_at < registry_expires_at: + raise AcceptanceError("qualification signer registry was not active at issuance") if payload["admission_id"] in revoked_admission_ids: raise AcceptanceError("qualification admission is revoked") @@ -667,6 +1150,8 @@ def validate_qualification_admission( _ADMISSION_CAMPAIGN_KEYS, "qualification admission campaign", ) + if campaign_binding["campaign_id"] != campaign["campaign_id"]: + raise AcceptanceError("qualification admission campaign ID differs") for key in ( "artifact_sha256", "contract_sha256", @@ -755,6 +1240,7 @@ def validate_qualification_admission( "issuer_workflow": issuer["workflow"], "issuer_ref": issuer["ref"], "expires_at": payload["expires_at"], + "evidence_identity_sha256": identity_digest, } @@ -821,7 +1307,10 @@ def _validate_certificate( raise AcceptanceError("certificate Flow release commit is not exact") _digest(flow["wheel_sha256"], "certificate Flow wheel") _digest(runtime["manifest_sha256"], "certificate managed-runtime manifest") + _digest(runtime["runner_artifact_sha256"], "certificate runner artifact") _nonempty(runtime["runner_build"], "certificate runner build") + if runtime["substrate"] != "web": + raise AcceptanceError("certificate managed-runtime substrate is not web") if not isinstance(runtime["playwright_version"], str) or _SEMVER.fullmatch( runtime["playwright_version"] ) is None: @@ -846,9 +1335,11 @@ def _validate_certificate( "oracle_contract_sha256", "runtime_validation_id_sha256", "admission_id_sha256", + "campaign_id_sha256", "workflow_version_id_sha256", "workflow_digest", "environment_digest", + "evidence_identity_sha256", ): _digest(qualification[key], f"certificate qualification {key}") for key in ( @@ -1203,16 +1694,20 @@ def _binding_pairs(certificate: Mapping[str, Any]) -> dict[str, Any]: return { "runtime_validation_id_sha256": qualification["runtime_validation_id_sha256"], "admission_id_sha256": qualification["admission_id_sha256"], + "campaign_id_sha256": qualification["campaign_id_sha256"], "workflow_version_id_sha256": qualification["workflow_version_id_sha256"], "workflow_digest": qualification["workflow_digest"], "environment_digest": qualification["environment_digest"], + "evidence_identity_sha256": qualification["evidence_identity_sha256"], "cloud_source_commit": product["cloud"]["source_commit"], "cloud_target_build_sha256": product["cloud"]["target_build_sha256"], "flow_version": product["flow"]["version"], "flow_release_commit": product["flow"]["release_commit"], "flow_wheel_sha256": product["flow"]["wheel_sha256"], "managed_runtime_manifest_sha256": product["managed_runtime"]["manifest_sha256"], + "runner_artifact_sha256": product["managed_runtime"]["runner_artifact_sha256"], "runner_build": product["managed_runtime"]["runner_build"], + "substrate": product["managed_runtime"]["substrate"], "playwright_version": product["managed_runtime"]["playwright_version"], "browser_base_image": product["managed_runtime"]["browser_base_image"], "campaign_contract_sha256": qualification["campaign_contract_sha256"], @@ -1265,6 +1760,163 @@ def _validate_authority_contract(value: Any) -> dict[str, tuple[str, bytes]]: return verified +def _unique_digest_list(value: Any, label: str) -> list[str]: + if not isinstance(value, list): + raise AcceptanceError(f"{label} must be a list") + digests = [_unprefixed_digest(item, f"{label} item") for item in value] + if len(digests) != len(set(digests)): + raise AcceptanceError(f"{label} must not contain duplicates") + return digests + + +def _validate_runner_facts( + value: Any, + *, + source_digest: str, + evidence_identity: Mapping[str, Any], + label: str, +) -> dict[str, Any]: + facts = _closed(value, _RUNNER_FACT_KEYS, f"{label} runner facts") + counter = _closed( + facts["model_call_counter"], + _MODEL_CALL_COUNTER_KEYS, + f"{label} model-call counter", + ) + if counter["source"] != "runner_signed_flow_report_and_enforced_egress_policy": + raise AcceptanceError(f"{label} model-call counter source is not reviewed") + counts = { + key: _count(counter[key], f"{label} model-call {key}") + for key in ( + "attempted", + "completed", + "input_tokens", + "output_tokens", + "cost_microusd", + ) + } + call_ids = _unique_digest_list( + counter["call_ids_sha256"], f"{label} model-call IDs" + ) + if len(call_ids) != counts["attempted"]: + raise AcceptanceError(f"{label} model-call IDs differ from attempted count") + if counts["completed"] > counts["attempted"]: + raise AcceptanceError(f"{label} completed model calls exceed attempted calls") + provider_models = counter["provider_models"] + if not isinstance(provider_models, list): + raise AcceptanceError(f"{label} provider-model inventory must be a list") + normalized_provider_models: list[tuple[str, str]] = [] + for index, entry in enumerate(provider_models): + item = _closed( + entry, + _PROVIDER_MODEL_KEYS, + f"{label} provider-model {index}", + ) + normalized_provider_models.append( + ( + _nonempty(item["provider"], f"{label} provider-model {index} provider"), + _nonempty(item["model"], f"{label} provider-model {index} model"), + ) + ) + if len(normalized_provider_models) != len(set(normalized_provider_models)): + raise AcceptanceError(f"{label} provider-model inventory contains duplicates") + if counts["attempted"] == 0 and normalized_provider_models: + raise AcceptanceError(f"{label} provider-model inventory exists without a model call") + if counter["egress_policy_sha256"] != evidence_identity["network_policy_sha256"]: + raise AcceptanceError(f"{label} model-call egress policy differs from admission") + if counter["report_sha256"] != source_digest: + raise AcceptanceError(f"{label} model-call report differs from source evidence") + operator_ids = _unique_digest_list( + facts["operator_intervention_ids_sha256"], + f"{label} operator intervention IDs", + ) + return { + "model_call_counter": {**counts, "call_ids": call_ids}, + "operator_intervention_count": len(operator_ids), + } + + +def _validate_observer_facts(value: Any, *, label: str) -> dict[str, Any]: + facts = _closed(value, _OBSERVER_FACT_KEYS, f"{label} observer facts") + if facts["dispatch_state"] not in {"dispatched", "not_dispatched"}: + raise AcceptanceError(f"{label} observer dispatch state is invalid") + if facts["verifier_method"] != "read_only_system_of_record_query": + raise AcceptanceError(f"{label} observer verifier method is not reviewed") + if facts["verifier_tier"] != "independent_system_of_record": + raise AcceptanceError(f"{label} observer verifier tier is not independent") + for key in ( + "pre_state_evidence_sha256", + "post_state_evidence_sha256", + "expected_record_id_sha256", + "expected_transaction_ref_sha256", + ): + _unprefixed_digest(facts[key], f"{label} observer {key}") + inventory = facts["effect_inventory"] + if not isinstance(inventory, list): + raise AcceptanceError(f"{label} observer effect inventory must be a list") + expected_record = facts["expected_record_id_sha256"] + expected_transaction = facts["expected_transaction_ref_sha256"] + effect_ids: set[str] = set() + intended = 0 + wrong_record = 0 + collateral = 0 + for index, value in enumerate(inventory): + effect = _closed(value, _EFFECT_KEYS, f"{label} observer effect {index}") + for key in _EFFECT_KEYS: + _unprefixed_digest(effect[key], f"{label} observer effect {index} {key}") + if effect["effect_id_sha256"] in effect_ids: + raise AcceptanceError(f"{label} observer effect inventory contains duplicates") + effect_ids.add(effect["effect_id_sha256"]) + if effect["transaction_ref_sha256"] != expected_transaction: + collateral += 1 + elif effect["record_id_sha256"] != expected_record: + wrong_record += 1 + else: + intended += 1 + if facts["dispatch_state"] == "not_dispatched" and inventory: + raise AcceptanceError(f"{label} observer found effects for an undispatched action") + derived = { + "intended_effect_count": intended, + "wrong_record_count": wrong_record, + "duplicate_effect_count": max(0, intended - 1), + "collateral_effect_count": collateral, + } + declared = _closed( + facts["derived_classifications"], + _EFFECT_CLASSIFICATION_KEYS, + f"{label} observer derived classifications", + ) + normalized_declared = { + key: _count(declared[key], f"{label} observer {key}") for key in declared + } + if normalized_declared != derived: + raise AcceptanceError( + f"{label} observer effect classifications differ from its inventory" + ) + return {"dispatch_state": facts["dispatch_state"], **derived} + + +def _validate_receipt_facts( + value: Any, + *, + receipt_type: str, + source_digest: str, + evidence_identity: Mapping[str, Any], + label: str, +) -> dict[str, Any]: + if receipt_type == "runner": + return _validate_runner_facts( + value, + source_digest=source_digest, + evidence_identity=evidence_identity, + label=label, + ) + if receipt_type == "observer": + return _validate_observer_facts(value, label=label) + if value != {}: + raise AcceptanceError(f"{label} {receipt_type} facts must be empty") + return {} + + def _verified_receipt( receipt_digest: Any, *, @@ -1275,9 +1927,10 @@ def _verified_receipt( trial: Mapping[str, Any], envelopes: Mapping[str, Any], authorities: Mapping[str, tuple[str, bytes]], + evidence_identity: Mapping[str, Any], generated_at: datetime, label: str, -) -> tuple[str, str]: +) -> tuple[str, str, dict[str, Any]]: digest = _unprefixed_digest(receipt_digest, f"{label} {receipt_type} receipt") if digest not in envelopes: raise AcceptanceError(f"{label} {receipt_type} receipt body is missing") @@ -1314,10 +1967,13 @@ def _verified_receipt( "attempt_id_sha256": trial["attempt_id_sha256"], "run_id_sha256": trial["run_id_sha256"], "workflow_version_id": trial["workflow_version_id"], + "admission_id": trial["admission_id"], "bundle_artifact_sha256": trial["bundle_artifact_sha256"], "runtime_validation_id": trial["runtime_validation_id"], + "evidence_identity_sha256": trial["evidence_identity_sha256"], "verdict": projection["verdict"], "evidence_sha256": source_digest, + "facts": projection["facts"], } if projection != expected_projection: raise AcceptanceError(f"{label} {receipt_type} projection differs from its row") @@ -1341,14 +1997,34 @@ def _verified_receipt( signature, RECEIPT_SIGNATURE_DOMAIN + canonical_json(signed).encode("utf-8"), ) - return projection["verdict"], source_digest + facts = _validate_receipt_facts( + projection["facts"], + receipt_type=receipt_type, + source_digest=source_digest, + evidence_identity=evidence_identity, + label=label, + ) + return projection["verdict"], source_digest, facts def _derive_trial_classification( *, expected: str, verdicts: Mapping[str, str], + receipt_facts: Mapping[str, Mapping[str, Any]], ) -> str: + runner_facts = receipt_facts["runner"] + observer_facts = receipt_facts["observer"] + if runner_facts["operator_intervention_count"]: + return "operator_intervention" + if observer_facts["wrong_record_count"]: + return "wrong_record" + if observer_facts["duplicate_effect_count"]: + return "duplicate_effect" + if observer_facts["collateral_effect_count"]: + return "collateral_effect" + if expected == "verified" and runner_facts["model_call_counter"]["attempted"]: + return "healthy_path_model_call" if verdicts["webhook"] != "delivered": return "uncertain_delivery" if verdicts["cleanup"] != "completed" or verdicts["cleanup_absence"] != "absent": @@ -1363,6 +2039,8 @@ def _derive_trial_classification( and verdicts["observer"] == "satisfied" and verdicts["replay"] == "verified" and "fault" not in verdicts + and observer_facts["dispatch_state"] == "dispatched" + and observer_facts["intended_effect_count"] == 1 ): return "verified" return "silent_incorrect_success" @@ -1371,6 +2049,8 @@ def _derive_trial_classification( and verdicts["observer"] == "satisfied" and verdicts["replay"] == "halted" and verdicts.get("fault") == "injected" + and observer_facts["dispatch_state"] == "not_dispatched" + and observer_facts["intended_effect_count"] == 0 ): return "safe_halt" return "silent_incorrect_success" @@ -1379,7 +2059,7 @@ def _derive_trial_classification( def _validate_campaign( campaign: Mapping[str, Any], admission_payload: Mapping[str, Any], -) -> tuple[Counter[str], dict[str, int]]: +) -> tuple[Counter[str], dict[str, int], Counter[str]]: campaign = _closed(campaign, _CAMPAIGN_KEYS, "campaign") if campaign["schema_version"] != CAMPAIGN_SCHEMA: raise AcceptanceError("campaign schema is not supported") @@ -1388,6 +2068,17 @@ def _validate_campaign( raise AcceptanceError("campaign ID must be a UUIDv4") if campaign["decision"] != "admitted": raise AcceptanceError("campaign decision is not admitted") + for key in ("admission_id", "runtime_validation_id"): + _canonical_uuid(campaign[key], f"campaign {key}") + if campaign[key] != admission_payload[key]: + raise AcceptanceError(f"campaign {key} differs from admission") + evidence_identity = _mapping( + admission_payload["evidence_identity"], + "qualification evidence identity", + ) + identity_digest = evidence_identity_sha256(evidence_identity) + if campaign["evidence_identity_sha256"] != identity_digest: + raise AcceptanceError("campaign evidence identity differs from admission") generated_at = _whole_second_timestamp(campaign["generated_at"], "campaign generated_at") oracle = _closed(campaign["oracle_contract"], _ORACLE_KEYS, "campaign oracle contract") if oracle != { @@ -1407,6 +2098,10 @@ def _validate_campaign( expected_cases = _case_contract(contract) task_id = contract["task_id"] authorities = _validate_authority_contract(campaign["authority_contract"]) + runner_public_key = authorities["runner"][1] + runner_fingerprint = hashlib.sha256(runner_public_key).hexdigest() + if runner_fingerprint != evidence_identity["managed_runner_signer_sha256"]: + raise AcceptanceError("campaign runner signer differs from admission") envelopes = _mapping(campaign["receipt_envelopes"], "campaign receipt envelopes") for digest in envelopes: _unprefixed_digest(digest, "campaign receipt envelope key") @@ -1420,6 +2115,7 @@ def _validate_campaign( used_receipts: set[str] = set() seen_source_artifacts: set[str] = set() taxonomy: Counter[str] = Counter() + fact_totals: Counter[str] = Counter() trials_per_condition: dict[str, int] = {} effect_invariant_observations = 0 healthy_model_observations = 0 @@ -1462,7 +2158,7 @@ def _validate_campaign( for trial_index, trial_value in enumerate(trials, start=1): label = f"campaign condition {condition_id!r} trial {trial_index}" trial = _closed(trial_value, _TRIAL_KEYS, label) - if trial["schema_version"] != "openadapt.qualification-trial-row/v1": + if trial["schema_version"] != TRIAL_SCHEMA: raise AcceptanceError(f"{label} schema is not supported") if trial["task"] != task_id or trial["condition"] != condition_id: raise AcceptanceError(f"{label} task or condition differs from its container") @@ -1481,11 +2177,16 @@ def _validate_campaign( seen_attempts.add(trial["attempt_id_sha256"]) seen_runs.add(trial["run_id_sha256"]) _canonical_uuid(trial["workflow_version_id"], f"{label} workflow version") + _canonical_uuid(trial["admission_id"], f"{label} admission") _canonical_uuid(trial["runtime_validation_id"], f"{label} runtime validation") if trial["workflow_version_id"] != admission_payload["workflow_version_id"]: raise AcceptanceError(f"{label} workflow version differs from admission") if trial["runtime_validation_id"] != admission_payload["runtime_validation_id"]: raise AcceptanceError(f"{label} runtime validation differs from admission") + if trial["admission_id"] != admission_payload["admission_id"]: + raise AcceptanceError(f"{label} admission ID differs from admission") + if trial["evidence_identity_sha256"] != identity_digest: + raise AcceptanceError(f"{label} evidence identity differs from admission") if trial["bundle_artifact_sha256"] != admission_payload["bundle_artifact_sha256"]: raise AcceptanceError(f"{label} bundle artifact differs from admission") started_at = _whole_second_timestamp(trial["started_at"], f"{label} started_at") @@ -1499,6 +2200,7 @@ def _validate_campaign( if trial["failure_class"] not in _FAILURE_TAXONOMY: raise AcceptanceError(f"{label} failure class is invalid") verdicts: dict[str, str] = {} + receipt_facts: dict[str, dict[str, Any]] = {} for receipt_type, row_field in _RECEIPT_ROW_FIELDS.items(): receipt_digest = trial[row_field] if receipt_type == "fault" and case["kind"] == "representative": @@ -1514,7 +2216,7 @@ def _validate_campaign( if receipt_digest in used_receipts: raise AcceptanceError(f"{label} reuses a receipt envelope") used_receipts.add(receipt_digest) - verdict, source_digest = _verified_receipt( + verdict, source_digest, facts = _verified_receipt( receipt_digest, receipt_type=receipt_type, campaign_id=campaign_id, @@ -1523,6 +2225,7 @@ def _validate_campaign( trial=trial, envelopes=envelopes, authorities=authorities, + evidence_identity=evidence_identity, generated_at=generated_at, label=label, ) @@ -1530,14 +2233,35 @@ def _validate_campaign( raise AcceptanceError(f"{label} reuses a source evidence artifact") seen_source_artifacts.add(source_digest) verdicts[receipt_type] = verdict + receipt_facts[receipt_type] = facts if verdicts["runner"] != trial["execution_outcome"]: raise AcceptanceError(f"{label} execution outcome differs from signed evidence") if verdicts["observer"] != trial["oracle_verdict"]: raise AcceptanceError(f"{label} oracle verdict differs from signed evidence") - classification = _derive_trial_classification(expected=expected, verdicts=verdicts) + classification = _derive_trial_classification( + expected=expected, + verdicts=verdicts, + receipt_facts=receipt_facts, + ) if trial["failure_class"] != classification: raise AcceptanceError(f"{label} failure class differs from signed evidence") taxonomy[classification] += 1 + observer_facts = receipt_facts["observer"] + runner_facts = receipt_facts["runner"] + fact_totals["wrong_record_count"] += observer_facts["wrong_record_count"] + fact_totals["duplicate_effect_count"] += observer_facts[ + "duplicate_effect_count" + ] + fact_totals["collateral_effect_count"] += observer_facts[ + "collateral_effect_count" + ] + fact_totals["operator_intervention_count"] += runner_facts[ + "operator_intervention_count" + ] + attempted_model_calls = runner_facts["model_call_counter"]["attempted"] + fact_totals["model_call_count"] += attempted_model_calls + if expected == "verified": + fact_totals["healthy_path_model_call_count"] += attempted_model_calls effect_invariant_observations += 1 if expected == "verified": healthy_model_observations += 1 @@ -1556,14 +2280,23 @@ def _validate_campaign( raise AcceptanceError("campaign invariants must be a non-empty list") derived_invariants = { "no_wrong_or_duplicate_effect": { - "holds": True, + "holds": ( + fact_totals["wrong_record_count"] + + fact_totals["duplicate_effect_count"] + + fact_totals["collateral_effect_count"] + == 0 + ), "observations": effect_invariant_observations, - "violations": 0, + "violations": ( + fact_totals["wrong_record_count"] + + fact_totals["duplicate_effect_count"] + + fact_totals["collateral_effect_count"] + ), }, "zero_model_healthy_path": { - "holds": True, + "holds": fact_totals["healthy_path_model_call_count"] == 0, "observations": healthy_model_observations, - "violations": 0, + "violations": fact_totals["healthy_path_model_call_count"], }, } seen_invariants: set[str] = set() @@ -1585,7 +2318,7 @@ def _validate_campaign( raise AcceptanceError(f"campaign invariant differs from retained trials: {invariant_id!r}") if seen_invariants != set(derived_invariants): raise AcceptanceError("campaign does not contain the exact derived invariant set") - return taxonomy, trials_per_condition + return taxonomy, trials_per_condition, fact_totals def verify_github_attestation( @@ -1906,6 +2639,66 @@ def derive_production_acceptance( if admission_digest != certificate["qualification"]["qualification_admission_sha256"]: raise AcceptanceError("qualification admission digest differs from certificate") admission_payload = _mapping(admission["payload"], "qualification admission payload") + evidence_identity = _mapping( + admission_payload["evidence_identity"], + "qualification evidence identity", + ) + identity_digest = evidence_identity_sha256(evidence_identity) + if certificate["qualification"]["evidence_identity_sha256"] != ( + "sha256:" + identity_digest + ): + raise AcceptanceError("certificate evidence identity differs from admission") + runtime_identity = _mapping( + evidence_identity["runtime_build_identity"], + "qualification runtime build identity", + ) + managed_browser = _mapping( + runtime_identity["managed_browser"], + "qualification managed-browser identity", + ) + product = certificate["product"] + certificate_identity_projection = { + "flow_version": product["flow"]["version"], + "flow_release_commit": product["flow"]["release_commit"], + "flow_wheel_sha256": product["flow"]["wheel_sha256"].removeprefix("sha256:"), + "runtime_manifest_sha256": product["managed_runtime"][ + "manifest_sha256" + ].removeprefix("sha256:"), + "runner_build": product["managed_runtime"]["runner_build"], + "runner_artifact_sha256": product["managed_runtime"][ + "runner_artifact_sha256" + ].removeprefix("sha256:"), + "substrate": product["managed_runtime"]["substrate"], + "playwright_version": product["managed_runtime"]["playwright_version"], + "browser_base_image": product["managed_runtime"]["browser_base_image"], + "workflow_digest": certificate["qualification"]["workflow_digest"].removeprefix( + "sha256:" + ), + "environment_digest": certificate["qualification"][ + "environment_digest" + ].removeprefix("sha256:"), + "managed_runner_signer_sha256": certificate["identities"][ + "managed_runner_signer_sha256" + ].removeprefix("sha256:"), + } + expected_identity_projection = { + "flow_version": runtime_identity["flow_version"], + "flow_release_commit": runtime_identity["flow_release_commit"], + "flow_wheel_sha256": runtime_identity["flow_wheel_sha256"], + "runtime_manifest_sha256": runtime_identity["runtime_manifest_sha256"], + "runner_build": runtime_identity["runner_build"], + "runner_artifact_sha256": runtime_identity["runner_artifact_sha256"], + "substrate": runtime_identity["substrate"], + "playwright_version": managed_browser["playwright_version"], + "browser_base_image": managed_browser["browser_base_image"], + "workflow_digest": evidence_identity["workflow_digest"], + "environment_digest": evidence_identity["environment_digest"], + "managed_runner_signer_sha256": evidence_identity[ + "managed_runner_signer_sha256" + ], + } + if certificate_identity_projection != expected_identity_projection: + raise AcceptanceError("certificate execution identity differs from admission") if certificate["qualification"]["admission_signer"] != { "algorithm": "ed25519", "key_id": admission_facts["signer_key_id"], @@ -1913,16 +2706,30 @@ def derive_production_acceptance( "issuer_ref": admission_facts["issuer_ref"], }: raise AcceptanceError("certificate qualification signer differs from admission") + admission_campaign = _mapping( + admission_payload["campaign"], + "qualification admission campaign", + ) opaque_bindings = { "runtime_validation_id_sha256": ( "runtime validation id", - "runtime_validation_id", + admission_payload["runtime_validation_id"], + ), + "admission_id_sha256": ( + "qualification admission id", + admission_payload["admission_id"], + ), + "campaign_id_sha256": ( + "qualification campaign id", + admission_campaign["campaign_id"], + ), + "workflow_version_id_sha256": ( + "workflow version id", + admission_payload["workflow_version_id"], ), - "admission_id_sha256": ("qualification admission id", "admission_id"), - "workflow_version_id_sha256": ("workflow version id", "workflow_version_id"), } - for certificate_key, (domain, payload_key) in opaque_bindings.items(): - expected = opaque_binding_sha256(domain, admission_payload[payload_key]) + for certificate_key, (domain, raw_value) in opaque_bindings.items(): + expected = opaque_binding_sha256(domain, raw_value) if certificate["qualification"][certificate_key] != expected: raise AcceptanceError( f"certificate {certificate_key} differs from the retained admission" @@ -1954,7 +2761,9 @@ def derive_production_acceptance( oracle_digest = canonical_sha256(campaign["oracle_contract"]) if oracle_digest != certificate["qualification"]["oracle_contract_sha256"]: raise AcceptanceError("campaign oracle digest differs from certificate") - taxonomy, trials_per_condition = _validate_campaign(campaign, admission_payload) + taxonomy, trials_per_condition, fact_totals = _validate_campaign( + campaign, admission_payload + ) conditions = campaign["conditions"] required_trial_count = sum(condition["required_trials"] for condition in conditions) observed_trial_count = sum(trials_per_condition.values()) @@ -2000,11 +2809,14 @@ def derive_production_acceptance( "silent_incorrect_success" ], "over_halt_count": counted_taxonomy["over_halt"], - "wrong_record_count": counted_taxonomy["wrong_record"], - "duplicate_effect_count": counted_taxonomy["duplicate_effect"], - "collateral_effect_count": counted_taxonomy["collateral_effect"], + "wrong_record_count": fact_totals["wrong_record_count"], + "duplicate_effect_count": fact_totals["duplicate_effect_count"], + "collateral_effect_count": fact_totals["collateral_effect_count"], + "operator_intervention_count": fact_totals[ + "operator_intervention_count" + ], "uncertain_delivery_count": counted_taxonomy["uncertain_delivery"], - "model_call_count": 0, + "model_call_count": fact_totals["model_call_count"], }, "retention": facts["retention"], "claim_limit": "not_general_product_production_readiness", diff --git a/tests/fixtures/production_acceptance/live-certificate.json b/tests/fixtures/production_acceptance/live-certificate.json index 11b6cb8..79f94b6 100644 --- a/tests/fixtures/production_acceptance/live-certificate.json +++ b/tests/fixtures/production_acceptance/live-certificate.json @@ -19,7 +19,7 @@ "zero_model_healthy_path": true }, "identities": { - "managed_runner_signer_sha256": "sha256:1212121212121212121212121212121212121212121212121212121212121212", + "managed_runner_signer_sha256": "sha256:7300c0ae1429cd153252736a781b78f404f4738f17db195dbef533b74a45ec86", "organization_id_sha256": "sha256:0ecd004dcbed992e16d1f90fbb2b2ae5433e32ed62e563f6fc53caa277516648", "producer": { "kind": "github_oidc_attested_workflow", @@ -62,7 +62,9 @@ "browser_base_image": "python:3.11-slim@sha256:4444444444444444444444444444444444444444444444444444444444444444", "manifest_sha256": "sha256:3333333333333333333333333333333333333333333333333333333333333333", "playwright_version": "1.62.0", - "runner_build": "report-v4" + "runner_artifact_sha256": "sha256:5555555555555555555555555555555555555555555555555555555555555555", + "runner_build": "report-v4", + "substrate": "web" } }, "qualification": { @@ -73,15 +75,17 @@ "issuer_workflow": "OpenAdaptAI/openadapt-internal/.github/workflows/production-qualification-admission.yml", "key_id": "qa-ed25519-34750f98bd59fcfc" }, - "campaign_artifact_sha256": "sha256:c0f85314d9bb6236226b37b4dce86ea9ccee4dbec344ddb49858f7898e912d66", + "campaign_artifact_sha256": "sha256:ed685043a835a14f4990cab8b7646de63bbb4e757df89d09e4331c24ae7734c2", "campaign_contract_sha256": "sha256:02b706e8251719c9ed4c62e3c9807074952f5ffe350a382fa61bb7d3832cfe41", - "campaign_outcomes_sha256": "sha256:7c33c1c98779b1eca72c5e5cd8110e07d5975801ff4e84d6e69de0508f50304d", + "campaign_id_sha256": "sha256:0c72b77f9c560be2306048462f681f01dbe27db818243d8e792c56afccca0a38", + "campaign_outcomes_sha256": "sha256:a7f5dd6c92774a487ffe8c57822f464dd5b84e94f92e01899acbbb61b580ab19", "condition_count": 9, "environment_digest": "sha256:eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee", + "evidence_identity_sha256": "sha256:e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", "minimum_trials_per_condition": 3, "observed_trial_count": 27, "oracle_contract_sha256": "sha256:a9d87b5deaa24c553e65aa0237136398fe7821ae7d226fc20d48c500765bc1e0", - "qualification_admission_sha256": "sha256:6d1fee47bb76630e2e75346ffca643da50ecce9e684859939045ce2c19ec9978", + "qualification_admission_sha256": "sha256:c978f962afbe278c0f49cb51c41fa20cedea7981d15110d19aff1ec780843ba7", "required_trial_count": 27, "runtime_validation_id_sha256": "sha256:4b0c7cd12b36f177beb4e28ab9fb4fa4da0d4d033274233d654bd5615758908f", "task_count": 1, @@ -109,7 +113,7 @@ "upload_verified": true, "uploader_identity_sha256": "sha256:6969696969696969696969696969696969696969696969696969696969696969" }, - "schema_version": "openadapt.execute-live-acceptance-record/v1", + "schema_version": "openadapt.execute-live-acceptance-record/v2", "transaction": { "acceptance_challenge_sha256": "sha256:7373737373737373737373737373737373737373737373737373737373737373", "acceptance_envelope_sha256": "sha256:5555555555555555555555555555555555555555555555555555555555555555", diff --git a/tests/fixtures/production_acceptance/qualification-admission-trust.json b/tests/fixtures/production_acceptance/qualification-admission-trust.json index 31f3442..0af0e80 100644 --- a/tests/fixtures/production_acceptance/qualification-admission-trust.json +++ b/tests/fixtures/production_acceptance/qualification-admission-trust.json @@ -1,11 +1,21 @@ { - "qa-ed25519-34750f98bd59fcfc": { - "allowed_ref_prefixes": [ - "refs/heads/main@" - ], - "allowed_workflows": [ - "OpenAdaptAI/openadapt-internal/.github/workflows/production-qualification-admission.yml" - ], - "public_key": "iojj3XQJ8ZX9UtstPLpdcspnCb8dlBIb83SIAbQPb1w=" - } + "expires_at": "2026-08-25T11:50:00Z", + "generated_at": "2026-08-18T11:50:00Z", + "revision": 1, + "schema_version": "openadapt.qualification-signer-registry/v2", + "signers": [ + { + "algorithm": "ed25519", + "allowed_ref_prefixes": [ + "refs/heads/main@" + ], + "allowed_workflows": [ + "OpenAdaptAI/openadapt-internal/.github/workflows/production-qualification-admission.yml" + ], + "key_id": "qa-ed25519-34750f98bd59fcfc", + "public_key": "iojj3XQJ8ZX9UtstPLpdcspnCb8dlBIb83SIAbQPb1w=", + "revoked_at": null, + "status": "active" + } + ] } diff --git a/tests/fixtures/production_acceptance/qualification-admission.json b/tests/fixtures/production_acceptance/qualification-admission.json index 68e696d..e59c101 100644 --- a/tests/fixtures/production_acceptance/qualification-admission.json +++ b/tests/fixtures/production_acceptance/qualification-admission.json @@ -8,12 +8,14 @@ "bundle_content_digest": "2222222222222222222222222222222222222222222222222222222222222222", "bundle_version_id": "55555555-5555-4555-8555-555555555555", "campaign": { - "artifact_sha256": "c0f85314d9bb6236226b37b4dce86ea9ccee4dbec344ddb49858f7898e912d66", + "artifact_sha256": "ed685043a835a14f4990cab8b7646de63bbb4e757df89d09e4331c24ae7734c2", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "contract_sha256": "02b706e8251719c9ed4c62e3c9807074952f5ffe350a382fa61bb7d3832cfe41", "decision": "admitted", "failure_taxonomy": [ "collateral_effect", "duplicate_effect", + "healthy_path_model_call", "operator_intervention", "over_halt", "platform_failure", @@ -25,7 +27,7 @@ ], "oracle_contract_sha256": "a9d87b5deaa24c553e65aa0237136398fe7821ae7d226fc20d48c500765bc1e0", "oracle_id": "openadapt.execute-acceptance-campaign-oracle/v1", - "outcomes_sha256": "7c33c1c98779b1eca72c5e5cd8110e07d5975801ff4e84d6e69de0508f50304d", + "outcomes_sha256": "a7f5dd6c92774a487ffe8c57822f464dd5b84e94f92e01899acbbb61b580ab19", "tasks": [ { "condition": "ambiguous-target", @@ -85,6 +87,57 @@ }, "effect_contract_sha256": "2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d", "environment_contract_sha256": "2626262626262626262626262626262626262626262626262626262626262626", + "evidence_identity": { + "action_policy_sha256": "2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a", + "admission_id": "11111111-1111-4111-8111-111111111111", + "admission_policy_sha256": "2d3969d8c5fcfe0c0a967f775562802ca20b6598a8a3199185d0da6b7a36fb6b", + "application_contract_sha256": "2424242424242424242424242424242424242424242424242424242424242424", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "bundle_content_digest": "2222222222222222222222222222222222222222222222222222222222222222", + "bundle_version_id": "55555555-5555-4555-8555-555555555555", + "campaign_contract_sha256": "02b706e8251719c9ed4c62e3c9807074952f5ffe350a382fa61bb7d3832cfe41", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "effect_contract_sha256": "2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d", + "environment_contract_sha256": "2626262626262626262626262626262626262626262626262626262626262626", + "environment_digest": "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee", + "governed_authorization_template_sha256": "2323232323232323232323232323232323232323232323232323232323232323", + "identity_contract_sha256": "2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c", + "input_policy_sha256": "2929292929292929292929292929292929292929292929292929292929292929", + "managed_runner_signer_sha256": "7300c0ae1429cd153252736a781b78f404f4738f17db195dbef533b74a45ec86", + "network_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "operator_contract_sha256": "2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e", + "oracle_contract_sha256": "a9d87b5deaa24c553e65aa0237136398fe7821ae7d226fc20d48c500765bc1e0", + "qualification_campaign_schema": "openadapt.qualification-campaign/v2", + "qualification_receipt_schema": "openadapt.qualification-evidence-receipt/v2", + "qualification_signer_registry_revision": 1, + "qualification_signer_registry_sha256": "109987886d89767a65bfb4422362c3b86a0e2fa9bad2cf0dcd8d7716245ffd65", + "qualification_trial_schema": "openadapt.qualification-trial-row/v2", + "runtime_build_identity": { + "flow_release_commit": "0123456789abcdef0123456789abcdef01234567", + "flow_version": "1.31.0", + "flow_wheel_sha256": "2222222222222222222222222222222222222222222222222222222222222222", + "managed_browser": { + "browser_base_image": "python:3.11-slim@sha256:4444444444444444444444444444444444444444444444444444444444444444", + "playwright_version": "1.62.0" + }, + "native_desktop": null, + "remote_display": null, + "runner_artifact_sha256": "5555555555555555555555555555555555555555555555555555555555555555", + "runner_build": "report-v4", + "runtime_manifest_sha256": "3333333333333333333333333333333333333333333333333333333333333333", + "schema_version": "openadapt.admitted-runtime-build/v1", + "substrate": "web" + }, + "runtime_contract_sha256": "2828282828282828282828282828282828282828282828282828282828282828", + "runtime_environment_sha256": "2727272727272727272727272727272727272727272727272727272727272727", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "schema_version": "openadapt.production-acceptance-evidence-identity/v2", + "substrate_contract_sha256": "2525252525252525252525252525252525252525252525252525252525252525", + "tenant_id": "22222222-2222-4222-8222-222222222222", + "workflow_digest": "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd", + "workflow_id": "33333333-3333-4333-8333-333333333333", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + }, "expires_at": "2026-09-17T11:59:00Z", "governed_authorization_template_sha256": "2323232323232323232323232323232323232323232323232323232323232323", "identity_contract_sha256": "2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c", @@ -101,11 +154,11 @@ "runtime_contract_sha256": "2828282828282828282828282828282828282828282828282828282828282828", "runtime_environment_sha256": "2727272727272727272727272727272727272727272727272727272727272727", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "schema_version": "openadapt.qualification-admission/v1", + "schema_version": "openadapt.qualification-admission/v2", "substrate_contract_sha256": "2525252525252525252525252525252525252525252525252525252525252525", "tenant_id": "22222222-2222-4222-8222-222222222222", "workflow_id": "33333333-3333-4333-8333-333333333333", "workflow_version_id": "44444444-4444-4444-8444-444444444444" }, - "signature": "OBEE1BaFQteeAGCKehi1Ssnzqts8cZz7aDVUSRE7maxU2L5rvbjA/F4vjWIOz/07wUZyfY3x7r/AOH1Pxy3nBA==" + "signature": "0slsNbAvAmflJs3XaskOMaCCmyD7YbQSEAQKKIJ4SYkWo+uOXzlxopCxJo+ZP5SYRdmmTb6F+VI18B139Cu4Bw==" } diff --git a/tests/fixtures/production_acceptance/qualification-campaign.json b/tests/fixtures/production_acceptance/qualification-campaign.json index 38b5293..772fe0f 100644 --- a/tests/fixtures/production_acceptance/qualification-campaign.json +++ b/tests/fixtures/production_acceptance/qualification-campaign.json @@ -1,53 +1,54 @@ { + "admission_id": "11111111-1111-4111-8111-111111111111", "authority_contract": { "cleanup": { "algorithm": "ed25519", "key_id": "qe-ed25519-138dfa227234ea5f", "public_key": "MfMyLUkj02xBwQm9sAmRkxh77ZmUIJbkkmokx379DS8=", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature_domain": "openadapt-qualification-evidence-receipt-v1\\0" + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature_domain": "openadapt-qualification-evidence-receipt-v2\\0" }, "cleanup_absence": { "algorithm": "ed25519", "key_id": "qe-ed25519-d92d542a589844dd", "public_key": "ZMMIFf8m1cSv+OESdKOO1t0FUwSdpMEDcqlXW3p3aQk=", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature_domain": "openadapt-qualification-evidence-receipt-v1\\0" + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature_domain": "openadapt-qualification-evidence-receipt-v2\\0" }, "fault": { "algorithm": "ed25519", "key_id": "qe-ed25519-59b2ad6131a74d03", "public_key": "U0cJYlWKbgg5AirmXGsnI7MncuXAxfR3bLjmo+ELovM=", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature_domain": "openadapt-qualification-evidence-receipt-v1\\0" + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature_domain": "openadapt-qualification-evidence-receipt-v2\\0" }, "observer": { "algorithm": "ed25519", "key_id": "qe-ed25519-d7e1e084be213b01", "public_key": "1UIH2hlJd9z0atv+wrwudbUtWopCGE/t/cAAJPDj6No=", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature_domain": "openadapt-qualification-evidence-receipt-v1\\0" + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature_domain": "openadapt-qualification-evidence-receipt-v2\\0" }, "replay": { "algorithm": "ed25519", "key_id": "qe-ed25519-e37abcd79efd08db", "public_key": "Md6+VdN8cidosTcTHKpghwgLLgtguUvXhdFFdc+kmLw=", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature_domain": "openadapt-qualification-evidence-receipt-v1\\0" + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature_domain": "openadapt-qualification-evidence-receipt-v2\\0" }, "runner": { "algorithm": "ed25519", "key_id": "qe-ed25519-7300c0ae1429cd15", "public_key": "IIKL9cW9ystoSGMzbCAvtVmdpIvlWWYVdCFwcFvsqfc=", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature_domain": "openadapt-qualification-evidence-receipt-v1\\0" + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature_domain": "openadapt-qualification-evidence-receipt-v2\\0" }, "webhook": { "algorithm": "ed25519", "key_id": "qe-ed25519-168c59a54a0d5b6c", "public_key": "URw0oaLLUh3xa7JGuN6OeZfOI1x+drIqPXUDokgZ3Yo=", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature_domain": "openadapt-qualification-evidence-receipt-v1\\0" + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature_domain": "openadapt-qualification-evidence-receipt-v2\\0" } }, "campaign_id": "12345678-1234-4abc-8def-1234567890ab", @@ -58,72 +59,78 @@ "required_trials": 3, "trials": [ { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "679af5a8dedceb8c696719e73f82a698c230cd8fc98bb61769f0883202c0b637", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "96be7cec9d956a7a3f3308730cf3377553a285ef6d7bd42100b43d044e161cbb", - "cleanup_receipt_sha256": "1674de43590311145df8c1149ad40d4f1f154497536cd3f86547d117b005aced", + "cleanup_absence_proof_sha256": "1618244896b44c013eeedf931ce4d2ad0899fed5c9ed7f6812c9d17d62003c6b", + "cleanup_receipt_sha256": "cb6c8afc587772aa8efc94807c1572115c22e8a1eca478dc2977cf785f7e4771", "completed_at": "2026-08-18T10:02:00Z", "condition": "healthy-01", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", "execution_outcome": "verified", "failure_class": "verified", "fault_receipt_sha256": null, - "observer_receipt_sha256": "ff7446448b7ca80801834d31758eb31968c04d7c27fb137b992ab574ff157cdd", + "observer_receipt_sha256": "7955935e031e774f701302635fe41d80f3cb44696a61234b7849200d253a24e3", "oracle_verdict": "satisfied", - "replay_report_sha256": "156f5af975f0f574aa73e2f8f296304d6b7ca1fb389d20bf1dbd571935d491e0", + "replay_report_sha256": "47a57ac3a76f6d6769d612a5d478882242a2354fce1255ed9ea6f3a1e4fdbb15", "run_id_sha256": "0b5bda916a0808165159166955a9563cf9c2303949f762a18eb037f41b44a6dc", - "runner_receipt_sha256": "85e18a244859259c2a8275a40afe0d6b887db2fb91e1982d56ad414924a3423c", + "runner_receipt_sha256": "e5d91e9b772fc407fe311e48b7b354f267782156817273b26f6906c7ef225ef3", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "schema_version": "openadapt.qualification-trial-row/v1", + "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T10:01:00Z", "task": "execute-acceptance", "trial_index": 1, - "webhook_receipt_sha256": "ab88cfde60ca5548f8b6812e3713c9d2541ba50da220a9b4e6196cba18f94145", + "webhook_receipt_sha256": "49de0ab8efa7c46b2f4594bf74c916ec99f1694e45b3ec734566913d14b4225f", "workflow_version_id": "44444444-4444-4444-8444-444444444444" }, { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "fdad940f245d690750ad647fac25c7e76aac2f474db49732fec8129051750186", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "d1146664cafb846d4dece5833facbe37778ae7f7ccece97b7fe6f3e7cabd8c27", - "cleanup_receipt_sha256": "596a2bb3c7e416b245f5ed30fc86e4208af76997b62472bfbf278c79abee47ec", + "cleanup_absence_proof_sha256": "78b6fbcd45afdcab40cc88b65a9c53caea37e18ea8df239812cfb2922fd26df4", + "cleanup_receipt_sha256": "76e7394342df02acda6f125c6069601220ea6de460350b3746e09b4b55cfa461", "completed_at": "2026-08-18T10:03:00Z", "condition": "healthy-01", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", "execution_outcome": "verified", "failure_class": "verified", "fault_receipt_sha256": null, - "observer_receipt_sha256": "d36db3d72f05e9e0142a41e47eb4f413fd585a3de836ddd991067e03b6c2fd4b", + "observer_receipt_sha256": "b90646d3845ffaf972be53d7d891abfa78c60975dbdf1aae85f55340ff5d6ba1", "oracle_verdict": "satisfied", - "replay_report_sha256": "5f0221453529c8e3be2e2b23b2603925fbdf1502f576c16e2a40304d75ec9808", + "replay_report_sha256": "df5539d0273ef7fe8dad28520de2664d6cb1434aa1bc7973d5099129ea8e9fb3", "run_id_sha256": "3739043a92a8781376cfbd022460c03aba40f92a800b3885ebc046321437bc40", - "runner_receipt_sha256": "2b291719429c998246226ba27143f7da1f03abeabce84abeb3e581662b60d6bc", + "runner_receipt_sha256": "94480255df8b3ebf0a824b340d666a28d5fff75dc3d668d6ed30b4c69d06590b", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "schema_version": "openadapt.qualification-trial-row/v1", + "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T10:02:00Z", "task": "execute-acceptance", "trial_index": 2, - "webhook_receipt_sha256": "a761ed49d1a6b031989d9a95d8d4ce740d3d5e6e8daad883e1daad675c4d19d5", + "webhook_receipt_sha256": "22401bb3f7cdbee8cc0fdd6ce84eb60a63cfce66db20f3cf5cc51e55f10055a6", "workflow_version_id": "44444444-4444-4444-8444-444444444444" }, { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "4c352a6999f77707e8837adebb4fc2b7451c2ef6de5145190b33a5c5645e47eb", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "0668d3958131859deae05b675b6859b48e043adf1443d21f19a6bfc1c6bbc6ad", - "cleanup_receipt_sha256": "994bdf2b435c1a57d515e4b881bbcac43289df1f20385f7150c0193e1d2acc6f", + "cleanup_absence_proof_sha256": "0009aee64285ed2cb340ab6c8923ebd0a9f3603db3cbe1bf8e593bdea6aa22a3", + "cleanup_receipt_sha256": "4408783aba57a0ec3124a3265f3a7eb34eeb429fcef2e60a955c91d84e2e91d2", "completed_at": "2026-08-18T10:04:00Z", "condition": "healthy-01", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", "execution_outcome": "verified", "failure_class": "verified", "fault_receipt_sha256": null, - "observer_receipt_sha256": "33d8fd907e482612d1d69669f9f91afe0dded59103f393643a57500c8ee1ff05", + "observer_receipt_sha256": "bc7e85e0380e3c790a86bec2d4ddda704fb1ae1db4979ec6d91aa0562ccdbb9c", "oracle_verdict": "satisfied", - "replay_report_sha256": "48c07213b9025ee2168a2a7972ae7a2ac8f7aeda08b2ef95273dddd94d086d34", + "replay_report_sha256": "b87015226ef172a5e717616fc75a97661c343124e5a17bcc3fb8c5c32a4a5a03", "run_id_sha256": "4ee2bb61fb883cc8e77d636fb471aa3c0ce9ef0c0a8abd9682214bf0a8f16f26", - "runner_receipt_sha256": "70a3703f7ae55e333da73a24399d55404bc28158ae6c0088656cce79103ff011", + "runner_receipt_sha256": "93325b31e545651925604b95ea62b9327da8cb98905734f4925ca5d77aa5d1ed", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "schema_version": "openadapt.qualification-trial-row/v1", + "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T10:03:00Z", "task": "execute-acceptance", "trial_index": 3, - "webhook_receipt_sha256": "f100bd4634c9eb9fa4bed44602c35082221c7369d661daee343d30cb1df16e45", + "webhook_receipt_sha256": "7fb90d2da8912d351338ac30b3136cfae35c3cfcb21a1be3cefe268eb732696c", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } ] @@ -134,72 +141,78 @@ "required_trials": 3, "trials": [ { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "940d3ca125ff87ce7539740fbae29d2d64fec839328b0639127e1d197d2485d8", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "bebd124852a24da854264263989ce3eb2a81dc7583641e725b882317634cd656", - "cleanup_receipt_sha256": "89a5d906de379f1e4dfa2e52a02916b84cd79388b52a30ea2f26c33834b2a094", + "cleanup_absence_proof_sha256": "de26659e031f4d186faf99c91d5b4506cf77d4cc82723581f5f163519c82b032", + "cleanup_receipt_sha256": "7b0b7f71536e3d63e9f66ed1e0e47efcb78cd4930e486371ce40dd82d114d035", "completed_at": "2026-08-18T10:12:00Z", "condition": "healthy-02", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", "execution_outcome": "verified", "failure_class": "verified", "fault_receipt_sha256": null, - "observer_receipt_sha256": "47380d14908be57018b19d846d86f0ba8f428ba7cd44f03219dd21117e504d3b", + "observer_receipt_sha256": "dc770cb91c01b638000f8f540bc2f3b6496f492d80b0aefed750b134a19bfe84", "oracle_verdict": "satisfied", - "replay_report_sha256": "950129910020acdc11ac8fd19134104516d2e8974d28c6c4044f757b9cda35c1", + "replay_report_sha256": "54c1991cfc25ee0e9c19b42b0901851afed31454ab224132d6ba1f0438543683", "run_id_sha256": "bbb9312ce4682b23580eced0f8d19438d8266b222555df85fb27eef22ad5afe2", - "runner_receipt_sha256": "e0e3d981c9ba2d0cf3195944e46a1c95815d42f5f69057fef276ee9ad794e4c6", + "runner_receipt_sha256": "0a5102012076aadf70baee8581543ac04d061241192f1ca3c0b12eb6e31473f0", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "schema_version": "openadapt.qualification-trial-row/v1", + "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T10:11:00Z", "task": "execute-acceptance", "trial_index": 1, - "webhook_receipt_sha256": "281c785f27d6347e718f61d7d326ddd42e38cb7c0977de9b5e7585253cc3899b", + "webhook_receipt_sha256": "84070f921aa2358567527d3ec76d99bad2dd8b589b8c908bde0f717f266ad696", "workflow_version_id": "44444444-4444-4444-8444-444444444444" }, { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "3d42601a69ef46cc44f57b51762affef4ccd829ffde30125619a6e582af00dab", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "bb54c9fee035e3fcf5c9daa6f6fc08bc1e5d3cffb2b0aa0b047b1006727c7918", - "cleanup_receipt_sha256": "bcefc56da8f7c303f207023baadc506246d85c8e9f140de46f1e28cbc5bae278", + "cleanup_absence_proof_sha256": "e3d1c240c70aaf5b49945c1a2cfef7f1c7f1c61de81e67dde515b07827a87bb2", + "cleanup_receipt_sha256": "74c0ad2e902682f3f0c36c859ab514c9d2ca0c5e62a6efd3054713b92dc094e6", "completed_at": "2026-08-18T10:13:00Z", "condition": "healthy-02", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", "execution_outcome": "verified", "failure_class": "verified", "fault_receipt_sha256": null, - "observer_receipt_sha256": "dc7048a424e18471caed8bd57b168512101197f3accf144c4d19acc40d01bf6a", + "observer_receipt_sha256": "7822fdf37dfcdd3dac8232707e1237c777e0fe82d4d6ef3424dff0c260b6ab18", "oracle_verdict": "satisfied", - "replay_report_sha256": "d9553baf538c005d37d0fa044211857d6a24114de97b70462fdac8fe97be3400", + "replay_report_sha256": "93a820891c954075ce0f99539579a121345fc59129f8465a37c3937e401c5c7f", "run_id_sha256": "091e13ed70dab439b31cb506cf3bba1ddf6476696531cf891c39a924a928b7a1", - "runner_receipt_sha256": "21b8a3b75d9b04406b4684602b1b1c4ffbf01fc814f3371d80a478c2271e143a", + "runner_receipt_sha256": "4ca3d5eb8e380f12fb327214dadcf889acb28d7970b29fca53bf9f8f85700ae1", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "schema_version": "openadapt.qualification-trial-row/v1", + "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T10:12:00Z", "task": "execute-acceptance", "trial_index": 2, - "webhook_receipt_sha256": "020265c9483aadd4321f39f4bd35ad152b53d5fcebc96c044fa1d84ea860e614", + "webhook_receipt_sha256": "85e7b8b6b58819ab3b4574721e4263084e66b3a3aa505c1a0d5fe04e5df8cda8", "workflow_version_id": "44444444-4444-4444-8444-444444444444" }, { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "019dd96e9a771ccc01ebafab321d7d3a8314df8b2d6465bcfc5fa14cbdeabdf2", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "97e53386169276ba5b6fe074df5e3b928617a1298e4fdf7c7100474d4af06152", - "cleanup_receipt_sha256": "8a33f194bdfb27d33344ac8e2e9085dd5e899b878157756f56886e9e29e88821", + "cleanup_absence_proof_sha256": "95d12087d75ba87fd4915c47e5b83e12371fac79a045b1fd1ac7f778089a16ff", + "cleanup_receipt_sha256": "3c917b1de8297d9d1578795470d6a379a5bc0171ac1488d5468cb201099865b7", "completed_at": "2026-08-18T10:14:00Z", "condition": "healthy-02", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", "execution_outcome": "verified", "failure_class": "verified", "fault_receipt_sha256": null, - "observer_receipt_sha256": "974ab867b3788102bd3f634d25770c9abe171a3101c3e206b81bc60dcaac1a65", + "observer_receipt_sha256": "86565ed67acb88cd35e0a34cf2639b54eedf257f0391a7fcaa9ecc29b98fd533", "oracle_verdict": "satisfied", - "replay_report_sha256": "6ab281eabcbff71abd1ffaa1b2ee7f6b082673890d01882b7a842b1ee3e7ac8d", + "replay_report_sha256": "2f5e6b2f5830a2af96d4caaa4154d8df09aad535e981334f256ac161509da31d", "run_id_sha256": "16cb8df40654c6a1b55ea0e50e772d8c6e6d4f0d8205bd1f8296be27d0af83eb", - "runner_receipt_sha256": "8e4466457228106adf081b8f17ea483f689a4022c30e1953cf273ddbf02519dd", + "runner_receipt_sha256": "97a4c47d8a841b03b91b1cbcf6df1d4c9c5cf9f11d5073d7c3586e835d872801", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "schema_version": "openadapt.qualification-trial-row/v1", + "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T10:13:00Z", "task": "execute-acceptance", "trial_index": 3, - "webhook_receipt_sha256": "033d48209efa84280e3035d72ed0627a27cb43d45f6e05d277e23f164f345472", + "webhook_receipt_sha256": "f23a094951b21e87b4bf29d155bd5ec7826dd97188a34bd5899c9e0c9e36aafb", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } ] @@ -210,72 +223,78 @@ "required_trials": 3, "trials": [ { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "fc097c8b2e6ece94544a19b8d81f5c4a9367a89059e3dd4b2f746ab06a2fc930", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "8c1afd600031c30f995fb9824e193c95b4d4ad585ca879c64c9d2e348fa1b10e", - "cleanup_receipt_sha256": "42c9725850c0b81507d63757a3427d48e93db412915891ffd538e18eb73736be", + "cleanup_absence_proof_sha256": "84e5195b0a66b7c41b3bd1424059ba26346faa8012fc4ab9d569e108e3553615", + "cleanup_receipt_sha256": "96ebae402e023ee731b31211979466c1ba782490d54bbf69f6e9741f6f3177a2", "completed_at": "2026-08-18T10:22:00Z", "condition": "healthy-03", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", "execution_outcome": "verified", "failure_class": "verified", "fault_receipt_sha256": null, - "observer_receipt_sha256": "cf9b127576b09758cdc73a384992a995d372c5e5eb2ad814c25e4b7ac4f2c343", + "observer_receipt_sha256": "c83d86c9abcf943cba78206214f7d9fe7088e46167c0f37f5caea0a48554c82e", "oracle_verdict": "satisfied", - "replay_report_sha256": "4090cbc85f145c1a2b33d9536ca9f2ca12f9109769eb702a0a46fbda70abace8", + "replay_report_sha256": "932ee45a17ff8efd7ce9813d4b02db10de4b9020f03797a2ee56d95c5d517366", "run_id_sha256": "28768f565659133f5bf1170e638b81de4d7ca38dfecacd09ccf462a35344432b", - "runner_receipt_sha256": "9d1fb286c570cad74e6f2e0c77a085c58bab02089cd52c84c0a3c7637f13ff04", + "runner_receipt_sha256": "0559c67e2109bea9b527eaaeef98992c12c687c01e8906dec8a87d24c626e792", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "schema_version": "openadapt.qualification-trial-row/v1", + "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T10:21:00Z", "task": "execute-acceptance", "trial_index": 1, - "webhook_receipt_sha256": "983cfdb068e5742ca3315545dbe1d5c0bca772ce0359994c7c856d089ff8a892", + "webhook_receipt_sha256": "a568e4172ae077650c03fe76891b0f0592699afd2e87c9e60ff669d78c484cd4", "workflow_version_id": "44444444-4444-4444-8444-444444444444" }, { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "2601335b1101424105277997a67850a8a60aa45f59637b7679c1f32af463c460", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "ad21ee460923f6b34bab8405db2f256e8b3318e31797a5d256c274c0e0407bf0", - "cleanup_receipt_sha256": "d5f9ea3188b044838ce9bee71ae6243bd2ad81b684d7c1e1b537bbce00e4d99b", + "cleanup_absence_proof_sha256": "8aec61997da4bb5f9445dd4625b2d07f5a94688dd77d182d32b47cc064f12902", + "cleanup_receipt_sha256": "61152c7946d6e0b701c6ff999dc1b1b63b0bdee8c4754077ce1909f5b6d279bd", "completed_at": "2026-08-18T10:23:00Z", "condition": "healthy-03", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", "execution_outcome": "verified", "failure_class": "verified", "fault_receipt_sha256": null, - "observer_receipt_sha256": "ea37aba51876e0039f1a875d74bb647b694a67625b103458c1c5001c94015409", + "observer_receipt_sha256": "7bd04520d9af9cf9f2f39acffd0fda362dd5e762823fcc38102fb847a1b803e8", "oracle_verdict": "satisfied", - "replay_report_sha256": "bffc584cb4cb04d08a01698a8700bab8c812bece8884d7d1f4fe57081b46b5dd", + "replay_report_sha256": "46db9b4b3f93076b0958db1375ebda5a9fec42081d32df4d1bec5e0b45bd39c0", "run_id_sha256": "237a0b7d1cafb64b1d113dca6699e6eefeaaf0b18679138545c3695495b901d5", - "runner_receipt_sha256": "6d0df009a1feb328d36e628a4591440d773dad58dcbfaa89101c51dbf210e246", + "runner_receipt_sha256": "f805590013237b1a309cbe766022724f3d5d0b02262b5aa432bfd9347dd7a458", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "schema_version": "openadapt.qualification-trial-row/v1", + "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T10:22:00Z", "task": "execute-acceptance", "trial_index": 2, - "webhook_receipt_sha256": "fdb2a16e80f05e06a44ff752694761a289fa386ea14642e5412033c0636b48bf", + "webhook_receipt_sha256": "64044bd99feae9406b2089417a4e5b33dca8a65bc8c4c0227b47594912bf71c1", "workflow_version_id": "44444444-4444-4444-8444-444444444444" }, { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "7573925adbd8a7a4a3b98bb0379549d77aa8ed46e312c1cd940c05b8587a039e", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "8d5373078fe224a410a6aa3c622308ea4058e7c846ec59ebba5d7288bc7fc3f2", - "cleanup_receipt_sha256": "8f293c1c43a0e7a6ca5aec96665bf2a869ce0ee065aa6ef5a5695a80765623f7", + "cleanup_absence_proof_sha256": "2e9e8e01ec1be899f4e038599fc64adbc3942c35c0565bb67e17d382bc5ca8a8", + "cleanup_receipt_sha256": "e7523a67b0d470b2e2f7d4ade8435b4fb6b5d1289862b50a57b7be2be42a84ee", "completed_at": "2026-08-18T10:24:00Z", "condition": "healthy-03", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", "execution_outcome": "verified", "failure_class": "verified", "fault_receipt_sha256": null, - "observer_receipt_sha256": "f0b50a9ab49377989815466eb28721d01c8ee89bff2b37a4a5f3c1901ce1cfc1", + "observer_receipt_sha256": "3cce0307da3bad33d18f117ca01623c6baea1b925048bef9a82fbb3ea576df62", "oracle_verdict": "satisfied", - "replay_report_sha256": "ada29f53b414f7aa7dd00232151d90f5f36d0f7d0c99f06d3c4e552088cc446e", + "replay_report_sha256": "4c3a2f062bd550c473b950f0dffd59d3526f54fadca154c653cc7f0011b9d31c", "run_id_sha256": "784a0a94e581700a3d93581e7ce5bac0d3bc53c58f3e73198b896b5da9a819b0", - "runner_receipt_sha256": "e824c2cd52e7d2ff5ecfa797b7d2e53fa7986c0a5ea5e77204511d9460662047", + "runner_receipt_sha256": "18343a300dbb47883fd932d0819e5b92aeaa6ad60dfa82ee8b66c6ac3190fbed", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "schema_version": "openadapt.qualification-trial-row/v1", + "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T10:23:00Z", "task": "execute-acceptance", "trial_index": 3, - "webhook_receipt_sha256": "b9e0d9c9f9ce5387a9cca061a4fd13f9f4dce4558a4295c86a2641ff038a4dbc", + "webhook_receipt_sha256": "23f53c85f34d6013ca5c2961470deddd7bc790d5096380b677a9bf5e83951335", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } ] @@ -286,72 +305,78 @@ "required_trials": 3, "trials": [ { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "3142933f4f168c98b8e89f2ae9d78fd3129e0a9975cbbaa60ddba853eee7d53c", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "31e84b9a0133f40ac67e9fa8b9b59b7a56b3069952903232a7b00402effac1dd", - "cleanup_receipt_sha256": "53299c8e5f88e4000630fe3142648c66fa7ea8c0bae92b94606a9dccb387a3cf", + "cleanup_absence_proof_sha256": "623ae0f6cc3220ffa04c016943dc42361acb180e7f5649b4b410e3661063a450", + "cleanup_receipt_sha256": "74bf2158a084de1057a2f9332e58a275be7e26aac5b1ff5ccdb29efb49923593", "completed_at": "2026-08-18T10:32:00Z", "condition": "idempotency-replay", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", "execution_outcome": "verified", "failure_class": "verified", "fault_receipt_sha256": null, - "observer_receipt_sha256": "3f9dbd4b5462c22c057ec74e389a00836aa7b3f2870a49095bb48310555f8b99", + "observer_receipt_sha256": "4975d0d0574f5e4ed180eae087569cfb1b53445945a9e03f7bdc0b51aa40bfa4", "oracle_verdict": "satisfied", - "replay_report_sha256": "740b98f25b9a7bd1377ef51336f483823b8ab09f9e1ee7bad1075aee460a277d", + "replay_report_sha256": "7680aca959060d5c6c03586cd4555132a94bbec661dd09cb82aa51f0fdea9746", "run_id_sha256": "6cdff0cf50d0164fe1eee9c4b7db0b969c24f9b960f5653b516313a913c90a0f", - "runner_receipt_sha256": "1eb22d963181e3e47e20a19387d74eba9c265f9f2bc8ef3b5680f75db6cc94b0", + "runner_receipt_sha256": "1cfb44a34276ac71b453562485ff70fb3b5f0c5d0718632601a8f05f62280cd5", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "schema_version": "openadapt.qualification-trial-row/v1", + "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T10:31:00Z", "task": "execute-acceptance", "trial_index": 1, - "webhook_receipt_sha256": "892f7c4bd8e3b8b91b3e349aba640c5c87c0268e74d72343c4d14d7a6eee57ed", + "webhook_receipt_sha256": "914f5d551d662ec06a7dd8f330bd5256cf317ed0d280fe1da10fdb296c9e9b5f", "workflow_version_id": "44444444-4444-4444-8444-444444444444" }, { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "4667302b580ff7ceb223dbb15eb6d029969a8f6a54bcd33e8df5b6bff41f41ad", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "6dad0042578bd7c79c09e312aeb104931fde6dc82c7e85cf3d540c49ced11a0b", - "cleanup_receipt_sha256": "9e3bbbe8b2d5c7987be2fd3e29228f407319832eee70ef1bcb56fce353a8fec1", + "cleanup_absence_proof_sha256": "2cc546bd37198e76ce6746f03869d3382b12582987ca76354cb1f4c0b913325a", + "cleanup_receipt_sha256": "67aef634540cce7bb70a512081e96ebc7edd41e8bb8835891ce1378efd425557", "completed_at": "2026-08-18T10:33:00Z", "condition": "idempotency-replay", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", "execution_outcome": "verified", "failure_class": "verified", "fault_receipt_sha256": null, - "observer_receipt_sha256": "789bb7f6d5d3968fbaa87e3cffec42e18b036d53e2eb560a1fe1b3834fd27300", + "observer_receipt_sha256": "76f7d5b5fc039b3ce624e887fb4e076bfc10f32577f8a3c72566678942ff8bea", "oracle_verdict": "satisfied", - "replay_report_sha256": "2a60a9e1e23380c3b33f8ca174cf3510660ac29a6e5a8ab2e3e2c678107613a4", + "replay_report_sha256": "d8c483eb7b08e73b722f6a305a73fd8d2a4e36cf0339e42774d7fd5b64650c5c", "run_id_sha256": "33e0ad9bf64e477f24d46508fa432123e046dcd1c5853d5cc60b7cde1bce7537", - "runner_receipt_sha256": "2fa257efdc7b2b5fbd3e5caa209d045d974201e96852760f38ca9a70bcd61755", + "runner_receipt_sha256": "eb27d821b05fccea7ed8b1568a4607b8de8b629e8f50cba1e543e4af416045f0", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "schema_version": "openadapt.qualification-trial-row/v1", + "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T10:32:00Z", "task": "execute-acceptance", "trial_index": 2, - "webhook_receipt_sha256": "7faacd55bef5f183c095457453d97320383b2202519d772ae533661a701da791", + "webhook_receipt_sha256": "50c2a328d61a13cb7fd97b9eafe0e28fea69e930de081ac511e2023f3596a15c", "workflow_version_id": "44444444-4444-4444-8444-444444444444" }, { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "3aee8ad755c7f4bec71cc194bcfaa805e0ea29cf8b830ed0782f8263dd9620ca", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "59c12284d73e7334ebbca691f3076346f93c97e78dc807dd4a65678b5bc74e42", - "cleanup_receipt_sha256": "4d217e2a3ebb192fa8e2b2126a002c17c90e22d8562e7a749c5a0d922015d625", + "cleanup_absence_proof_sha256": "64adf7272b03ff909a4d9420d130a4755b4925ea6f6e76341b621a79e975a5d7", + "cleanup_receipt_sha256": "ad0a42eb042759c673eb9a940f4924f8b054fbf2ecc5b9d6bdf9e16bb1996caf", "completed_at": "2026-08-18T10:34:00Z", "condition": "idempotency-replay", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", "execution_outcome": "verified", "failure_class": "verified", "fault_receipt_sha256": null, - "observer_receipt_sha256": "1ab983f4a4047724dfdb2f131ca6450811acb618a1bfee8e10844d5106065a36", + "observer_receipt_sha256": "3f5b7d5d21d2bd5fdff3bfca3f28f239673753668c9007bb04d6541fb3ef2226", "oracle_verdict": "satisfied", - "replay_report_sha256": "a2945533984428f22741891a6ad7bb56d247cb48bcba5b1c04abd6d0bb874fe8", + "replay_report_sha256": "11c3e276c44dd5d91dc79a7c94803e2ee06ae40712905927af21104098792fd4", "run_id_sha256": "3df83453126754a62d00ed10837720542d0469799bb8a88cb5257ac5f477a919", - "runner_receipt_sha256": "75ea2d7baeaecffbfa9b5fca73b8bf70e398697d76f9d1bec9a620bae3063765", + "runner_receipt_sha256": "be17be06d1fa1a089368e219302e3a4e142173b4c72e574c40410477d4dc2a2d", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "schema_version": "openadapt.qualification-trial-row/v1", + "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T10:33:00Z", "task": "execute-acceptance", "trial_index": 3, - "webhook_receipt_sha256": "f8c79e22c64f0b26775b0c105f8087f5fa147fa7cb3e7888bfcd6f6499cea2e3", + "webhook_receipt_sha256": "7d63a530b52e8faf6e3476894739e626da62bc5df1ccbe74ee9645b7fc8ef05a", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } ] @@ -362,72 +387,78 @@ "required_trials": 3, "trials": [ { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "e93521e706ad90d799dcd4e8cac15229c5da6aec1638540606f5fab4efce59fc", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "acf6d491add27b4b7a31a472243d873a000b70e758fd0adb6625e279dfa05dd3", - "cleanup_receipt_sha256": "1e611a0e77ce192cc9f46fe9544472b3352f58c6a8f3f1377c7a688a8a18d702", + "cleanup_absence_proof_sha256": "50ff634de0b6e29c4dfec89dae15e01e3872c32eff0ad8473e3eae442ea9f45a", + "cleanup_receipt_sha256": "06483a5a3def1a0eb09b1623870f68ef9ef1f5c923d10e220b4acbbecd3a0ff8", "completed_at": "2026-08-18T10:42:00Z", "condition": "wrong-reference", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", "execution_outcome": "halted", "failure_class": "safe_halt", - "fault_receipt_sha256": "e7de3e25e41b185b7d787423eb75096f31c60c53bb16339deb6cc1d34631dcb3", - "observer_receipt_sha256": "a0e9b443f4c32b7625331527491aa59f8e106cc72042f16e6b6a821cd0f7fccf", + "fault_receipt_sha256": "61de0f8814b796a5fc827d229ec0a83d37e81a097a8e8a0ab276d0eb1a274ae5", + "observer_receipt_sha256": "7ed9cc546bbca6006bf1cde43b11ded649bc2f080ffbf74b3e820d8775e05170", "oracle_verdict": "satisfied", - "replay_report_sha256": "4964bd1ea76f57d04c90ac2cb32ad42b9aa24e8c8d42439c7c7a4176d8a5589e", + "replay_report_sha256": "061a034a55abba5d6d8a4b22dbf24c70b016b7c1b06fc24b9fece9a3b1e0c933", "run_id_sha256": "ee82112f55e5e6c86cfd6e16df8c8b652549a8bd72de492f435d8255eb3dd252", - "runner_receipt_sha256": "8fc04ed993b5b503978034b069e82430afd713fec60fe7dd998675c5995d93ab", + "runner_receipt_sha256": "db5e2e6a02b80563230b4d36825d863af418ec707ae81789cc9001052351cc8a", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "schema_version": "openadapt.qualification-trial-row/v1", + "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T10:41:00Z", "task": "execute-acceptance", "trial_index": 1, - "webhook_receipt_sha256": "79aa9017fd55bce5532f4bc6ca88aaaf1244fd3eb00acbae04d8b2eb2529b836", + "webhook_receipt_sha256": "290c960538dbc38ee2260052e5b97353e41c9ea3572cf627dbb2d7ce1124eb9e", "workflow_version_id": "44444444-4444-4444-8444-444444444444" }, { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "6b0e5c10d55fc92c1ff8576392270a24fb65722414cf58ff9a51b8ce9ef88587", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "e559276a48fe1c67b3d827bf49a6fa86b069834a9ac294c570b0e429410aabd5", - "cleanup_receipt_sha256": "d7ea0a0b1670116dd9bd45378335199d7805fd2c8b56b2e52b7d8b8df1a2d376", + "cleanup_absence_proof_sha256": "a4f8f64f3037b61213ea0e1e562cce78f79c336de874f207224906d671a84531", + "cleanup_receipt_sha256": "5653aa19c3b4662ef8d1add74e5911af8f972791895812f4fec40722fd8af7e9", "completed_at": "2026-08-18T10:43:00Z", "condition": "wrong-reference", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", "execution_outcome": "halted", "failure_class": "safe_halt", - "fault_receipt_sha256": "4e04402568630dfc4590fbecf04015269f4a6e6546e276a92bf4b6b657f8a8db", - "observer_receipt_sha256": "ae73206f663e332e61d69c76ec221fa5e456e5c8b847b5b21543900b03f93105", + "fault_receipt_sha256": "d8db564da881ce1888bee8e886f149da4ab06239ff1325fac6f2402738c33480", + "observer_receipt_sha256": "379bdd3e735612de1d2a7c4860a87692e78175e7425ffdbcb65a45e2c205af28", "oracle_verdict": "satisfied", - "replay_report_sha256": "261cb4aedf65989c753e88445ab1c34145bd44ff72212cd80c99418d0e47877d", + "replay_report_sha256": "14233009f4f65cd0a0fa81a233f4d0cc48d7f6c9b8d6f9ef8e2c12b8593047d3", "run_id_sha256": "577e37b10b1c87fd9c1b5d320888b736d272824657fd59a012e85a284ee88540", - "runner_receipt_sha256": "fb7adef7d6907ae3e36182ff1a4574e6d2900ba700648928333295be904cedc5", + "runner_receipt_sha256": "272e2c3c224b19f532d7a894d08b28f94782824ed6cdf90a3b216b2ded828210", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "schema_version": "openadapt.qualification-trial-row/v1", + "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T10:42:00Z", "task": "execute-acceptance", "trial_index": 2, - "webhook_receipt_sha256": "9dc862e47d7e3dc1cfa80048c17b4c566a36aff741e4a7914b3dc0e9c3729b13", + "webhook_receipt_sha256": "def8a0faa88928a2b87804705ece6f712edd9aeb7ca4fed4e066fdaea75229ca", "workflow_version_id": "44444444-4444-4444-8444-444444444444" }, { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "7c910764b2dcc6f05261d609082f75474e4638c3f356006307212b8fed4a2eb7", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "6bd1e4fa831b1274c6011187dec731e64b9076912681ddfbfbf53f68ab826b86", - "cleanup_receipt_sha256": "56b976ecc7eab49bd4b71a8735efac41939cd37654e0a90b7e45053ead2b8d73", + "cleanup_absence_proof_sha256": "c0f41eadbf7b50c360fb45ee132b23ba8b45bbb4d32cc7a96517d8a82abd9afe", + "cleanup_receipt_sha256": "24a0e21ab6813638a727b551149261a2220c7d3543d655234d685fc9d3bb4133", "completed_at": "2026-08-18T10:44:00Z", "condition": "wrong-reference", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", "execution_outcome": "halted", "failure_class": "safe_halt", - "fault_receipt_sha256": "ca4213a203a9c2047c114c5bbd18837bf2d44fd2a9741b850ca6abf26e4934a9", - "observer_receipt_sha256": "10b9c9e23bb12807fe3446fa41b66ecc1df3f7720d4a6bd018243668a85afb14", + "fault_receipt_sha256": "db47eb5e8daad06624900c87959770bf1bddc5e74e391b0e7a7e31ce9521e8dc", + "observer_receipt_sha256": "b6148432883a666f0099767e8e3a51c46b65e8f765b75afc9106ceccec1c2e5a", "oracle_verdict": "satisfied", - "replay_report_sha256": "2b4060abcc8e69b9f87cb79a3b378fe93014566680b4140b3f5dff1b23c3af85", + "replay_report_sha256": "01e0e1e9f8d50d08a1e6a52833cbfb490ad0541a2b67b47528ff6d0fcd4a0219", "run_id_sha256": "fe98ce7f0e66b885201f4667875fd38f5890ffddb575d68bd4cd5a66f8d53ca8", - "runner_receipt_sha256": "3f1d8304c662af081aae90b0d6ffb2e01f21c5debf95a740595bd97d740965dc", + "runner_receipt_sha256": "41c5089c652797dd8892e0d7ada46912cf69f72bcd43bee7170b65f3ef278f7e", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "schema_version": "openadapt.qualification-trial-row/v1", + "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T10:43:00Z", "task": "execute-acceptance", "trial_index": 3, - "webhook_receipt_sha256": "0d4542a41deb0cb2b3f9291f4067d2fe88924884c6efcd742b85f7504d2840eb", + "webhook_receipt_sha256": "624fbbdd7880133c85ef5e91662bd815d4f451b168876822f76ac149caba0b11", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } ] @@ -438,72 +469,78 @@ "required_trials": 3, "trials": [ { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "fbfce2be9ce964be8b668aa518a310fe4a89e5c014f42bd0ea81401bd83bfd7a", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "765f8d15ba0ee4a35a281110faf81931a4bef2ff9a530050d2be0097c13e1f15", - "cleanup_receipt_sha256": "b1ceae7aa3fdcfabe16c842627a0b05f92894b90653fc43682f45975a9a69c4c", + "cleanup_absence_proof_sha256": "deda444b535e16e5e8c0b26f674bb9facf018b808a1c734a23d2b75101819f47", + "cleanup_receipt_sha256": "532808072697066585e9e78c84eb3df8a14d22f57a3499cd47a1a26c61062330", "completed_at": "2026-08-18T10:52:00Z", "condition": "stale-session", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", "execution_outcome": "halted", "failure_class": "safe_halt", - "fault_receipt_sha256": "47801787a92ee5738ee64b2bc3cda555dfc53682673d70e11bb9f94f799b371a", - "observer_receipt_sha256": "ea2c537ac99f78c9175fc41640fc030b6139c33c02ffa964597672932f1bc149", + "fault_receipt_sha256": "57af80b4f9c67ba20ca7749c4d68e814cf91aba0141012d9f7385b7d9ec3f60f", + "observer_receipt_sha256": "d798a4e28710daf65f49160ea167bc715efaea32bfab50c3d577df9d45bbad8d", "oracle_verdict": "satisfied", - "replay_report_sha256": "48204dcfbb7f14bb9885b499109da046b6455d3e2cdf47b6f017cf1aae9cf2f4", + "replay_report_sha256": "b8cc1d45257e2e92b93bff7e19fbd9cb80a18ba97f174f5b2983ff73ba8f627a", "run_id_sha256": "d9270fd4c85e4226a9347ecf703e876b9ffdc330f60c7fb8bed8f9321ea30225", - "runner_receipt_sha256": "f35aeb8c55ead7bbe677fd5fc293f41185ff75aa21101128a8c0d9fa4a591f05", + "runner_receipt_sha256": "873af0327d6a3360731e326c236f2b05e1220aa18a00a83d0c42b6d5012f0c08", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "schema_version": "openadapt.qualification-trial-row/v1", + "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T10:51:00Z", "task": "execute-acceptance", "trial_index": 1, - "webhook_receipt_sha256": "1847925251f6ac7a782baf4a381494cc662ad60bf1c0f2f3eddaecbc86940c29", + "webhook_receipt_sha256": "6af0a975d21278b3a18e55ee5036101ea423eb08313a1923528755ab608c889d", "workflow_version_id": "44444444-4444-4444-8444-444444444444" }, { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "f5df4d6e64a2d38ffa8e320c87ad05d04025de267a8e152a755d3f1928ded120", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "0f5b6ed8cfa03ef7f89f57a9a07926cd8fd9183b69e720ab914196b5fe9cdcd3", - "cleanup_receipt_sha256": "2995df9d47d9de4b42c9b5d90e71af5e47cc4bfac9fa9d9eb15ca521da785f02", + "cleanup_absence_proof_sha256": "1ca68224ff7ed710e02c185155a819a937f0297aed33d249c351ae3145706b27", + "cleanup_receipt_sha256": "a940f273dc2d98ad1504d3a5308e8a53af1d16f8801c2a15efaacbe548ec3efd", "completed_at": "2026-08-18T10:53:00Z", "condition": "stale-session", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", "execution_outcome": "halted", "failure_class": "safe_halt", - "fault_receipt_sha256": "97f6959aeb4a3659829a200f85e403a6001866e6495675fd3fe27542ed765ea2", - "observer_receipt_sha256": "e37d0a752e30a9964257bb1bc5def9409f3902ef3d739aa88b0a91048e9715e3", + "fault_receipt_sha256": "6944fec3e81116c5e5fa95147eeb513a8d68d388d64b0269fa617cde342b9f4f", + "observer_receipt_sha256": "741bb99666db76220c53c49c9729b0f8b75036e458f2d75542760ad6581184fc", "oracle_verdict": "satisfied", - "replay_report_sha256": "1ac32da3abb3085b0b9ff8093c06f8e5cfb3cd290d1ae053ca0b99807a81f759", + "replay_report_sha256": "9db2b18e2dc3cf9b5d36401b3b39deff53f42376f1ef0e4db7e5bf74f8a2d41c", "run_id_sha256": "fd3a041b705d8c6277ce26134dc0018e866218cfa3fadd16ac29d1ad498965a3", - "runner_receipt_sha256": "50cfc15f662201c2e03cf91d2156a213a28ab028cc4856c64d7da2204a5cdc55", + "runner_receipt_sha256": "d8c7108342370f14c1531094e3fdaeecea401a7608d17e2873dbe1ac63b71982", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "schema_version": "openadapt.qualification-trial-row/v1", + "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T10:52:00Z", "task": "execute-acceptance", "trial_index": 2, - "webhook_receipt_sha256": "0b0efbd1f00044f8f2fb8e1107723509061a4ad86a0eb9118c551ef806212465", + "webhook_receipt_sha256": "4830780f8c7ad36604ef1bd4935ae8ef598ac06c766368c7cadd8576a1d293e5", "workflow_version_id": "44444444-4444-4444-8444-444444444444" }, { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "958342a9ddca98a83b82b662f52f404239d583afe7ed70634760e1b8dd592f3b", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "2ee187a8c4b7240ee8767499afd16c6efc9356a3211766d00910d0ea2294a76e", - "cleanup_receipt_sha256": "ec0a1bc99a2e3e8249dafda43f54e76d647c86464d87e1caf40480f35f460868", + "cleanup_absence_proof_sha256": "65fba274ba6ef5364ee1212f448cacfa222246d4c278b29535b3569b9bfd699b", + "cleanup_receipt_sha256": "9a7ff6004d469b48ff0888078d491586e9590f75f13abd4764fd6295eb6aabb7", "completed_at": "2026-08-18T10:54:00Z", "condition": "stale-session", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", "execution_outcome": "halted", "failure_class": "safe_halt", - "fault_receipt_sha256": "cff75b636a312f1bb5f2e99eb6935abe16347884df3077f72780662d31804a38", - "observer_receipt_sha256": "893a8247b0fc26e0c36954a23409a8930a5e70fd085f987726277a3a30622f9f", + "fault_receipt_sha256": "4649e4901902dd6aadb3108e0f89bd75854f5b64b0d59a28e567596a4ee75d58", + "observer_receipt_sha256": "2798955cd738b419669697b8db8cfc4ef28861e4a00851f5addcb2967214c10f", "oracle_verdict": "satisfied", - "replay_report_sha256": "34e01549f75b1a8132541730937ba43e9f673d0886239a3adae2142502961c03", + "replay_report_sha256": "0eb5ab24ba6f40dd5d6e9c060f3a241672cde509dc3483dda42ef27fd76ff9cf", "run_id_sha256": "6f2fb10bc2018c9f78e9702d5ccac0bedd78ee3b2e9d2a6ad779fba72d90ae50", - "runner_receipt_sha256": "8aeff82557645b5c4719bd7dc52daff351274389e5be8e98bdf6191acb475984", + "runner_receipt_sha256": "83a40647d6d151da844fcff4f96c40516ee57ceae72f370078106244e2efb750", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "schema_version": "openadapt.qualification-trial-row/v1", + "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T10:53:00Z", "task": "execute-acceptance", "trial_index": 3, - "webhook_receipt_sha256": "661cc3ad4b5da051980466dc525c7a6b1366756913780519657bf5b148ce440e", + "webhook_receipt_sha256": "e5448eebaa458e6a8c2750acff6634232de77856d5c9920769cb1c3c90ab7b56", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } ] @@ -514,72 +551,78 @@ "required_trials": 3, "trials": [ { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "60ee9db05b1126cfaa3b31c13bc3fab4755ac09c44e846b4d07ee51865dfa7b1", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "b650e56035131f355c13d2d3948cc452fce8dae01d5bf2dd7ea3435c0b013e87", - "cleanup_receipt_sha256": "1a219a5a11101378903c40163101018c2d55b6877d88cdb3b29d1116de3e952a", + "cleanup_absence_proof_sha256": "2a78ce1f942edcd37931679bf672ad893a1cfea2a6a027c0210f53380c083cb4", + "cleanup_receipt_sha256": "39a0a13faa3fbc11b08573ce721f16a0312f03f22fd3f8066c1ff74a34445b22", "completed_at": "2026-08-18T11:02:00Z", "condition": "ambiguous-target", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", "execution_outcome": "halted", "failure_class": "safe_halt", - "fault_receipt_sha256": "c8eacb7caeaa9125a97121ca8bfdfe848cf5d658a0c88b163b326c9db99949f8", - "observer_receipt_sha256": "4cfd8a817a8c1420280b8aea0a449a467135ebcbc3bb6295e2a1a908a0d22a8a", + "fault_receipt_sha256": "9842d656d4d92597e76248af6b34e1577d204588dd9b446cc98424630c4ba79f", + "observer_receipt_sha256": "695743910a9a3fc4f38f7cef21f960b3ad157b1c971cb6d5858c866f10eecb7f", "oracle_verdict": "satisfied", - "replay_report_sha256": "00acd7fd6d1a4eb625a7d16057f94ceb1da3f8a05f8cb6f07a83d760c8f778af", + "replay_report_sha256": "23f4a977cecbb6af1ccef4d88c9bd19fc9c474c0a382a0e22ce7bec1aeb706de", "run_id_sha256": "628f991a182613b8700294d7483b5a4c06872cb9d5ca6047ea552b8ab6585357", - "runner_receipt_sha256": "37179d92aae8590ec9894154d581e654113f2fcb230673b466c345c5e68d7003", + "runner_receipt_sha256": "b661cb27d6061e177a2d7305a99de342ccf5336168bafbe9d0356c0ad65c92b8", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "schema_version": "openadapt.qualification-trial-row/v1", + "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T11:01:00Z", "task": "execute-acceptance", "trial_index": 1, - "webhook_receipt_sha256": "9631c84144936efd84f60d5becc81b736dcd00dca94797ec7ab3dc2a4152a80f", + "webhook_receipt_sha256": "1d8f4884ac384317209d4a4116a19a597a60f7483bacacc99a81adcd01c666c5", "workflow_version_id": "44444444-4444-4444-8444-444444444444" }, { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "1ec11a9862ede3ac701af71835ac28c551d604a026b5bab7d776dbcdf288394e", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "af535e76d2f849ee84e5d54123508736219c482ac68737053ba110dc5330ad2e", - "cleanup_receipt_sha256": "6909ceef7116356c56ca4737de1356b656ee491362571e3b50e588b4f6359b17", + "cleanup_absence_proof_sha256": "620ac6e3d7907f00bc17a13c98a6f49d1b6e5f4be2f45e348f07b8cb680f1f81", + "cleanup_receipt_sha256": "cfd92154fe2f468fa965ab716b63dfdffaab97240c67cda15b262e993ccc3b08", "completed_at": "2026-08-18T11:03:00Z", "condition": "ambiguous-target", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", "execution_outcome": "halted", "failure_class": "safe_halt", - "fault_receipt_sha256": "590846759c1280e18e608456c0e11b64221cfcafa73ab8f061d6dcb5fd762699", - "observer_receipt_sha256": "88aa95277a9bbc5666ac0b4a542bafa91ac60ee30d5fff79647d9ef050f10b75", + "fault_receipt_sha256": "42e108a2f781e3945e94c43caabc5314a03d47af1caf8380b032300a206a914c", + "observer_receipt_sha256": "d11f22309560ed2a7f681efe767e871d45348f2d0a1d80616d8e4dd7012e0044", "oracle_verdict": "satisfied", - "replay_report_sha256": "d9a6d4aa7064e5bfba2fb43680aa1891a29249aa899b5c4e7d2858aa8b27825b", + "replay_report_sha256": "f7051979b50415fc22bf21c2e154a96b44c6e20344ac9a11cf02a7ed66576f23", "run_id_sha256": "43f0a1c00950c390b0676fab55a2aa98c354d028f2347c461661e6cdb72f717e", - "runner_receipt_sha256": "250a2d98c537e0180459263bb61f21c6a1f12c144bc064ed993961fd98511ac5", + "runner_receipt_sha256": "be4bcc0de90d3e47d83b3285b71c911aab5367c05949bc04f422a1fb60ec606b", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "schema_version": "openadapt.qualification-trial-row/v1", + "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T11:02:00Z", "task": "execute-acceptance", "trial_index": 2, - "webhook_receipt_sha256": "0da9d385b5d1c9805b8bccc2598fd48e59365ca8b14f37dc943b7b12777850c4", + "webhook_receipt_sha256": "0b700db3525db248fddd3cde06607a194c809c76d5cece6a56745202ff8f707b", "workflow_version_id": "44444444-4444-4444-8444-444444444444" }, { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "491a544656d05aea37920e5c7e2ad65a9452eac8d6e100268a599aeebd41187a", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "fcc4e2987962120108fd11d6baf6c9d8c4c9b0bc5a2c6bce166f3bae1d328b50", - "cleanup_receipt_sha256": "2cb93f1da48f525ba6706aa6e042d870bf902fc22ed125fa90e9692d5a6ea1e9", + "cleanup_absence_proof_sha256": "9b67f51c4c82736ce53e697d96f9d24851bd56aaf11882d44ded060ea9417a8c", + "cleanup_receipt_sha256": "b6865344d649c442168a1a23f725bde6cecc3c2a2ac876c58aae1f28ed3fa044", "completed_at": "2026-08-18T11:04:00Z", "condition": "ambiguous-target", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", "execution_outcome": "halted", "failure_class": "safe_halt", - "fault_receipt_sha256": "0fb52130820a183fa318c24dd0e504f3505ca28f32a98d6fee032f6b19642a37", - "observer_receipt_sha256": "dee002824b0aacb73e258cbf2ffce66cdb8870f871b0f750e7d299102e153341", + "fault_receipt_sha256": "353a8e94bb09676bab144917696e954ea6351cb3cd171add5e2abb6c7134d61e", + "observer_receipt_sha256": "35fde2e03b3dc98d4b7cd66082f330ce9f3501d4d236e4c5394348d85e7f176c", "oracle_verdict": "satisfied", - "replay_report_sha256": "386dbd16e6ae7d1d0b6c82a6992fe211c81630928689722057964a0dda3c3942", + "replay_report_sha256": "1aeb42c46a7567c1fa5436e662dea85f649029f4a03e573907f477dab40e9653", "run_id_sha256": "aa62c7a17701a7ef01ea1d3519b4c1f90d357495b329fdda3054cc24c581a593", - "runner_receipt_sha256": "3d8eb365f4d3b3332b5d8416e465962d4c3c1b55f12f6500d62144fb512a6051", + "runner_receipt_sha256": "49e6a4db6325d7245a2f8be4ae4d3defe236bf45fe8cf7775e5126575652a805", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "schema_version": "openadapt.qualification-trial-row/v1", + "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T11:03:00Z", "task": "execute-acceptance", "trial_index": 3, - "webhook_receipt_sha256": "11b317991d7ac80a31d423d73f9b0312af2f7e53eeda77e640a524650611e77d", + "webhook_receipt_sha256": "9ad9415421ff129296360281cd537671da5f6894ab31b17254eb0d15aa976584", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } ] @@ -590,72 +633,78 @@ "required_trials": 3, "trials": [ { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "f5e96a2e9a580376b18beabf57798b8761e772a0c4d112877045780bb12b3720", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "c2f2b635cde60b553f1722c8593bb95ad7ed7023307693e3f024ffb125165db6", - "cleanup_receipt_sha256": "4862d7d39d33f17de4c889096ecaa907d1584807b22fc916e2a15d2462e70696", + "cleanup_absence_proof_sha256": "3e7ffe28a48816b6b63017f4d4e4fd2f3c387841bc5e8bfc14fa4f749653cf85", + "cleanup_receipt_sha256": "f308095e47a50231e48617fde6819ea8f160be521f2583b601c6f3c9918d3761", "completed_at": "2026-08-18T11:12:00Z", "condition": "verifier-unavailable", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", "execution_outcome": "halted", "failure_class": "safe_halt", - "fault_receipt_sha256": "a871118c067954b7150653696449fa0d547da2cb75a906394a899d7e81811365", - "observer_receipt_sha256": "a8b00915dcebc57be31a774634b0371cd299935f86c7c0213fdaf215480cb6c1", + "fault_receipt_sha256": "cbe1607f5b948d288e9fdb6ab638d5f3cde433d739670d52bfd0a1426d560300", + "observer_receipt_sha256": "a084fd73559d8b3db4eb489627c23d3fbddcb149c5f22bdc0f21b3057fe78fc5", "oracle_verdict": "satisfied", - "replay_report_sha256": "8979e7a57aae81f1b0da3757d74783fdd94996bfc44fbdda9843885daecad6fc", + "replay_report_sha256": "de88bb941c8dcaf4123f41230b235a5097a327e4408dd496c8a658bba071fc6b", "run_id_sha256": "e8e89651045a5f5c011c9543ed968e0fe7697a061ed8ad5cedc27d194cb96acb", - "runner_receipt_sha256": "dfcca365e78d63d5b6107cff019f577018420e7e4e6863991f92dbcb51ad4406", + "runner_receipt_sha256": "d67f951f5150477f5b6f23fd49cfb5dfb983c77c6f000ed977da83aa142ef62b", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "schema_version": "openadapt.qualification-trial-row/v1", + "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T11:11:00Z", "task": "execute-acceptance", "trial_index": 1, - "webhook_receipt_sha256": "45f1eee738934969cca1cb5fcdaed7dab6398cd9a05a7050822e88293b5d4cc7", + "webhook_receipt_sha256": "5c27733530c91746965049d5f68a6941c1b64018aa0272eb8eca9a1a086386fe", "workflow_version_id": "44444444-4444-4444-8444-444444444444" }, { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "42259dbb767ced4c25ad8bd40edc209720a748897194c925ed9bd2e27b2258b2", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "5ba58c2263a1dd72bb9bd200222709f04dadba7bebbf1d1bec3e779780f39c7b", - "cleanup_receipt_sha256": "30943ab2222e8fd4fb98d2a4e6ca8bd944800dc26e136492f4616f4e8d8f1ec4", + "cleanup_absence_proof_sha256": "a1e2cf48ee6a452726941504cdfcb692d395b1d31133f828215e77c2ac8228b5", + "cleanup_receipt_sha256": "e3d0a44d6733f68ad2f52b4ebe689b65537b49e3e2d2b06c7599db54a93a36b9", "completed_at": "2026-08-18T11:13:00Z", "condition": "verifier-unavailable", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", "execution_outcome": "halted", "failure_class": "safe_halt", - "fault_receipt_sha256": "38d632dc612aa9d18bc141fea23812d46fb9345a230b4e58b53336402a2a9289", - "observer_receipt_sha256": "465866a38613308e52f541786521a40df3e6444bc5dab1858e13e061239193c7", + "fault_receipt_sha256": "aa9087e68e6a8479b57a4463ffc5c56b32f86c74f9b79f6a507b816a68ed843e", + "observer_receipt_sha256": "ae850dfd7e4e0688962457aa9c6277ca031ff48e9046ecd1339ba5ac3a8bc8fb", "oracle_verdict": "satisfied", - "replay_report_sha256": "abca187283c219dbc776aaae8d38842e8ef0ae7b56007f5a6708f27e161e997a", + "replay_report_sha256": "cf1810125ebf9f6238ab3d93015329a48e69eeb4c925ad2cf6d658d08b492b3f", "run_id_sha256": "4af84f2608a25a27e6252a5800263a238bb70fb3bec65148601ddcdddbf3e03c", - "runner_receipt_sha256": "d71287d6a633a01d9edcc3f0c7552799e586aa942dff0330cc13238333f676cf", + "runner_receipt_sha256": "5634cde23250446592813e4ebf81ff20cffd3b116818f8d8a4297d175e993be7", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "schema_version": "openadapt.qualification-trial-row/v1", + "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T11:12:00Z", "task": "execute-acceptance", "trial_index": 2, - "webhook_receipt_sha256": "eb31e3c8e4d77a0dcc9e9204ce5c8761e52cd666cae9cdf2c79ff209ea3a6e22", + "webhook_receipt_sha256": "c2803318f01695a40e402726d0ed4cf471c4f579a3b7c9dcdecb0cfbd3cee666", "workflow_version_id": "44444444-4444-4444-8444-444444444444" }, { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "ad76dacfe19a4421ef1f128d4eef1099e846b385d29f17b8588ae5130b487118", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "bcf1ed30725b2853e7f37119a06ccb2838942b32c14d4d0a69378932349f5620", - "cleanup_receipt_sha256": "471f74bd9498b31888a1ec333c7d225af618fe9a072dd2952587bb50bcd6a170", + "cleanup_absence_proof_sha256": "1bcc8b374768c067cecc0c817d1b424a1823529f712ced903d54b8963338c37c", + "cleanup_receipt_sha256": "08fcec4f61b57e84172aa5e0c0780487ef97b93bdac4801f3f5fdefd8419802c", "completed_at": "2026-08-18T11:14:00Z", "condition": "verifier-unavailable", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", "execution_outcome": "halted", "failure_class": "safe_halt", - "fault_receipt_sha256": "4b3a4b3c9eca7b6cc75e95ac329d8825b3caa30aa49f425d714f2409a566485f", - "observer_receipt_sha256": "be295e21b91bb577b764151cd66a1a1aaf4302809b9a52766361d108611afe74", + "fault_receipt_sha256": "9ecd01ee39fd20d52a6ac0015f2d41508e79bdae57d936cbadc31dddf3f9a1a6", + "observer_receipt_sha256": "cc5c198782b833eac26154a61cbae483021dd950daa665f0e9633a57ee14931b", "oracle_verdict": "satisfied", - "replay_report_sha256": "9ff950e9dfd77d6c9e04fba2111f9e49115c2bb248ba26e3441a76a60d07eb18", + "replay_report_sha256": "2e9cd2761799c0bf0feef8b9bba65cfb1b5f888d314a2663a33d49cae4834122", "run_id_sha256": "87014cd8063f5a43ea22c995be03ec41ef5aa613145acacdef71b68c468fc8f1", - "runner_receipt_sha256": "8c5e9d5c0d5330e70eceb4a7a0b11295161a7f4ca9ad6c8af091fde8afb1c6a9", + "runner_receipt_sha256": "b69c63d7548ba4bcd6870077e4a5baedd402af5d7528845cfb9187913a26e46c", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "schema_version": "openadapt.qualification-trial-row/v1", + "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T11:13:00Z", "task": "execute-acceptance", "trial_index": 3, - "webhook_receipt_sha256": "b881269a603f7e323a56c17fd2d2f6db9e20485ee7687ece93f22aa12b7ea69d", + "webhook_receipt_sha256": "3f720f6c3da1e29759c17b9ff24984dbbf64bf8aeed6f8d0d33777b54f65498f", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } ] @@ -666,78 +715,85 @@ "required_trials": 3, "trials": [ { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "73a097b8b20bab7794369384f7ca1d7d711aad07967b7e1292373babbb7ff1b7", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "e4a4e9961ad6f679f61438dfadc80c1c45d213a25e9a508d1f3008fc2c652f9e", - "cleanup_receipt_sha256": "1d0d33cddb33f11719b645321ab4b811110a7dda9dada423fce56eef9337f6b9", + "cleanup_absence_proof_sha256": "c48a078a0d240e39cf8193c9c14a3719048553cf39278f3d0656aaa1caccd55f", + "cleanup_receipt_sha256": "0c1c0a6fd5f726600fcadfc64d5a34e027d4b36d00382877d841b3261360f336", "completed_at": "2026-08-18T11:22:00Z", "condition": "weak-effect-only", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", "execution_outcome": "halted", "failure_class": "safe_halt", - "fault_receipt_sha256": "07e68326931f9e91b6195accd0a81480662998a9e6fcba52c3348fe00448d206", - "observer_receipt_sha256": "caf4bdd8d724820689f50a52d92a1280fbc90215c7b12991b3681541fd8c2206", + "fault_receipt_sha256": "fe7e801fb8e3d5bfbe488815493a91fbf89f99a730cc2544e841f5373b49782d", + "observer_receipt_sha256": "399969b28d2a8a4508e5aba7deeb80a5d10271732c45ec8b771afca68c5019c2", "oracle_verdict": "satisfied", - "replay_report_sha256": "8dd51f7605352784d26b1cc7c77746ebfd297d51b90a2953f7282228bbaf7591", + "replay_report_sha256": "9c2d9af1bfda87a93cd19e5f83962d6c0332255f487fd35b5a494468cee86b32", "run_id_sha256": "b44783e70a980ec5b3cf3752bd5d1d01b2ff29f5a6892cba0c1c939d8aeb7c02", - "runner_receipt_sha256": "6e3b9d04b81cf54fb150be35e2d27acdd45247573f0a933e42cca67796427eb5", + "runner_receipt_sha256": "8a046aaef8eff4fe4e86a69ef8ef2c0b035131876b0628a7fd6258cc34f1976b", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "schema_version": "openadapt.qualification-trial-row/v1", + "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T11:21:00Z", "task": "execute-acceptance", "trial_index": 1, - "webhook_receipt_sha256": "ce56478b940c828f034cfd1c6ebc41185771a3154a621076db6d36a4d706b413", + "webhook_receipt_sha256": "f3f0ca82ea31420f48cdc9b1c4cf01adf4e929df1a1b0a54506b4ab4a782de8e", "workflow_version_id": "44444444-4444-4444-8444-444444444444" }, { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "eb52fb1b1bf2fac92d8f3a444bb5081161be8b3d0ef457c5065e7b79e96df770", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "acbcfae15099ebc8a2d63b87be87a0431e560968cb06899ee82754ccecec1b9f", - "cleanup_receipt_sha256": "ed82b83288101e083452346de7469ed7b1fd050e29e6bafac2e7691a37a8992b", + "cleanup_absence_proof_sha256": "0cef130f26153da53089908b85e93a0d3d471c44d0216fabfc4beff90f62bb69", + "cleanup_receipt_sha256": "5cfada7a9502dc0499d3b9d2ab92a6ad84e6b2a5b1298a05e006fdac34e9fbb5", "completed_at": "2026-08-18T11:23:00Z", "condition": "weak-effect-only", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", "execution_outcome": "halted", "failure_class": "safe_halt", - "fault_receipt_sha256": "418572792d67d3158bae6f0ab06a3c5e6aac3b56333c28fd7e00bf7452be9c0b", - "observer_receipt_sha256": "b92631c4736c084b0a8f01f7dee8d27672b7cffab352fca684f025b0e9f66b02", + "fault_receipt_sha256": "f415d84e6709d0d41f1a9df63018d95b34554defd6ca273b9ae24fb389b0d675", + "observer_receipt_sha256": "960800964e484e67a3e76cdcc336b8b620f46d64b6fce87bdd6475c66097416c", "oracle_verdict": "satisfied", - "replay_report_sha256": "5702bcf5ba24d9f8ff0df4cc5fd89d67a89b385d7de2d45101840a56f183003a", + "replay_report_sha256": "97d0bac2c04b176b3a168f9692a80308b7a473fe021aa8e3936ba660c7425eab", "run_id_sha256": "794033f9da2a42448254a478fb6de954898b1e544148708ad30264efdc255431", - "runner_receipt_sha256": "9360f101c663dba041ccc6d4531e5d0924cc0f4425f62aa51e3b90b145d93adf", + "runner_receipt_sha256": "36112ed5002c4c5621bcfe60eb7e41873051625d844ff153a403684b410467a7", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "schema_version": "openadapt.qualification-trial-row/v1", + "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T11:22:00Z", "task": "execute-acceptance", "trial_index": 2, - "webhook_receipt_sha256": "8e671061a2ed724aebae4da714f8342c7aa1156a8151018c4cd45e8ea2b13a4e", + "webhook_receipt_sha256": "4f32c6974bf19b3fcf9871beed963b99ec03ac9347a55059e9f5451333cb5b50", "workflow_version_id": "44444444-4444-4444-8444-444444444444" }, { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "aa7d6be4f25a8992c0a22649ba7e703d6955abf5fece9f8322f560149cf09776", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "b8f596a87c49f45f75a055ed31e6c86f591fefd2cda6c1778bdd3212b4175e0b", - "cleanup_receipt_sha256": "c1d15f47a1fad41c545fa9c0c26422c179518fea0841d1f3551ab1070a4669d9", + "cleanup_absence_proof_sha256": "b33cd0b3700716aed5d44075b7e26be191c809331d4cd3e25212c307e43655e5", + "cleanup_receipt_sha256": "26c7adab527c721616e340b24605509062c669f64c41ec24cc5041f32bad0bfc", "completed_at": "2026-08-18T11:24:00Z", "condition": "weak-effect-only", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", "execution_outcome": "halted", "failure_class": "safe_halt", - "fault_receipt_sha256": "bfdd995c0709fd95a59fd044664d11d88fc4d51b2df6b3525c384df39504e087", - "observer_receipt_sha256": "4157e3e1e661cb3eb666347e1777e7a0f91db0beded1a3894b9bba5d60b8d7b8", + "fault_receipt_sha256": "1d7c6883d52086c9398b6bd05b4b95dbd7d764e1e0291eb8f7ac0311ec8e4daa", + "observer_receipt_sha256": "e326380f27a42e658689cce26a59cdfb4867f512ba7016355487954a99eeaebe", "oracle_verdict": "satisfied", - "replay_report_sha256": "09ce45437a9d439b6fad70b045da259bdb7d96b2ca71035bcaf3036ee641e7a2", + "replay_report_sha256": "369bbe15a24b28d16d87482480bed7ee9b4ab2cedef0a051a930e3f95ec39a1a", "run_id_sha256": "b974de9da8ef77c8dc9a7662114cc51023ab8c131c488681eeebb7d4c435c8d0", - "runner_receipt_sha256": "745ccd149ea968ca38642bd362a867a92243f9a556b8653b2be088f0fa636a36", + "runner_receipt_sha256": "4938c27207a78a9be3803dd7c6889dcba7f8be5af7ed4adc9cb6193dc1364b4f", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "schema_version": "openadapt.qualification-trial-row/v1", + "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T11:23:00Z", "task": "execute-acceptance", "trial_index": 3, - "webhook_receipt_sha256": "d5ec8f549f8730997d735287bc83fa1d1e008de2960d14ebcbb4b140ff1fdd8a", + "webhook_receipt_sha256": "6ce64d58e69df317d74e94e480a3952ba89133053a77da3f7fcbb51e22da53ce", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } ] } ], "decision": "admitted", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", "excluded_trials": [], "generated_at": "2026-08-18T11:55:00Z", "invariants": [ @@ -873,219 +929,277 @@ "task_id": "execute-acceptance" }, "receipt_envelopes": { - "00acd7fd6d1a4eb625a7d16057f94ceb1da3f8a05f8cb6f07a83d760c8f778af": { + "0009aee64285ed2cb340ab6c8923ebd0a9f3603db3cbe1bf8e593bdea6aa22a3": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "LMblyrBXpBlSsZ1dnFJOd4ebFoyEYxR/iOLJH0vy2/jwZXolCI34J0aEN4766Lnw6Ekcm6dNBc/XlnoXL81zAg==", - "source_artifact_sha256": "ddb254eb6e2490fcb9e2b2952775ac00220ba9a95a70f4f784bec71ab5df37b7", - "verified_at": "2026-08-18T11:02:00Z", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "eAesV1L/oMvhDVq81dZ+zhHVFs4oPhHVG/qq+ynwgM2m6J8xoW1Kzntbzl34n3G2GqCpawJ1HCPG1NzGiTEnBw==", + "source_artifact_sha256": "f48ec4e4f6e1af9e9a55730fef4ff0bc364683d1c08d1e0399281699f0f49444", + "verified_at": "2026-08-18T10:04:00Z", "verified_projection": { - "attempt_id_sha256": "60ee9db05b1126cfaa3b31c13bc3fab4755ac09c44e846b4d07ee51865dfa7b1", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "4c352a6999f77707e8837adebb4fc2b7451c2ef6de5145190b33a5c5645e47eb", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "ambiguous-target", - "evidence_sha256": "ddb254eb6e2490fcb9e2b2952775ac00220ba9a95a70f4f784bec71ab5df37b7", - "run_id_sha256": "628f991a182613b8700294d7483b5a4c06872cb9d5ca6047ea552b8ab6585357", + "condition": "healthy-01", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "f48ec4e4f6e1af9e9a55730fef4ff0bc364683d1c08d1e0399281699f0f49444", + "facts": {}, + "run_id_sha256": "4ee2bb61fb883cc8e77d636fb471aa3c0ce9ef0c0a8abd9682214bf0a8f16f26", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, - "verdict": "halted", + "trial_index": 3, + "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "020265c9483aadd4321f39f4bd35ad152b53d5fcebc96c044fa1d84ea860e614": { + "01e0e1e9f8d50d08a1e6a52833cbfb490ad0541a2b67b47528ff6d0fcd4a0219": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "Q1BchDcNoIt/q1AI8/kcaTsDSvmhOfwobkBlhOzz0B8UJvr9/kZX04v5SpoFPYtCSgnpQgEsrcKD6vq58uzMCA==", - "source_artifact_sha256": "67d2fc6cdd3fbe39ae3cd6003edb1e7069940afea7f0c3b00794713d26646677", - "verified_at": "2026-08-18T10:13:00Z", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "uzBk9CFlcVbRcHw8+13Rp5JbscF4T0yRP26uRSfOGFfC+PZ60fwohtms6jofcKeR9iYH0xfe2PsB/TA9NMQWAg==", + "source_artifact_sha256": "f0e1b62eb7c877e3b75f5be31a69021e88bedc4ccfd95d69395483193bb5669f", + "verified_at": "2026-08-18T10:44:00Z", "verified_projection": { - "attempt_id_sha256": "3d42601a69ef46cc44f57b51762affef4ccd829ffde30125619a6e582af00dab", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "7c910764b2dcc6f05261d609082f75474e4638c3f356006307212b8fed4a2eb7", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-02", - "evidence_sha256": "67d2fc6cdd3fbe39ae3cd6003edb1e7069940afea7f0c3b00794713d26646677", - "run_id_sha256": "091e13ed70dab439b31cb506cf3bba1ddf6476696531cf891c39a924a928b7a1", + "condition": "wrong-reference", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "f0e1b62eb7c877e3b75f5be31a69021e88bedc4ccfd95d69395483193bb5669f", + "facts": {}, + "run_id_sha256": "fe98ce7f0e66b885201f4667875fd38f5890ffddb575d68bd4cd5a66f8d53ca8", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "delivered", + "trial_index": 3, + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "033d48209efa84280e3035d72ed0627a27cb43d45f6e05d277e23f164f345472": { + "0559c67e2109bea9b527eaaeef98992c12c687c01e8906dec8a87d24c626e792": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "2Ln6s7qumx+7m23Z7tPsryQImLX6b08yq/F6zdTmAtk/iM7AjHR8ZhQX34Ogzdv4ySmg798cZDH4A/2cEUR8Aw==", - "source_artifact_sha256": "5774a782f9ec582ec3f9a710ccfee0a6b3fd6076d73029b33889cbb99d0526ed", - "verified_at": "2026-08-18T10:14:00Z", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "4+DyP3Ag/eh/m59/mSZaCzzzRf7Mr7d+Fbk5Wd7Mxw3T7TPP/17Y+dv2X3ObHQp7DhpenzH7j7YgbKBuP4h/Bw==", + "source_artifact_sha256": "009c1c1e67709868ad5218f72fe47f2fe26660be981c32e064da92de8bc4e85e", + "verified_at": "2026-08-18T10:22:00Z", "verified_projection": { - "attempt_id_sha256": "019dd96e9a771ccc01ebafab321d7d3a8314df8b2d6465bcfc5fa14cbdeabdf2", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "fc097c8b2e6ece94544a19b8d81f5c4a9367a89059e3dd4b2f746ab06a2fc930", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-02", - "evidence_sha256": "5774a782f9ec582ec3f9a710ccfee0a6b3fd6076d73029b33889cbb99d0526ed", - "run_id_sha256": "16cb8df40654c6a1b55ea0e50e772d8c6e6d4f0d8205bd1f8296be27d0af83eb", + "condition": "healthy-03", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "009c1c1e67709868ad5218f72fe47f2fe26660be981c32e064da92de8bc4e85e", + "facts": { + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "009c1c1e67709868ad5218f72fe47f2fe26660be981c32e064da92de8bc4e85e", + "source": "runner_signed_flow_report_and_enforced_egress_policy" + }, + "operator_intervention_ids_sha256": [] + }, + "run_id_sha256": "28768f565659133f5bf1170e638b81de4d7ca38dfecacd09ccf462a35344432b", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "delivered", + "trial_index": 1, + "verdict": "verified", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "0668d3958131859deae05b675b6859b48e043adf1443d21f19a6bfc1c6bbc6ad": { + "061a034a55abba5d6d8a4b22dbf24c70b016b7c1b06fc24b9fece9a3b1e0c933": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "QVlHQ3lNpxMZpMo6bIwVS5yHtk0E2xEhTZtjU/jjDFrRDzSlp8ZYfxj2pVMQyUKnfsojmgO0L1QhMX8PyNmcDw==", - "source_artifact_sha256": "f48ec4e4f6e1af9e9a55730fef4ff0bc364683d1c08d1e0399281699f0f49444", - "verified_at": "2026-08-18T10:04:00Z", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "VupDb7mixihZzBE0zHONmTR5NTx9LjV+j2LqWzM/d8ljO15wAaKOKiUHP5OgHhKWyqKAiLHgMIponzkJoexzCA==", + "source_artifact_sha256": "3a27387e7fb8b622f0150b1da9c81b97bbbf046c3e6be1dd3360f203fb460925", + "verified_at": "2026-08-18T10:42:00Z", "verified_projection": { - "attempt_id_sha256": "4c352a6999f77707e8837adebb4fc2b7451c2ef6de5145190b33a5c5645e47eb", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "e93521e706ad90d799dcd4e8cac15229c5da6aec1638540606f5fab4efce59fc", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-01", - "evidence_sha256": "f48ec4e4f6e1af9e9a55730fef4ff0bc364683d1c08d1e0399281699f0f49444", - "run_id_sha256": "4ee2bb61fb883cc8e77d636fb471aa3c0ce9ef0c0a8abd9682214bf0a8f16f26", + "condition": "wrong-reference", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "3a27387e7fb8b622f0150b1da9c81b97bbbf046c3e6be1dd3360f203fb460925", + "facts": {}, + "run_id_sha256": "ee82112f55e5e6c86cfd6e16df8c8b652549a8bd72de492f435d8255eb3dd252", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "absent", + "trial_index": 1, + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "07e68326931f9e91b6195accd0a81480662998a9e6fcba52c3348fe00448d206": { + "06483a5a3def1a0eb09b1623870f68ef9ef1f5c923d10e220b4acbbecd3a0ff8": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", - "receipt_type": "fault", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "JX8ih23WEk+kiDCrQWjmcrQ4qo6ObAC77x0DZ0dnHcpZPwLKimhE2rqvZvuaFeNnruPSaLiGJw+GYZ8MdoyDAg==", - "source_artifact_sha256": "753ac5d5256a729ac572debdef63e5a8acd11b2b6ef909f8efb94d885f37d065", - "verified_at": "2026-08-18T11:22:00Z", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "P23MElFH0hSlJtDj0f1otOGpVLSz3LU4tby5nKKneBkUmLvo0rViAJtwwIzxR9mnm8ElTtW1O1/x07BJ1RmlAw==", + "source_artifact_sha256": "c99ff9e16fc08dfa2947c8baa3cd32d837e5e3c19ebbf6ce751821e33ee578f5", + "verified_at": "2026-08-18T10:42:00Z", "verified_projection": { - "attempt_id_sha256": "73a097b8b20bab7794369384f7ca1d7d711aad07967b7e1292373babbb7ff1b7", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "e93521e706ad90d799dcd4e8cac15229c5da6aec1638540606f5fab4efce59fc", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "weak-effect-only", - "evidence_sha256": "753ac5d5256a729ac572debdef63e5a8acd11b2b6ef909f8efb94d885f37d065", - "run_id_sha256": "b44783e70a980ec5b3cf3752bd5d1d01b2ff29f5a6892cba0c1c939d8aeb7c02", + "condition": "wrong-reference", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "c99ff9e16fc08dfa2947c8baa3cd32d837e5e3c19ebbf6ce751821e33ee578f5", + "facts": {}, + "run_id_sha256": "ee82112f55e5e6c86cfd6e16df8c8b652549a8bd72de492f435d8255eb3dd252", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, - "verdict": "injected", + "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "09ce45437a9d439b6fad70b045da259bdb7d96b2ca71035bcaf3036ee641e7a2": { + "08fcec4f61b57e84172aa5e0c0780487ef97b93bdac4801f3f5fdefd8419802c": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "TSq6weZF/VyML5H6sli/Q82n4wniZ0ZUaGTWeDyhRV1GB5e7fhf/QL4YMlruVSIHk7PMOEeeJPnZMcCvgj/WBw==", - "source_artifact_sha256": "65140882628aea7d2f64f788fcf9fcb6addfd372449a58a0221ac27b0355af3f", - "verified_at": "2026-08-18T11:24:00Z", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "ubGCmrju+BqItO33xCWn1cDZzFMJtwL16l9d4fyLF0VQ/8OPTujGdY4/H7HzBxg5INTFZKv45i3lP+tQM1KKAQ==", + "source_artifact_sha256": "a28ad5edfe12f8c387974db36928b3aa5aa2bded20b70ce40baeea09eb16b8e1", + "verified_at": "2026-08-18T11:14:00Z", "verified_projection": { - "attempt_id_sha256": "aa7d6be4f25a8992c0a22649ba7e703d6955abf5fece9f8322f560149cf09776", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "ad76dacfe19a4421ef1f128d4eef1099e846b385d29f17b8588ae5130b487118", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "weak-effect-only", - "evidence_sha256": "65140882628aea7d2f64f788fcf9fcb6addfd372449a58a0221ac27b0355af3f", - "run_id_sha256": "b974de9da8ef77c8dc9a7662114cc51023ab8c131c488681eeebb7d4c435c8d0", + "condition": "verifier-unavailable", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "a28ad5edfe12f8c387974db36928b3aa5aa2bded20b70ce40baeea09eb16b8e1", + "facts": {}, + "run_id_sha256": "87014cd8063f5a43ea22c995be03ec41ef5aa613145acacdef71b68c468fc8f1", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, - "verdict": "halted", + "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "0b0efbd1f00044f8f2fb8e1107723509061a4ad86a0eb9118c551ef806212465": { + "0a5102012076aadf70baee8581543ac04d061241192f1ca3c0b12eb6e31473f0": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "WbJMIMWV2FTF/08CK5Mfi8faZ79UNKEQ4nmJodLIZp63mocDufdIMszb3cTSwS/0IQZmT5mfFGvmSqJuA5FnBg==", - "source_artifact_sha256": "ce91f56ef05d03386741ded56d7c2728b371c0ffcd8dc025c0dcad239242f6d5", - "verified_at": "2026-08-18T10:53:00Z", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "ZfZyk+k5pryV9IMoHkc3e4tPICZvuMHLoqHzcvC0IyR030i2wXlAtmHehdsBL0H4XUfAoXJaqFyzbkyPjNNkCA==", + "source_artifact_sha256": "40933d309a18fba8094517dfd195dd4feea0486e031db26f66ff09699477bda9", + "verified_at": "2026-08-18T10:12:00Z", "verified_projection": { - "attempt_id_sha256": "f5df4d6e64a2d38ffa8e320c87ad05d04025de267a8e152a755d3f1928ded120", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "940d3ca125ff87ce7539740fbae29d2d64fec839328b0639127e1d197d2485d8", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "stale-session", - "evidence_sha256": "ce91f56ef05d03386741ded56d7c2728b371c0ffcd8dc025c0dcad239242f6d5", - "run_id_sha256": "fd3a041b705d8c6277ce26134dc0018e866218cfa3fadd16ac29d1ad498965a3", + "condition": "healthy-02", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "40933d309a18fba8094517dfd195dd4feea0486e031db26f66ff09699477bda9", + "facts": { + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "40933d309a18fba8094517dfd195dd4feea0486e031db26f66ff09699477bda9", + "source": "runner_signed_flow_report_and_enforced_egress_policy" + }, + "operator_intervention_ids_sha256": [] + }, + "run_id_sha256": "bbb9312ce4682b23580eced0f8d19438d8266b222555df85fb27eef22ad5afe2", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "delivered", + "trial_index": 1, + "verdict": "verified", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "0d4542a41deb0cb2b3f9291f4067d2fe88924884c6efcd742b85f7504d2840eb": { + "0b700db3525db248fddd3cde06607a194c809c76d5cece6a56745202ff8f707b": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", "receipt_type": "webhook", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "SHkE4txHMopCdNVErTNV9kaeiiRiXro93k9n0ySd9eRkxgoN00CCB/6RXOBInVNt5LOpAY/fZRXGmWXoPn7ODw==", - "source_artifact_sha256": "2c464c80d9d0976e30c3c1b674426f3db967a0264e7bb8ee48984e6b235a5a80", - "verified_at": "2026-08-18T10:44:00Z", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "Ls87poqS/6vCPEhXkuYt70u/cpJZ41GuXtjbanB+woIE/wM+/gtVT2kiiG3MjCMDIp/CSF19zgliiFICzcStBQ==", + "source_artifact_sha256": "5d0a6686e8f1d277c080d35d24db5e2f371ce4a69ee7b9d275d63a34af50f9d2", + "verified_at": "2026-08-18T11:03:00Z", "verified_projection": { - "attempt_id_sha256": "7c910764b2dcc6f05261d609082f75474e4638c3f356006307212b8fed4a2eb7", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "1ec11a9862ede3ac701af71835ac28c551d604a026b5bab7d776dbcdf288394e", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "wrong-reference", - "evidence_sha256": "2c464c80d9d0976e30c3c1b674426f3db967a0264e7bb8ee48984e6b235a5a80", - "run_id_sha256": "fe98ce7f0e66b885201f4667875fd38f5890ffddb575d68bd4cd5a66f8d53ca8", + "condition": "ambiguous-target", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "5d0a6686e8f1d277c080d35d24db5e2f371ce4a69ee7b9d275d63a34af50f9d2", + "facts": {}, + "run_id_sha256": "43f0a1c00950c390b0676fab55a2aa98c354d028f2347c461661e6cdb72f717e", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, + "trial_index": 2, "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "0da9d385b5d1c9805b8bccc2598fd48e59365ca8b14f37dc943b7b12777850c4": { + "0c1c0a6fd5f726600fcadfc64d5a34e027d4b36d00382877d841b3261360f336": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "aacNxYSnrwOQg/qSzfnZasKVwZPdJYxAcGKxJ+mqNRhCshjqmMeUYryjkCItQvi1cZ05MHD9Tms0TZKCqt9MDQ==", - "source_artifact_sha256": "5d0a6686e8f1d277c080d35d24db5e2f371ce4a69ee7b9d275d63a34af50f9d2", - "verified_at": "2026-08-18T11:03:00Z", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "qFi27q/tG+6eQ5Wne2mAcozWt2qs+pb34zk9APKkz0sFTwwS7T9stnX/Yp/I2/xyBS5d9AKoY83dowR7ZmWRCQ==", + "source_artifact_sha256": "82558495613e411f7ace5490f50e22b445058f1f1d0661f39959e3fa8d25a742", + "verified_at": "2026-08-18T11:22:00Z", "verified_projection": { - "attempt_id_sha256": "1ec11a9862ede3ac701af71835ac28c551d604a026b5bab7d776dbcdf288394e", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "73a097b8b20bab7794369384f7ca1d7d711aad07967b7e1292373babbb7ff1b7", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "ambiguous-target", - "evidence_sha256": "5d0a6686e8f1d277c080d35d24db5e2f371ce4a69ee7b9d275d63a34af50f9d2", - "run_id_sha256": "43f0a1c00950c390b0676fab55a2aa98c354d028f2347c461661e6cdb72f717e", + "condition": "weak-effect-only", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "82558495613e411f7ace5490f50e22b445058f1f1d0661f39959e3fa8d25a742", + "facts": {}, + "run_id_sha256": "b44783e70a980ec5b3cf3752bd5d1d01b2ff29f5a6892cba0c1c939d8aeb7c02", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "delivered", + "trial_index": 1, + "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "0f5b6ed8cfa03ef7f89f57a9a07926cd8fd9183b69e720ab914196b5fe9cdcd3": { + "0cef130f26153da53089908b85e93a0d3d471c44d0216fabfc4beff90f62bb69": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-d92d542a589844dd", "receipt_type": "cleanup_absence", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "rBFZeakz1mFX63iIkkopZGvzPPA+L7k8bIX0Z6sn+Iidkm9H/1D2ei2i2fk+ZGV3UxRuaKhXwEXwksU0GLTwAw==", - "source_artifact_sha256": "2a7ccbc187c0627ad574c752f1aea534e5f283859d8b8e6fcdeaad3e603d4386", - "verified_at": "2026-08-18T10:53:00Z", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "iIfiSNLkUzbK8soZC45T6XItwUvuI/zRqPhCuPLBIZQ/QB4v4Nrl9x/9RgPj0pmlUX6M2xn/dn3v1YADJi4nCA==", + "source_artifact_sha256": "5b97c09965f50b433ebd2e38459a56f0ae35537b2267b3e89faf7125ea0c2e25", + "verified_at": "2026-08-18T11:23:00Z", "verified_projection": { - "attempt_id_sha256": "f5df4d6e64a2d38ffa8e320c87ad05d04025de267a8e152a755d3f1928ded120", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "eb52fb1b1bf2fac92d8f3a444bb5081161be8b3d0ef457c5065e7b79e96df770", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "stale-session", - "evidence_sha256": "2a7ccbc187c0627ad574c752f1aea534e5f283859d8b8e6fcdeaad3e603d4386", - "run_id_sha256": "fd3a041b705d8c6277ce26134dc0018e866218cfa3fadd16ac29d1ad498965a3", + "condition": "weak-effect-only", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "5b97c09965f50b433ebd2e38459a56f0ae35537b2267b3e89faf7125ea0c2e25", + "facts": {}, + "run_id_sha256": "794033f9da2a42448254a478fb6de954898b1e544148708ad30264efdc255431", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, @@ -1093,702 +1207,1095 @@ "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "0fb52130820a183fa318c24dd0e504f3505ca28f32a98d6fee032f6b19642a37": { + "0eb5ab24ba6f40dd5d6e9c060f3a241672cde509dc3483dda42ef27fd76ff9cf": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", - "receipt_type": "fault", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "vtYYZnGtKbMNJ9fFrKNe5WTwWkTZSMg9Bi3niOzeekG+AuN6MDzCeRZaNtwIjgod3Mf82ssJykUvGhb4V+JCAg==", - "source_artifact_sha256": "ac34c209ded7d003e6d99a60a52adc51e65926a708df1a94834a196ba9fe9812", - "verified_at": "2026-08-18T11:04:00Z", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "yoNzlruvZrZuOZQudl686kxk6H7Z1ns+cm/wFdsdrrOlnxpvfqYawUVw0ffY4EUKgtGgud6GB3XdKB3+rvOxDA==", + "source_artifact_sha256": "32974d92bebc7e4e4d26c3f6df9b0cd6dfb4e7f0f23baa1df91fa850acf666da", + "verified_at": "2026-08-18T10:54:00Z", "verified_projection": { - "attempt_id_sha256": "491a544656d05aea37920e5c7e2ad65a9452eac8d6e100268a599aeebd41187a", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "958342a9ddca98a83b82b662f52f404239d583afe7ed70634760e1b8dd592f3b", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "ambiguous-target", - "evidence_sha256": "ac34c209ded7d003e6d99a60a52adc51e65926a708df1a94834a196ba9fe9812", - "run_id_sha256": "aa62c7a17701a7ef01ea1d3519b4c1f90d357495b329fdda3054cc24c581a593", + "condition": "stale-session", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "32974d92bebc7e4e4d26c3f6df9b0cd6dfb4e7f0f23baa1df91fa850acf666da", + "facts": {}, + "run_id_sha256": "6f2fb10bc2018c9f78e9702d5ccac0bedd78ee3b2e9d2a6ad779fba72d90ae50", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, - "verdict": "injected", + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "10b9c9e23bb12807fe3446fa41b66ecc1df3f7720d4a6bd018243668a85afb14": { + "11c3e276c44dd5d91dc79a7c94803e2ee06ae40712905927af21104098792fd4": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d7e1e084be213b01", - "receipt_type": "observer", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "aIMQzdfObDxf8qbsmG4vg+SbXYAxEy3KNp2eB/OQQbxrzan6+P/0HLq2iJu50q4gK99++FVD3+S5JbgZU4vNCw==", - "source_artifact_sha256": "79805e89b0f4e3d696c11dc8e97714ea0bcdca545f81356e0ed760612fe2925e", - "verified_at": "2026-08-18T10:44:00Z", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "IcBi+2cC5wWAQpga/nxgljX7LdsVO6MZnXQP5OqOYkaEL9A/bLS7+luQJqPYhkFR7kjgSddCTCvidC5qMtVcAg==", + "source_artifact_sha256": "5715c0e7be0a23b342d074947567c9aab924b43b2318265f28013a0d5715506f", + "verified_at": "2026-08-18T10:34:00Z", "verified_projection": { - "attempt_id_sha256": "7c910764b2dcc6f05261d609082f75474e4638c3f356006307212b8fed4a2eb7", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "3aee8ad755c7f4bec71cc194bcfaa805e0ea29cf8b830ed0782f8263dd9620ca", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "wrong-reference", - "evidence_sha256": "79805e89b0f4e3d696c11dc8e97714ea0bcdca545f81356e0ed760612fe2925e", - "run_id_sha256": "fe98ce7f0e66b885201f4667875fd38f5890ffddb575d68bd4cd5a66f8d53ca8", + "condition": "idempotency-replay", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "5715c0e7be0a23b342d074947567c9aab924b43b2318265f28013a0d5715506f", + "facts": {}, + "run_id_sha256": "3df83453126754a62d00ed10837720542d0469799bb8a88cb5257ac5f477a919", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, - "verdict": "satisfied", + "verdict": "verified", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "11b317991d7ac80a31d423d73f9b0312af2f7e53eeda77e640a524650611e77d": { + "14233009f4f65cd0a0fa81a233f4d0cc48d7f6c9b8d6f9ef8e2c12b8593047d3": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "I9I79mduZDb/0J6CwDHe44yGtgblTcivYpxTkuYPIdgHFMI2GxolF0WiF89GWysDQ6jxUshMgeCHNzf8xPXTAw==", - "source_artifact_sha256": "19c8e4a8e4ef48302a4600b8bf8bd600dbffa7e3b33c7ac91fa693b98487bdf2", - "verified_at": "2026-08-18T11:04:00Z", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "Jbs5uOzZ/Rmlro77e7WWF8+rzwA0z/PTbMzYL177PqSHLdiT3ErvDumkwZhUECVtGMnfhw/YxvDhXKVZbGwOAA==", + "source_artifact_sha256": "ce0aa45ff0449ef101823a15d86eaad2e81cfaedb64c35017e27146adae0a845", + "verified_at": "2026-08-18T10:43:00Z", "verified_projection": { - "attempt_id_sha256": "491a544656d05aea37920e5c7e2ad65a9452eac8d6e100268a599aeebd41187a", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "6b0e5c10d55fc92c1ff8576392270a24fb65722414cf58ff9a51b8ce9ef88587", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "ambiguous-target", - "evidence_sha256": "19c8e4a8e4ef48302a4600b8bf8bd600dbffa7e3b33c7ac91fa693b98487bdf2", - "run_id_sha256": "aa62c7a17701a7ef01ea1d3519b4c1f90d357495b329fdda3054cc24c581a593", + "condition": "wrong-reference", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "ce0aa45ff0449ef101823a15d86eaad2e81cfaedb64c35017e27146adae0a845", + "facts": {}, + "run_id_sha256": "577e37b10b1c87fd9c1b5d320888b736d272824657fd59a012e85a284ee88540", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "delivered", + "trial_index": 2, + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "156f5af975f0f574aa73e2f8f296304d6b7ca1fb389d20bf1dbd571935d491e0": { + "1618244896b44c013eeedf931ce4d2ad0899fed5c9ed7f6812c9d17d62003c6b": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "pYp33Ulh35O+DQu5uE3GOcH7aVXu6tXCbCGJf242fvVwBkbqr9Ci3APYOJXGVUnVB3EQjbSD0vLTvsN6QrVcAQ==", - "source_artifact_sha256": "c2fe1abfc1e16a5382ce8eaf67f3774f713d586e6aefe6a00783455dceae530d", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "xnpvMNsYFBJQtrtL9RpBfZ/3SQNgiLDiRcAaGipAJ1IpnoeYxzI/siRUyZnN4akE7Gjp4ucYvIUELcH5leiBCg==", + "source_artifact_sha256": "738fb82696e36887119e66c49386fc345003080f8417dcd4157684ca9a820236", "verified_at": "2026-08-18T10:02:00Z", "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "679af5a8dedceb8c696719e73f82a698c230cd8fc98bb61769f0883202c0b637", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "healthy-01", - "evidence_sha256": "c2fe1abfc1e16a5382ce8eaf67f3774f713d586e6aefe6a00783455dceae530d", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "738fb82696e36887119e66c49386fc345003080f8417dcd4157684ca9a820236", + "facts": {}, "run_id_sha256": "0b5bda916a0808165159166955a9563cf9c2303949f762a18eb037f41b44a6dc", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, - "verdict": "verified", + "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "1674de43590311145df8c1149ad40d4f1f154497536cd3f86547d117b005aced": { + "18343a300dbb47883fd932d0819e5b92aeaa6ad60dfa82ee8b66c6ac3190fbed": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-138dfa227234ea5f", - "receipt_type": "cleanup", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "AB/7kq6uEfr31Hs/DryyES7oCijEKxvIL/zH1DvHd4bZg8M7OG7TjqckO93bmSQNghrCp+tXEWZaWHK7JHS0CQ==", - "source_artifact_sha256": "e02b4733d09ac9c9e6e5d98ba7fc6645738e022e2f137f73feded4d27f3925e9", - "verified_at": "2026-08-18T10:02:00Z", - "verified_projection": { - "attempt_id_sha256": "679af5a8dedceb8c696719e73f82a698c230cd8fc98bb61769f0883202c0b637", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "xe9t7baJaylv9NfHEeOHOk7XMg00sUSLE1yCsyvnQz4QMyD8vlCCPuwgcwwPzJ/fXPM6l3o0JpZvxngBrtATBQ==", + "source_artifact_sha256": "5a34e35fec7ee614b3ae06606f9778a2e11d5c8b34ca4792f79b0fc127c7d95a", + "verified_at": "2026-08-18T10:24:00Z", + "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "7573925adbd8a7a4a3b98bb0379549d77aa8ed46e312c1cd940c05b8587a039e", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-01", - "evidence_sha256": "e02b4733d09ac9c9e6e5d98ba7fc6645738e022e2f137f73feded4d27f3925e9", - "run_id_sha256": "0b5bda916a0808165159166955a9563cf9c2303949f762a18eb037f41b44a6dc", + "condition": "healthy-03", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "5a34e35fec7ee614b3ae06606f9778a2e11d5c8b34ca4792f79b0fc127c7d95a", + "facts": { + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "5a34e35fec7ee614b3ae06606f9778a2e11d5c8b34ca4792f79b0fc127c7d95a", + "source": "runner_signed_flow_report_and_enforced_egress_policy" + }, + "operator_intervention_ids_sha256": [] + }, + "run_id_sha256": "784a0a94e581700a3d93581e7ce5bac0d3bc53c58f3e73198b896b5da9a819b0", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, - "verdict": "completed", + "trial_index": 3, + "verdict": "verified", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "1847925251f6ac7a782baf4a381494cc662ad60bf1c0f2f3eddaecbc86940c29": { + "1aeb42c46a7567c1fa5436e662dea85f649029f4a03e573907f477dab40e9653": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "jVxMp5yLKFZIsEou//d4qzyi4gIF732WiCzgSUXm/MAeqgHTM1lhvGunRmS3M538pZ9hMjNuyFbH4oHbsRBCAw==", - "source_artifact_sha256": "b181977448bfbd12d2ed392d09d1d8be4a7489c9f5214c80bf97e84b3f745b64", - "verified_at": "2026-08-18T10:52:00Z", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "hxkyv9f1hUelPtt7NLZjJSt83DkLBmpt4xOK+tJLbM7BcwJnpPvW8sKtrytu/gXlmh5w7XXOgAVUJTO/IGzlAA==", + "source_artifact_sha256": "8fd27141f1a8f201ab2aff52f1ba0273e506dc25a0fb7567513d140a1cc9a2fa", + "verified_at": "2026-08-18T11:04:00Z", "verified_projection": { - "attempt_id_sha256": "fbfce2be9ce964be8b668aa518a310fe4a89e5c014f42bd0ea81401bd83bfd7a", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "491a544656d05aea37920e5c7e2ad65a9452eac8d6e100268a599aeebd41187a", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "ambiguous-target", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "8fd27141f1a8f201ab2aff52f1ba0273e506dc25a0fb7567513d140a1cc9a2fa", + "facts": {}, + "run_id_sha256": "aa62c7a17701a7ef01ea1d3519b4c1f90d357495b329fdda3054cc24c581a593", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "halted", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "1bcc8b374768c067cecc0c817d1b424a1823529f712ced903d54b8963338c37c": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "PD5Jk4JeKjH6IPfx9Ug/yQGXC5/vHi5qXgy6ydMZ5w8JZnalW3M5IwLLcuhHkBTT9aJKJUQ6zYUTyLyhsHwBBA==", + "source_artifact_sha256": "05601e1e28046d813b5d1fc7fc6f90292c7397fe2bfacb1b27e302242c388659", + "verified_at": "2026-08-18T11:14:00Z", + "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "ad76dacfe19a4421ef1f128d4eef1099e846b385d29f17b8588ae5130b487118", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "verifier-unavailable", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "05601e1e28046d813b5d1fc7fc6f90292c7397fe2bfacb1b27e302242c388659", + "facts": {}, + "run_id_sha256": "87014cd8063f5a43ea22c995be03ec41ef5aa613145acacdef71b68c468fc8f1", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "absent", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "1ca68224ff7ed710e02c185155a819a937f0297aed33d249c351ae3145706b27": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "pShauyfgkXIlvB0KcrCyNEzFIdfEhA1zUE5/1IyckyNJrIp4Uo5wWmOrn+47P314kw9dkjDt66FUus5DmFM9DQ==", + "source_artifact_sha256": "2a7ccbc187c0627ad574c752f1aea534e5f283859d8b8e6fcdeaad3e603d4386", + "verified_at": "2026-08-18T10:53:00Z", + "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "f5df4d6e64a2d38ffa8e320c87ad05d04025de267a8e152a755d3f1928ded120", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "stale-session", - "evidence_sha256": "b181977448bfbd12d2ed392d09d1d8be4a7489c9f5214c80bf97e84b3f745b64", - "run_id_sha256": "d9270fd4c85e4226a9347ecf703e876b9ffdc330f60c7fb8bed8f9321ea30225", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "2a7ccbc187c0627ad574c752f1aea534e5f283859d8b8e6fcdeaad3e603d4386", + "facts": {}, + "run_id_sha256": "fd3a041b705d8c6277ce26134dc0018e866218cfa3fadd16ac29d1ad498965a3", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "absent", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "1cfb44a34276ac71b453562485ff70fb3b5f0c5d0718632601a8f05f62280cd5": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "MQ377O4rgsUrut6UmhAoOFI6/t2FWHj5tJbqZvufk01+zUeGKEQpcNg2iA41yYEsLI6ol70wczG20ROypBE7BQ==", + "source_artifact_sha256": "2939663aad44035d0e4b7f6c59580cd6d7589dc8db1f48abe2e60db3cef03a78", + "verified_at": "2026-08-18T10:32:00Z", + "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "3142933f4f168c98b8e89f2ae9d78fd3129e0a9975cbbaa60ddba853eee7d53c", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "idempotency-replay", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "2939663aad44035d0e4b7f6c59580cd6d7589dc8db1f48abe2e60db3cef03a78", + "facts": { + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "2939663aad44035d0e4b7f6c59580cd6d7589dc8db1f48abe2e60db3cef03a78", + "source": "runner_signed_flow_report_and_enforced_egress_policy" + }, + "operator_intervention_ids_sha256": [] + }, + "run_id_sha256": "6cdff0cf50d0164fe1eee9c4b7db0b969c24f9b960f5653b516313a913c90a0f", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, - "verdict": "delivered", + "verdict": "verified", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "1a219a5a11101378903c40163101018c2d55b6877d88cdb3b29d1116de3e952a": { + "1d7c6883d52086c9398b6bd05b4b95dbd7d764e1e0291eb8f7ac0311ec8e4daa": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-138dfa227234ea5f", - "receipt_type": "cleanup", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "QIFs7YGBp+EL4NoCkaliRkMlOeq/N8mWNf3SnsyiP5P8tL32UvJ6GNG7bgMQ1QpWY0y6gZCa8bUN2AK4gZQ2DQ==", - "source_artifact_sha256": "3edf91becb8c50a0a4c4769e60bfd13bf8bfc1727bb05e1737099caba33e651e", + "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", + "receipt_type": "fault", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "Dzqpo2gKDazjCQ88VMx5sYfSI2E65MTRf1Wak+aCF7n4vt9EP+aQurLXkTbg6RU6bLQXKb1sGNSAScAzcfxcCA==", + "source_artifact_sha256": "c483629c37faa74e65b11335e5d15e741a5a1d5a7af2f6a4757767a446b00a34", + "verified_at": "2026-08-18T11:24:00Z", + "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "aa7d6be4f25a8992c0a22649ba7e703d6955abf5fece9f8322f560149cf09776", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "weak-effect-only", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "c483629c37faa74e65b11335e5d15e741a5a1d5a7af2f6a4757767a446b00a34", + "facts": {}, + "run_id_sha256": "b974de9da8ef77c8dc9a7662114cc51023ab8c131c488681eeebb7d4c435c8d0", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "injected", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "1d8f4884ac384317209d4a4116a19a597a60f7483bacacc99a81adcd01c666c5": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "1Q8U2lCh/1+7HJORT52QfcAczQ0xzjR4rjQcT5CQ+LcJaZmog1eTxNK/1VNu2m6harvPJrU0/gbIEUwqtgf7Cg==", + "source_artifact_sha256": "7d36fcea2384b6bb28044bc68847492fefb2783909042a96f6416cc457c258c6", "verified_at": "2026-08-18T11:02:00Z", "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "60ee9db05b1126cfaa3b31c13bc3fab4755ac09c44e846b4d07ee51865dfa7b1", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "ambiguous-target", - "evidence_sha256": "3edf91becb8c50a0a4c4769e60bfd13bf8bfc1727bb05e1737099caba33e651e", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "7d36fcea2384b6bb28044bc68847492fefb2783909042a96f6416cc457c258c6", + "facts": {}, "run_id_sha256": "628f991a182613b8700294d7483b5a4c06872cb9d5ca6047ea552b8ab6585357", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, - "verdict": "completed", + "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "1ab983f4a4047724dfdb2f131ca6450811acb618a1bfee8e10844d5106065a36": { + "22401bb3f7cdbee8cc0fdd6ce84eb60a63cfce66db20f3cf5cc51e55f10055a6": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d7e1e084be213b01", - "receipt_type": "observer", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "YcUcOhOEu0Th8/EJONqEJ8L8A+HFT+eJ1AtqfImXAGw/VHTEnNmkw5yVKDZ1XqsuYHDW2ybKeFN/0AfjZIoJDA==", - "source_artifact_sha256": "c91752eaaac4392dd7aeb24d399c347eb77db07214d1121d39629b13b9dff7a6", - "verified_at": "2026-08-18T10:34:00Z", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "d9sSKQsoWcbmbhegtitDx0KFu8s5ODI1gMwkrJJ6/8hn44yGMZLmli0xU3O74TuCA1Kn52rAURfFHJVftd/XDw==", + "source_artifact_sha256": "e8401afc508900868571caae7995d9771884b1f6faac3543a13bc77ce498c1fd", + "verified_at": "2026-08-18T10:03:00Z", "verified_projection": { - "attempt_id_sha256": "3aee8ad755c7f4bec71cc194bcfaa805e0ea29cf8b830ed0782f8263dd9620ca", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "fdad940f245d690750ad647fac25c7e76aac2f474db49732fec8129051750186", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "idempotency-replay", - "evidence_sha256": "c91752eaaac4392dd7aeb24d399c347eb77db07214d1121d39629b13b9dff7a6", - "run_id_sha256": "3df83453126754a62d00ed10837720542d0469799bb8a88cb5257ac5f477a919", + "condition": "healthy-01", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "e8401afc508900868571caae7995d9771884b1f6faac3543a13bc77ce498c1fd", + "facts": {}, + "run_id_sha256": "3739043a92a8781376cfbd022460c03aba40f92a800b3885ebc046321437bc40", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "satisfied", + "trial_index": 2, + "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "1ac32da3abb3085b0b9ff8093c06f8e5cfb3cd290d1ae053ca0b99807a81f759": { + "23f4a977cecbb6af1ccef4d88c9bd19fc9c474c0a382a0e22ce7bec1aeb706de": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-e37abcd79efd08db", "receipt_type": "replay", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "RtW/P/wVALW/o0z8CqPFMUBqCahS5xLuXlHrnYlQfb9kDe95WSzdD4FgDHC5kdOM/86K8bdRkyVqETV9Xx7mCQ==", - "source_artifact_sha256": "975e43caa5b1e34f06e36ad0fd995c5ba6662a55f5cb8d8d28a9f6208420b800", - "verified_at": "2026-08-18T10:53:00Z", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "YolJuiUCQbpd/IW4hQPiiSftf0IUkswOwkppvD6eHEtu5zN5oSe7u2ayns1/TYCiNLUILz3ABrsh5X+rBYxZBw==", + "source_artifact_sha256": "ddb254eb6e2490fcb9e2b2952775ac00220ba9a95a70f4f784bec71ab5df37b7", + "verified_at": "2026-08-18T11:02:00Z", "verified_projection": { - "attempt_id_sha256": "f5df4d6e64a2d38ffa8e320c87ad05d04025de267a8e152a755d3f1928ded120", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "60ee9db05b1126cfaa3b31c13bc3fab4755ac09c44e846b4d07ee51865dfa7b1", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "stale-session", - "evidence_sha256": "975e43caa5b1e34f06e36ad0fd995c5ba6662a55f5cb8d8d28a9f6208420b800", - "run_id_sha256": "fd3a041b705d8c6277ce26134dc0018e866218cfa3fadd16ac29d1ad498965a3", + "condition": "ambiguous-target", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "ddb254eb6e2490fcb9e2b2952775ac00220ba9a95a70f4f784bec71ab5df37b7", + "facts": {}, + "run_id_sha256": "628f991a182613b8700294d7483b5a4c06872cb9d5ca6047ea552b8ab6585357", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, + "trial_index": 1, "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "1d0d33cddb33f11719b645321ab4b811110a7dda9dada423fce56eef9337f6b9": { + "23f53c85f34d6013ca5c2961470deddd7bc790d5096380b677a9bf5e83951335": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-138dfa227234ea5f", - "receipt_type": "cleanup", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "nQRGJ2BEO/t0d5YcLLs0fDsZwUb7RywiBbpvo8fEjoynEYa5ub7M1W1rnt63nABLlj4wwoBhtwpopBTz9TASAg==", - "source_artifact_sha256": "82558495613e411f7ace5490f50e22b445058f1f1d0661f39959e3fa8d25a742", - "verified_at": "2026-08-18T11:22:00Z", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "Pw/4pQgvNhOgpGeEu9+Ctdz9LQXxizNWRWPLksV1KxO2POvl3tgLTC6TwTBAq78Frsc2C9PvaqXHZtJhqBQXBg==", + "source_artifact_sha256": "f9e70034e68ce8783bb50fb2f53e6c7f8f5ed238916ab72298bcc5068ba7cef8", + "verified_at": "2026-08-18T10:24:00Z", "verified_projection": { - "attempt_id_sha256": "73a097b8b20bab7794369384f7ca1d7d711aad07967b7e1292373babbb7ff1b7", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "7573925adbd8a7a4a3b98bb0379549d77aa8ed46e312c1cd940c05b8587a039e", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "weak-effect-only", - "evidence_sha256": "82558495613e411f7ace5490f50e22b445058f1f1d0661f39959e3fa8d25a742", - "run_id_sha256": "b44783e70a980ec5b3cf3752bd5d1d01b2ff29f5a6892cba0c1c939d8aeb7c02", + "condition": "healthy-03", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "f9e70034e68ce8783bb50fb2f53e6c7f8f5ed238916ab72298bcc5068ba7cef8", + "facts": {}, + "run_id_sha256": "784a0a94e581700a3d93581e7ce5bac0d3bc53c58f3e73198b896b5da9a819b0", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, - "verdict": "completed", + "trial_index": 3, + "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "1e611a0e77ce192cc9f46fe9544472b3352f58c6a8f3f1377c7a688a8a18d702": { + "24a0e21ab6813638a727b551149261a2220c7d3543d655234d685fc9d3bb4133": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-138dfa227234ea5f", "receipt_type": "cleanup", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "cATHd62yKfK8OPSNsMy+ENc9wQpA6ajohnfE7wXTXhX3byIPj6LJzP05sqSeHrPqfMZOplGG/ZxvdQS4xH5KCQ==", - "source_artifact_sha256": "c99ff9e16fc08dfa2947c8baa3cd32d837e5e3c19ebbf6ce751821e33ee578f5", - "verified_at": "2026-08-18T10:42:00Z", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "n3mVM2tkoLMvCyKDwZuNlW8uTRA2yF5qykRFsBopDDjmGHHPcg5P3Wd8Icf+SgVILxcl0MHPImwHu019NoBdAQ==", + "source_artifact_sha256": "61e65cf0f747b77668ae9e6632a66d6d32d3dff99318b22ed782df46a78dbf0f", + "verified_at": "2026-08-18T10:44:00Z", "verified_projection": { - "attempt_id_sha256": "e93521e706ad90d799dcd4e8cac15229c5da6aec1638540606f5fab4efce59fc", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "7c910764b2dcc6f05261d609082f75474e4638c3f356006307212b8fed4a2eb7", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "wrong-reference", - "evidence_sha256": "c99ff9e16fc08dfa2947c8baa3cd32d837e5e3c19ebbf6ce751821e33ee578f5", - "run_id_sha256": "ee82112f55e5e6c86cfd6e16df8c8b652549a8bd72de492f435d8255eb3dd252", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "61e65cf0f747b77668ae9e6632a66d6d32d3dff99318b22ed782df46a78dbf0f", + "facts": {}, + "run_id_sha256": "fe98ce7f0e66b885201f4667875fd38f5890ffddb575d68bd4cd5a66f8d53ca8", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, + "trial_index": 3, "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "1eb22d963181e3e47e20a19387d74eba9c265f9f2bc8ef3b5680f75db6cc94b0": { + "26c7adab527c721616e340b24605509062c669f64c41ec24cc5041f32bad0bfc": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", - "receipt_type": "runner", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "15GS1tW9mt3jm6E3Gu9La4v9OflFgQv94nVrqh6xYMuBbOEJUAr1OHAd7s0rp3Cstdw6ZAucssBjqDS89+pzDQ==", - "source_artifact_sha256": "2939663aad44035d0e4b7f6c59580cd6d7589dc8db1f48abe2e60db3cef03a78", - "verified_at": "2026-08-18T10:32:00Z", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "UBoA/r6iXeisgAqxoY2D3Z532nUm1llt3t+4opIehAXo7XJZrdGVv3lJePflEMvGn9xUs7S+XpxXl4MZ/4v+Dg==", + "source_artifact_sha256": "f9f54cc3691f84eaf5543a39f915bc4b888249e20be389e737f07cc048fc796b", + "verified_at": "2026-08-18T11:24:00Z", "verified_projection": { - "attempt_id_sha256": "3142933f4f168c98b8e89f2ae9d78fd3129e0a9975cbbaa60ddba853eee7d53c", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "aa7d6be4f25a8992c0a22649ba7e703d6955abf5fece9f8322f560149cf09776", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "idempotency-replay", - "evidence_sha256": "2939663aad44035d0e4b7f6c59580cd6d7589dc8db1f48abe2e60db3cef03a78", - "run_id_sha256": "6cdff0cf50d0164fe1eee9c4b7db0b969c24f9b960f5653b516313a913c90a0f", + "condition": "weak-effect-only", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "f9f54cc3691f84eaf5543a39f915bc4b888249e20be389e737f07cc048fc796b", + "facts": {}, + "run_id_sha256": "b974de9da8ef77c8dc9a7662114cc51023ab8c131c488681eeebb7d4c435c8d0", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, - "verdict": "verified", + "trial_index": 3, + "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "21b8a3b75d9b04406b4684602b1b1c4ffbf01fc814f3371d80a478c2271e143a": { + "272e2c3c224b19f532d7a894d08b28f94782824ed6cdf90a3b216b2ded828210": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", "receipt_type": "runner", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "Th6CWGnpMyKLcbMwYO5Y4hQslapUunaij2n1UIpNBCL3fSiA8bzKiZIz1n16R9ukuh29GhJq/Rlx3oB7yzjhDw==", - "source_artifact_sha256": "4166eb8e3a385de458c987a5463a1a35943cb8e54fa4a174c56729232a96605a", - "verified_at": "2026-08-18T10:13:00Z", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "qxsftP76Cj96/Gs+7wNGiK+lFtUmIPkCUh8jkr4K7H4WJQJ/afj0eQWkoF8YK/jPYAg2Fz4fQsUyf5XUXKZGBw==", + "source_artifact_sha256": "c20ee28b4875041089aace249d6634176c0ed5050228c8c0fba2b37db74b7632", + "verified_at": "2026-08-18T10:43:00Z", "verified_projection": { - "attempt_id_sha256": "3d42601a69ef46cc44f57b51762affef4ccd829ffde30125619a6e582af00dab", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "6b0e5c10d55fc92c1ff8576392270a24fb65722414cf58ff9a51b8ce9ef88587", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-02", - "evidence_sha256": "4166eb8e3a385de458c987a5463a1a35943cb8e54fa4a174c56729232a96605a", - "run_id_sha256": "091e13ed70dab439b31cb506cf3bba1ddf6476696531cf891c39a924a928b7a1", + "condition": "wrong-reference", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "c20ee28b4875041089aace249d6634176c0ed5050228c8c0fba2b37db74b7632", + "facts": { + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "c20ee28b4875041089aace249d6634176c0ed5050228c8c0fba2b37db74b7632", + "source": "runner_signed_flow_report_and_enforced_egress_policy" + }, + "operator_intervention_ids_sha256": [] + }, + "run_id_sha256": "577e37b10b1c87fd9c1b5d320888b736d272824657fd59a012e85a284ee88540", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, - "verdict": "verified", + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "250a2d98c537e0180459263bb61f21c6a1f12c144bc064ed993961fd98511ac5": { + "2798955cd738b419669697b8db8cfc4ef28861e4a00851f5addcb2967214c10f": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", - "receipt_type": "runner", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "woesRH04CRbtGGGlq6HgSSz7EQQ7GkS2us+qQvCZV2PAOScvB6mLHtwviDfOLH9EhxkkQRtPuWlKSpSy0cFtDg==", - "source_artifact_sha256": "aa76163afc05d85e7c2925d286aa8e9c2abda820aa88bcddb1c2a8d525a8be2b", - "verified_at": "2026-08-18T11:03:00Z", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "hmxykqri21ljkcu25p4fzJffG/UA6wMEKyGLsZL0oBNPCvAkCsdr1ioAypRgFUy9BSomVGCnnrykhOiLkyL3Bw==", + "source_artifact_sha256": "086aa3c333f8a4fdf55b0ef09ae301f38faa388075355ba8356b2a2e72f7b80e", + "verified_at": "2026-08-18T10:54:00Z", "verified_projection": { - "attempt_id_sha256": "1ec11a9862ede3ac701af71835ac28c551d604a026b5bab7d776dbcdf288394e", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "958342a9ddca98a83b82b662f52f404239d583afe7ed70634760e1b8dd592f3b", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "ambiguous-target", - "evidence_sha256": "aa76163afc05d85e7c2925d286aa8e9c2abda820aa88bcddb1c2a8d525a8be2b", - "run_id_sha256": "43f0a1c00950c390b0676fab55a2aa98c354d028f2347c461661e6cdb72f717e", + "condition": "stale-session", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "086aa3c333f8a4fdf55b0ef09ae301f38faa388075355ba8356b2a2e72f7b80e", + "facts": { + "derived_classifications": { + "collateral_effect_count": 0, + "duplicate_effect_count": 0, + "intended_effect_count": 0, + "wrong_record_count": 0 + }, + "dispatch_state": "not_dispatched", + "effect_inventory": [], + "expected_record_id_sha256": "e2bfc459a52b773d833645ffe96420a991d4761d31989876840d25b4b302c7aa", + "expected_transaction_ref_sha256": "95a5987fa6dfc58ef200281706e9fd73fc28a1d3d44d7eb278478e065e05d3be", + "post_state_evidence_sha256": "a34e8e155989eb0f32dbaf1dba2758e9355bff86a0d7fda67170ce423fd6fe25", + "pre_state_evidence_sha256": "c6dd473eaf43722b7b24747137e017fe88410937978ed19e9c3c694b01515608", + "verifier_method": "read_only_system_of_record_query", + "verifier_tier": "independent_system_of_record" + }, + "run_id_sha256": "6f2fb10bc2018c9f78e9702d5ccac0bedd78ee3b2e9d2a6ad779fba72d90ae50", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "halted", + "trial_index": 3, + "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "261cb4aedf65989c753e88445ab1c34145bd44ff72212cd80c99418d0e47877d": { + "290c960538dbc38ee2260052e5b97353e41c9ea3572cf627dbb2d7ce1124eb9e": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "//MsUG8XdZ1dnaaAWRYh/++At1ZQAbzDiyMNhyLhNMUAzyPrRvFPKGPeH2XjtklN27ecBEPMHIymYKUYagHsCw==", - "source_artifact_sha256": "ce0aa45ff0449ef101823a15d86eaad2e81cfaedb64c35017e27146adae0a845", - "verified_at": "2026-08-18T10:43:00Z", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "v6xnygfr/720J08ZrwVSLU+gMrVzqrPqLD0qLU+aYkcWdjchqjrQKtbwHikiTZykzHK5YoEGuPxrUVHlInv+BA==", + "source_artifact_sha256": "6c8e592e4280ffc6dc1202667837a33a8d1f4c8d88f7cde6d24a3d9b3317ad33", + "verified_at": "2026-08-18T10:42:00Z", "verified_projection": { - "attempt_id_sha256": "6b0e5c10d55fc92c1ff8576392270a24fb65722414cf58ff9a51b8ce9ef88587", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "e93521e706ad90d799dcd4e8cac15229c5da6aec1638540606f5fab4efce59fc", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "wrong-reference", - "evidence_sha256": "ce0aa45ff0449ef101823a15d86eaad2e81cfaedb64c35017e27146adae0a845", - "run_id_sha256": "577e37b10b1c87fd9c1b5d320888b736d272824657fd59a012e85a284ee88540", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "6c8e592e4280ffc6dc1202667837a33a8d1f4c8d88f7cde6d24a3d9b3317ad33", + "facts": {}, + "run_id_sha256": "ee82112f55e5e6c86cfd6e16df8c8b652549a8bd72de492f435d8255eb3dd252", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "halted", + "trial_index": 1, + "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "281c785f27d6347e718f61d7d326ddd42e38cb7c0977de9b5e7585253cc3899b": { + "2a78ce1f942edcd37931679bf672ad893a1cfea2a6a027c0210f53380c083cb4": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "hdziFtNDaeuIqNSbvYzcZUA3hYgFb2P4wgozvLxMAI+f9OADwKtDDZxxNaaqc8/XmASYBSgcNxFgZ9vU7YQiBQ==", - "source_artifact_sha256": "841ebd8beb38baf63b1ce9c65d1f22d80a15e36e268eab7f019f063c7242ce9e", - "verified_at": "2026-08-18T10:12:00Z", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "KIFjrwN/K+gcF45dRYNRI1ih8J3oTC6Vlx1twxpquElw2ycn71WDK4OPG5EoBn752pbEQBCwcyLJd/86F3v5Dg==", + "source_artifact_sha256": "051bac821eaa3486034f245101d6c1f831d659444be87a3b5d774a9abaea05ff", + "verified_at": "2026-08-18T11:02:00Z", "verified_projection": { - "attempt_id_sha256": "940d3ca125ff87ce7539740fbae29d2d64fec839328b0639127e1d197d2485d8", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "60ee9db05b1126cfaa3b31c13bc3fab4755ac09c44e846b4d07ee51865dfa7b1", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-02", - "evidence_sha256": "841ebd8beb38baf63b1ce9c65d1f22d80a15e36e268eab7f019f063c7242ce9e", - "run_id_sha256": "bbb9312ce4682b23580eced0f8d19438d8266b222555df85fb27eef22ad5afe2", + "condition": "ambiguous-target", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "051bac821eaa3486034f245101d6c1f831d659444be87a3b5d774a9abaea05ff", + "facts": {}, + "run_id_sha256": "628f991a182613b8700294d7483b5a4c06872cb9d5ca6047ea552b8ab6585357", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, - "verdict": "delivered", + "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "2995df9d47d9de4b42c9b5d90e71af5e47cc4bfac9fa9d9eb15ca521da785f02": { + "2cc546bd37198e76ce6746f03869d3382b12582987ca76354cb1f4c0b913325a": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-138dfa227234ea5f", - "receipt_type": "cleanup", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "ahh8BDB7Q+DfCnBr/+ttvAJAE8ZBbmNlCmrF/5Hg5V6q9icaBpgolsXoST362qmjYyDn7j5ZArtHu8xVcNq6DQ==", - "source_artifact_sha256": "d132a667b9a158fba09b3f6dca9d0d1ef2f87570aba4df8bc3f9fa30778693c1", - "verified_at": "2026-08-18T10:53:00Z", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "lcWmc3jQQ9YeclbmxaWQQHivfzQr1B5uzTLhe0pWbAMioKYsYqVWZIfcDn4+17TC9zO8XVazHja2dpPk1EnGDw==", + "source_artifact_sha256": "1f121d102e5fbb97098da4d1334dfe5ffc8566bedbc601d9a73f719d325e04c3", + "verified_at": "2026-08-18T10:33:00Z", "verified_projection": { - "attempt_id_sha256": "f5df4d6e64a2d38ffa8e320c87ad05d04025de267a8e152a755d3f1928ded120", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "4667302b580ff7ceb223dbb15eb6d029969a8f6a54bcd33e8df5b6bff41f41ad", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "stale-session", - "evidence_sha256": "d132a667b9a158fba09b3f6dca9d0d1ef2f87570aba4df8bc3f9fa30778693c1", - "run_id_sha256": "fd3a041b705d8c6277ce26134dc0018e866218cfa3fadd16ac29d1ad498965a3", + "condition": "idempotency-replay", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "1f121d102e5fbb97098da4d1334dfe5ffc8566bedbc601d9a73f719d325e04c3", + "facts": {}, + "run_id_sha256": "33e0ad9bf64e477f24d46508fa432123e046dcd1c5853d5cc60b7cde1bce7537", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, - "verdict": "completed", + "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "2a60a9e1e23380c3b33f8ca174cf3510660ac29a6e5a8ab2e3e2c678107613a4": { + "2e9cd2761799c0bf0feef8b9bba65cfb1b5f888d314a2663a33d49cae4834122": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-e37abcd79efd08db", "receipt_type": "replay", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "27S2OWjSPZ0N3u77J762OgXqxVBkqzhZo6j9hfdBCzLTqShK0UVDIAhjycgdXkaiCr/aeCxvggA9TWYwP0VCBg==", - "source_artifact_sha256": "343f637659566d84e7014bb1c057b6f9363086e8d04e122e7df754c45b3367d3", - "verified_at": "2026-08-18T10:33:00Z", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "r9DGqCxk+I4QO0A6k98ggdcmfBk+waTX+zgeBw5o6aQQXqGOEPYoYS/WrUeXYbjWGgskKOzJPFPYiG/1iGDWBg==", + "source_artifact_sha256": "40ce452beafd723531d21b631c3b7710042cff165f085f929b65d07e9575e16b", + "verified_at": "2026-08-18T11:14:00Z", "verified_projection": { - "attempt_id_sha256": "4667302b580ff7ceb223dbb15eb6d029969a8f6a54bcd33e8df5b6bff41f41ad", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "ad76dacfe19a4421ef1f128d4eef1099e846b385d29f17b8588ae5130b487118", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "idempotency-replay", - "evidence_sha256": "343f637659566d84e7014bb1c057b6f9363086e8d04e122e7df754c45b3367d3", - "run_id_sha256": "33e0ad9bf64e477f24d46508fa432123e046dcd1c5853d5cc60b7cde1bce7537", + "condition": "verifier-unavailable", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "40ce452beafd723531d21b631c3b7710042cff165f085f929b65d07e9575e16b", + "facts": {}, + "run_id_sha256": "87014cd8063f5a43ea22c995be03ec41ef5aa613145acacdef71b68c468fc8f1", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "verified", + "trial_index": 3, + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "2b291719429c998246226ba27143f7da1f03abeabce84abeb3e581662b60d6bc": { + "2e9e8e01ec1be899f4e038599fc64adbc3942c35c0565bb67e17d382bc5ca8a8": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", - "receipt_type": "runner", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "G91NEWiQVT+PHT1GEOwzwCz8UNCEEVQbXUoOky/EzVhnCuEZcmhR2qRQJCzhp+2EJq3cGoou27+d7jENfW0ABA==", - "source_artifact_sha256": "693c5de78792744df15509b8187bfaf3ec71a4d879011e9773e98d139b5d7856", - "verified_at": "2026-08-18T10:03:00Z", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "5rzUypB8Maj2Gaj/xyjK+FIxqVwdsnZ6vfUcMk7h1pv1Q8KM0DwZuw9mXKijy8Yv94RJiOQY9JwVWx4xBENICg==", + "source_artifact_sha256": "fac9c9cf16a2c781d6f7c55b241c6266c4fa513744fb05a705c1c8d33e3c7ccf", + "verified_at": "2026-08-18T10:24:00Z", "verified_projection": { - "attempt_id_sha256": "fdad940f245d690750ad647fac25c7e76aac2f474db49732fec8129051750186", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "7573925adbd8a7a4a3b98bb0379549d77aa8ed46e312c1cd940c05b8587a039e", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-01", - "evidence_sha256": "693c5de78792744df15509b8187bfaf3ec71a4d879011e9773e98d139b5d7856", - "run_id_sha256": "3739043a92a8781376cfbd022460c03aba40f92a800b3885ebc046321437bc40", + "condition": "healthy-03", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "fac9c9cf16a2c781d6f7c55b241c6266c4fa513744fb05a705c1c8d33e3c7ccf", + "facts": {}, + "run_id_sha256": "784a0a94e581700a3d93581e7ce5bac0d3bc53c58f3e73198b896b5da9a819b0", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "verified", + "trial_index": 3, + "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "2b4060abcc8e69b9f87cb79a3b378fe93014566680b4140b3f5dff1b23c3af85": { + "2f5e6b2f5830a2af96d4caaa4154d8df09aad535e981334f256ac161509da31d": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-e37abcd79efd08db", "receipt_type": "replay", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "1uOJphpSrnVRvxuccuwy9FXLsOyk88wXxjOIEd8wgfhHRbg2pD8rKMIEyKdYDxzoovfLPUGNRum9oWNRgdOIAQ==", - "source_artifact_sha256": "f0e1b62eb7c877e3b75f5be31a69021e88bedc4ccfd95d69395483193bb5669f", - "verified_at": "2026-08-18T10:44:00Z", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "vbB6/g1ADS1Wa3smWK9pzLD03A6g1gDjjAIv9IwBBSRkijIe6Igy+tPcMlhbmYXPSBnFiwcXo2/yMwkWCdNXDA==", + "source_artifact_sha256": "a46df95e5690b582be425e126233998cf8a82e1db8ea11a5dade90b3cc616b28", + "verified_at": "2026-08-18T10:14:00Z", "verified_projection": { - "attempt_id_sha256": "7c910764b2dcc6f05261d609082f75474e4638c3f356006307212b8fed4a2eb7", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "019dd96e9a771ccc01ebafab321d7d3a8314df8b2d6465bcfc5fa14cbdeabdf2", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "wrong-reference", - "evidence_sha256": "f0e1b62eb7c877e3b75f5be31a69021e88bedc4ccfd95d69395483193bb5669f", - "run_id_sha256": "fe98ce7f0e66b885201f4667875fd38f5890ffddb575d68bd4cd5a66f8d53ca8", + "condition": "healthy-02", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "a46df95e5690b582be425e126233998cf8a82e1db8ea11a5dade90b3cc616b28", + "facts": {}, + "run_id_sha256": "16cb8df40654c6a1b55ea0e50e772d8c6e6d4f0d8205bd1f8296be27d0af83eb", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, - "verdict": "halted", + "verdict": "verified", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "2cb93f1da48f525ba6706aa6e042d870bf902fc22ed125fa90e9692d5a6ea1e9": { + "353a8e94bb09676bab144917696e954ea6351cb3cd171add5e2abb6c7134d61e": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-138dfa227234ea5f", - "receipt_type": "cleanup", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "hRC2ENLfWW0Ghxgwp2pOY/axv7xj3Mn8d4r1IjnQadymUftbjk+F7a8vvHVH9pj/f4quwJ5z7W86oDcj8iikDQ==", - "source_artifact_sha256": "0c3d68b46266286eb32f09365d96174863b4fe9cac3fb3f91625fcbb4f521e71", + "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", + "receipt_type": "fault", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "4r5Fptluo7tIKyfnfpzaeqmPjXGZPymvfXSEq7w2uPSuKulw3ILbNFF5f7QF2hIgSVUdDEzQNIOqkQipjVc1Dg==", + "source_artifact_sha256": "ac34c209ded7d003e6d99a60a52adc51e65926a708df1a94834a196ba9fe9812", "verified_at": "2026-08-18T11:04:00Z", "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "491a544656d05aea37920e5c7e2ad65a9452eac8d6e100268a599aeebd41187a", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "ambiguous-target", - "evidence_sha256": "0c3d68b46266286eb32f09365d96174863b4fe9cac3fb3f91625fcbb4f521e71", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "ac34c209ded7d003e6d99a60a52adc51e65926a708df1a94834a196ba9fe9812", + "facts": {}, "run_id_sha256": "aa62c7a17701a7ef01ea1d3519b4c1f90d357495b329fdda3054cc24c581a593", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, - "verdict": "completed", + "verdict": "injected", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "2ee187a8c4b7240ee8767499afd16c6efc9356a3211766d00910d0ea2294a76e": { + "35fde2e03b3dc98d4b7cd66082f330ce9f3501d4d236e4c5394348d85e7f176c": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "gRziheFArjoQmwLhrPmOgun3YQIPNlCPHZ9Uf3cxIfpZ/4YFiCyj3BIMGHxzhUb0rX4LIapz42mPq8yB9LS+BQ==", - "source_artifact_sha256": "c129344c7dd911068c387c21d9a1042713a90190dcd848662cf894d8283c4db2", - "verified_at": "2026-08-18T10:54:00Z", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "EGlia6pU8sjqGFo0WaZ9WKemS1xU1sF/Pe7aqsbESdxYNBjrF6A2vMRImSVgCnPhptZeRhRSc/9e2/we6UqWAQ==", + "source_artifact_sha256": "669b90f52ab8347c72f46f47c7493d314fafe014431fa4d576db6a8d42eeb0dd", + "verified_at": "2026-08-18T11:04:00Z", "verified_projection": { - "attempt_id_sha256": "958342a9ddca98a83b82b662f52f404239d583afe7ed70634760e1b8dd592f3b", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "491a544656d05aea37920e5c7e2ad65a9452eac8d6e100268a599aeebd41187a", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "stale-session", - "evidence_sha256": "c129344c7dd911068c387c21d9a1042713a90190dcd848662cf894d8283c4db2", - "run_id_sha256": "6f2fb10bc2018c9f78e9702d5ccac0bedd78ee3b2e9d2a6ad779fba72d90ae50", + "condition": "ambiguous-target", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "669b90f52ab8347c72f46f47c7493d314fafe014431fa4d576db6a8d42eeb0dd", + "facts": { + "derived_classifications": { + "collateral_effect_count": 0, + "duplicate_effect_count": 0, + "intended_effect_count": 0, + "wrong_record_count": 0 + }, + "dispatch_state": "not_dispatched", + "effect_inventory": [], + "expected_record_id_sha256": "c9446a96197759e6626c902a50c333132d48db209984b45b7b664dee186a7578", + "expected_transaction_ref_sha256": "95f52355bde231835ef1b23f37e8ce989bdf4042ee52fd679fc8eeb514949ad1", + "post_state_evidence_sha256": "d71deb3de9d35b282b7ac9eed3feffc5432a6f28295101b520c1cd0943756dd6", + "pre_state_evidence_sha256": "6d640c6c9ca204c38d59f02e48d62e1d9b9eb13080f6ddf18196c807c8770c30", + "verifier_method": "read_only_system_of_record_query", + "verifier_tier": "independent_system_of_record" + }, + "run_id_sha256": "aa62c7a17701a7ef01ea1d3519b4c1f90d357495b329fdda3054cc24c581a593", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, - "verdict": "absent", + "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "2fa257efdc7b2b5fbd3e5caa209d045d974201e96852760f38ca9a70bcd61755": { + "36112ed5002c4c5621bcfe60eb7e41873051625d844ff153a403684b410467a7": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", "receipt_type": "runner", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "KqG4GWswhggd7BkvVmrDm6oQxCZ2zfldTItCxYuqTl6QI2Hi1Dr+UfbPqkHcxR02kejWSSslPQo3ml/HFVPGAw==", - "source_artifact_sha256": "11df3fb01cf5dba128c9a69827676bb2d78cf90dedf8bd2071bcea42c25916e5", - "verified_at": "2026-08-18T10:33:00Z", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "0dHbAZQcnLVtzksOy7CP3Pc82FYynnPy6IePhqHdq1NLY5WFnK8VjO4SjLt9U+jV8WLdFgeGAJmapFy/rLOtAw==", + "source_artifact_sha256": "9e7ce6c0c14f2e05ca217cb2830c9fbdd1205753014ece86f7e77671774081da", + "verified_at": "2026-08-18T11:23:00Z", "verified_projection": { - "attempt_id_sha256": "4667302b580ff7ceb223dbb15eb6d029969a8f6a54bcd33e8df5b6bff41f41ad", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "eb52fb1b1bf2fac92d8f3a444bb5081161be8b3d0ef457c5065e7b79e96df770", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "idempotency-replay", - "evidence_sha256": "11df3fb01cf5dba128c9a69827676bb2d78cf90dedf8bd2071bcea42c25916e5", - "run_id_sha256": "33e0ad9bf64e477f24d46508fa432123e046dcd1c5853d5cc60b7cde1bce7537", + "condition": "weak-effect-only", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "9e7ce6c0c14f2e05ca217cb2830c9fbdd1205753014ece86f7e77671774081da", + "facts": { + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "9e7ce6c0c14f2e05ca217cb2830c9fbdd1205753014ece86f7e77671774081da", + "source": "runner_signed_flow_report_and_enforced_egress_policy" + }, + "operator_intervention_ids_sha256": [] + }, + "run_id_sha256": "794033f9da2a42448254a478fb6de954898b1e544148708ad30264efdc255431", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, - "verdict": "verified", + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "30943ab2222e8fd4fb98d2a4e6ca8bd944800dc26e136492f4616f4e8d8f1ec4": { + "369bbe15a24b28d16d87482480bed7ee9b4ab2cedef0a051a930e3f95ec39a1a": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-138dfa227234ea5f", - "receipt_type": "cleanup", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "xSXHRjakO6fsR3feo8dHlvkW+NnsOb19VmC4Rw/j/5BbTcLge7wZxXqIY9q+fzq9TEtlq+sWCErLkodEmOTdDA==", - "source_artifact_sha256": "11f183b9a6fd7d20a3cfc66e95960832da64804b9d3f6980ee365679b3a1793f", - "verified_at": "2026-08-18T11:13:00Z", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "Q8dFLP4O1evr+ECPcnlKvLeUcoBiusxLQtaDWXNO2unOqRId1c5UEFEu5V42esnD/4qHCYw0mgbimMy09aIVAA==", + "source_artifact_sha256": "65140882628aea7d2f64f788fcf9fcb6addfd372449a58a0221ac27b0355af3f", + "verified_at": "2026-08-18T11:24:00Z", "verified_projection": { - "attempt_id_sha256": "42259dbb767ced4c25ad8bd40edc209720a748897194c925ed9bd2e27b2258b2", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "aa7d6be4f25a8992c0a22649ba7e703d6955abf5fece9f8322f560149cf09776", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "verifier-unavailable", - "evidence_sha256": "11f183b9a6fd7d20a3cfc66e95960832da64804b9d3f6980ee365679b3a1793f", - "run_id_sha256": "4af84f2608a25a27e6252a5800263a238bb70fb3bec65148601ddcdddbf3e03c", + "condition": "weak-effect-only", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "65140882628aea7d2f64f788fcf9fcb6addfd372449a58a0221ac27b0355af3f", + "facts": {}, + "run_id_sha256": "b974de9da8ef77c8dc9a7662114cc51023ab8c131c488681eeebb7d4c435c8d0", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "completed", + "trial_index": 3, + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "31e84b9a0133f40ac67e9fa8b9b59b7a56b3069952903232a7b00402effac1dd": { + "379bdd3e735612de1d2a7c4860a87692e78175e7425ffdbcb65a45e2c205af28": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "DV7yeJBgebFFLo/uEjVQGj/iMaCqhZgpHcMHL5sCxYDVjhu/Pu5/4tYns6BtesM2fiuo+ZE3Ke3+NJg+wcAEBw==", - "source_artifact_sha256": "0e7b1e0c28c2cfe39870f987c674129552a27582914b580f2e13474b3636e942", - "verified_at": "2026-08-18T10:32:00Z", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "SGMcXAPZ3ItKN8whwqa6y/RRAVx0lbbFCSX+9bmfcH9eUZbXdKr+X/WgRnRosPOpx0Bz4JOcI+IkzwaS8AyBAw==", + "source_artifact_sha256": "b4cd01f298514b82ac8baafbaf99475b073f39bad0a7c9ad414d5fdd8fe5ccd5", + "verified_at": "2026-08-18T10:43:00Z", "verified_projection": { - "attempt_id_sha256": "3142933f4f168c98b8e89f2ae9d78fd3129e0a9975cbbaa60ddba853eee7d53c", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "6b0e5c10d55fc92c1ff8576392270a24fb65722414cf58ff9a51b8ce9ef88587", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "idempotency-replay", - "evidence_sha256": "0e7b1e0c28c2cfe39870f987c674129552a27582914b580f2e13474b3636e942", - "run_id_sha256": "6cdff0cf50d0164fe1eee9c4b7db0b969c24f9b960f5653b516313a913c90a0f", + "condition": "wrong-reference", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "b4cd01f298514b82ac8baafbaf99475b073f39bad0a7c9ad414d5fdd8fe5ccd5", + "facts": { + "derived_classifications": { + "collateral_effect_count": 0, + "duplicate_effect_count": 0, + "intended_effect_count": 0, + "wrong_record_count": 0 + }, + "dispatch_state": "not_dispatched", + "effect_inventory": [], + "expected_record_id_sha256": "635a8a05ef43c6aa69c8a658a72f59687ebda6a9799a17db1bd6dfd70abfff15", + "expected_transaction_ref_sha256": "b37ca33f4b6b8162e928b6b03b31d47f3ff044d4947f5e113e1f1a49bd15f40f", + "post_state_evidence_sha256": "6394a575d25ea8199fe4cff9d7fe855ff3c2db94468a69f0165d0759c896b99e", + "pre_state_evidence_sha256": "d254b6167e6ec999ee08c9b3ff18bf1cfa914b0a228603e9062abe5ecb99430c", + "verifier_method": "read_only_system_of_record_query", + "verifier_tier": "independent_system_of_record" + }, + "run_id_sha256": "577e37b10b1c87fd9c1b5d320888b736d272824657fd59a012e85a284ee88540", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, - "verdict": "absent", + "trial_index": 2, + "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "33d8fd907e482612d1d69669f9f91afe0dded59103f393643a57500c8ee1ff05": { + "399969b28d2a8a4508e5aba7deeb80a5d10271732c45ec8b771afca68c5019c2": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-d7e1e084be213b01", "receipt_type": "observer", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "NG0XMjNJ4npWFcfG4nuJLulMFaUmw49r/TmsjfGE2rtZf0iLS5aorQeh/vKISGXZzifesY9sNebD1HCD+FQ/Cg==", - "source_artifact_sha256": "b54d78461c69265574bc5e0a08e1ae1f2c53150056399d8de419de8d50868c80", - "verified_at": "2026-08-18T10:04:00Z", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "zrkF3u6yilvhZAHjPYqNM1OVPoUdIQSI6qnNXdIZJjgnh50629XZeXaFeoY6nK+nP2Ese/ZM2vgycya/tueGBg==", + "source_artifact_sha256": "57e3d1b277db5cbe456c303c9cb64859db7dc268807b185a31e35936e13ee8c3", + "verified_at": "2026-08-18T11:22:00Z", "verified_projection": { - "attempt_id_sha256": "4c352a6999f77707e8837adebb4fc2b7451c2ef6de5145190b33a5c5645e47eb", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "73a097b8b20bab7794369384f7ca1d7d711aad07967b7e1292373babbb7ff1b7", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-01", - "evidence_sha256": "b54d78461c69265574bc5e0a08e1ae1f2c53150056399d8de419de8d50868c80", - "run_id_sha256": "4ee2bb61fb883cc8e77d636fb471aa3c0ce9ef0c0a8abd9682214bf0a8f16f26", + "condition": "weak-effect-only", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "57e3d1b277db5cbe456c303c9cb64859db7dc268807b185a31e35936e13ee8c3", + "facts": { + "derived_classifications": { + "collateral_effect_count": 0, + "duplicate_effect_count": 0, + "intended_effect_count": 0, + "wrong_record_count": 0 + }, + "dispatch_state": "not_dispatched", + "effect_inventory": [], + "expected_record_id_sha256": "9834b8ac2ddaa9ad681db17b9bec4f192d28619c87021bce9515e9d2c5c0f4c8", + "expected_transaction_ref_sha256": "7feab8a28dcdcf6a94bb2e1551e37c1ec9443784e191b71faddd012c020fcb93", + "post_state_evidence_sha256": "6c1e8b0581e0efa08372ff5ea57591c559aaa279cf20353418d7e2f21bc53f59", + "pre_state_evidence_sha256": "02df7d1e41ca49f834c03a39fb4403890fb1aad742f41cd014a99926926dc8d5", + "verifier_method": "read_only_system_of_record_query", + "verifier_tier": "independent_system_of_record" + }, + "run_id_sha256": "b44783e70a980ec5b3cf3752bd5d1d01b2ff29f5a6892cba0c1c939d8aeb7c02", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, + "trial_index": 1, "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "34e01549f75b1a8132541730937ba43e9f673d0886239a3adae2142502961c03": { + "39a0a13faa3fbc11b08573ce721f16a0312f03f22fd3f8066c1ff74a34445b22": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "w/02t/CZCL7UPkO6s4hohBMjTEa5LNNEvLfB2mxGfkadEQHzc5Sh/xjAgqZsk14dKed+RDoRjo5105r0q/s8DQ==", - "source_artifact_sha256": "32974d92bebc7e4e4d26c3f6df9b0cd6dfb4e7f0f23baa1df91fa850acf666da", - "verified_at": "2026-08-18T10:54:00Z", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "so9kStMrXAYl+siUxeR0v9ozOROTB8oSizS5ik/lXZFNTrB8fwyb8+wMM5kOGgn8TJSFoVIQeQU1ejJ6gnFHCw==", + "source_artifact_sha256": "3edf91becb8c50a0a4c4769e60bfd13bf8bfc1727bb05e1737099caba33e651e", + "verified_at": "2026-08-18T11:02:00Z", "verified_projection": { - "attempt_id_sha256": "958342a9ddca98a83b82b662f52f404239d583afe7ed70634760e1b8dd592f3b", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "60ee9db05b1126cfaa3b31c13bc3fab4755ac09c44e846b4d07ee51865dfa7b1", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "stale-session", - "evidence_sha256": "32974d92bebc7e4e4d26c3f6df9b0cd6dfb4e7f0f23baa1df91fa850acf666da", - "run_id_sha256": "6f2fb10bc2018c9f78e9702d5ccac0bedd78ee3b2e9d2a6ad779fba72d90ae50", + "condition": "ambiguous-target", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "3edf91becb8c50a0a4c4769e60bfd13bf8bfc1727bb05e1737099caba33e651e", + "facts": {}, + "run_id_sha256": "628f991a182613b8700294d7483b5a4c06872cb9d5ca6047ea552b8ab6585357", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "halted", + "trial_index": 1, + "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "37179d92aae8590ec9894154d581e654113f2fcb230673b466c345c5e68d7003": { + "3c917b1de8297d9d1578795470d6a379a5bc0171ac1488d5468cb201099865b7": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", - "receipt_type": "runner", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "3C0LbshxV6uUJNU3B2zcLfJiMldSwDG67DkpCMH9rc0QMqwi7BQGSgLnhOOvxVNllAJ/1MINwzvljYcuYcOMAw==", - "source_artifact_sha256": "3f1ce2b52c8b8ed56bc485f70b885b295f43f601b14c7834ee455b982154a6e5", - "verified_at": "2026-08-18T11:02:00Z", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "WCJXjMRnbQxfQRpVeBMmuAKGzT5MDA2jzvNbHmbzPCVBPrkR4VgQTvxe176w166niYYKjPvfG8LmWcYMhIxSAQ==", + "source_artifact_sha256": "1594ca15edbb7755f6b59f1e58383c96dab980507ce5edff073a7a295f07069b", + "verified_at": "2026-08-18T10:14:00Z", "verified_projection": { - "attempt_id_sha256": "60ee9db05b1126cfaa3b31c13bc3fab4755ac09c44e846b4d07ee51865dfa7b1", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "019dd96e9a771ccc01ebafab321d7d3a8314df8b2d6465bcfc5fa14cbdeabdf2", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "ambiguous-target", - "evidence_sha256": "3f1ce2b52c8b8ed56bc485f70b885b295f43f601b14c7834ee455b982154a6e5", - "run_id_sha256": "628f991a182613b8700294d7483b5a4c06872cb9d5ca6047ea552b8ab6585357", + "condition": "healthy-02", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "1594ca15edbb7755f6b59f1e58383c96dab980507ce5edff073a7a295f07069b", + "facts": {}, + "run_id_sha256": "16cb8df40654c6a1b55ea0e50e772d8c6e6d4f0d8205bd1f8296be27d0af83eb", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, - "verdict": "halted", + "trial_index": 3, + "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "386dbd16e6ae7d1d0b6c82a6992fe211c81630928689722057964a0dda3c3942": { + "3cce0307da3bad33d18f117ca01623c6baea1b925048bef9a82fbb3ea576df62": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "BXhpbM9qvlT64dfMQ+A3NvG3yWrzXsFdzxrzr1afgEy6EPyMdjXn6+4hgpvQJfNrowM1MyogCrSdC59ZVkwlAg==", - "source_artifact_sha256": "8fd27141f1a8f201ab2aff52f1ba0273e506dc25a0fb7567513d140a1cc9a2fa", - "verified_at": "2026-08-18T11:04:00Z", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "pzdjxS706zUxP+/6MtnvfHX50LXcXi7FMUOMmqnCl2vvB1wWvBX9HxdKK43ufqC+EA9XJ83hdCldd75dEZC2Dw==", + "source_artifact_sha256": "ed51ba8ee340b00da87808f45e1ed935c200be0ed41ea55cba8ebcc8e4b3872f", + "verified_at": "2026-08-18T10:24:00Z", "verified_projection": { - "attempt_id_sha256": "491a544656d05aea37920e5c7e2ad65a9452eac8d6e100268a599aeebd41187a", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "7573925adbd8a7a4a3b98bb0379549d77aa8ed46e312c1cd940c05b8587a039e", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "ambiguous-target", - "evidence_sha256": "8fd27141f1a8f201ab2aff52f1ba0273e506dc25a0fb7567513d140a1cc9a2fa", - "run_id_sha256": "aa62c7a17701a7ef01ea1d3519b4c1f90d357495b329fdda3054cc24c581a593", + "condition": "healthy-03", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "ed51ba8ee340b00da87808f45e1ed935c200be0ed41ea55cba8ebcc8e4b3872f", + "facts": { + "derived_classifications": { + "collateral_effect_count": 0, + "duplicate_effect_count": 0, + "intended_effect_count": 1, + "wrong_record_count": 0 + }, + "dispatch_state": "dispatched", + "effect_inventory": [ + { + "effect_id_sha256": "840362150d294fb842a0c430c081c44a514e216c4132f6658b2b0407e8336467", + "record_id_sha256": "5d8c903c632927ac9da078a25888efd1b9f104001bcbbe75434bfff1cb0e89d6", + "transaction_ref_sha256": "58e0d46c681d3c9e62f50fe840b0ccd8c6aa127d05e91bab2f24b530ff550039" + } + ], + "expected_record_id_sha256": "5d8c903c632927ac9da078a25888efd1b9f104001bcbbe75434bfff1cb0e89d6", + "expected_transaction_ref_sha256": "58e0d46c681d3c9e62f50fe840b0ccd8c6aa127d05e91bab2f24b530ff550039", + "post_state_evidence_sha256": "a0c814b977f2af708e63f07584860c9ce3060ae5c2416678d88bf7948a6287a4", + "pre_state_evidence_sha256": "0d2090d7b6d69d898af9f95d735324ff9f05a5f8b24ead01f37df42dcac6ced6", + "verifier_method": "read_only_system_of_record_query", + "verifier_tier": "independent_system_of_record" + }, + "run_id_sha256": "784a0a94e581700a3d93581e7ce5bac0d3bc53c58f3e73198b896b5da9a819b0", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, - "verdict": "halted", + "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "38d632dc612aa9d18bc141fea23812d46fb9345a230b4e58b53336402a2a9289": { + "3e7ffe28a48816b6b63017f4d4e4fd2f3c387841bc5e8bfc14fa4f749653cf85": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", - "receipt_type": "fault", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "pPFpY0OmY1FW4JVLRkFjFo8mhXuYNJhuBeM+i0uZr3/g1VWf0NODYx7HzTy53+F/44QtjGF1H7IjtV1IU2xLBg==", - "source_artifact_sha256": "18258b93a65383507d1a93b2de83059c8074fd781add23d4f4d40911bf56b059", - "verified_at": "2026-08-18T11:13:00Z", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "pICsevbvjG2HMpwKvO/B2rcofr52fkVfSKJVSMg6xyz2VkUoAWPiIuRkq9lcCfrA+89640wIYEHD2Mi54K3ZBw==", + "source_artifact_sha256": "98f3bd644c3f5baa2083f90afb499c9a29160c8160a518c2d6fac7d9a3cf3792", + "verified_at": "2026-08-18T11:12:00Z", "verified_projection": { - "attempt_id_sha256": "42259dbb767ced4c25ad8bd40edc209720a748897194c925ed9bd2e27b2258b2", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "f5e96a2e9a580376b18beabf57798b8761e772a0c4d112877045780bb12b3720", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "verifier-unavailable", - "evidence_sha256": "18258b93a65383507d1a93b2de83059c8074fd781add23d4f4d40911bf56b059", - "run_id_sha256": "4af84f2608a25a27e6252a5800263a238bb70fb3bec65148601ddcdddbf3e03c", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "98f3bd644c3f5baa2083f90afb499c9a29160c8160a518c2d6fac7d9a3cf3792", + "facts": {}, + "run_id_sha256": "e8e89651045a5f5c011c9543ed968e0fe7697a061ed8ad5cedc27d194cb96acb", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "injected", + "trial_index": 1, + "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "3d8eb365f4d3b3332b5d8416e465962d4c3c1b55f12f6500d62144fb512a6051": { + "3f5b7d5d21d2bd5fdff3bfca3f28f239673753668c9007bb04d6541fb3ef2226": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", - "receipt_type": "runner", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "LjsE49T5c/qicI9XQNWovyK4tK3z+7fFWxi8QEUvFF5cIj72VfLwLcxFtnvAaSL1/HJ5C0/mbdgQz/HNG7pZBg==", - "source_artifact_sha256": "ddf817056f83e416082775455ee6cb2ccc0139eeaeec131996cc584694bb9cf6", - "verified_at": "2026-08-18T11:04:00Z", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "64RU3ZLFHUM0y64zMz7QYXkOHqFYlCqGn6eY43bDgLfy1NyIWKHoMPdyM4/xP0XlAi0CD+GutVykPR4ScNJ/Bg==", + "source_artifact_sha256": "c91752eaaac4392dd7aeb24d399c347eb77db07214d1121d39629b13b9dff7a6", + "verified_at": "2026-08-18T10:34:00Z", "verified_projection": { - "attempt_id_sha256": "491a544656d05aea37920e5c7e2ad65a9452eac8d6e100268a599aeebd41187a", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "3aee8ad755c7f4bec71cc194bcfaa805e0ea29cf8b830ed0782f8263dd9620ca", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "idempotency-replay", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "c91752eaaac4392dd7aeb24d399c347eb77db07214d1121d39629b13b9dff7a6", + "facts": { + "derived_classifications": { + "collateral_effect_count": 0, + "duplicate_effect_count": 0, + "intended_effect_count": 1, + "wrong_record_count": 0 + }, + "dispatch_state": "dispatched", + "effect_inventory": [ + { + "effect_id_sha256": "86bffa79f59e7a839b38edfddced10a0329f7c46625f812b0791062e2975c21f", + "record_id_sha256": "6fc6b4a09a4cb0e71faf8a0b537d308527b4b5f8563a72be9e779ba072bdc954", + "transaction_ref_sha256": "717e0261bd78563991a1f9643d3501a699fe53230ec01c973f42f7b98aa411ac" + } + ], + "expected_record_id_sha256": "6fc6b4a09a4cb0e71faf8a0b537d308527b4b5f8563a72be9e779ba072bdc954", + "expected_transaction_ref_sha256": "717e0261bd78563991a1f9643d3501a699fe53230ec01c973f42f7b98aa411ac", + "post_state_evidence_sha256": "b1e104f5f06bee9c27a2275103156f8eb3274048197efe52f9abc393d9fac129", + "pre_state_evidence_sha256": "813f12a9a620bb94137fe4534de4f1d83e85eadb73e8483267da89c79fd9b984", + "verifier_method": "read_only_system_of_record_query", + "verifier_tier": "independent_system_of_record" + }, + "run_id_sha256": "3df83453126754a62d00ed10837720542d0469799bb8a88cb5257ac5f477a919", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "satisfied", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "3f720f6c3da1e29759c17b9ff24984dbbf64bf8aeed6f8d0d33777b54f65498f": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "9JqztUim2dDE0WUb5gLWRsXyh0goxAGeyzGWT2dD8UYM/oGgvpIyI+pN8q7rZ94OIqlsrAGfKwv5hkiyf0jFAw==", + "source_artifact_sha256": "e5dea576ba929b469a889784b3eb264880f21206f61c472ea33b1b5b59d161cf", + "verified_at": "2026-08-18T11:14:00Z", + "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "ad76dacfe19a4421ef1f128d4eef1099e846b385d29f17b8588ae5130b487118", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "ambiguous-target", - "evidence_sha256": "ddf817056f83e416082775455ee6cb2ccc0139eeaeec131996cc584694bb9cf6", - "run_id_sha256": "aa62c7a17701a7ef01ea1d3519b4c1f90d357495b329fdda3054cc24c581a593", + "condition": "verifier-unavailable", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "e5dea576ba929b469a889784b3eb264880f21206f61c472ea33b1b5b59d161cf", + "facts": {}, + "run_id_sha256": "87014cd8063f5a43ea22c995be03ec41ef5aa613145acacdef71b68c468fc8f1", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, - "verdict": "halted", + "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "3f1d8304c662af081aae90b0d6ffb2e01f21c5debf95a740595bd97d740965dc": { + "41c5089c652797dd8892e0d7ada46912cf69f72bcd43bee7170b65f3ef278f7e": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", "receipt_type": "runner", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "brekMePk7znfV3QmslkK5nQUEuXHuQrDixlISNnTf6XOJxVGM0S97MUbwacFmtFmPw9BU/+R7CwpobC2gZ0VCQ==", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "l9yAor66F5lPm327s5ZL0sQrLyDuaIqKcwaadDf6WsXaWeKtCqnA8ERzojSagv4r+iV/BR1ONMMqcP52LcMRAg==", "source_artifact_sha256": "aecd407f56e892dd31846bf13f26f1d2b2683f375928da672b2d04773349cdc0", "verified_at": "2026-08-18T10:44:00Z", "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "7c910764b2dcc6f05261d609082f75474e4638c3f356006307212b8fed4a2eb7", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "wrong-reference", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", "evidence_sha256": "aecd407f56e892dd31846bf13f26f1d2b2683f375928da672b2d04773349cdc0", + "facts": { + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "aecd407f56e892dd31846bf13f26f1d2b2683f375928da672b2d04773349cdc0", + "source": "runner_signed_flow_report_and_enforced_egress_policy" + }, + "operator_intervention_ids_sha256": [] + }, "run_id_sha256": "fe98ce7f0e66b885201f4667875fd38f5890ffddb575d68bd4cd5a66f8d53ca8", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", @@ -1797,637 +2304,851 @@ "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "3f9dbd4b5462c22c057ec74e389a00836aa7b3f2870a49095bb48310555f8b99": { + "42e108a2f781e3945e94c43caabc5314a03d47af1caf8380b032300a206a914c": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d7e1e084be213b01", - "receipt_type": "observer", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "YgCkyHeYlnViN/p9FpU8UwLWI5+98+GcxB43vJzPCMwDT+GUL/Qz7dW3hkUptEELLLVhmC9dsAehJP9oiMM/Bw==", - "source_artifact_sha256": "2ae10ced05bdd00ae95b7a8d2893b178979ff8cf6d455c9e9fcf2596ecac18fb", - "verified_at": "2026-08-18T10:32:00Z", + "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", + "receipt_type": "fault", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "CopvvatCU+3mhUJG2j9yJEus4yGc3frpm/EEJbrPzDRYJAuGENr/sBa1Oh5w1SMSZOrKJ9hiQR2zZgE+Xps3AA==", + "source_artifact_sha256": "99fd8516daeb8b22c42479814dbed2b01d63985db824c0237ed8ac83efd0dca0", + "verified_at": "2026-08-18T11:03:00Z", "verified_projection": { - "attempt_id_sha256": "3142933f4f168c98b8e89f2ae9d78fd3129e0a9975cbbaa60ddba853eee7d53c", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "1ec11a9862ede3ac701af71835ac28c551d604a026b5bab7d776dbcdf288394e", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "idempotency-replay", - "evidence_sha256": "2ae10ced05bdd00ae95b7a8d2893b178979ff8cf6d455c9e9fcf2596ecac18fb", - "run_id_sha256": "6cdff0cf50d0164fe1eee9c4b7db0b969c24f9b960f5653b516313a913c90a0f", + "condition": "ambiguous-target", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "99fd8516daeb8b22c42479814dbed2b01d63985db824c0237ed8ac83efd0dca0", + "facts": {}, + "run_id_sha256": "43f0a1c00950c390b0676fab55a2aa98c354d028f2347c461661e6cdb72f717e", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, - "verdict": "satisfied", + "trial_index": 2, + "verdict": "injected", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "4090cbc85f145c1a2b33d9536ca9f2ca12f9109769eb702a0a46fbda70abace8": { + "4408783aba57a0ec3124a3265f3a7eb34eeb429fcef2e60a955c91d84e2e91d2": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "QSUThYwpg1DzJV1l3ASw8HRgLLUWt0qK03NrF1InXMMZjm2bfRkDWB+mDrrJB2hOEs8NRs+ueBAW+ipt/IohAg==", - "source_artifact_sha256": "1f77854e1846d96a3d4c187c4946e746d7139d3a025dbd5ede6e8a6ee6be2c40", - "verified_at": "2026-08-18T10:22:00Z", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "6tGxqeS8mYKz/z+CrKMYxH7v3xNyTpCdBf6Y3EqLepql9qiNxiiaocjccm1UXDSUM0QJrw1PTSnb9tcXtlGUCA==", + "source_artifact_sha256": "a44dac787050d0cb99551f8f0735973f618907d4b8f58c6f5760fc1634522c2f", + "verified_at": "2026-08-18T10:04:00Z", "verified_projection": { - "attempt_id_sha256": "fc097c8b2e6ece94544a19b8d81f5c4a9367a89059e3dd4b2f746ab06a2fc930", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "4c352a6999f77707e8837adebb4fc2b7451c2ef6de5145190b33a5c5645e47eb", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-03", - "evidence_sha256": "1f77854e1846d96a3d4c187c4946e746d7139d3a025dbd5ede6e8a6ee6be2c40", - "run_id_sha256": "28768f565659133f5bf1170e638b81de4d7ca38dfecacd09ccf462a35344432b", + "condition": "healthy-01", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "a44dac787050d0cb99551f8f0735973f618907d4b8f58c6f5760fc1634522c2f", + "facts": {}, + "run_id_sha256": "4ee2bb61fb883cc8e77d636fb471aa3c0ce9ef0c0a8abd9682214bf0a8f16f26", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, - "verdict": "verified", + "trial_index": 3, + "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "4157e3e1e661cb3eb666347e1777e7a0f91db0beded1a3894b9bba5d60b8d7b8": { + "4649e4901902dd6aadb3108e0f89bd75854f5b64b0d59a28e567596a4ee75d58": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d7e1e084be213b01", - "receipt_type": "observer", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "O7R18ZRVdW9pT2SfPLszCk3dNu9SxXbRvYwT2kAvMFQfKM+raZpuTsTjK8uHj3Iha14qX23leTANv/kVmXZOBQ==", - "source_artifact_sha256": "bd93f6e9d767166a948c91db13a6d6ebf759630b605e6ecf130420e0511ee3a4", - "verified_at": "2026-08-18T11:24:00Z", + "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", + "receipt_type": "fault", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "jOuFrpBJNqqO9xoG1NMKELf9L5wymA8toKsai4zM6VyTCwSR0Hw9vyasVKyFT4J/9xZVZthxC+/ARQ4l1aL5CA==", + "source_artifact_sha256": "226019cc9a5778388b2bfe87bde12f7a08f8b33074eadc925d3e79197245a493", + "verified_at": "2026-08-18T10:54:00Z", "verified_projection": { - "attempt_id_sha256": "aa7d6be4f25a8992c0a22649ba7e703d6955abf5fece9f8322f560149cf09776", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "958342a9ddca98a83b82b662f52f404239d583afe7ed70634760e1b8dd592f3b", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "weak-effect-only", - "evidence_sha256": "bd93f6e9d767166a948c91db13a6d6ebf759630b605e6ecf130420e0511ee3a4", - "run_id_sha256": "b974de9da8ef77c8dc9a7662114cc51023ab8c131c488681eeebb7d4c435c8d0", + "condition": "stale-session", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "226019cc9a5778388b2bfe87bde12f7a08f8b33074eadc925d3e79197245a493", + "facts": {}, + "run_id_sha256": "6f2fb10bc2018c9f78e9702d5ccac0bedd78ee3b2e9d2a6ad779fba72d90ae50", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, - "verdict": "satisfied", + "verdict": "injected", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "418572792d67d3158bae6f0ab06a3c5e6aac3b56333c28fd7e00bf7452be9c0b": { + "46db9b4b3f93076b0958db1375ebda5a9fec42081d32df4d1bec5e0b45bd39c0": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", - "receipt_type": "fault", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "Y3q5qeX0v+8dHvYsUvpfpN8FmpGALAC2tQF8EhCvFjhLB+5i/ZiXi+dM5DS4t82vuXVqleW1sK75z4/7RSLqAw==", - "source_artifact_sha256": "3e1b6e01581eb35f1854a259db0f29c5efdebe4507aefb8ab6d4b0201182593c", - "verified_at": "2026-08-18T11:23:00Z", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "oxaxqhBx7WZIa6G+Uf1Bv9Yrpf/nQ915DNGUiHYVQHlkSCA069iYK4s4c0Et8K/ImoO24m4koqwtqz78bffiDA==", + "source_artifact_sha256": "0f409e89e3eb515df85e6adff2f2e9067dd70007afab83b7da6b7dce22e1824b", + "verified_at": "2026-08-18T10:23:00Z", "verified_projection": { - "attempt_id_sha256": "eb52fb1b1bf2fac92d8f3a444bb5081161be8b3d0ef457c5065e7b79e96df770", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "2601335b1101424105277997a67850a8a60aa45f59637b7679c1f32af463c460", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "weak-effect-only", - "evidence_sha256": "3e1b6e01581eb35f1854a259db0f29c5efdebe4507aefb8ab6d4b0201182593c", - "run_id_sha256": "794033f9da2a42448254a478fb6de954898b1e544148708ad30264efdc255431", + "condition": "healthy-03", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "0f409e89e3eb515df85e6adff2f2e9067dd70007afab83b7da6b7dce22e1824b", + "facts": {}, + "run_id_sha256": "237a0b7d1cafb64b1d113dca6699e6eefeaaf0b18679138545c3695495b901d5", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, - "verdict": "injected", + "verdict": "verified", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "42c9725850c0b81507d63757a3427d48e93db412915891ffd538e18eb73736be": { + "47a57ac3a76f6d6769d612a5d478882242a2354fce1255ed9ea6f3a1e4fdbb15": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-138dfa227234ea5f", - "receipt_type": "cleanup", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "CGUrGDnqzG/V+2jGC/Mkx+VdhkFoVCMN7eLOXt0ZWQ4zTtGXNmeNkFSHk3L/+H5AUUll3LLgsEzm4GVEu03qCg==", - "source_artifact_sha256": "feb27a02d37abdd67aa0b50cdce26c636bfc6b3284475e77a21d027738a91b5a", - "verified_at": "2026-08-18T10:22:00Z", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "xfOv3X/zCJBy9ufohNFWPtYWDPcZlRIYWyp5kZxJNilDMFZyPKmtNPibtTMyd67rjjSaM2H2/CJTgAulV7xxAQ==", + "source_artifact_sha256": "c2fe1abfc1e16a5382ce8eaf67f3774f713d586e6aefe6a00783455dceae530d", + "verified_at": "2026-08-18T10:02:00Z", "verified_projection": { - "attempt_id_sha256": "fc097c8b2e6ece94544a19b8d81f5c4a9367a89059e3dd4b2f746ab06a2fc930", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "679af5a8dedceb8c696719e73f82a698c230cd8fc98bb61769f0883202c0b637", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-03", - "evidence_sha256": "feb27a02d37abdd67aa0b50cdce26c636bfc6b3284475e77a21d027738a91b5a", - "run_id_sha256": "28768f565659133f5bf1170e638b81de4d7ca38dfecacd09ccf462a35344432b", + "condition": "healthy-01", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "c2fe1abfc1e16a5382ce8eaf67f3774f713d586e6aefe6a00783455dceae530d", + "facts": {}, + "run_id_sha256": "0b5bda916a0808165159166955a9563cf9c2303949f762a18eb037f41b44a6dc", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, - "verdict": "completed", + "verdict": "verified", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "45f1eee738934969cca1cb5fcdaed7dab6398cd9a05a7050822e88293b5d4cc7": { + "4830780f8c7ad36604ef1bd4935ae8ef598ac06c766368c7cadd8576a1d293e5": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", "receipt_type": "webhook", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "D5bR0BkmD06E08gOFVhwkAtGkFyaEMBQv1asy5P9AyOSPObFumY1WHL85gTMoylQiavKkpQ9Um2fC/Kb20QvAw==", - "source_artifact_sha256": "72afc710ff840f8432ddcceda6a5dd0e1e24f1d5bf0b5ee610c56b51ff260c6d", - "verified_at": "2026-08-18T11:12:00Z", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "jt6OB9Y2C2KB+wEBBy5RSO0Rx/6MVGvIJmAM2fP3Z3gH0XjSLEN3WxzGdwvvEevdssbuHk3akrOAVdspF6aSDg==", + "source_artifact_sha256": "ce91f56ef05d03386741ded56d7c2728b371c0ffcd8dc025c0dcad239242f6d5", + "verified_at": "2026-08-18T10:53:00Z", "verified_projection": { - "attempt_id_sha256": "f5e96a2e9a580376b18beabf57798b8761e772a0c4d112877045780bb12b3720", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "f5df4d6e64a2d38ffa8e320c87ad05d04025de267a8e152a755d3f1928ded120", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "verifier-unavailable", - "evidence_sha256": "72afc710ff840f8432ddcceda6a5dd0e1e24f1d5bf0b5ee610c56b51ff260c6d", - "run_id_sha256": "e8e89651045a5f5c011c9543ed968e0fe7697a061ed8ad5cedc27d194cb96acb", + "condition": "stale-session", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "ce91f56ef05d03386741ded56d7c2728b371c0ffcd8dc025c0dcad239242f6d5", + "facts": {}, + "run_id_sha256": "fd3a041b705d8c6277ce26134dc0018e866218cfa3fadd16ac29d1ad498965a3", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, + "trial_index": 2, "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "465866a38613308e52f541786521a40df3e6444bc5dab1858e13e061239193c7": { + "4938c27207a78a9be3803dd7c6889dcba7f8be5af7ed4adc9cb6193dc1364b4f": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d7e1e084be213b01", - "receipt_type": "observer", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "NONTpr+AZmp2e37ZmI1V/NoyflhTU5CrqiRV7TPU5bPuJjNtAeifBmNPJQlUNQPxv1UBIZe0X6MyTVtCYhPzCQ==", - "source_artifact_sha256": "7783dfcd8f2e57ff07c7bd69c17fa37665760981171e801c30d76e22a8d5802a", - "verified_at": "2026-08-18T11:13:00Z", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "7igZ9zpheClPWEucT+j5nNDpphMdhWDj8K2xvGHFbMAL+xMUKH7WisR1hQblcQFtrbbgehRmnhRic9swbmg7Bg==", + "source_artifact_sha256": "5e9c28fdf8c09dcfbbefa41ca8075e7daaa783d6ef24d5050cc9973c6aacb810", + "verified_at": "2026-08-18T11:24:00Z", "verified_projection": { - "attempt_id_sha256": "42259dbb767ced4c25ad8bd40edc209720a748897194c925ed9bd2e27b2258b2", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "aa7d6be4f25a8992c0a22649ba7e703d6955abf5fece9f8322f560149cf09776", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "verifier-unavailable", - "evidence_sha256": "7783dfcd8f2e57ff07c7bd69c17fa37665760981171e801c30d76e22a8d5802a", - "run_id_sha256": "4af84f2608a25a27e6252a5800263a238bb70fb3bec65148601ddcdddbf3e03c", + "condition": "weak-effect-only", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "5e9c28fdf8c09dcfbbefa41ca8075e7daaa783d6ef24d5050cc9973c6aacb810", + "facts": { + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "5e9c28fdf8c09dcfbbefa41ca8075e7daaa783d6ef24d5050cc9973c6aacb810", + "source": "runner_signed_flow_report_and_enforced_egress_policy" + }, + "operator_intervention_ids_sha256": [] + }, + "run_id_sha256": "b974de9da8ef77c8dc9a7662114cc51023ab8c131c488681eeebb7d4c435c8d0", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "satisfied", + "trial_index": 3, + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "471f74bd9498b31888a1ec333c7d225af618fe9a072dd2952587bb50bcd6a170": { + "4975d0d0574f5e4ed180eae087569cfb1b53445945a9e03f7bdc0b51aa40bfa4": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-138dfa227234ea5f", - "receipt_type": "cleanup", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "AeOBmu2Q57Oqy7zOy5agoWaRjbJGE9lj48MKpdsc19T1TVaZ0PrUG32HU/Y+GPjufroosX9zL1t6IF2TafQAAg==", - "source_artifact_sha256": "a28ad5edfe12f8c387974db36928b3aa5aa2bded20b70ce40baeea09eb16b8e1", - "verified_at": "2026-08-18T11:14:00Z", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "FhIwHVhDjDqbMWMMjBolYU3L5KC92thpL+EScRQrgyVnGwQ4xreceY1X5GEsBRfQ51BItpj9vyaRNQ4ski83Bg==", + "source_artifact_sha256": "2ae10ced05bdd00ae95b7a8d2893b178979ff8cf6d455c9e9fcf2596ecac18fb", + "verified_at": "2026-08-18T10:32:00Z", "verified_projection": { - "attempt_id_sha256": "ad76dacfe19a4421ef1f128d4eef1099e846b385d29f17b8588ae5130b487118", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "3142933f4f168c98b8e89f2ae9d78fd3129e0a9975cbbaa60ddba853eee7d53c", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "verifier-unavailable", - "evidence_sha256": "a28ad5edfe12f8c387974db36928b3aa5aa2bded20b70ce40baeea09eb16b8e1", - "run_id_sha256": "87014cd8063f5a43ea22c995be03ec41ef5aa613145acacdef71b68c468fc8f1", + "condition": "idempotency-replay", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "2ae10ced05bdd00ae95b7a8d2893b178979ff8cf6d455c9e9fcf2596ecac18fb", + "facts": { + "derived_classifications": { + "collateral_effect_count": 0, + "duplicate_effect_count": 0, + "intended_effect_count": 1, + "wrong_record_count": 0 + }, + "dispatch_state": "dispatched", + "effect_inventory": [ + { + "effect_id_sha256": "85bd45c21ceba0278062e4a705854e8e10526bc02ae78161394f25b4364eabf6", + "record_id_sha256": "0b1c6a0c1bb7de295f5b36891fd2b6b1edd16a9b926b3a24548d2374711a2751", + "transaction_ref_sha256": "e984028cb73b01ea87ff6063feeac5ec2136c993f8db59af4cb7956b44fd9c03" + } + ], + "expected_record_id_sha256": "0b1c6a0c1bb7de295f5b36891fd2b6b1edd16a9b926b3a24548d2374711a2751", + "expected_transaction_ref_sha256": "e984028cb73b01ea87ff6063feeac5ec2136c993f8db59af4cb7956b44fd9c03", + "post_state_evidence_sha256": "9fa1859d90e896d31fd6e3180e29b09b5b23e48beb0a87e10059798232a14f8c", + "pre_state_evidence_sha256": "8499492a906730830b1977c341eb8d1f7a825f8710231c6f9e615b1d1497d288", + "verifier_method": "read_only_system_of_record_query", + "verifier_tier": "independent_system_of_record" + }, + "run_id_sha256": "6cdff0cf50d0164fe1eee9c4b7db0b969c24f9b960f5653b516313a913c90a0f", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "completed", + "trial_index": 1, + "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "47380d14908be57018b19d846d86f0ba8f428ba7cd44f03219dd21117e504d3b": { + "49de0ab8efa7c46b2f4594bf74c916ec99f1694e45b3ec734566913d14b4225f": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d7e1e084be213b01", - "receipt_type": "observer", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "GDkutcMWF5gDivL/NIAZ+vbjY7ew+ewDnw5J/UxCEk8YcaXACLbbg3jIlqPeDNYcNNGeM5LCvteCZWT7ZSErAg==", - "source_artifact_sha256": "2a8bec5d9988588a24b36ed1499927f102d61b5867aad99f171fb4a89ce595bf", - "verified_at": "2026-08-18T10:12:00Z", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "8wb7TRu0pLCTQYdMoYop94kyad5g8FTw+w0vFt9P1rviTWf0JXo79NneYpW99HPBXleX1DK0TqG0t2fAqaJHDg==", + "source_artifact_sha256": "82e77fe44a201615e8f4c27505e4418bc71c0e4706dbe79be35ff085e812e4ad", + "verified_at": "2026-08-18T10:02:00Z", "verified_projection": { - "attempt_id_sha256": "940d3ca125ff87ce7539740fbae29d2d64fec839328b0639127e1d197d2485d8", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "679af5a8dedceb8c696719e73f82a698c230cd8fc98bb61769f0883202c0b637", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-02", - "evidence_sha256": "2a8bec5d9988588a24b36ed1499927f102d61b5867aad99f171fb4a89ce595bf", - "run_id_sha256": "bbb9312ce4682b23580eced0f8d19438d8266b222555df85fb27eef22ad5afe2", + "condition": "healthy-01", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "82e77fe44a201615e8f4c27505e4418bc71c0e4706dbe79be35ff085e812e4ad", + "facts": {}, + "run_id_sha256": "0b5bda916a0808165159166955a9563cf9c2303949f762a18eb037f41b44a6dc", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, - "verdict": "satisfied", + "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "47801787a92ee5738ee64b2bc3cda555dfc53682673d70e11bb9f94f799b371a": { + "49e6a4db6325d7245a2f8be4ae4d3defe236bf45fe8cf7775e5126575652a805": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", - "receipt_type": "fault", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "zAfOuFlelbRt715MjZlBj7QCevlk2pJ/nePNAd9T1HYCkDdvACuRzvDQcL87Rv52xtwmz2e1jWMg4JJ81WclDw==", - "source_artifact_sha256": "4337a75a39ceb7d333cbceb0fb54815f7dbe029048dbe20740c85d0b31f4d202", - "verified_at": "2026-08-18T10:52:00Z", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "FIEo66yW8J/k7LJ7PuVFCnjyuPW+Nsnw2Jjk8yFoQNtd5oivYv69mb7SYLL1tU5sXDF75O4HDSoaeqQXAw6DAw==", + "source_artifact_sha256": "ddf817056f83e416082775455ee6cb2ccc0139eeaeec131996cc584694bb9cf6", + "verified_at": "2026-08-18T11:04:00Z", "verified_projection": { - "attempt_id_sha256": "fbfce2be9ce964be8b668aa518a310fe4a89e5c014f42bd0ea81401bd83bfd7a", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "491a544656d05aea37920e5c7e2ad65a9452eac8d6e100268a599aeebd41187a", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "stale-session", - "evidence_sha256": "4337a75a39ceb7d333cbceb0fb54815f7dbe029048dbe20740c85d0b31f4d202", - "run_id_sha256": "d9270fd4c85e4226a9347ecf703e876b9ffdc330f60c7fb8bed8f9321ea30225", + "condition": "ambiguous-target", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "ddf817056f83e416082775455ee6cb2ccc0139eeaeec131996cc584694bb9cf6", + "facts": { + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "ddf817056f83e416082775455ee6cb2ccc0139eeaeec131996cc584694bb9cf6", + "source": "runner_signed_flow_report_and_enforced_egress_policy" + }, + "operator_intervention_ids_sha256": [] + }, + "run_id_sha256": "aa62c7a17701a7ef01ea1d3519b4c1f90d357495b329fdda3054cc24c581a593", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, - "verdict": "injected", + "trial_index": 3, + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "48204dcfbb7f14bb9885b499109da046b6455d3e2cdf47b6f017cf1aae9cf2f4": { + "4c3a2f062bd550c473b950f0dffd59d3526f54fadca154c653cc7f0011b9d31c": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-e37abcd79efd08db", "receipt_type": "replay", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "Ffx2GCjuALxTxbZbIduYzcsY3SpvHAPvW+ARR+LRdI6BZFHhFRxWdkIIis6NDPTk2y2XlIMeEuXUHr1HivjEAg==", - "source_artifact_sha256": "ffae42ea2ab78a78ef0b9b71e9b8a63f6b470d949ecfd892d84ebc512c1b64b9", - "verified_at": "2026-08-18T10:52:00Z", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "sVihMEI/TmGprVout2Hm+DnYN2SZcSX+Cp0PkjMwl6dblUYtSBk3njtMDphlSX+PWk448E27WbUlJmn9CrOCBQ==", + "source_artifact_sha256": "072e0fd54863672011c83e29fe39c24ea7e477fb77ad912967512a7e5d7ffa65", + "verified_at": "2026-08-18T10:24:00Z", "verified_projection": { - "attempt_id_sha256": "fbfce2be9ce964be8b668aa518a310fe4a89e5c014f42bd0ea81401bd83bfd7a", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "7573925adbd8a7a4a3b98bb0379549d77aa8ed46e312c1cd940c05b8587a039e", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "stale-session", - "evidence_sha256": "ffae42ea2ab78a78ef0b9b71e9b8a63f6b470d949ecfd892d84ebc512c1b64b9", - "run_id_sha256": "d9270fd4c85e4226a9347ecf703e876b9ffdc330f60c7fb8bed8f9321ea30225", + "condition": "healthy-03", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "072e0fd54863672011c83e29fe39c24ea7e477fb77ad912967512a7e5d7ffa65", + "facts": {}, + "run_id_sha256": "784a0a94e581700a3d93581e7ce5bac0d3bc53c58f3e73198b896b5da9a819b0", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, - "verdict": "halted", + "trial_index": 3, + "verdict": "verified", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "4862d7d39d33f17de4c889096ecaa907d1584807b22fc916e2a15d2462e70696": { + "4ca3d5eb8e380f12fb327214dadcf889acb28d7970b29fca53bf9f8f85700ae1": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-138dfa227234ea5f", - "receipt_type": "cleanup", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "fjYrcSKhsFsDCw77TFQ83UStv+5DOjx8TRDYtx8dfScjhejiAqr8gcfUo9K6U5y7eVfFMDieG6yzDKr/5kYRAg==", - "source_artifact_sha256": "ae52f89326f6a1eaced707ed240c61ddf62d1abbd3ac6891f3dc097aef1451cb", - "verified_at": "2026-08-18T11:12:00Z", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "HgAX1ZVGoKF9W/LNksPO13gkMPa9jisi1Wo9GXw5WRLQoGHwxxr/Io2RObvdZlf5RxihnukZ4IVJWjgm1qbEDQ==", + "source_artifact_sha256": "4166eb8e3a385de458c987a5463a1a35943cb8e54fa4a174c56729232a96605a", + "verified_at": "2026-08-18T10:13:00Z", "verified_projection": { - "attempt_id_sha256": "f5e96a2e9a580376b18beabf57798b8761e772a0c4d112877045780bb12b3720", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "3d42601a69ef46cc44f57b51762affef4ccd829ffde30125619a6e582af00dab", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "verifier-unavailable", - "evidence_sha256": "ae52f89326f6a1eaced707ed240c61ddf62d1abbd3ac6891f3dc097aef1451cb", - "run_id_sha256": "e8e89651045a5f5c011c9543ed968e0fe7697a061ed8ad5cedc27d194cb96acb", + "condition": "healthy-02", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "4166eb8e3a385de458c987a5463a1a35943cb8e54fa4a174c56729232a96605a", + "facts": { + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "4166eb8e3a385de458c987a5463a1a35943cb8e54fa4a174c56729232a96605a", + "source": "runner_signed_flow_report_and_enforced_egress_policy" + }, + "operator_intervention_ids_sha256": [] + }, + "run_id_sha256": "091e13ed70dab439b31cb506cf3bba1ddf6476696531cf891c39a924a928b7a1", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, - "verdict": "completed", + "trial_index": 2, + "verdict": "verified", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "48c07213b9025ee2168a2a7972ae7a2ac8f7aeda08b2ef95273dddd94d086d34": { + "4f32c6974bf19b3fcf9871beed963b99ec03ac9347a55059e9f5451333cb5b50": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "uwtk0AYuEmk/o0m8uJlCrKaFieNTBQZDSvnhZwgqHOHIVMO3XyQ+pEEvR8d/rTVJAT45zzWyOnAYPzVyOiQsCQ==", - "source_artifact_sha256": "7edf6488f59115500b130e22484d3834f8757bc027ac738d8616461b11f6c2c5", - "verified_at": "2026-08-18T10:04:00Z", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "dkr/ghG5sczKNzJLmd5DalgoQmVslTeE26kNtLzHz8M3uKVKTzEct4tljKVkwvyT/5rbrGHuLs4bZA+l4LPXBA==", + "source_artifact_sha256": "68f28b4ae7bd66c29ac1d2e3cf594da46ea4d7fa7bfc29557c835bb848cf81d8", + "verified_at": "2026-08-18T11:23:00Z", + "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "eb52fb1b1bf2fac92d8f3a444bb5081161be8b3d0ef457c5065e7b79e96df770", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "weak-effect-only", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "68f28b4ae7bd66c29ac1d2e3cf594da46ea4d7fa7bfc29557c835bb848cf81d8", + "facts": {}, + "run_id_sha256": "794033f9da2a42448254a478fb6de954898b1e544148708ad30264efdc255431", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "delivered", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "50c2a328d61a13cb7fd97b9eafe0e28fea69e930de081ac511e2023f3596a15c": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "k8K7i8ckUErWWhSTnlvdOeJkDR+5AKQz1X24MbfTJM2YcXqJdhr71JSTdQCg2tM7A6Oe6MKNwEzfps8+hQ3fCQ==", + "source_artifact_sha256": "48d2fa219c08a4043c3d974e574816a8b3952b9f1b5d638dd8a8fa098edc61dc", + "verified_at": "2026-08-18T10:33:00Z", "verified_projection": { - "attempt_id_sha256": "4c352a6999f77707e8837adebb4fc2b7451c2ef6de5145190b33a5c5645e47eb", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "4667302b580ff7ceb223dbb15eb6d029969a8f6a54bcd33e8df5b6bff41f41ad", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-01", - "evidence_sha256": "7edf6488f59115500b130e22484d3834f8757bc027ac738d8616461b11f6c2c5", - "run_id_sha256": "4ee2bb61fb883cc8e77d636fb471aa3c0ce9ef0c0a8abd9682214bf0a8f16f26", + "condition": "idempotency-replay", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "48d2fa219c08a4043c3d974e574816a8b3952b9f1b5d638dd8a8fa098edc61dc", + "facts": {}, + "run_id_sha256": "33e0ad9bf64e477f24d46508fa432123e046dcd1c5853d5cc60b7cde1bce7537", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "verified", + "trial_index": 2, + "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "4964bd1ea76f57d04c90ac2cb32ad42b9aa24e8c8d42439c7c7a4176d8a5589e": { + "50ff634de0b6e29c4dfec89dae15e01e3872c32eff0ad8473e3eae442ea9f45a": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "vPxMoYsh7u1afXkgVE7VS5Desx448pwQXh4XWGJIxGXTYI/HnDlM9dLp2nO1uHSXLOyRAJcu45WLfNtU/cgLAQ==", - "source_artifact_sha256": "3a27387e7fb8b622f0150b1da9c81b97bbbf046c3e6be1dd3360f203fb460925", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "1uGrvhyOUZfUygvmJLehCAGah4BVFD7N7q69kWLVMzKU+BI0eMqTtex3kb00FntefzWuMJkfmFCte8naWAUTAA==", + "source_artifact_sha256": "11cdb7bd9282bd8b9c10b25bd5e552c14ca6658cb559b133ce7e6b8dfc17f0f3", "verified_at": "2026-08-18T10:42:00Z", "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "e93521e706ad90d799dcd4e8cac15229c5da6aec1638540606f5fab4efce59fc", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "wrong-reference", - "evidence_sha256": "3a27387e7fb8b622f0150b1da9c81b97bbbf046c3e6be1dd3360f203fb460925", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "11cdb7bd9282bd8b9c10b25bd5e552c14ca6658cb559b133ce7e6b8dfc17f0f3", + "facts": {}, "run_id_sha256": "ee82112f55e5e6c86cfd6e16df8c8b652549a8bd72de492f435d8255eb3dd252", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, - "verdict": "halted", + "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "4b3a4b3c9eca7b6cc75e95ac329d8825b3caa30aa49f425d714f2409a566485f": { + "532808072697066585e9e78c84eb3df8a14d22f57a3499cd47a1a26c61062330": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", - "receipt_type": "fault", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "GPgunEwXGewn18IveY1+pHln+lbQfJs/1vGPjnvojzXJ60nTdVpyhL8Kt+2e4WKkGDOS0IO1UQP+WdySJNPQDw==", - "source_artifact_sha256": "49dbd40897c1bf5714a6e032fc07ef378207978f4db7ee347783daf9bfba90ca", - "verified_at": "2026-08-18T11:14:00Z", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "TnlFbmWHqcatRTc9JA8Ff89GiP0O/cHFEJfLYOWWIXN8vbl2mCXswd0PDdjCydidIHAWJQPyZ1tsRcQOyRf3AA==", + "source_artifact_sha256": "d8c7b50d16df0a959a2fd2323040253e31e95b612b1ab829e460e68e6ad935b1", + "verified_at": "2026-08-18T10:52:00Z", "verified_projection": { - "attempt_id_sha256": "ad76dacfe19a4421ef1f128d4eef1099e846b385d29f17b8588ae5130b487118", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "fbfce2be9ce964be8b668aa518a310fe4a89e5c014f42bd0ea81401bd83bfd7a", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "verifier-unavailable", - "evidence_sha256": "49dbd40897c1bf5714a6e032fc07ef378207978f4db7ee347783daf9bfba90ca", - "run_id_sha256": "87014cd8063f5a43ea22c995be03ec41ef5aa613145acacdef71b68c468fc8f1", + "condition": "stale-session", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "d8c7b50d16df0a959a2fd2323040253e31e95b612b1ab829e460e68e6ad935b1", + "facts": {}, + "run_id_sha256": "d9270fd4c85e4226a9347ecf703e876b9ffdc330f60c7fb8bed8f9321ea30225", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "injected", + "trial_index": 1, + "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "4cfd8a817a8c1420280b8aea0a449a467135ebcbc3bb6295e2a1a908a0d22a8a": { + "54c1991cfc25ee0e9c19b42b0901851afed31454ab224132d6ba1f0438543683": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d7e1e084be213b01", - "receipt_type": "observer", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "MEjflJ78ngaXqG7iEOVH1l/42w/AfShIyOnc5yoI1/dPnrmyGI/3tanDDrFZmFPu9RJ0XKAV5f8XBCMb+QirCQ==", - "source_artifact_sha256": "6820b7608a765ba712f9643379187af143db8c68f93b58d7a8825daa976ffc69", - "verified_at": "2026-08-18T11:02:00Z", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "N29jsZ9hX3mN4OWmVbFboeX8NkHD+rvZDKXhOhJQhBl2BSm/xTHOqqUgWl/MrzYQKvhN02q5K9LTG6IC4gioDA==", + "source_artifact_sha256": "2811b870f1234408f64ada1ddab6eb1a4160941d92a9f9df96df037d1da69536", + "verified_at": "2026-08-18T10:12:00Z", "verified_projection": { - "attempt_id_sha256": "60ee9db05b1126cfaa3b31c13bc3fab4755ac09c44e846b4d07ee51865dfa7b1", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "940d3ca125ff87ce7539740fbae29d2d64fec839328b0639127e1d197d2485d8", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "ambiguous-target", - "evidence_sha256": "6820b7608a765ba712f9643379187af143db8c68f93b58d7a8825daa976ffc69", - "run_id_sha256": "628f991a182613b8700294d7483b5a4c06872cb9d5ca6047ea552b8ab6585357", + "condition": "healthy-02", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "2811b870f1234408f64ada1ddab6eb1a4160941d92a9f9df96df037d1da69536", + "facts": {}, + "run_id_sha256": "bbb9312ce4682b23580eced0f8d19438d8266b222555df85fb27eef22ad5afe2", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, - "verdict": "satisfied", + "verdict": "verified", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "4d217e2a3ebb192fa8e2b2126a002c17c90e22d8562e7a749c5a0d922015d625": { + "5634cde23250446592813e4ebf81ff20cffd3b116818f8d8a4297d175e993be7": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-138dfa227234ea5f", - "receipt_type": "cleanup", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "P8thSMKp6iujbuyZHxGUDW9/3Boal18QxOZ3QUA4rG3YC9/fCiq1v5+858bzc8wZJ6gPywboqdu+S65xXM/QCg==", - "source_artifact_sha256": "c51fe4dc79cc2e8b749809c818af5f63c67cbe6e82656cb990d1bc7b13a0b6eb", - "verified_at": "2026-08-18T10:34:00Z", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "utfHRpHOIRKsCYVFTc9H2H8xVRcH8gbJTTDlpjgHIqpSt4rgy0MV3QjXYHcjsw8W5pgBFzwudSNvsM6Ngd9vBg==", + "source_artifact_sha256": "cfa32a5a84ca628c634a548be23b97ffb53dc187e1e8b479a30dba14275ec44a", + "verified_at": "2026-08-18T11:13:00Z", "verified_projection": { - "attempt_id_sha256": "3aee8ad755c7f4bec71cc194bcfaa805e0ea29cf8b830ed0782f8263dd9620ca", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "42259dbb767ced4c25ad8bd40edc209720a748897194c925ed9bd2e27b2258b2", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "idempotency-replay", - "evidence_sha256": "c51fe4dc79cc2e8b749809c818af5f63c67cbe6e82656cb990d1bc7b13a0b6eb", - "run_id_sha256": "3df83453126754a62d00ed10837720542d0469799bb8a88cb5257ac5f477a919", + "condition": "verifier-unavailable", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "cfa32a5a84ca628c634a548be23b97ffb53dc187e1e8b479a30dba14275ec44a", + "facts": { + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "cfa32a5a84ca628c634a548be23b97ffb53dc187e1e8b479a30dba14275ec44a", + "source": "runner_signed_flow_report_and_enforced_egress_policy" + }, + "operator_intervention_ids_sha256": [] + }, + "run_id_sha256": "4af84f2608a25a27e6252a5800263a238bb70fb3bec65148601ddcdddbf3e03c", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "completed", + "trial_index": 2, + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "4e04402568630dfc4590fbecf04015269f4a6e6546e276a92bf4b6b657f8a8db": { + "5653aa19c3b4662ef8d1add74e5911af8f972791895812f4fec40722fd8af7e9": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", - "receipt_type": "fault", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "oStPtcqHOGUF2Kmd0v2T3AZ1ch3yU+ud6Xop1yJ9Bq3wqxMN0Ik7Xg2ImY6VGpvuJ7xcbxMu576MGF4gI8frAw==", - "source_artifact_sha256": "e7f1dc034e24ac6d0aad3990e694aa281baa8c3e11415deb28fdd2e98bbdd313", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "NFmSUg0NetpHQH9dS3K6ma1BYTV4589cF3/29CdczLAsR4mjC1DpLhxK0rTDAYR13++BlC3wNQ/vds7VkOWfDw==", + "source_artifact_sha256": "7d89d8f99f5fd27361d5750bd99439b0669933179a8e2ce8e3c66d7f551cf8c3", "verified_at": "2026-08-18T10:43:00Z", "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "6b0e5c10d55fc92c1ff8576392270a24fb65722414cf58ff9a51b8ce9ef88587", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "wrong-reference", - "evidence_sha256": "e7f1dc034e24ac6d0aad3990e694aa281baa8c3e11415deb28fdd2e98bbdd313", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "7d89d8f99f5fd27361d5750bd99439b0669933179a8e2ce8e3c66d7f551cf8c3", + "facts": {}, "run_id_sha256": "577e37b10b1c87fd9c1b5d320888b736d272824657fd59a012e85a284ee88540", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, - "verdict": "injected", + "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "50cfc15f662201c2e03cf91d2156a213a28ab028cc4856c64d7da2204a5cdc55": { + "57af80b4f9c67ba20ca7749c4d68e814cf91aba0141012d9f7385b7d9ec3f60f": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", - "receipt_type": "runner", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "z9MS+rTNm5TahzStaE696L0PNsx6X80DI2YeI209gLOaGl6kbsKIk4kRfPpD5ZBbyAMiLKpuUVwmG+rlXDgoBA==", - "source_artifact_sha256": "17bb1d69cfdd94f6150054ac594fc42cd59a8d09b780ee0103962cd549f157ef", - "verified_at": "2026-08-18T10:53:00Z", + "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", + "receipt_type": "fault", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "M4DeWIBYMUad26tVjrdjz9yVkraW21z+uCplyM9mN7gU9euh+ambYGSvQXMbu+PSARac9OkJl0gpMlJnRpDtBw==", + "source_artifact_sha256": "4337a75a39ceb7d333cbceb0fb54815f7dbe029048dbe20740c85d0b31f4d202", + "verified_at": "2026-08-18T10:52:00Z", "verified_projection": { - "attempt_id_sha256": "f5df4d6e64a2d38ffa8e320c87ad05d04025de267a8e152a755d3f1928ded120", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "fbfce2be9ce964be8b668aa518a310fe4a89e5c014f42bd0ea81401bd83bfd7a", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "stale-session", - "evidence_sha256": "17bb1d69cfdd94f6150054ac594fc42cd59a8d09b780ee0103962cd549f157ef", - "run_id_sha256": "fd3a041b705d8c6277ce26134dc0018e866218cfa3fadd16ac29d1ad498965a3", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "4337a75a39ceb7d333cbceb0fb54815f7dbe029048dbe20740c85d0b31f4d202", + "facts": {}, + "run_id_sha256": "d9270fd4c85e4226a9347ecf703e876b9ffdc330f60c7fb8bed8f9321ea30225", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "halted", + "trial_index": 1, + "verdict": "injected", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "53299c8e5f88e4000630fe3142648c66fa7ea8c0bae92b94606a9dccb387a3cf": { + "5c27733530c91746965049d5f68a6941c1b64018aa0272eb8eca9a1a086386fe": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-138dfa227234ea5f", - "receipt_type": "cleanup", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "kuw45taK0wj/mrX/+B868Q5YaRB9x+sZTkdAGhh7J5a+7MZIwJ65GeWjuA01g0hlIrcf7k4nHeRnQjs2QDnaBg==", - "source_artifact_sha256": "89e92e0a76d7ef86a369ad65837369620240dc66bc215bc9fa3fddc21d777f9e", - "verified_at": "2026-08-18T10:32:00Z", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "QQO1+hA3S9E/VHw41nouxsPY/InCwNMNmFzWHBuPo6nbMUDxkJs6ulZOijeqWurdLf9P0+qAiELiO+loXIVtBA==", + "source_artifact_sha256": "72afc710ff840f8432ddcceda6a5dd0e1e24f1d5bf0b5ee610c56b51ff260c6d", + "verified_at": "2026-08-18T11:12:00Z", "verified_projection": { - "attempt_id_sha256": "3142933f4f168c98b8e89f2ae9d78fd3129e0a9975cbbaa60ddba853eee7d53c", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "f5e96a2e9a580376b18beabf57798b8761e772a0c4d112877045780bb12b3720", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "idempotency-replay", - "evidence_sha256": "89e92e0a76d7ef86a369ad65837369620240dc66bc215bc9fa3fddc21d777f9e", - "run_id_sha256": "6cdff0cf50d0164fe1eee9c4b7db0b969c24f9b960f5653b516313a913c90a0f", + "condition": "verifier-unavailable", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "72afc710ff840f8432ddcceda6a5dd0e1e24f1d5bf0b5ee610c56b51ff260c6d", + "facts": {}, + "run_id_sha256": "e8e89651045a5f5c011c9543ed968e0fe7697a061ed8ad5cedc27d194cb96acb", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, - "verdict": "completed", + "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "56b976ecc7eab49bd4b71a8735efac41939cd37654e0a90b7e45053ead2b8d73": { + "5cfada7a9502dc0499d3b9d2ab92a6ad84e6b2a5b1298a05e006fdac34e9fbb5": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-138dfa227234ea5f", "receipt_type": "cleanup", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "ePCK33av9aw6waScoT0pai97j4ogr5txjw35nRITtLceyJGc5EqSpPiu5rwCjq6dN0XfvqMeriwVuCsgHOiUAw==", - "source_artifact_sha256": "61e65cf0f747b77668ae9e6632a66d6d32d3dff99318b22ed782df46a78dbf0f", - "verified_at": "2026-08-18T10:44:00Z", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "m3DdYHjPp4RH5S3vba5hxxkzFyL42KNkxWM/2f9kMxWYHxL6rLI2Ju101/+p+oZYFchwVnVvqx5uKi4xvS0+Dw==", + "source_artifact_sha256": "9aff04082026c9a005b5b56eb7078d056d424b5024e1034aa161c875b0f71b80", + "verified_at": "2026-08-18T11:23:00Z", "verified_projection": { - "attempt_id_sha256": "7c910764b2dcc6f05261d609082f75474e4638c3f356006307212b8fed4a2eb7", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "eb52fb1b1bf2fac92d8f3a444bb5081161be8b3d0ef457c5065e7b79e96df770", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "wrong-reference", - "evidence_sha256": "61e65cf0f747b77668ae9e6632a66d6d32d3dff99318b22ed782df46a78dbf0f", - "run_id_sha256": "fe98ce7f0e66b885201f4667875fd38f5890ffddb575d68bd4cd5a66f8d53ca8", + "condition": "weak-effect-only", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "9aff04082026c9a005b5b56eb7078d056d424b5024e1034aa161c875b0f71b80", + "facts": {}, + "run_id_sha256": "794033f9da2a42448254a478fb6de954898b1e544148708ad30264efdc255431", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, + "trial_index": 2, "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "5702bcf5ba24d9f8ff0df4cc5fd89d67a89b385d7de2d45101840a56f183003a": { + "61152c7946d6e0b701c6ff999dc1b1b63b0bdee8c4754077ce1909f5b6d279bd": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "W/dKjg41r91I837cW++pdeVNrceYiUvyqTxyN18SMXujvBdLgBa57k38ogfnNFI9kAMn9Rx6HGwzA48Ddkr6AA==", - "source_artifact_sha256": "6eac8e2767237847378635c85aa204fee9f7317f048965d102409679612f37c4", - "verified_at": "2026-08-18T11:23:00Z", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "1fzHxpsdM+XN9mq3E/fwCkGnPwYH2d57LlQg46Zl7IXIfagXuHyb5YU7DSSY4qKtOMI6Bzee+CkUC+jGb2HGDg==", + "source_artifact_sha256": "e7e294aaa63908c75e3513aee7e29b3bd24623d3fda8d6fe6fbb9dd04227630f", + "verified_at": "2026-08-18T10:23:00Z", "verified_projection": { - "attempt_id_sha256": "eb52fb1b1bf2fac92d8f3a444bb5081161be8b3d0ef457c5065e7b79e96df770", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "2601335b1101424105277997a67850a8a60aa45f59637b7679c1f32af463c460", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "weak-effect-only", - "evidence_sha256": "6eac8e2767237847378635c85aa204fee9f7317f048965d102409679612f37c4", - "run_id_sha256": "794033f9da2a42448254a478fb6de954898b1e544148708ad30264efdc255431", + "condition": "healthy-03", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "e7e294aaa63908c75e3513aee7e29b3bd24623d3fda8d6fe6fbb9dd04227630f", + "facts": {}, + "run_id_sha256": "237a0b7d1cafb64b1d113dca6699e6eefeaaf0b18679138545c3695495b901d5", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, - "verdict": "halted", + "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "590846759c1280e18e608456c0e11b64221cfcafa73ab8f061d6dcb5fd762699": { + "61de0f8814b796a5fc827d229ec0a83d37e81a097a8e8a0ab276d0eb1a274ae5": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", "receipt_type": "fault", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "F+o4UhDVHDOhoW5zNKrH8E+NcdfO4hRq/CnB2g88u592JmKvhC8msfrzquGvJum6f5FFf+wheeeCWQWWOS2JDw==", - "source_artifact_sha256": "99fd8516daeb8b22c42479814dbed2b01d63985db824c0237ed8ac83efd0dca0", - "verified_at": "2026-08-18T11:03:00Z", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "IdOCDuUKXQPfG7xbL6PSwIUXJ35WEV70TMShZgyBmGtFTKAKi2ddpWZqKCkNg9l7qtx8oc4n2mK9DqGTGcuhDg==", + "source_artifact_sha256": "0eafb7867b5bb7cf68f39f40315893e1d694dd3566b71331a554025c69b9504f", + "verified_at": "2026-08-18T10:42:00Z", "verified_projection": { - "attempt_id_sha256": "1ec11a9862ede3ac701af71835ac28c551d604a026b5bab7d776dbcdf288394e", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "e93521e706ad90d799dcd4e8cac15229c5da6aec1638540606f5fab4efce59fc", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "ambiguous-target", - "evidence_sha256": "99fd8516daeb8b22c42479814dbed2b01d63985db824c0237ed8ac83efd0dca0", - "run_id_sha256": "43f0a1c00950c390b0676fab55a2aa98c354d028f2347c461661e6cdb72f717e", + "condition": "wrong-reference", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "0eafb7867b5bb7cf68f39f40315893e1d694dd3566b71331a554025c69b9504f", + "facts": {}, + "run_id_sha256": "ee82112f55e5e6c86cfd6e16df8c8b652549a8bd72de492f435d8255eb3dd252", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, + "trial_index": 1, "verdict": "injected", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "596a2bb3c7e416b245f5ed30fc86e4208af76997b62472bfbf278c79abee47ec": { + "620ac6e3d7907f00bc17a13c98a6f49d1b6e5f4be2f45e348f07b8cb680f1f81": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-138dfa227234ea5f", - "receipt_type": "cleanup", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "lvwUuOfdkm5vqUcK1uSspK/zWH8DjGCypU+WDqzBbWziXCeqnmuhE5m1WzdP/JXtWrNoiMUTgzwUpenXkjGwCQ==", - "source_artifact_sha256": "d4f5375e18344432614ad6d37de4727b4ccbfb1465851f36df15fcd2cf052c4e", - "verified_at": "2026-08-18T10:03:00Z", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "B7BNXAf5AnNinlwLkeND38ks1cilN5saiM3Z+8Vba0Bgd850Rb2PtmKTmtSZG6nmNBgvSwgqIVRfI92BYBhDBw==", + "source_artifact_sha256": "9ee6e57b75e164f5f91625d37f3d8286db558d96de0fe27acfcfc45c1288fda5", + "verified_at": "2026-08-18T11:03:00Z", "verified_projection": { - "attempt_id_sha256": "fdad940f245d690750ad647fac25c7e76aac2f474db49732fec8129051750186", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "1ec11a9862ede3ac701af71835ac28c551d604a026b5bab7d776dbcdf288394e", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-01", - "evidence_sha256": "d4f5375e18344432614ad6d37de4727b4ccbfb1465851f36df15fcd2cf052c4e", - "run_id_sha256": "3739043a92a8781376cfbd022460c03aba40f92a800b3885ebc046321437bc40", + "condition": "ambiguous-target", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "9ee6e57b75e164f5f91625d37f3d8286db558d96de0fe27acfcfc45c1288fda5", + "facts": {}, + "run_id_sha256": "43f0a1c00950c390b0676fab55a2aa98c354d028f2347c461661e6cdb72f717e", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, - "verdict": "completed", + "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "59c12284d73e7334ebbca691f3076346f93c97e78dc807dd4a65678b5bc74e42": { + "623ae0f6cc3220ffa04c016943dc42361acb180e7f5649b4b410e3661063a450": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-d92d542a589844dd", "receipt_type": "cleanup_absence", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "Ry0ulK360QfUGjlEVSQFonEOzQezpdZOACErX+Y9yFJTJrgHvhebfntInqKYscGXuG+vA1GaMm7LVa+aSPnhDA==", - "source_artifact_sha256": "b9930bf1c041fb17cb156788d0424c034c6be2711ca5911469fb8791a6c925f4", - "verified_at": "2026-08-18T10:34:00Z", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "+bU3ND+Mc3wR4g/HLadcuzvY5605oX79uJzz3tBE3bWybVLojL7HXZ/haeVyPvTnAeMVCS/5EI/89Zuslk0HDg==", + "source_artifact_sha256": "0e7b1e0c28c2cfe39870f987c674129552a27582914b580f2e13474b3636e942", + "verified_at": "2026-08-18T10:32:00Z", "verified_projection": { - "attempt_id_sha256": "3aee8ad755c7f4bec71cc194bcfaa805e0ea29cf8b830ed0782f8263dd9620ca", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "3142933f4f168c98b8e89f2ae9d78fd3129e0a9975cbbaa60ddba853eee7d53c", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "idempotency-replay", - "evidence_sha256": "b9930bf1c041fb17cb156788d0424c034c6be2711ca5911469fb8791a6c925f4", - "run_id_sha256": "3df83453126754a62d00ed10837720542d0469799bb8a88cb5257ac5f477a919", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "0e7b1e0c28c2cfe39870f987c674129552a27582914b580f2e13474b3636e942", + "facts": {}, + "run_id_sha256": "6cdff0cf50d0164fe1eee9c4b7db0b969c24f9b960f5653b516313a913c90a0f", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, + "trial_index": 1, "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "5ba58c2263a1dd72bb9bd200222709f04dadba7bebbf1d1bec3e779780f39c7b": { + "624fbbdd7880133c85ef5e91662bd815d4f451b168876822f76ac149caba0b11": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "suQE12DW7RJtQcrvlsZBY8qvTfMdn+vFXitM/QFMIR8AGRzkWjYazOC0UR72slCZfRDWW5TY7s9shuc5Ata+Ag==", - "source_artifact_sha256": "0e28a6c49ce0c22f0e6a0220a2c3340d4e956f0f9a29511f0c44e7492d004a89", - "verified_at": "2026-08-18T11:13:00Z", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "Vy5RiysTcZFYrD8cw94AB+mEumRD+wQ7XosmMSCI3tfT8S+WCbkT+CLQ+RQY+K+pmj3/394T+1jbIMH73EWgAg==", + "source_artifact_sha256": "2c464c80d9d0976e30c3c1b674426f3db967a0264e7bb8ee48984e6b235a5a80", + "verified_at": "2026-08-18T10:44:00Z", "verified_projection": { - "attempt_id_sha256": "42259dbb767ced4c25ad8bd40edc209720a748897194c925ed9bd2e27b2258b2", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "7c910764b2dcc6f05261d609082f75474e4638c3f356006307212b8fed4a2eb7", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "verifier-unavailable", - "evidence_sha256": "0e28a6c49ce0c22f0e6a0220a2c3340d4e956f0f9a29511f0c44e7492d004a89", - "run_id_sha256": "4af84f2608a25a27e6252a5800263a238bb70fb3bec65148601ddcdddbf3e03c", + "condition": "wrong-reference", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "2c464c80d9d0976e30c3c1b674426f3db967a0264e7bb8ee48984e6b235a5a80", + "facts": {}, + "run_id_sha256": "fe98ce7f0e66b885201f4667875fd38f5890ffddb575d68bd4cd5a66f8d53ca8", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "delivered", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "64044bd99feae9406b2089417a4e5b33dca8a65bc8c4c0227b47594912bf71c1": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "eQhYzzODVj5EOITyB1i7RnkM9ku3kXliT5Dy9HaXc8QQYLIm0d/BHQBD5g2V/G2MKjiBstWMn/0Nz8445TnaAQ==", + "source_artifact_sha256": "c68ae5d22981662c17338c01af40177a0e375c993c4e4dcefc9aaf4df2d5366d", + "verified_at": "2026-08-18T10:23:00Z", + "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "2601335b1101424105277997a67850a8a60aa45f59637b7679c1f32af463c460", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-03", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "c68ae5d22981662c17338c01af40177a0e375c993c4e4dcefc9aaf4df2d5366d", + "facts": {}, + "run_id_sha256": "237a0b7d1cafb64b1d113dca6699e6eefeaaf0b18679138545c3695495b901d5", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, - "verdict": "absent", + "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "5f0221453529c8e3be2e2b23b2603925fbdf1502f576c16e2a40304d75ec9808": { + "64adf7272b03ff909a4d9420d130a4755b4925ea6f6e76341b621a79e975a5d7": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "8U8glS/KUma1lgaMlm7O7Ew80hm3f1+kHFDoMgD4W/E67+VkeIxhwsZ1PD5DAsP5GbVwHDJhOHurtVsPz7zbBA==", - "source_artifact_sha256": "dcdc96c4f09e390d61f558318a74baef2f65d601e71808bdbf922fcc7f4d5bbf", - "verified_at": "2026-08-18T10:03:00Z", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "yT/7ky+j24+nw9fIpaJhD8tgTv0OzAiVHGRC2fTUG4IFe92P5HccmQZUcVSyBq6GYHupOf25f/GrRnUOaH0xBg==", + "source_artifact_sha256": "b9930bf1c041fb17cb156788d0424c034c6be2711ca5911469fb8791a6c925f4", + "verified_at": "2026-08-18T10:34:00Z", "verified_projection": { - "attempt_id_sha256": "fdad940f245d690750ad647fac25c7e76aac2f474db49732fec8129051750186", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "3aee8ad755c7f4bec71cc194bcfaa805e0ea29cf8b830ed0782f8263dd9620ca", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-01", - "evidence_sha256": "dcdc96c4f09e390d61f558318a74baef2f65d601e71808bdbf922fcc7f4d5bbf", - "run_id_sha256": "3739043a92a8781376cfbd022460c03aba40f92a800b3885ebc046321437bc40", + "condition": "idempotency-replay", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "b9930bf1c041fb17cb156788d0424c034c6be2711ca5911469fb8791a6c925f4", + "facts": {}, + "run_id_sha256": "3df83453126754a62d00ed10837720542d0469799bb8a88cb5257ac5f477a919", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "verified", + "trial_index": 3, + "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "661cc3ad4b5da051980466dc525c7a6b1366756913780519657bf5b148ce440e": { + "65fba274ba6ef5364ee1212f448cacfa222246d4c278b29535b3569b9bfd699b": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "iKCxOVOs0sblvfMn4jKokvGptmZL69HLmgG6WpEoAZhXMFQIlNKWEKh01a2brWekzDVGe8hUzXgR0trwAXTIAg==", - "source_artifact_sha256": "c5d1d4394bb4197462d6bb136e8e249ac9d8c283bf8563a8ffbd0b7e0141795f", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "8T5U0FgVeZTtZqvZdi7iRA36FC/hLFPbtczSmdSRTWA3LTjSwoeWFbXxavbxC3VGU9XYHFOP/6yPv8QeufrHAw==", + "source_artifact_sha256": "c129344c7dd911068c387c21d9a1042713a90190dcd848662cf894d8283c4db2", "verified_at": "2026-08-18T10:54:00Z", "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "958342a9ddca98a83b82b662f52f404239d583afe7ed70634760e1b8dd592f3b", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "stale-session", - "evidence_sha256": "c5d1d4394bb4197462d6bb136e8e249ac9d8c283bf8563a8ffbd0b7e0141795f", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "c129344c7dd911068c387c21d9a1042713a90190dcd848662cf894d8283c4db2", + "facts": {}, "run_id_sha256": "6f2fb10bc2018c9f78e9702d5ccac0bedd78ee3b2e9d2a6ad779fba72d90ae50", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, - "verdict": "delivered", + "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "6909ceef7116356c56ca4737de1356b656ee491362571e3b50e588b4f6359b17": { + "67aef634540cce7bb70a512081e96ebc7edd41e8bb8835891ce1378efd425557": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-138dfa227234ea5f", "receipt_type": "cleanup", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "GBCdnUEfOfVI29XBWss94kkyXao0c7etlOya26qXeF8L8fob3FODGm0sWYBICGTOUsscxmmdNjHyzdSwVrUBCQ==", - "source_artifact_sha256": "27c78ad5d0a8808752297aff7a4618ed4a5fb67e9ad3f7cb237a202a19a83282", - "verified_at": "2026-08-18T11:03:00Z", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "VZqeX1oqQnQLVuUUmXRa8IamudaFHwFsy1pR7G2pSheJmSYho28B5tRuTdNiwvBvwTisKDKzRBmqYHuQP62QBQ==", + "source_artifact_sha256": "b2d52421d96d2fc81f80e91f43d0228f793bae8fefedbea6d79a281c903b0000", + "verified_at": "2026-08-18T10:33:00Z", "verified_projection": { - "attempt_id_sha256": "1ec11a9862ede3ac701af71835ac28c551d604a026b5bab7d776dbcdf288394e", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "4667302b580ff7ceb223dbb15eb6d029969a8f6a54bcd33e8df5b6bff41f41ad", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "ambiguous-target", - "evidence_sha256": "27c78ad5d0a8808752297aff7a4618ed4a5fb67e9ad3f7cb237a202a19a83282", - "run_id_sha256": "43f0a1c00950c390b0676fab55a2aa98c354d028f2347c461661e6cdb72f717e", + "condition": "idempotency-replay", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "b2d52421d96d2fc81f80e91f43d0228f793bae8fefedbea6d79a281c903b0000", + "facts": {}, + "run_id_sha256": "33e0ad9bf64e477f24d46508fa432123e046dcd1c5853d5cc60b7cde1bce7537", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, @@ -2435,240 +3156,299 @@ "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "6ab281eabcbff71abd1ffaa1b2ee7f6b082673890d01882b7a842b1ee3e7ac8d": { - "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "5cFTW3YNDdfCzqAGYfBP60ACwb3Uj9vWTPY4LDdvR4FbHuhi4oV90yPK08m7iBWFr2jbNXh0c1dTYX93pbRgCQ==", - "source_artifact_sha256": "a46df95e5690b582be425e126233998cf8a82e1db8ea11a5dade90b3cc616b28", - "verified_at": "2026-08-18T10:14:00Z", - "verified_projection": { - "attempt_id_sha256": "019dd96e9a771ccc01ebafab321d7d3a8314df8b2d6465bcfc5fa14cbdeabdf2", - "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-02", - "evidence_sha256": "a46df95e5690b582be425e126233998cf8a82e1db8ea11a5dade90b3cc616b28", - "run_id_sha256": "16cb8df40654c6a1b55ea0e50e772d8c6e6d4f0d8205bd1f8296be27d0af83eb", - "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "task": "execute-acceptance", - "trial_index": 3, - "verdict": "verified", - "workflow_version_id": "44444444-4444-4444-8444-444444444444" - } - }, - "6bd1e4fa831b1274c6011187dec731e64b9076912681ddfbfbf53f68ab826b86": { + "6944fec3e81116c5e5fa95147eeb513a8d68d388d64b0269fa617cde342b9f4f": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "dy42cNO+VCTULJC2LjWY8cYdOnk+CN45xFIHAnEjzXTNNh8qkMSRDWadzJvYGLHrty9NRwYuiUAbKX4KaMPJBw==", - "source_artifact_sha256": "ff1fd4393986dfb3dd0e3e75fe379c4dfa4b424938dac23ab436e1e31f594225", - "verified_at": "2026-08-18T10:44:00Z", + "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", + "receipt_type": "fault", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "Km9/LP+fYy9HU/BZG/nToFMfBFVMkOEJ57jwKCumlsUoYTsZhz8rhQCUywzUT5K5y8dqdUHQSRu+mSix2ixEBA==", + "source_artifact_sha256": "002efaa296dd38b0596e300894d23a4d0a9ceda1480bd302602a34e6d5d6b884", + "verified_at": "2026-08-18T10:53:00Z", "verified_projection": { - "attempt_id_sha256": "7c910764b2dcc6f05261d609082f75474e4638c3f356006307212b8fed4a2eb7", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "f5df4d6e64a2d38ffa8e320c87ad05d04025de267a8e152a755d3f1928ded120", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "wrong-reference", - "evidence_sha256": "ff1fd4393986dfb3dd0e3e75fe379c4dfa4b424938dac23ab436e1e31f594225", - "run_id_sha256": "fe98ce7f0e66b885201f4667875fd38f5890ffddb575d68bd4cd5a66f8d53ca8", + "condition": "stale-session", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "002efaa296dd38b0596e300894d23a4d0a9ceda1480bd302602a34e6d5d6b884", + "facts": {}, + "run_id_sha256": "fd3a041b705d8c6277ce26134dc0018e866218cfa3fadd16ac29d1ad498965a3", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "absent", + "trial_index": 2, + "verdict": "injected", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "6d0df009a1feb328d36e628a4591440d773dad58dcbfaa89101c51dbf210e246": { + "695743910a9a3fc4f38f7cef21f960b3ad157b1c971cb6d5858c866f10eecb7f": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", - "receipt_type": "runner", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "Ug2a2XiATGn2Lidjh6mvpkHXgnqg+DUjUway3LdnxaF9mqLrzbwDRpqCC6whVZZv6X2ANoXaRcAcpWndWr4UAA==", - "source_artifact_sha256": "43d2d3f884205de0a56e566e84429edcbc2e0a31f4904212f36f787c3ea8df6a", - "verified_at": "2026-08-18T10:23:00Z", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "/m5MCULfiyrWEh4xtoqCAZDxtDVov6VKdTef5B0sSlG9wp0XdyBPgGKEETIUQn/b9FfxN6VbbBoFYZ3DoekKAw==", + "source_artifact_sha256": "6820b7608a765ba712f9643379187af143db8c68f93b58d7a8825daa976ffc69", + "verified_at": "2026-08-18T11:02:00Z", "verified_projection": { - "attempt_id_sha256": "2601335b1101424105277997a67850a8a60aa45f59637b7679c1f32af463c460", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "60ee9db05b1126cfaa3b31c13bc3fab4755ac09c44e846b4d07ee51865dfa7b1", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-03", - "evidence_sha256": "43d2d3f884205de0a56e566e84429edcbc2e0a31f4904212f36f787c3ea8df6a", - "run_id_sha256": "237a0b7d1cafb64b1d113dca6699e6eefeaaf0b18679138545c3695495b901d5", + "condition": "ambiguous-target", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "6820b7608a765ba712f9643379187af143db8c68f93b58d7a8825daa976ffc69", + "facts": { + "derived_classifications": { + "collateral_effect_count": 0, + "duplicate_effect_count": 0, + "intended_effect_count": 0, + "wrong_record_count": 0 + }, + "dispatch_state": "not_dispatched", + "effect_inventory": [], + "expected_record_id_sha256": "7d599c341cd3b8ec3ce6c069e9a62b9e3aa59670bcba88b72b660f9dbbfa62f4", + "expected_transaction_ref_sha256": "0d92f2608c1d242b3bc3560b9c2cfcf3960432c5c36cb6a69608100e5d1b5ecd", + "post_state_evidence_sha256": "d71194830ea6369e85b522ee44e4f3d44f4fe9a4936a7643e75a8816ea89ee4d", + "pre_state_evidence_sha256": "8b4ae3dd7daeabd4c3609a04d2e8d42349500558fbc4fb7be692d2268a6229f1", + "verifier_method": "read_only_system_of_record_query", + "verifier_tier": "independent_system_of_record" + }, + "run_id_sha256": "628f991a182613b8700294d7483b5a4c06872cb9d5ca6047ea552b8ab6585357", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "verified", + "trial_index": 1, + "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "6dad0042578bd7c79c09e312aeb104931fde6dc82c7e85cf3d540c49ced11a0b": { + "6af0a975d21278b3a18e55ee5036101ea423eb08313a1923528755ab608c889d": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "D7FLZZrZXzyKWu1tCl3U/hYOtVCSr+U8iApkpOnNuSCgiHxBGK5Es1Nv3OMFMPeEIp9/8Zr5PBJQD8YfP/XOAg==", - "source_artifact_sha256": "1f121d102e5fbb97098da4d1334dfe5ffc8566bedbc601d9a73f719d325e04c3", - "verified_at": "2026-08-18T10:33:00Z", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "jX3Jt06o66b0HEvwCa2fyPyoELeOEff9e1hWVrrbG7L6mmGhEiBpt1jHrr1SOhRQiUTo888F2L+kUGma3SgfDA==", + "source_artifact_sha256": "b181977448bfbd12d2ed392d09d1d8be4a7489c9f5214c80bf97e84b3f745b64", + "verified_at": "2026-08-18T10:52:00Z", "verified_projection": { - "attempt_id_sha256": "4667302b580ff7ceb223dbb15eb6d029969a8f6a54bcd33e8df5b6bff41f41ad", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "fbfce2be9ce964be8b668aa518a310fe4a89e5c014f42bd0ea81401bd83bfd7a", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "idempotency-replay", - "evidence_sha256": "1f121d102e5fbb97098da4d1334dfe5ffc8566bedbc601d9a73f719d325e04c3", - "run_id_sha256": "33e0ad9bf64e477f24d46508fa432123e046dcd1c5853d5cc60b7cde1bce7537", + "condition": "stale-session", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "b181977448bfbd12d2ed392d09d1d8be4a7489c9f5214c80bf97e84b3f745b64", + "facts": {}, + "run_id_sha256": "d9270fd4c85e4226a9347ecf703e876b9ffdc330f60c7fb8bed8f9321ea30225", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "absent", + "trial_index": 1, + "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "6e3b9d04b81cf54fb150be35e2d27acdd45247573f0a933e42cca67796427eb5": { + "6ce64d58e69df317d74e94e480a3952ba89133053a77da3f7fcbb51e22da53ce": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", - "receipt_type": "runner", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "ITYV/Ppba/PrN5NvxsBEdLJ/R0uOTqa1Q2AEkBjqN7uv/KW9uZpW/9zmQUiyR7W7xQ5AENqrTD2aQUTUGrplDg==", - "source_artifact_sha256": "6fe2828f0849b15893e440cf5a75e8cb3040f255c8d6d99adec885362da6f9c5", - "verified_at": "2026-08-18T11:22:00Z", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "ue83YucAh+RDLqjFFLLSWOiFAT7oNrb9Z1LPx32crtMEGriJ1jVdRnZHQjj3t48saManeW2D+llcTYRldAD5Dw==", + "source_artifact_sha256": "dc043aee537d3d9f2971b9f6f507101da11be20d6c62347dddc91b4c9eeb8fdc", + "verified_at": "2026-08-18T11:24:00Z", "verified_projection": { - "attempt_id_sha256": "73a097b8b20bab7794369384f7ca1d7d711aad07967b7e1292373babbb7ff1b7", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "aa7d6be4f25a8992c0a22649ba7e703d6955abf5fece9f8322f560149cf09776", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "weak-effect-only", - "evidence_sha256": "6fe2828f0849b15893e440cf5a75e8cb3040f255c8d6d99adec885362da6f9c5", - "run_id_sha256": "b44783e70a980ec5b3cf3752bd5d1d01b2ff29f5a6892cba0c1c939d8aeb7c02", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "dc043aee537d3d9f2971b9f6f507101da11be20d6c62347dddc91b4c9eeb8fdc", + "facts": {}, + "run_id_sha256": "b974de9da8ef77c8dc9a7662114cc51023ab8c131c488681eeebb7d4c435c8d0", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, - "verdict": "halted", + "trial_index": 3, + "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "70a3703f7ae55e333da73a24399d55404bc28158ae6c0088656cce79103ff011": { + "741bb99666db76220c53c49c9729b0f8b75036e458f2d75542760ad6581184fc": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", - "receipt_type": "runner", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "wGvL5qbyZg7VFIp6XC+pmc7gOB3+Uw8tlQMD1oAvX2KN1wmWjeOrHmn11oBikLG3KX7Hcu5/VZT6hK98cAmzAQ==", - "source_artifact_sha256": "516ecd879cd6bf3ddce68daf59c204f277f8dc9c69b44e4aab5485a9563bb56b", - "verified_at": "2026-08-18T10:04:00Z", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "mc9zUvRFUXlJvcg7/E8IgqzveIeYIVRMd6e6/7LXo0+EdcgDFZ2wj/jFdM+bMT0l0HIkOphuuwIfy08kdOdVCw==", + "source_artifact_sha256": "8f3a90b44ab62c40384d697eeb5664143c64378dc1162f48f40843beeb892c40", + "verified_at": "2026-08-18T10:53:00Z", "verified_projection": { - "attempt_id_sha256": "4c352a6999f77707e8837adebb4fc2b7451c2ef6de5145190b33a5c5645e47eb", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "f5df4d6e64a2d38ffa8e320c87ad05d04025de267a8e152a755d3f1928ded120", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-01", - "evidence_sha256": "516ecd879cd6bf3ddce68daf59c204f277f8dc9c69b44e4aab5485a9563bb56b", - "run_id_sha256": "4ee2bb61fb883cc8e77d636fb471aa3c0ce9ef0c0a8abd9682214bf0a8f16f26", + "condition": "stale-session", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "8f3a90b44ab62c40384d697eeb5664143c64378dc1162f48f40843beeb892c40", + "facts": { + "derived_classifications": { + "collateral_effect_count": 0, + "duplicate_effect_count": 0, + "intended_effect_count": 0, + "wrong_record_count": 0 + }, + "dispatch_state": "not_dispatched", + "effect_inventory": [], + "expected_record_id_sha256": "1f281cf15b2a004cdd209558e754a9da1899d8ebc38689a353294b23448d9676", + "expected_transaction_ref_sha256": "454701823a6df98835a9b226538dc4772a1e3b6784a805907a45fd2590113fbe", + "post_state_evidence_sha256": "5af3f3e3a79cc3ac0cad3c3f31b71ebe92b8e3d4390d0ebda9951ba00e220d86", + "pre_state_evidence_sha256": "660b59ae4de4abb38c1d1bc900987fa8d4f15035c045cb40bf5384aaf94bad66", + "verifier_method": "read_only_system_of_record_query", + "verifier_tier": "independent_system_of_record" + }, + "run_id_sha256": "fd3a041b705d8c6277ce26134dc0018e866218cfa3fadd16ac29d1ad498965a3", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "verified", + "trial_index": 2, + "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "740b98f25b9a7bd1377ef51336f483823b8ab09f9e1ee7bad1075aee460a277d": { + "74bf2158a084de1057a2f9332e58a275be7e26aac5b1ff5ccdb29efb49923593": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "4dtCjatTgZFrOcYUro8p6SGAY6+AcBUcW1/zIZZBr5Xi45X12snFHltWzPmlYa4wG6y5jWJXVddf4K1GThJLAA==", - "source_artifact_sha256": "92c76843346dc97ecdd23535ab0cebf2aecbaddd30aae938fed40434fb6b2da0", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "97/8BzGFuGdlxnvXyNoVYZ0jdSruTSBwHhzjast9BV2cNfSArL9rgQk01anb+AXiSR+glzkfc8oVhMQEOj8jCg==", + "source_artifact_sha256": "89e92e0a76d7ef86a369ad65837369620240dc66bc215bc9fa3fddc21d777f9e", "verified_at": "2026-08-18T10:32:00Z", "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "3142933f4f168c98b8e89f2ae9d78fd3129e0a9975cbbaa60ddba853eee7d53c", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "idempotency-replay", - "evidence_sha256": "92c76843346dc97ecdd23535ab0cebf2aecbaddd30aae938fed40434fb6b2da0", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "89e92e0a76d7ef86a369ad65837369620240dc66bc215bc9fa3fddc21d777f9e", + "facts": {}, "run_id_sha256": "6cdff0cf50d0164fe1eee9c4b7db0b969c24f9b960f5653b516313a913c90a0f", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, - "verdict": "verified", + "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "745ccd149ea968ca38642bd362a867a92243f9a556b8653b2be088f0fa636a36": { + "74c0ad2e902682f3f0c36c859ab514c9d2ca0c5e62a6efd3054713b92dc094e6": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", - "receipt_type": "runner", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "AP8ipYAK78TS4/JjFgtM3cUWIbNeSN5c2JHZBH9dHWQ/kAFC3pMPkuyaArwwsI5gTjwbnvo4vA7ru5P9JxGmCA==", - "source_artifact_sha256": "5e9c28fdf8c09dcfbbefa41ca8075e7daaa783d6ef24d5050cc9973c6aacb810", - "verified_at": "2026-08-18T11:24:00Z", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "bUamh8YT7cXAPWKlsA7GwbZV59ZajMLYR4rIaB0S382SnhEXDCKE4edP7hZsWgSy78kqhhxTt3189hIuT6A1DA==", + "source_artifact_sha256": "4b49c957d7eeb5d558fc4b83415475999503aa48aa8d8be5ec00a745b6c78701", + "verified_at": "2026-08-18T10:13:00Z", "verified_projection": { - "attempt_id_sha256": "aa7d6be4f25a8992c0a22649ba7e703d6955abf5fece9f8322f560149cf09776", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "3d42601a69ef46cc44f57b51762affef4ccd829ffde30125619a6e582af00dab", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "weak-effect-only", - "evidence_sha256": "5e9c28fdf8c09dcfbbefa41ca8075e7daaa783d6ef24d5050cc9973c6aacb810", - "run_id_sha256": "b974de9da8ef77c8dc9a7662114cc51023ab8c131c488681eeebb7d4c435c8d0", + "condition": "healthy-02", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "4b49c957d7eeb5d558fc4b83415475999503aa48aa8d8be5ec00a745b6c78701", + "facts": {}, + "run_id_sha256": "091e13ed70dab439b31cb506cf3bba1ddf6476696531cf891c39a924a928b7a1", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "halted", + "trial_index": 2, + "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "75ea2d7baeaecffbfa9b5fca73b8bf70e398697d76f9d1bec9a620bae3063765": { + "7680aca959060d5c6c03586cd4555132a94bbec661dd09cb82aa51f0fdea9746": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", - "receipt_type": "runner", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "YiDQmnXgzqcx6UEcIRhxe4K8X8H1+kwselbv4PySdUdybfIHKoNKJcbPEXBMiyh0Xz9CxyIOXRnV6yRnCOVKAw==", - "source_artifact_sha256": "79566ede5f64ddd1b0c40fdfcfdb0f7500d96abb5c46c9abdabddca1500c599d", - "verified_at": "2026-08-18T10:34:00Z", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "GyqjM3ToZrQdV+I6PFKCyYbXjiQhVz5PEzu57TI68NbgMNiUa/Hpg9rp23zp6AvP1Cg4/J57Lngpn2Ny6oQCAg==", + "source_artifact_sha256": "92c76843346dc97ecdd23535ab0cebf2aecbaddd30aae938fed40434fb6b2da0", + "verified_at": "2026-08-18T10:32:00Z", "verified_projection": { - "attempt_id_sha256": "3aee8ad755c7f4bec71cc194bcfaa805e0ea29cf8b830ed0782f8263dd9620ca", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "3142933f4f168c98b8e89f2ae9d78fd3129e0a9975cbbaa60ddba853eee7d53c", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "idempotency-replay", - "evidence_sha256": "79566ede5f64ddd1b0c40fdfcfdb0f7500d96abb5c46c9abdabddca1500c599d", - "run_id_sha256": "3df83453126754a62d00ed10837720542d0469799bb8a88cb5257ac5f477a919", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "92c76843346dc97ecdd23535ab0cebf2aecbaddd30aae938fed40434fb6b2da0", + "facts": {}, + "run_id_sha256": "6cdff0cf50d0164fe1eee9c4b7db0b969c24f9b960f5653b516313a913c90a0f", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, + "trial_index": 1, "verdict": "verified", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "765f8d15ba0ee4a35a281110faf81931a4bef2ff9a530050d2be0097c13e1f15": { + "76e7394342df02acda6f125c6069601220ea6de460350b3746e09b4b55cfa461": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "br0Uwf5VSWB9T30yVkEBVlIQkNjzbdKucpahuFb34gwteP+IggPbbUkduNCl0x/Zxuv8FzX7rv0E3gjEfhy+DA==", - "source_artifact_sha256": "23708d813c5434c08faf44e36a798621030200b33f634d785750d86cf7fb96d7", - "verified_at": "2026-08-18T10:52:00Z", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "L7SfdkFP5nL3A2lafVF7uoe5gT02finHwrjguBwA/PCG+w+M/BInqhYR41gGlKq6T5k7ju3GzXQDl4HntcEVAg==", + "source_artifact_sha256": "d4f5375e18344432614ad6d37de4727b4ccbfb1465851f36df15fcd2cf052c4e", + "verified_at": "2026-08-18T10:03:00Z", "verified_projection": { - "attempt_id_sha256": "fbfce2be9ce964be8b668aa518a310fe4a89e5c014f42bd0ea81401bd83bfd7a", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "fdad940f245d690750ad647fac25c7e76aac2f474db49732fec8129051750186", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "stale-session", - "evidence_sha256": "23708d813c5434c08faf44e36a798621030200b33f634d785750d86cf7fb96d7", - "run_id_sha256": "d9270fd4c85e4226a9347ecf703e876b9ffdc330f60c7fb8bed8f9321ea30225", + "condition": "healthy-01", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "d4f5375e18344432614ad6d37de4727b4ccbfb1465851f36df15fcd2cf052c4e", + "facts": {}, + "run_id_sha256": "3739043a92a8781376cfbd022460c03aba40f92a800b3885ebc046321437bc40", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, - "verdict": "absent", + "trial_index": 2, + "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "789bb7f6d5d3968fbaa87e3cffec42e18b036d53e2eb560a1fe1b3834fd27300": { + "76f7d5b5fc039b3ce624e887fb4e076bfc10f32577f8a3c72566678942ff8bea": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-d7e1e084be213b01", "receipt_type": "observer", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "dinccSYtl2S0phv+suwI02Mt077kA6vEOv1TdGhVp+XFSA8ZuSrDzTyaJYyfzB3jPKSx//Z4hctlf/lsoXSCCw==", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "BAVUqLTyK/B6rPr0oogBhlPsAS2Gz0DdeGuPwI17PTEpH0NDQkZPRTfcOaLm9QuEvcYvy9ORfs0nT0yYuJC1Ag==", "source_artifact_sha256": "f4e30b79fe5403ce13c6b1b63149637b35847c5bb37a7e923317e0cb11fdce22", "verified_at": "2026-08-18T10:33:00Z", "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "4667302b580ff7ceb223dbb15eb6d029969a8f6a54bcd33e8df5b6bff41f41ad", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "idempotency-replay", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", "evidence_sha256": "f4e30b79fe5403ce13c6b1b63149637b35847c5bb37a7e923317e0cb11fdce22", + "facts": { + "derived_classifications": { + "collateral_effect_count": 0, + "duplicate_effect_count": 0, + "intended_effect_count": 1, + "wrong_record_count": 0 + }, + "dispatch_state": "dispatched", + "effect_inventory": [ + { + "effect_id_sha256": "3de74331383c83b299c3122cdd26ec8f11285c4bf933b8a7fb07fbacab6fa222", + "record_id_sha256": "f937550eaf086105b0c0b3bd09d88c72b16eadd01378e96a650960491e50bbb1", + "transaction_ref_sha256": "dc78636b2afb08f287cc1754e616ac46e228aa478a330e9c914e90c55bfa795c" + } + ], + "expected_record_id_sha256": "f937550eaf086105b0c0b3bd09d88c72b16eadd01378e96a650960491e50bbb1", + "expected_transaction_ref_sha256": "dc78636b2afb08f287cc1754e616ac46e228aa478a330e9c914e90c55bfa795c", + "post_state_evidence_sha256": "d0d8ebe302f92064c831e89e995d7b53b02e7814a5b9314715f4144e06536451", + "pre_state_evidence_sha256": "8ddef5d347d9382ea81a6b68f1475284a4383cc8341fd3104a762695ffc2f97b", + "verifier_method": "read_only_system_of_record_query", + "verifier_tier": "independent_system_of_record" + }, "run_id_sha256": "33e0ad9bf64e477f24d46508fa432123e046dcd1c5853d5cc60b7cde1bce7537", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", @@ -2677,218 +3457,315 @@ "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "79aa9017fd55bce5532f4bc6ca88aaaf1244fd3eb00acbae04d8b2eb2529b836": { - "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "LVoRwsGx9uilzEpQHSottBMgr6EY1cc8d9r24ExePtMMJEvUXJoOex+MQN+s75mAfrZK7sZ1NHmBL9Fs3JjKBw==", - "source_artifact_sha256": "6c8e592e4280ffc6dc1202667837a33a8d1f4c8d88f7cde6d24a3d9b3317ad33", - "verified_at": "2026-08-18T10:42:00Z", - "verified_projection": { - "attempt_id_sha256": "e93521e706ad90d799dcd4e8cac15229c5da6aec1638540606f5fab4efce59fc", - "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "wrong-reference", - "evidence_sha256": "6c8e592e4280ffc6dc1202667837a33a8d1f4c8d88f7cde6d24a3d9b3317ad33", - "run_id_sha256": "ee82112f55e5e6c86cfd6e16df8c8b652549a8bd72de492f435d8255eb3dd252", - "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "task": "execute-acceptance", - "trial_index": 1, - "verdict": "delivered", - "workflow_version_id": "44444444-4444-4444-8444-444444444444" - } - }, - "7faacd55bef5f183c095457453d97320383b2202519d772ae533661a701da791": { + "7822fdf37dfcdd3dac8232707e1237c777e0fe82d4d6ef3424dff0c260b6ab18": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "QbEdrtUCw76v7zZ4lQ9oM471h1ovgqYHyq5SkhJHxiF/b4imx0C8QxFIBI4tgA/Xj9+4CS91GQCw4qoTJj7LAA==", - "source_artifact_sha256": "48d2fa219c08a4043c3d974e574816a8b3952b9f1b5d638dd8a8fa098edc61dc", - "verified_at": "2026-08-18T10:33:00Z", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "WNCfzfILsVQN0U6Shbrk02zwnzX40gEZfFhlX2CWVyTEj4p8bg6kih46EhdGsxBzlsDaj2KGtFoBA84MiG9bCQ==", + "source_artifact_sha256": "e0ce2fefc18a96fdbe4db27543f31525ec9852a94a94d757559ccdd960f8faf9", + "verified_at": "2026-08-18T10:13:00Z", "verified_projection": { - "attempt_id_sha256": "4667302b580ff7ceb223dbb15eb6d029969a8f6a54bcd33e8df5b6bff41f41ad", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "3d42601a69ef46cc44f57b51762affef4ccd829ffde30125619a6e582af00dab", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "idempotency-replay", - "evidence_sha256": "48d2fa219c08a4043c3d974e574816a8b3952b9f1b5d638dd8a8fa098edc61dc", - "run_id_sha256": "33e0ad9bf64e477f24d46508fa432123e046dcd1c5853d5cc60b7cde1bce7537", + "condition": "healthy-02", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "e0ce2fefc18a96fdbe4db27543f31525ec9852a94a94d757559ccdd960f8faf9", + "facts": { + "derived_classifications": { + "collateral_effect_count": 0, + "duplicate_effect_count": 0, + "intended_effect_count": 1, + "wrong_record_count": 0 + }, + "dispatch_state": "dispatched", + "effect_inventory": [ + { + "effect_id_sha256": "8b445acee6aae04feb051f8c04d3c5983b50b60075a530553e9ef68a94339497", + "record_id_sha256": "d11cba9b016242b077f75fca7a6ba081ffcd42685c539aae24aa6a6a345873ae", + "transaction_ref_sha256": "9e9fc97defc5a1352a121bbb49532d28352f7488b87f5ffe23650890cc1828b3" + } + ], + "expected_record_id_sha256": "d11cba9b016242b077f75fca7a6ba081ffcd42685c539aae24aa6a6a345873ae", + "expected_transaction_ref_sha256": "9e9fc97defc5a1352a121bbb49532d28352f7488b87f5ffe23650890cc1828b3", + "post_state_evidence_sha256": "688116b3cbe3b2c66b24588c90a8240bcabbaf0aac8f1aadd8a8294e31114f32", + "pre_state_evidence_sha256": "b604ab87a04cc6869af9c1991b242920aa576870d7f254ec9169294c5ff9f13b", + "verifier_method": "read_only_system_of_record_query", + "verifier_tier": "independent_system_of_record" + }, + "run_id_sha256": "091e13ed70dab439b31cb506cf3bba1ddf6476696531cf891c39a924a928b7a1", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, - "verdict": "delivered", + "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "85e18a244859259c2a8275a40afe0d6b887db2fb91e1982d56ad414924a3423c": { + "78b6fbcd45afdcab40cc88b65a9c53caea37e18ea8df239812cfb2922fd26df4": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", - "receipt_type": "runner", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "3I73T+HrvwwXc3yzT/5RIvY0YbLN6Ks+GlF7YO/sj9fYeEH+JGu5bDMbAeV+mNeW3okCBMg0T9oL3I3QR2s/DQ==", - "source_artifact_sha256": "e1dd07c3df4aed8ff42376ff74a3f68c13ebb7fb509304a544b0e8bde5b1f4ed", - "verified_at": "2026-08-18T10:02:00Z", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "hH8bNIAWeZZOYxITXxHgfhdhajUoqDztL+BwJXVPalnv3eXR1RRRMd88H0tVHsCNAaSnaOkaY+lwGBmza1dkDg==", + "source_artifact_sha256": "fc34b2087c0ac5df3a7283f31412b0a354de6d6f9a21946e56ad9f8cd42edfd6", + "verified_at": "2026-08-18T10:03:00Z", "verified_projection": { - "attempt_id_sha256": "679af5a8dedceb8c696719e73f82a698c230cd8fc98bb61769f0883202c0b637", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "fdad940f245d690750ad647fac25c7e76aac2f474db49732fec8129051750186", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "healthy-01", - "evidence_sha256": "e1dd07c3df4aed8ff42376ff74a3f68c13ebb7fb509304a544b0e8bde5b1f4ed", - "run_id_sha256": "0b5bda916a0808165159166955a9563cf9c2303949f762a18eb037f41b44a6dc", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "fc34b2087c0ac5df3a7283f31412b0a354de6d6f9a21946e56ad9f8cd42edfd6", + "facts": {}, + "run_id_sha256": "3739043a92a8781376cfbd022460c03aba40f92a800b3885ebc046321437bc40", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, - "verdict": "verified", + "trial_index": 2, + "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "88aa95277a9bbc5666ac0b4a542bafa91ac60ee30d5fff79647d9ef050f10b75": { + "7955935e031e774f701302635fe41d80f3cb44696a61234b7849200d253a24e3": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-d7e1e084be213b01", "receipt_type": "observer", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "AatMhqmeZmS9TTk/PlfuVH6njmho1PbSYr05+DV5XRBFEfhNk8c9D1nCVpljHgHIkyDQuDUGpmx+mBS6SV32Bg==", - "source_artifact_sha256": "8558af088d566bf88f4efb53d9cea316fe8385eb40828881aa49418896707c6b", - "verified_at": "2026-08-18T11:03:00Z", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "0EkXqS+k8l6ufSZ3LO3u2cc13k4+LmkOmL70V5VdnES5v3i7goAT7IglUqvqX0BAlWt7SRC9/FjMTyAO0Fo6CA==", + "source_artifact_sha256": "237359293198c0bcf55e931c23b25d4af0950bb1488672f69a6d6260eb2aee06", + "verified_at": "2026-08-18T10:02:00Z", "verified_projection": { - "attempt_id_sha256": "1ec11a9862ede3ac701af71835ac28c551d604a026b5bab7d776dbcdf288394e", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "679af5a8dedceb8c696719e73f82a698c230cd8fc98bb61769f0883202c0b637", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "ambiguous-target", - "evidence_sha256": "8558af088d566bf88f4efb53d9cea316fe8385eb40828881aa49418896707c6b", - "run_id_sha256": "43f0a1c00950c390b0676fab55a2aa98c354d028f2347c461661e6cdb72f717e", + "condition": "healthy-01", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "237359293198c0bcf55e931c23b25d4af0950bb1488672f69a6d6260eb2aee06", + "facts": { + "derived_classifications": { + "collateral_effect_count": 0, + "duplicate_effect_count": 0, + "intended_effect_count": 1, + "wrong_record_count": 0 + }, + "dispatch_state": "dispatched", + "effect_inventory": [ + { + "effect_id_sha256": "07635412bdd073f2f53c0be32e8df7b16940124d3693645e5af379b76ecebbc1", + "record_id_sha256": "22bafa5f842de0c2269205fd3478833f83c5c6f54d0066a5af6b89940f1564e9", + "transaction_ref_sha256": "7ac0c694e5cb88e5efd44ea972cad8449b7292b86e10a54bba4982f8e26078a4" + } + ], + "expected_record_id_sha256": "22bafa5f842de0c2269205fd3478833f83c5c6f54d0066a5af6b89940f1564e9", + "expected_transaction_ref_sha256": "7ac0c694e5cb88e5efd44ea972cad8449b7292b86e10a54bba4982f8e26078a4", + "post_state_evidence_sha256": "5a7aef9cfd51033988dd21227fdbc210ca4c54128fa825521f5d56ad71f4ae44", + "pre_state_evidence_sha256": "03f1c91bf767df95663ac91cb91323fe712c1f5284c789c96ad65f5f94d1c090", + "verifier_method": "read_only_system_of_record_query", + "verifier_tier": "independent_system_of_record" + }, + "run_id_sha256": "0b5bda916a0808165159166955a9563cf9c2303949f762a18eb037f41b44a6dc", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, + "trial_index": 1, "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "892f7c4bd8e3b8b91b3e349aba640c5c87c0268e74d72343c4d14d7a6eee57ed": { + "7b0b7f71536e3d63e9f66ed1e0e47efcb78cd4930e486371ce40dd82d114d035": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "TouNDW/zg06X+xsfu3haJmKjCsyS1QJFDdEEGClueySZrLmGquADETISybWYQ2W2YcGBNu9KsTEWqgiWhaNKCg==", - "source_artifact_sha256": "6381975addf1b4ec60255f58a8d2ec052c169a3228310d84dc3954d444e76d0f", - "verified_at": "2026-08-18T10:32:00Z", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "KGQFNk/YqfiRFiyNIXKD7YR+xk/7reXclP5r8SzizCAlmssPB5y2JLrqoHVpuFne//WnB1/am3X5ZY37Rzi5BA==", + "source_artifact_sha256": "9003f18eed9ca02f5288ee8e9b498e2a7792375249a68b2444ff5d147b9c24d2", + "verified_at": "2026-08-18T10:12:00Z", "verified_projection": { - "attempt_id_sha256": "3142933f4f168c98b8e89f2ae9d78fd3129e0a9975cbbaa60ddba853eee7d53c", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "940d3ca125ff87ce7539740fbae29d2d64fec839328b0639127e1d197d2485d8", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "idempotency-replay", - "evidence_sha256": "6381975addf1b4ec60255f58a8d2ec052c169a3228310d84dc3954d444e76d0f", - "run_id_sha256": "6cdff0cf50d0164fe1eee9c4b7db0b969c24f9b960f5653b516313a913c90a0f", + "condition": "healthy-02", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "9003f18eed9ca02f5288ee8e9b498e2a7792375249a68b2444ff5d147b9c24d2", + "facts": {}, + "run_id_sha256": "bbb9312ce4682b23580eced0f8d19438d8266b222555df85fb27eef22ad5afe2", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, - "verdict": "delivered", + "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "893a8247b0fc26e0c36954a23409a8930a5e70fd085f987726277a3a30622f9f": { + "7bd04520d9af9cf9f2f39acffd0fda362dd5e762823fcc38102fb847a1b803e8": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-d7e1e084be213b01", "receipt_type": "observer", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "pOtSZzHR5GzRn1f2ZhRTqBhdZWP0guB9XzdIw8KO0HBBSUofQ0IQrgYprKlm2UqYuAUJRFHmfsjQ93D/PeFeBg==", - "source_artifact_sha256": "086aa3c333f8a4fdf55b0ef09ae301f38faa388075355ba8356b2a2e72f7b80e", - "verified_at": "2026-08-18T10:54:00Z", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "UJtNwuagERerC/EaIJuY01IAn+JDchBLVbbyFMBkUjELua8sVWc+cBtha2glXTW95naJP4on3XmW3YwLWevxBg==", + "source_artifact_sha256": "a8a94089ae42720eff6c8154fd7ed91674171e6a51ac522db76f1d69704673d6", + "verified_at": "2026-08-18T10:23:00Z", "verified_projection": { - "attempt_id_sha256": "958342a9ddca98a83b82b662f52f404239d583afe7ed70634760e1b8dd592f3b", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "2601335b1101424105277997a67850a8a60aa45f59637b7679c1f32af463c460", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "stale-session", - "evidence_sha256": "086aa3c333f8a4fdf55b0ef09ae301f38faa388075355ba8356b2a2e72f7b80e", - "run_id_sha256": "6f2fb10bc2018c9f78e9702d5ccac0bedd78ee3b2e9d2a6ad779fba72d90ae50", + "condition": "healthy-03", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "a8a94089ae42720eff6c8154fd7ed91674171e6a51ac522db76f1d69704673d6", + "facts": { + "derived_classifications": { + "collateral_effect_count": 0, + "duplicate_effect_count": 0, + "intended_effect_count": 1, + "wrong_record_count": 0 + }, + "dispatch_state": "dispatched", + "effect_inventory": [ + { + "effect_id_sha256": "4cb3b1b2bddf9bab2ecc70f350793a5c08d1ef6995f03d83613414232aa67915", + "record_id_sha256": "376b86277507af8309dd9c7ee34843c68aa8000b6cb6246f3df9311e1a157a57", + "transaction_ref_sha256": "a8dcbf41043fdea74256844cddce6df4cb244c53ad6021edac20c136e24f7ffe" + } + ], + "expected_record_id_sha256": "376b86277507af8309dd9c7ee34843c68aa8000b6cb6246f3df9311e1a157a57", + "expected_transaction_ref_sha256": "a8dcbf41043fdea74256844cddce6df4cb244c53ad6021edac20c136e24f7ffe", + "post_state_evidence_sha256": "d186e527afc60846f97057220efa366ccf99dc2bf1c32e246bc947602bce5487", + "pre_state_evidence_sha256": "a7b5943eb7e95bc4d94fc9bdf6bb5650e69e23b75c5d1a0a1abc572fdc20060c", + "verifier_method": "read_only_system_of_record_query", + "verifier_tier": "independent_system_of_record" + }, + "run_id_sha256": "237a0b7d1cafb64b1d113dca6699e6eefeaaf0b18679138545c3695495b901d5", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, + "trial_index": 2, "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "8979e7a57aae81f1b0da3757d74783fdd94996bfc44fbdda9843885daecad6fc": { + "7d63a530b52e8faf6e3476894739e626da62bc5df1ccbe74ee9645b7fc8ef05a": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "aUwmIIt/LW0YomBNlexWVYEqMrlBmzxu3UvpSFiGzernDnkkVhrv9WuWKQ9HFYVqkOQyoZpWIQCzCbHm+l93BQ==", - "source_artifact_sha256": "26eef6795405076a78c4a1d95d85251e7454d3059e296b07b2cf612e7b6231a2", - "verified_at": "2026-08-18T11:12:00Z", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "+GlFwk7708zu3wylnNfsZTtQbzA1lWwbuJtx7ske1ujmOoO+DprqArGh3ZB6A88s4OMsmxRjHyk2V293RPwkAQ==", + "source_artifact_sha256": "b6355ed63a5d7f1df450f75bb77fdcf81321616662fe3728a6da23d2a8957ce5", + "verified_at": "2026-08-18T10:34:00Z", "verified_projection": { - "attempt_id_sha256": "f5e96a2e9a580376b18beabf57798b8761e772a0c4d112877045780bb12b3720", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "3aee8ad755c7f4bec71cc194bcfaa805e0ea29cf8b830ed0782f8263dd9620ca", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "verifier-unavailable", - "evidence_sha256": "26eef6795405076a78c4a1d95d85251e7454d3059e296b07b2cf612e7b6231a2", - "run_id_sha256": "e8e89651045a5f5c011c9543ed968e0fe7697a061ed8ad5cedc27d194cb96acb", + "condition": "idempotency-replay", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "b6355ed63a5d7f1df450f75bb77fdcf81321616662fe3728a6da23d2a8957ce5", + "facts": {}, + "run_id_sha256": "3df83453126754a62d00ed10837720542d0469799bb8a88cb5257ac5f477a919", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, - "verdict": "halted", + "trial_index": 3, + "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "89a5d906de379f1e4dfa2e52a02916b84cd79388b52a30ea2f26c33834b2a094": { + "7ed9cc546bbca6006bf1cde43b11ded649bc2f080ffbf74b3e820d8775e05170": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-138dfa227234ea5f", - "receipt_type": "cleanup", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "+7IVGi46RiulpdfQxeJyoUCEqtQkCjW9iOITl6QtXwBh1UDahEZJuowoTiWgU0gDP5RnIDhTrpZ1PcJsaLbfDA==", - "source_artifact_sha256": "9003f18eed9ca02f5288ee8e9b498e2a7792375249a68b2444ff5d147b9c24d2", - "verified_at": "2026-08-18T10:12:00Z", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "qhtsaGBUWRD+mPkXZrb68dk//dJOZPFvCRjWlXz+o6t2yFZ5yfu6ieCqpHUNioI05K+xrR03heLup2a6NJhKBQ==", + "source_artifact_sha256": "7742811fd54dc2fb2b1336f83c65918fcb116f4cf437d0246c2095228d61249a", + "verified_at": "2026-08-18T10:42:00Z", "verified_projection": { - "attempt_id_sha256": "940d3ca125ff87ce7539740fbae29d2d64fec839328b0639127e1d197d2485d8", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "e93521e706ad90d799dcd4e8cac15229c5da6aec1638540606f5fab4efce59fc", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-02", - "evidence_sha256": "9003f18eed9ca02f5288ee8e9b498e2a7792375249a68b2444ff5d147b9c24d2", - "run_id_sha256": "bbb9312ce4682b23580eced0f8d19438d8266b222555df85fb27eef22ad5afe2", + "condition": "wrong-reference", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "7742811fd54dc2fb2b1336f83c65918fcb116f4cf437d0246c2095228d61249a", + "facts": { + "derived_classifications": { + "collateral_effect_count": 0, + "duplicate_effect_count": 0, + "intended_effect_count": 0, + "wrong_record_count": 0 + }, + "dispatch_state": "not_dispatched", + "effect_inventory": [], + "expected_record_id_sha256": "2d1f4e51a934947a53e829f1608e93181d2cd4c7b9c24394cfd615713fc3c6be", + "expected_transaction_ref_sha256": "098205ce5255fe5150c178cd23e88274085b7dcd77c3eefba408633c996c4897", + "post_state_evidence_sha256": "ab3889d4bf86da6e33192c3de9bda5de4ff596bb0c04a4e581e834e95ec60bda", + "pre_state_evidence_sha256": "8b14b2452165cda2d8b0053c956b6bfa60abf5a6935b7e98f4b549fad3ca055e", + "verifier_method": "read_only_system_of_record_query", + "verifier_tier": "independent_system_of_record" + }, + "run_id_sha256": "ee82112f55e5e6c86cfd6e16df8c8b652549a8bd72de492f435d8255eb3dd252", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, - "verdict": "completed", + "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "8a33f194bdfb27d33344ac8e2e9085dd5e899b878157756f56886e9e29e88821": { + "7fb90d2da8912d351338ac30b3136cfae35c3cfcb21a1be3cefe268eb732696c": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-138dfa227234ea5f", - "receipt_type": "cleanup", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "AhKJo7I3mn4GWrWY4oPy2iwRIpciuv0rZRuvxqKCN2C1BeHCf9wKTDiT6OY4qcFer/TMuPm5qDUVFJu/0LDVBw==", - "source_artifact_sha256": "1594ca15edbb7755f6b59f1e58383c96dab980507ce5edff073a7a295f07069b", - "verified_at": "2026-08-18T10:14:00Z", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "0Q0nLVYKU9+1BbZRVNlX3VV9quImn7rhfc0+rj44JYMjFHq++/xMnzHty9D4dnWOh1RPkDD+mMR5FcMSVbBvBQ==", + "source_artifact_sha256": "12e1cf402efb1b543738dbf0096014533d4c1324c94e1af43a90e76c161e34d4", + "verified_at": "2026-08-18T10:04:00Z", "verified_projection": { - "attempt_id_sha256": "019dd96e9a771ccc01ebafab321d7d3a8314df8b2d6465bcfc5fa14cbdeabdf2", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "4c352a6999f77707e8837adebb4fc2b7451c2ef6de5145190b33a5c5645e47eb", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-02", - "evidence_sha256": "1594ca15edbb7755f6b59f1e58383c96dab980507ce5edff073a7a295f07069b", - "run_id_sha256": "16cb8df40654c6a1b55ea0e50e772d8c6e6d4f0d8205bd1f8296be27d0af83eb", + "condition": "healthy-01", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "12e1cf402efb1b543738dbf0096014533d4c1324c94e1af43a90e76c161e34d4", + "facts": {}, + "run_id_sha256": "4ee2bb61fb883cc8e77d636fb471aa3c0ce9ef0c0a8abd9682214bf0a8f16f26", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, - "verdict": "completed", + "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "8aeff82557645b5c4719bd7dc52daff351274389e5be8e98bdf6191acb475984": { + "83a40647d6d151da844fcff4f96c40516ee57ceae72f370078106244e2efb750": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", "receipt_type": "runner", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "ne/dBbrIEwahDB+lGr9zQY49HkQsOlzL1ObFIuz634jW8h2vPrObSmYYbZi5Rs3Z1yiGTLQuSRy6h1NWgk31Bg==", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "0MiRpRLNXpVDdCYYbFsJ8jep/E8nBPkB5VVJvmvl2HA8YfqGSGPLgBlpcla4TwAPn/eZvAzbIV1ojbqzn55lAg==", "source_artifact_sha256": "25166ea6bdc49a633c232781e8ef3511a9a11ef23e033b141c9a8ec8cb3f6834", "verified_at": "2026-08-18T10:54:00Z", "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "958342a9ddca98a83b82b662f52f404239d583afe7ed70634760e1b8dd592f3b", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "stale-session", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", "evidence_sha256": "25166ea6bdc49a633c232781e8ef3511a9a11ef23e033b141c9a8ec8cb3f6834", + "facts": { + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "25166ea6bdc49a633c232781e8ef3511a9a11ef23e033b141c9a8ec8cb3f6834", + "source": "runner_signed_flow_report_and_enforced_egress_policy" + }, + "operator_intervention_ids_sha256": [] + }, "run_id_sha256": "6f2fb10bc2018c9f78e9702d5ccac0bedd78ee3b2e9d2a6ad779fba72d90ae50", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", @@ -2897,175 +3774,198 @@ "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "8c1afd600031c30f995fb9824e193c95b4d4ad585ca879c64c9d2e348fa1b10e": { + "84070f921aa2358567527d3ec76d99bad2dd8b589b8c908bde0f717f266ad696": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "SgbEnO9KPyhEeFEhnyzTCmjqKn6SfWsPrWBv4mEHSFNI3N0rTlwHYfOjWWqGtboAh1I8TzPj1uUB47HrF6mwBw==", - "source_artifact_sha256": "f8152ccb0471b92317861ddb7fabeae5fcf740530b8b050510e29e1da130d3e3", - "verified_at": "2026-08-18T10:22:00Z", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "cSyqgHGEZBvBF+LhpkWsJ4cdfTWtXEYRYiGbAhPj/W/EwIRTtec06NH+ONwL6Ugakk/CIpUnNyMo2AtcbT1yDA==", + "source_artifact_sha256": "841ebd8beb38baf63b1ce9c65d1f22d80a15e36e268eab7f019f063c7242ce9e", + "verified_at": "2026-08-18T10:12:00Z", "verified_projection": { - "attempt_id_sha256": "fc097c8b2e6ece94544a19b8d81f5c4a9367a89059e3dd4b2f746ab06a2fc930", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "940d3ca125ff87ce7539740fbae29d2d64fec839328b0639127e1d197d2485d8", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-03", - "evidence_sha256": "f8152ccb0471b92317861ddb7fabeae5fcf740530b8b050510e29e1da130d3e3", - "run_id_sha256": "28768f565659133f5bf1170e638b81de4d7ca38dfecacd09ccf462a35344432b", + "condition": "healthy-02", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "841ebd8beb38baf63b1ce9c65d1f22d80a15e36e268eab7f019f063c7242ce9e", + "facts": {}, + "run_id_sha256": "bbb9312ce4682b23580eced0f8d19438d8266b222555df85fb27eef22ad5afe2", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, - "verdict": "absent", - "workflow_version_id": "44444444-4444-4444-8444-444444444444" - } - }, - "8c5e9d5c0d5330e70eceb4a7a0b11295161a7f4ca9ad6c8af091fde8afb1c6a9": { - "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", - "receipt_type": "runner", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "vSrJVlomLbiXHntckSOFPBXfx5nC5oVyf8hSOpCNON+YuWhHM+RK4iQN99BH3YeUdgeVMFDuUgogSa1JkUQIBQ==", - "source_artifact_sha256": "f2226cc85e803eb3cf39a88aa39b32d75a3910acc381cbd3197767c9c0b75b5b", - "verified_at": "2026-08-18T11:14:00Z", - "verified_projection": { - "attempt_id_sha256": "ad76dacfe19a4421ef1f128d4eef1099e846b385d29f17b8588ae5130b487118", - "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "verifier-unavailable", - "evidence_sha256": "f2226cc85e803eb3cf39a88aa39b32d75a3910acc381cbd3197767c9c0b75b5b", - "run_id_sha256": "87014cd8063f5a43ea22c995be03ec41ef5aa613145acacdef71b68c468fc8f1", - "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "task": "execute-acceptance", - "trial_index": 3, - "verdict": "halted", + "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "8d5373078fe224a410a6aa3c622308ea4058e7c846ec59ebba5d7288bc7fc3f2": { + "84e5195b0a66b7c41b3bd1424059ba26346faa8012fc4ab9d569e108e3553615": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-d92d542a589844dd", "receipt_type": "cleanup_absence", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "aG9Tx/kWr6HcUFAOunbFhbrOMgO0+BxfJeLsif8S4jO/Ngzz26uhREXHjqtBVqGmeDDbSKxr5HUC0ofgRMd1Dw==", - "source_artifact_sha256": "fac9c9cf16a2c781d6f7c55b241c6266c4fa513744fb05a705c1c8d33e3c7ccf", - "verified_at": "2026-08-18T10:24:00Z", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "CIth4iY2GxRop9zRmBY2Atv+1ZGlP5/uW/VspodSv/65rbJOZ5Icy6qedHQlAA0RmoVWYRDfgjKgCWAKg8noBw==", + "source_artifact_sha256": "f8152ccb0471b92317861ddb7fabeae5fcf740530b8b050510e29e1da130d3e3", + "verified_at": "2026-08-18T10:22:00Z", "verified_projection": { - "attempt_id_sha256": "7573925adbd8a7a4a3b98bb0379549d77aa8ed46e312c1cd940c05b8587a039e", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "fc097c8b2e6ece94544a19b8d81f5c4a9367a89059e3dd4b2f746ab06a2fc930", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "healthy-03", - "evidence_sha256": "fac9c9cf16a2c781d6f7c55b241c6266c4fa513744fb05a705c1c8d33e3c7ccf", - "run_id_sha256": "784a0a94e581700a3d93581e7ce5bac0d3bc53c58f3e73198b896b5da9a819b0", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "f8152ccb0471b92317861ddb7fabeae5fcf740530b8b050510e29e1da130d3e3", + "facts": {}, + "run_id_sha256": "28768f565659133f5bf1170e638b81de4d7ca38dfecacd09ccf462a35344432b", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, + "trial_index": 1, "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "8dd51f7605352784d26b1cc7c77746ebfd297d51b90a2953f7282228bbaf7591": { + "85e7b8b6b58819ab3b4574721e4263084e66b3a3aa505c1a0d5fe04e5df8cda8": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "ixc+sUvdANFWTEhymJsJsBw0HWSF3+wsMXCfSSKjPrwBPBL5v0VMhLpI6S2D4XLUlJliG2btb78YYNUBxwlJDg==", - "source_artifact_sha256": "1eca1abe283fecbe71ddaa403079343a5a6893d159482e26421de9b3004b7e29", - "verified_at": "2026-08-18T11:22:00Z", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "Jqtj6q3UaBtetU/qaQ3cGM+wByza3Fp+ouKQZDYCyAr5hDrBRRcvoQO55Lxt2k10JVubrc7YkP0tjNj56tFQDg==", + "source_artifact_sha256": "67d2fc6cdd3fbe39ae3cd6003edb1e7069940afea7f0c3b00794713d26646677", + "verified_at": "2026-08-18T10:13:00Z", "verified_projection": { - "attempt_id_sha256": "73a097b8b20bab7794369384f7ca1d7d711aad07967b7e1292373babbb7ff1b7", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "3d42601a69ef46cc44f57b51762affef4ccd829ffde30125619a6e582af00dab", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "weak-effect-only", - "evidence_sha256": "1eca1abe283fecbe71ddaa403079343a5a6893d159482e26421de9b3004b7e29", - "run_id_sha256": "b44783e70a980ec5b3cf3752bd5d1d01b2ff29f5a6892cba0c1c939d8aeb7c02", + "condition": "healthy-02", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "67d2fc6cdd3fbe39ae3cd6003edb1e7069940afea7f0c3b00794713d26646677", + "facts": {}, + "run_id_sha256": "091e13ed70dab439b31cb506cf3bba1ddf6476696531cf891c39a924a928b7a1", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, - "verdict": "halted", + "trial_index": 2, + "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "8e4466457228106adf081b8f17ea483f689a4022c30e1953cf273ddbf02519dd": { + "86565ed67acb88cd35e0a34cf2639b54eedf257f0391a7fcaa9ecc29b98fd533": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", - "receipt_type": "runner", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "0N0gNLP0kVRMIAvIO0sykRiEedLFjj2tmjFIkcltX9/6QbFpDFitXPP26yieHX+EzH04Uk/TZLeC0kmHnvaGAA==", - "source_artifact_sha256": "f847f556481bc9323fcdfb083e5068e729d1de913f60d34a1f7f7352a95af4a0", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "m8dGgS6Rg617uu+O2FK4f2UOOboIiGEQq1WWKdN3KyXTPGYnurXMGu78ZCxO6xZ42vVg04ZptYgVYYYbG902CQ==", + "source_artifact_sha256": "e92cda8b4f49cc4af5827dbf65d991b60d7bdb9a894000c57505f7fe072616ce", "verified_at": "2026-08-18T10:14:00Z", "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "019dd96e9a771ccc01ebafab321d7d3a8314df8b2d6465bcfc5fa14cbdeabdf2", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "healthy-02", - "evidence_sha256": "f847f556481bc9323fcdfb083e5068e729d1de913f60d34a1f7f7352a95af4a0", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "e92cda8b4f49cc4af5827dbf65d991b60d7bdb9a894000c57505f7fe072616ce", + "facts": { + "derived_classifications": { + "collateral_effect_count": 0, + "duplicate_effect_count": 0, + "intended_effect_count": 1, + "wrong_record_count": 0 + }, + "dispatch_state": "dispatched", + "effect_inventory": [ + { + "effect_id_sha256": "d5f1622c2956d2563fb993ded150f7a36e0a79b51f070beec032b8bb5acab8a2", + "record_id_sha256": "168a687e3fd8fbed76d59d0f70899eab30f82058098fc47ba24a1d253c425d62", + "transaction_ref_sha256": "bf754d98ea2b40b05ef93a4212b0285b205b20e9d30b402bc9fdeae969a8503a" + } + ], + "expected_record_id_sha256": "168a687e3fd8fbed76d59d0f70899eab30f82058098fc47ba24a1d253c425d62", + "expected_transaction_ref_sha256": "bf754d98ea2b40b05ef93a4212b0285b205b20e9d30b402bc9fdeae969a8503a", + "post_state_evidence_sha256": "bf2a04f127fef945d393aee65f6c924165667c723fcfd86b2073084b3b1fcd2b", + "pre_state_evidence_sha256": "8c1ec681950f04f1b3509f2a0add5b414c992fc27f3f9604378a7512ecdb510f", + "verifier_method": "read_only_system_of_record_query", + "verifier_tier": "independent_system_of_record" + }, "run_id_sha256": "16cb8df40654c6a1b55ea0e50e772d8c6e6d4f0d8205bd1f8296be27d0af83eb", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, - "verdict": "verified", - "workflow_version_id": "44444444-4444-4444-8444-444444444444" - } - }, - "8e671061a2ed724aebae4da714f8342c7aa1156a8151018c4cd45e8ea2b13a4e": { - "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "5YN4OXLAmxcy/VCHw8gnEHjkFlmWwf3G6KYGFx4G+ocKcEmYK+h60VMMRlMW4zPq7g97YCo/XnBh7fePFGtnCA==", - "source_artifact_sha256": "68f28b4ae7bd66c29ac1d2e3cf594da46ea4d7fa7bfc29557c835bb848cf81d8", - "verified_at": "2026-08-18T11:23:00Z", - "verified_projection": { - "attempt_id_sha256": "eb52fb1b1bf2fac92d8f3a444bb5081161be8b3d0ef457c5065e7b79e96df770", - "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "weak-effect-only", - "evidence_sha256": "68f28b4ae7bd66c29ac1d2e3cf594da46ea4d7fa7bfc29557c835bb848cf81d8", - "run_id_sha256": "794033f9da2a42448254a478fb6de954898b1e544148708ad30264efdc255431", - "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "task": "execute-acceptance", - "trial_index": 2, - "verdict": "delivered", + "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "8f293c1c43a0e7a6ca5aec96665bf2a869ce0ee065aa6ef5a5695a80765623f7": { + "873af0327d6a3360731e326c236f2b05e1220aa18a00a83d0c42b6d5012f0c08": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-138dfa227234ea5f", - "receipt_type": "cleanup", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "8EG7QELpfiMP402x2styX7um85fv6aDulsjCyET2n0Ogb+oDdJpQBHdoCEcEMIOsemBnxlfTD5mgP1gAfMj1AA==", - "source_artifact_sha256": "13d5f53016f80b5ba9f95ceaa4d79970bbf9870cc12470744d0291bbef3a1cda", - "verified_at": "2026-08-18T10:24:00Z", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "02hXX7MYoTXKHF6UfLrnw6/xSk+aQDIr+U6EtC5WOPVLTFF3I/Qgml4YIBRLzgcqx0PSH286g+BtP1an+evHBQ==", + "source_artifact_sha256": "a19b4b67cbeff4e08ebe9a0818d950e8d1ebeec5dec837efe97635b5fb541ea0", + "verified_at": "2026-08-18T10:52:00Z", "verified_projection": { - "attempt_id_sha256": "7573925adbd8a7a4a3b98bb0379549d77aa8ed46e312c1cd940c05b8587a039e", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "fbfce2be9ce964be8b668aa518a310fe4a89e5c014f42bd0ea81401bd83bfd7a", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-03", - "evidence_sha256": "13d5f53016f80b5ba9f95ceaa4d79970bbf9870cc12470744d0291bbef3a1cda", - "run_id_sha256": "784a0a94e581700a3d93581e7ce5bac0d3bc53c58f3e73198b896b5da9a819b0", + "condition": "stale-session", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "a19b4b67cbeff4e08ebe9a0818d950e8d1ebeec5dec837efe97635b5fb541ea0", + "facts": { + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "a19b4b67cbeff4e08ebe9a0818d950e8d1ebeec5dec837efe97635b5fb541ea0", + "source": "runner_signed_flow_report_and_enforced_egress_policy" + }, + "operator_intervention_ids_sha256": [] + }, + "run_id_sha256": "d9270fd4c85e4226a9347ecf703e876b9ffdc330f60c7fb8bed8f9321ea30225", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "completed", + "trial_index": 1, + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "8fc04ed993b5b503978034b069e82430afd713fec60fe7dd998675c5995d93ab": { + "8a046aaef8eff4fe4e86a69ef8ef2c0b035131876b0628a7fd6258cc34f1976b": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", "receipt_type": "runner", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "KclPArA7IERbgqJ9Z1/n1gkRtkcP9+lVodDHdsnVKwRw3UrIQv3vs192LyqRSudjXVVmwmWH7vnKmdQsh1ZkCQ==", - "source_artifact_sha256": "d216e429bd0611ac65b285ab73297d037fa3aeb3adb76d299da0c91d2559f159", - "verified_at": "2026-08-18T10:42:00Z", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "7vw7ezzX6lGrP6XwV1ZXe8OOZSzARBB4fopfIySIyBuihKPN9qCpHND0ybUn3UA+Gg/E+pX72bMgFCfDk0BIBg==", + "source_artifact_sha256": "6fe2828f0849b15893e440cf5a75e8cb3040f255c8d6d99adec885362da6f9c5", + "verified_at": "2026-08-18T11:22:00Z", "verified_projection": { - "attempt_id_sha256": "e93521e706ad90d799dcd4e8cac15229c5da6aec1638540606f5fab4efce59fc", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "73a097b8b20bab7794369384f7ca1d7d711aad07967b7e1292373babbb7ff1b7", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "wrong-reference", - "evidence_sha256": "d216e429bd0611ac65b285ab73297d037fa3aeb3adb76d299da0c91d2559f159", - "run_id_sha256": "ee82112f55e5e6c86cfd6e16df8c8b652549a8bd72de492f435d8255eb3dd252", + "condition": "weak-effect-only", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "6fe2828f0849b15893e440cf5a75e8cb3040f255c8d6d99adec885362da6f9c5", + "facts": { + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "6fe2828f0849b15893e440cf5a75e8cb3040f255c8d6d99adec885362da6f9c5", + "source": "runner_signed_flow_report_and_enforced_egress_policy" + }, + "operator_intervention_ids_sha256": [] + }, + "run_id_sha256": "b44783e70a980ec5b3cf3752bd5d1d01b2ff29f5a6892cba0c1c939d8aeb7c02", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, @@ -3073,130 +3973,201 @@ "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "9360f101c663dba041ccc6d4531e5d0924cc0f4425f62aa51e3b90b145d93adf": { + "8aec61997da4bb5f9445dd4625b2d07f5a94688dd77d182d32b47cc064f12902": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", - "receipt_type": "runner", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "AomwBewNM+5CYb1Q3+KfRllxPhwCGNMvsYtCEfDDcRuMwkGFBK/F2xO1iIvMb1OHr1OalzDsx3M6CpsEgrrHDw==", - "source_artifact_sha256": "9e7ce6c0c14f2e05ca217cb2830c9fbdd1205753014ece86f7e77671774081da", - "verified_at": "2026-08-18T11:23:00Z", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "EgxW23N8XFlNNn1mYd+idnIeYbcbScVNTGa1JrlgEkSQFXnVNBEhy9gkOxss1ZQCazkYtVU8XV2yOJASyJinCg==", + "source_artifact_sha256": "7cfb7c321bd76fc1bf31a8453b02adde00c9bde35f22ce38726f169660f2b323", + "verified_at": "2026-08-18T10:23:00Z", "verified_projection": { - "attempt_id_sha256": "eb52fb1b1bf2fac92d8f3a444bb5081161be8b3d0ef457c5065e7b79e96df770", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "2601335b1101424105277997a67850a8a60aa45f59637b7679c1f32af463c460", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "weak-effect-only", - "evidence_sha256": "9e7ce6c0c14f2e05ca217cb2830c9fbdd1205753014ece86f7e77671774081da", - "run_id_sha256": "794033f9da2a42448254a478fb6de954898b1e544148708ad30264efdc255431", + "condition": "healthy-03", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "7cfb7c321bd76fc1bf31a8453b02adde00c9bde35f22ce38726f169660f2b323", + "facts": {}, + "run_id_sha256": "237a0b7d1cafb64b1d113dca6699e6eefeaaf0b18679138545c3695495b901d5", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, - "verdict": "halted", + "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "950129910020acdc11ac8fd19134104516d2e8974d28c6c4044f757b9cda35c1": { + "914f5d551d662ec06a7dd8f330bd5256cf317ed0d280fe1da10fdb296c9e9b5f": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "Orrbx5zybHaptmLgDxeuPUK26F0BRyrCcTe/Bgtxa/8sX4A3Bbu+TnfGDudwx+1+whlqH9ebbp3MQH59v81vBQ==", - "source_artifact_sha256": "2811b870f1234408f64ada1ddab6eb1a4160941d92a9f9df96df037d1da69536", - "verified_at": "2026-08-18T10:12:00Z", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "1u8xRYwU8p0xHXvQr1JVe95+Z8AacMPaY5tgnd1nDsytNlec0KlIQuF8sAmTCYyNHPVhhHlw6/wBRkBQh8c/Dw==", + "source_artifact_sha256": "6381975addf1b4ec60255f58a8d2ec052c169a3228310d84dc3954d444e76d0f", + "verified_at": "2026-08-18T10:32:00Z", "verified_projection": { - "attempt_id_sha256": "940d3ca125ff87ce7539740fbae29d2d64fec839328b0639127e1d197d2485d8", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "3142933f4f168c98b8e89f2ae9d78fd3129e0a9975cbbaa60ddba853eee7d53c", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-02", - "evidence_sha256": "2811b870f1234408f64ada1ddab6eb1a4160941d92a9f9df96df037d1da69536", - "run_id_sha256": "bbb9312ce4682b23580eced0f8d19438d8266b222555df85fb27eef22ad5afe2", + "condition": "idempotency-replay", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "6381975addf1b4ec60255f58a8d2ec052c169a3228310d84dc3954d444e76d0f", + "facts": {}, + "run_id_sha256": "6cdff0cf50d0164fe1eee9c4b7db0b969c24f9b960f5653b516313a913c90a0f", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, - "verdict": "verified", + "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "9631c84144936efd84f60d5becc81b736dcd00dca94797ec7ab3dc2a4152a80f": { + "932ee45a17ff8efd7ce9813d4b02db10de4b9020f03797a2ee56d95c5d517366": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "6BDloCbCM+gXlZrQpX8vsH9G2iKjyC4ysHlb8RC2Tn4GnJmR+sUmd5on8M5UQ4bQ+bOXv3nYouVjLVq+xa2BAw==", - "source_artifact_sha256": "7d36fcea2384b6bb28044bc68847492fefb2783909042a96f6416cc457c258c6", - "verified_at": "2026-08-18T11:02:00Z", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "tkuPgg8/Bbc1iQ/3JyNvo5w0SIK96+GPo87M7/I1+kqIVmuN1LWCcIOg6NwbPuEkyI0pymRo1FHIsNHe2xVSCw==", + "source_artifact_sha256": "1f77854e1846d96a3d4c187c4946e746d7139d3a025dbd5ede6e8a6ee6be2c40", + "verified_at": "2026-08-18T10:22:00Z", "verified_projection": { - "attempt_id_sha256": "60ee9db05b1126cfaa3b31c13bc3fab4755ac09c44e846b4d07ee51865dfa7b1", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "fc097c8b2e6ece94544a19b8d81f5c4a9367a89059e3dd4b2f746ab06a2fc930", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "ambiguous-target", - "evidence_sha256": "7d36fcea2384b6bb28044bc68847492fefb2783909042a96f6416cc457c258c6", - "run_id_sha256": "628f991a182613b8700294d7483b5a4c06872cb9d5ca6047ea552b8ab6585357", + "condition": "healthy-03", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "1f77854e1846d96a3d4c187c4946e746d7139d3a025dbd5ede6e8a6ee6be2c40", + "facts": {}, + "run_id_sha256": "28768f565659133f5bf1170e638b81de4d7ca38dfecacd09ccf462a35344432b", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, - "verdict": "delivered", + "verdict": "verified", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "96be7cec9d956a7a3f3308730cf3377553a285ef6d7bd42100b43d044e161cbb": { + "93325b31e545651925604b95ea62b9327da8cb98905734f4925ca5d77aa5d1ed": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "Qj70t0XZGPEpjhigr/Yyzu5dA4ZhicXIuTFq5j/DsnLH+HN4Nn8XpiqUl4RyTQDqE54hEedlFD/Jtcfbv9W0BA==", - "source_artifact_sha256": "738fb82696e36887119e66c49386fc345003080f8417dcd4157684ca9a820236", - "verified_at": "2026-08-18T10:02:00Z", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "pk3fWzT8VLQJg/HkT+0sS7BfPSkR2fz7LSZi5QlPFpgaDh9D7Inel9EYambeiNkXZ93jYFR0zy0u7VbDmAuQAA==", + "source_artifact_sha256": "516ecd879cd6bf3ddce68daf59c204f277f8dc9c69b44e4aab5485a9563bb56b", + "verified_at": "2026-08-18T10:04:00Z", "verified_projection": { - "attempt_id_sha256": "679af5a8dedceb8c696719e73f82a698c230cd8fc98bb61769f0883202c0b637", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "4c352a6999f77707e8837adebb4fc2b7451c2ef6de5145190b33a5c5645e47eb", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "healthy-01", - "evidence_sha256": "738fb82696e36887119e66c49386fc345003080f8417dcd4157684ca9a820236", - "run_id_sha256": "0b5bda916a0808165159166955a9563cf9c2303949f762a18eb037f41b44a6dc", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "516ecd879cd6bf3ddce68daf59c204f277f8dc9c69b44e4aab5485a9563bb56b", + "facts": { + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "516ecd879cd6bf3ddce68daf59c204f277f8dc9c69b44e4aab5485a9563bb56b", + "source": "runner_signed_flow_report_and_enforced_egress_policy" + }, + "operator_intervention_ids_sha256": [] + }, + "run_id_sha256": "4ee2bb61fb883cc8e77d636fb471aa3c0ce9ef0c0a8abd9682214bf0a8f16f26", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, - "verdict": "absent", + "trial_index": 3, + "verdict": "verified", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "974ab867b3788102bd3f634d25770c9abe171a3101c3e206b81bc60dcaac1a65": { + "93a820891c954075ce0f99539579a121345fc59129f8465a37c3937e401c5c7f": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d7e1e084be213b01", - "receipt_type": "observer", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "fMED3XGAHBlhnK1izzlZVdicc0gXduZGeRYxwKawkdxPkNrfL2XIx1C+o9rR7GwAosEBvMedQ5p3cKfn7w8dAg==", - "source_artifact_sha256": "e92cda8b4f49cc4af5827dbf65d991b60d7bdb9a894000c57505f7fe072616ce", - "verified_at": "2026-08-18T10:14:00Z", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "bR+QhRcOk4EBDKLjJz/pnIhaq4S/FgEIttGvPKgcbMx3qmKasgm7rFkPiHNN9e+x1mlEA/Qk2YJvs/hMwdxLAQ==", + "source_artifact_sha256": "63a797c26af0607f83fd33dbce35617c4061915381435f3fbbd782b3554c15dc", + "verified_at": "2026-08-18T10:13:00Z", "verified_projection": { - "attempt_id_sha256": "019dd96e9a771ccc01ebafab321d7d3a8314df8b2d6465bcfc5fa14cbdeabdf2", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "3d42601a69ef46cc44f57b51762affef4ccd829ffde30125619a6e582af00dab", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "healthy-02", - "evidence_sha256": "e92cda8b4f49cc4af5827dbf65d991b60d7bdb9a894000c57505f7fe072616ce", - "run_id_sha256": "16cb8df40654c6a1b55ea0e50e772d8c6e6d4f0d8205bd1f8296be27d0af83eb", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "63a797c26af0607f83fd33dbce35617c4061915381435f3fbbd782b3554c15dc", + "facts": {}, + "run_id_sha256": "091e13ed70dab439b31cb506cf3bba1ddf6476696531cf891c39a924a928b7a1", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "satisfied", + "trial_index": 2, + "verdict": "verified", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "94480255df8b3ebf0a824b340d666a28d5fff75dc3d668d6ed30b4c69d06590b": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "6guxXkBYJx7whL3RpfwFeEQqUVXvR9jJfM/B/sBi/EYvaAAN9UVOlsqBHNV9jNVE950V69Feddml7dSEm1KrBQ==", + "source_artifact_sha256": "693c5de78792744df15509b8187bfaf3ec71a4d879011e9773e98d139b5d7856", + "verified_at": "2026-08-18T10:03:00Z", + "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "fdad940f245d690750ad647fac25c7e76aac2f474db49732fec8129051750186", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-01", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "693c5de78792744df15509b8187bfaf3ec71a4d879011e9773e98d139b5d7856", + "facts": { + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "693c5de78792744df15509b8187bfaf3ec71a4d879011e9773e98d139b5d7856", + "source": "runner_signed_flow_report_and_enforced_egress_policy" + }, + "operator_intervention_ids_sha256": [] + }, + "run_id_sha256": "3739043a92a8781376cfbd022460c03aba40f92a800b3885ebc046321437bc40", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "verified", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "97e53386169276ba5b6fe074df5e3b928617a1298e4fdf7c7100474d4af06152": { + "95d12087d75ba87fd4915c47e5b83e12371fac79a045b1fd1ac7f778089a16ff": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-d92d542a589844dd", "receipt_type": "cleanup_absence", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "vrNcbIf8sJZj7wqu48hsN/YLt/lJexSG7rUXVXtgOrmgAZmBLHqq4+xgijfOhts8feRTcTqnJfJ/dvmv5RsbBg==", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "mMwosfl1xK5ystPKMT167odFKgy0+P80y3BXd7xiY0UPfssVl3MAhntDfluQ22yNB6WUri5MFGdPnm6r06BYDA==", "source_artifact_sha256": "5a3777b92fabc030635bb4f578eda746f0b307d541bf84a0099314eed54c8d00", "verified_at": "2026-08-18T10:14:00Z", "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "019dd96e9a771ccc01ebafab321d7d3a8314df8b2d6465bcfc5fa14cbdeabdf2", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "healthy-02", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", "evidence_sha256": "5a3777b92fabc030635bb4f578eda746f0b307d541bf84a0099314eed54c8d00", + "facts": {}, "run_id_sha256": "16cb8df40654c6a1b55ea0e50e772d8c6e6d4f0d8205bd1f8296be27d0af83eb", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", @@ -3205,262 +4176,342 @@ "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "97f6959aeb4a3659829a200f85e403a6001866e6495675fd3fe27542ed765ea2": { + "960800964e484e67a3e76cdcc336b8b620f46d64b6fce87bdd6475c66097416c": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", - "receipt_type": "fault", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "mbJaQFWtZdbGe+NOOcbuf2o7DOyUVrFtfU+4JDn4FPiHORqvL6YKVSSelOO0WFq4PM320ExsfA2Bfrf7IFA9Aw==", - "source_artifact_sha256": "002efaa296dd38b0596e300894d23a4d0a9ceda1480bd302602a34e6d5d6b884", - "verified_at": "2026-08-18T10:53:00Z", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "EusYsr8DJKBRwi2FbjlRtR6EjSTcmb6hHB6FudNycpKGCNwTMHdhROQJi8Ri9Y4Yjsm4WummM192uTT2DLk6DA==", + "source_artifact_sha256": "58703c8fb721c8bd010e150d01acbc91a664c3273b9d1b85d945398148b6ff87", + "verified_at": "2026-08-18T11:23:00Z", "verified_projection": { - "attempt_id_sha256": "f5df4d6e64a2d38ffa8e320c87ad05d04025de267a8e152a755d3f1928ded120", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "eb52fb1b1bf2fac92d8f3a444bb5081161be8b3d0ef457c5065e7b79e96df770", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "stale-session", - "evidence_sha256": "002efaa296dd38b0596e300894d23a4d0a9ceda1480bd302602a34e6d5d6b884", - "run_id_sha256": "fd3a041b705d8c6277ce26134dc0018e866218cfa3fadd16ac29d1ad498965a3", + "condition": "weak-effect-only", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "58703c8fb721c8bd010e150d01acbc91a664c3273b9d1b85d945398148b6ff87", + "facts": { + "derived_classifications": { + "collateral_effect_count": 0, + "duplicate_effect_count": 0, + "intended_effect_count": 0, + "wrong_record_count": 0 + }, + "dispatch_state": "not_dispatched", + "effect_inventory": [], + "expected_record_id_sha256": "21c651c545d2279507f7ddd513acee7961b4cb9e59e9738831b5b2a8bc1fae80", + "expected_transaction_ref_sha256": "822f722f5eb229e4240375407ed8896979fc5fea472542519de2a1525e020012", + "post_state_evidence_sha256": "26299f46a60d4c30304e365977a48f64fa8c8f64d408f804601a3153d2b058f4", + "pre_state_evidence_sha256": "9e0c1139ef3ee5b7e2f4e9d209ba561c244af89fc8211606a0698486ad47e930", + "verifier_method": "read_only_system_of_record_query", + "verifier_tier": "independent_system_of_record" + }, + "run_id_sha256": "794033f9da2a42448254a478fb6de954898b1e544148708ad30264efdc255431", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, - "verdict": "injected", + "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "983cfdb068e5742ca3315545dbe1d5c0bca772ce0359994c7c856d089ff8a892": { + "96ebae402e023ee731b31211979466c1ba782490d54bbf69f6e9741f6f3177a2": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "pGn8BSjps9RfCDv0iG6U4Q1LznQIdDxWmjCP5N9DUmgGjyAv2HHY0FyBaroA8HDJPN7OUuzWV03MyUOQ5O4mCg==", - "source_artifact_sha256": "19bdab0320cb59b56b35ff49a7413fec8a975d93a0f54d88dbb5ccb742efafcf", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "G6lBKOHThIVwysrHQjmuxoeBb6Oq3pUuePhadofUFFMJgc/X+ceHQBPzPou0UqsGmd5EO5Ppsb96/vSL77wZDA==", + "source_artifact_sha256": "feb27a02d37abdd67aa0b50cdce26c636bfc6b3284475e77a21d027738a91b5a", "verified_at": "2026-08-18T10:22:00Z", "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "fc097c8b2e6ece94544a19b8d81f5c4a9367a89059e3dd4b2f746ab06a2fc930", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "healthy-03", - "evidence_sha256": "19bdab0320cb59b56b35ff49a7413fec8a975d93a0f54d88dbb5ccb742efafcf", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "feb27a02d37abdd67aa0b50cdce26c636bfc6b3284475e77a21d027738a91b5a", + "facts": {}, "run_id_sha256": "28768f565659133f5bf1170e638b81de4d7ca38dfecacd09ccf462a35344432b", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, - "verdict": "delivered", + "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "994bdf2b435c1a57d515e4b881bbcac43289df1f20385f7150c0193e1d2acc6f": { + "97a4c47d8a841b03b91b1cbcf6df1d4c9c5cf9f11d5073d7c3586e835d872801": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-138dfa227234ea5f", - "receipt_type": "cleanup", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "ROvNllHfko7wMob+jDHi4UDl/lKNEOVHu2c5z2/lJmLeFPPU0AER4s+QBvImzNQbpWU7fC8T5EaIZZxZ1qFMDA==", - "source_artifact_sha256": "a44dac787050d0cb99551f8f0735973f618907d4b8f58c6f5760fc1634522c2f", - "verified_at": "2026-08-18T10:04:00Z", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "JJ1D4qevhD+boJZ6OwlvccOdFGL0j1Dt0TFhsPbU+hEyNhvVUIsn9K+lQLbW4iPlYJrOBpE4HzfYXdEkKXJBDg==", + "source_artifact_sha256": "f847f556481bc9323fcdfb083e5068e729d1de913f60d34a1f7f7352a95af4a0", + "verified_at": "2026-08-18T10:14:00Z", "verified_projection": { - "attempt_id_sha256": "4c352a6999f77707e8837adebb4fc2b7451c2ef6de5145190b33a5c5645e47eb", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "019dd96e9a771ccc01ebafab321d7d3a8314df8b2d6465bcfc5fa14cbdeabdf2", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-01", - "evidence_sha256": "a44dac787050d0cb99551f8f0735973f618907d4b8f58c6f5760fc1634522c2f", - "run_id_sha256": "4ee2bb61fb883cc8e77d636fb471aa3c0ce9ef0c0a8abd9682214bf0a8f16f26", + "condition": "healthy-02", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "f847f556481bc9323fcdfb083e5068e729d1de913f60d34a1f7f7352a95af4a0", + "facts": { + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "f847f556481bc9323fcdfb083e5068e729d1de913f60d34a1f7f7352a95af4a0", + "source": "runner_signed_flow_report_and_enforced_egress_policy" + }, + "operator_intervention_ids_sha256": [] + }, + "run_id_sha256": "16cb8df40654c6a1b55ea0e50e772d8c6e6d4f0d8205bd1f8296be27d0af83eb", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, - "verdict": "completed", + "verdict": "verified", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "9d1fb286c570cad74e6f2e0c77a085c58bab02089cd52c84c0a3c7637f13ff04": { + "97d0bac2c04b176b3a168f9692a80308b7a473fe021aa8e3936ba660c7425eab": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", - "receipt_type": "runner", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "ZHbB4V6PpsQNwGuAgTM2eaWxpLF4Ty8C6y75s0EehJEfTNIdkRqnbUK0J9lr1jXqt2cKe/lVioZH+v6L71oGBg==", - "source_artifact_sha256": "009c1c1e67709868ad5218f72fe47f2fe26660be981c32e064da92de8bc4e85e", - "verified_at": "2026-08-18T10:22:00Z", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "UuzHkZ+xRvo9LFGiAXBvB4LARuI3i1bvS9o9bRxHQ4FkTm4DSjdUgURf6itEvhLIdMLCH+6eHaR/4Hlw57gpBQ==", + "source_artifact_sha256": "6eac8e2767237847378635c85aa204fee9f7317f048965d102409679612f37c4", + "verified_at": "2026-08-18T11:23:00Z", "verified_projection": { - "attempt_id_sha256": "fc097c8b2e6ece94544a19b8d81f5c4a9367a89059e3dd4b2f746ab06a2fc930", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "eb52fb1b1bf2fac92d8f3a444bb5081161be8b3d0ef457c5065e7b79e96df770", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-03", - "evidence_sha256": "009c1c1e67709868ad5218f72fe47f2fe26660be981c32e064da92de8bc4e85e", - "run_id_sha256": "28768f565659133f5bf1170e638b81de4d7ca38dfecacd09ccf462a35344432b", + "condition": "weak-effect-only", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "6eac8e2767237847378635c85aa204fee9f7317f048965d102409679612f37c4", + "facts": {}, + "run_id_sha256": "794033f9da2a42448254a478fb6de954898b1e544148708ad30264efdc255431", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, - "verdict": "verified", + "trial_index": 2, + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "9dc862e47d7e3dc1cfa80048c17b4c566a36aff741e4a7914b3dc0e9c3729b13": { + "9842d656d4d92597e76248af6b34e1577d204588dd9b446cc98424630c4ba79f": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "tMjcxMhQPM6mWFOaJcWbthLm0mjVIWyccxILufEW0qsH4SnSicXtcMx/U4twqcY+Qv1N0wv27CIZM0IVe6yABQ==", - "source_artifact_sha256": "fe35b956dbe29b97bcbf293cf40b9c9c9c6eac8466925d706e684648b3d43d9b", - "verified_at": "2026-08-18T10:43:00Z", + "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", + "receipt_type": "fault", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "wsbwuw/Ie7cVjsoqUq6DDl+LotOlzY6MoM5qrOwqObYgbkupWwrn7Pu8rXrugua6bO/NP9Naflu3ax9udTiuDA==", + "source_artifact_sha256": "7d54c11699d0fc258007146c754f3dd04a68594dea5bf0402d10aa55a04b514d", + "verified_at": "2026-08-18T11:02:00Z", "verified_projection": { - "attempt_id_sha256": "6b0e5c10d55fc92c1ff8576392270a24fb65722414cf58ff9a51b8ce9ef88587", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "60ee9db05b1126cfaa3b31c13bc3fab4755ac09c44e846b4d07ee51865dfa7b1", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "wrong-reference", - "evidence_sha256": "fe35b956dbe29b97bcbf293cf40b9c9c9c6eac8466925d706e684648b3d43d9b", - "run_id_sha256": "577e37b10b1c87fd9c1b5d320888b736d272824657fd59a012e85a284ee88540", + "condition": "ambiguous-target", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "7d54c11699d0fc258007146c754f3dd04a68594dea5bf0402d10aa55a04b514d", + "facts": {}, + "run_id_sha256": "628f991a182613b8700294d7483b5a4c06872cb9d5ca6047ea552b8ab6585357", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "delivered", + "trial_index": 1, + "verdict": "injected", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "9e3bbbe8b2d5c7987be2fd3e29228f407319832eee70ef1bcb56fce353a8fec1": { + "9a7ff6004d469b48ff0888078d491586e9590f75f13abd4764fd6295eb6aabb7": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-138dfa227234ea5f", "receipt_type": "cleanup", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "uUCAw1zpszyQi/JdeZHu7AArWdv2hfUkTFpk4VkIAZduMm4IOeOAf/MfNsaq/7yHwoVFyY5pLISRy6m76LHJAQ==", - "source_artifact_sha256": "b2d52421d96d2fc81f80e91f43d0228f793bae8fefedbea6d79a281c903b0000", - "verified_at": "2026-08-18T10:33:00Z", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "n4X/HhHTESCcumMo+/kswvM2xWqWBKWehNKpd1SVL50wjcfJYhwWeFJUePLtVO+iVnQy9rGgoB0xfZqpIZo6Bg==", + "source_artifact_sha256": "6f4098a4cb069c24d492715c73eabdf78d759e24953b88a134df911d06fd36f5", + "verified_at": "2026-08-18T10:54:00Z", "verified_projection": { - "attempt_id_sha256": "4667302b580ff7ceb223dbb15eb6d029969a8f6a54bcd33e8df5b6bff41f41ad", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "958342a9ddca98a83b82b662f52f404239d583afe7ed70634760e1b8dd592f3b", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "idempotency-replay", - "evidence_sha256": "b2d52421d96d2fc81f80e91f43d0228f793bae8fefedbea6d79a281c903b0000", - "run_id_sha256": "33e0ad9bf64e477f24d46508fa432123e046dcd1c5853d5cc60b7cde1bce7537", + "condition": "stale-session", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "6f4098a4cb069c24d492715c73eabdf78d759e24953b88a134df911d06fd36f5", + "facts": {}, + "run_id_sha256": "6f2fb10bc2018c9f78e9702d5ccac0bedd78ee3b2e9d2a6ad779fba72d90ae50", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, + "trial_index": 3, "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "9ff950e9dfd77d6c9e04fba2111f9e49115c2bb248ba26e3441a76a60d07eb18": { + "9ad9415421ff129296360281cd537671da5f6894ab31b17254eb0d15aa976584": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "1hAlajSMFI/qdRJgyb58x8PBi8LgsVcxFMy464jj2inT7trfMsKR3gUmrV6TB+LHHGn9SlxFuEfcjEfaYBB4BA==", - "source_artifact_sha256": "40ce452beafd723531d21b631c3b7710042cff165f085f929b65d07e9575e16b", - "verified_at": "2026-08-18T11:14:00Z", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "S4jo6gZ95myTyqyH6a0kc3T7Bk6Y1AP0t8qUuIMQaU+uMN9qZhL/FGVEGC+RM+ePVwNJBthKWuTED+z1d3HuBg==", + "source_artifact_sha256": "19c8e4a8e4ef48302a4600b8bf8bd600dbffa7e3b33c7ac91fa693b98487bdf2", + "verified_at": "2026-08-18T11:04:00Z", "verified_projection": { - "attempt_id_sha256": "ad76dacfe19a4421ef1f128d4eef1099e846b385d29f17b8588ae5130b487118", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "491a544656d05aea37920e5c7e2ad65a9452eac8d6e100268a599aeebd41187a", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "verifier-unavailable", - "evidence_sha256": "40ce452beafd723531d21b631c3b7710042cff165f085f929b65d07e9575e16b", - "run_id_sha256": "87014cd8063f5a43ea22c995be03ec41ef5aa613145acacdef71b68c468fc8f1", + "condition": "ambiguous-target", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "19c8e4a8e4ef48302a4600b8bf8bd600dbffa7e3b33c7ac91fa693b98487bdf2", + "facts": {}, + "run_id_sha256": "aa62c7a17701a7ef01ea1d3519b4c1f90d357495b329fdda3054cc24c581a593", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, - "verdict": "halted", + "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "a0e9b443f4c32b7625331527491aa59f8e106cc72042f16e6b6a821cd0f7fccf": { + "9b67f51c4c82736ce53e697d96f9d24851bd56aaf11882d44ded060ea9417a8c": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d7e1e084be213b01", - "receipt_type": "observer", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "EMX2HfS9UBThedJUYNO/qL7ZpxCDEG4ull1ExODrryFc7vsB+PBT/WltWnmILpE+7VHMZeW3LHiSnRqnHTJBAA==", - "source_artifact_sha256": "7742811fd54dc2fb2b1336f83c65918fcb116f4cf437d0246c2095228d61249a", - "verified_at": "2026-08-18T10:42:00Z", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "DEdefsUk7IYe+OzAHlV2gbR6I54BT1ogex/at7YILyi5XZXdGIX1N3kpTlDk1g4PRqhb4YQrBxDSfacG5r+NCA==", + "source_artifact_sha256": "450c89cbaa5a936d700d26b432db8bd4bbdbc51112a84e99abd73954c0897001", + "verified_at": "2026-08-18T11:04:00Z", "verified_projection": { - "attempt_id_sha256": "e93521e706ad90d799dcd4e8cac15229c5da6aec1638540606f5fab4efce59fc", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "491a544656d05aea37920e5c7e2ad65a9452eac8d6e100268a599aeebd41187a", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "wrong-reference", - "evidence_sha256": "7742811fd54dc2fb2b1336f83c65918fcb116f4cf437d0246c2095228d61249a", - "run_id_sha256": "ee82112f55e5e6c86cfd6e16df8c8b652549a8bd72de492f435d8255eb3dd252", + "condition": "ambiguous-target", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "450c89cbaa5a936d700d26b432db8bd4bbdbc51112a84e99abd73954c0897001", + "facts": {}, + "run_id_sha256": "aa62c7a17701a7ef01ea1d3519b4c1f90d357495b329fdda3054cc24c581a593", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, - "verdict": "satisfied", + "trial_index": 3, + "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "a2945533984428f22741891a6ad7bb56d247cb48bcba5b1c04abd6d0bb874fe8": { + "9c2d9af1bfda87a93cd19e5f83962d6c0332255f487fd35b5a494468cee86b32": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-e37abcd79efd08db", "receipt_type": "replay", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "pr7K+4S9n4SkvVAzG7Bt4B4OSkdM9fUgHmN3gb2j8EhxytZyCWyzDbQQzo94XgrJDoJpxb/Y9D7EgxnHPspRBw==", - "source_artifact_sha256": "5715c0e7be0a23b342d074947567c9aab924b43b2318265f28013a0d5715506f", - "verified_at": "2026-08-18T10:34:00Z", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "fB87wo9UI/17XHNqfEKlSCeYK8H4zrlf7WXk3Xp9/x41jjU7VlSm6ZW8ixmd6llp+qVzQQcoKVhtq2xxmYzzBQ==", + "source_artifact_sha256": "1eca1abe283fecbe71ddaa403079343a5a6893d159482e26421de9b3004b7e29", + "verified_at": "2026-08-18T11:22:00Z", "verified_projection": { - "attempt_id_sha256": "3aee8ad755c7f4bec71cc194bcfaa805e0ea29cf8b830ed0782f8263dd9620ca", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "73a097b8b20bab7794369384f7ca1d7d711aad07967b7e1292373babbb7ff1b7", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "idempotency-replay", - "evidence_sha256": "5715c0e7be0a23b342d074947567c9aab924b43b2318265f28013a0d5715506f", - "run_id_sha256": "3df83453126754a62d00ed10837720542d0469799bb8a88cb5257ac5f477a919", + "condition": "weak-effect-only", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "1eca1abe283fecbe71ddaa403079343a5a6893d159482e26421de9b3004b7e29", + "facts": {}, + "run_id_sha256": "b44783e70a980ec5b3cf3752bd5d1d01b2ff29f5a6892cba0c1c939d8aeb7c02", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "verified", + "trial_index": 1, + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "a761ed49d1a6b031989d9a95d8d4ce740d3d5e6e8daad883e1daad675c4d19d5": { + "9db2b18e2dc3cf9b5d36401b3b39deff53f42376f1ef0e4db7e5bf74f8a2d41c": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "68Q+WmqB7IsYmJAqkoggwBWedta3WUXNpLJCUpjq+aLzQCxqGXsgIh3eGgSBeNAc25SDygFxXOdelT401gmNAA==", - "source_artifact_sha256": "e8401afc508900868571caae7995d9771884b1f6faac3543a13bc77ce498c1fd", - "verified_at": "2026-08-18T10:03:00Z", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "gdZpLo07H3UPnCZ2ml+YovGEvpTgnY5UEd7BGV8w7Xgoi9/ww6hcBjMQOH390mTHrOhlE4viQaqUerLFcMcrAQ==", + "source_artifact_sha256": "975e43caa5b1e34f06e36ad0fd995c5ba6662a55f5cb8d8d28a9f6208420b800", + "verified_at": "2026-08-18T10:53:00Z", "verified_projection": { - "attempt_id_sha256": "fdad940f245d690750ad647fac25c7e76aac2f474db49732fec8129051750186", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "f5df4d6e64a2d38ffa8e320c87ad05d04025de267a8e152a755d3f1928ded120", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-01", - "evidence_sha256": "e8401afc508900868571caae7995d9771884b1f6faac3543a13bc77ce498c1fd", - "run_id_sha256": "3739043a92a8781376cfbd022460c03aba40f92a800b3885ebc046321437bc40", + "condition": "stale-session", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "975e43caa5b1e34f06e36ad0fd995c5ba6662a55f5cb8d8d28a9f6208420b800", + "facts": {}, + "run_id_sha256": "fd3a041b705d8c6277ce26134dc0018e866218cfa3fadd16ac29d1ad498965a3", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, - "verdict": "delivered", + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "a871118c067954b7150653696449fa0d547da2cb75a906394a899d7e81811365": { + "9ecd01ee39fd20d52a6ac0015f2d41508e79bdae57d936cbadc31dddf3f9a1a6": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", "receipt_type": "fault", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "oAOvxXF+5Q4M9EPj2nwWcYgySkLS54NE5c1COGCfdiA3qg3I15SLRGphWlAOgUTAta1kujo0IWmOF2LoFowRCg==", - "source_artifact_sha256": "d80e5faa489be940291e74948facb9a38c3f6ce34fbe6fb5c586b966e5c82228", - "verified_at": "2026-08-18T11:12:00Z", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "YcA8RX/nVVCzbegHGJ6FG4ERtYa5BOfzGT0q+NhrUE7rpzhfbR79lBbk/j1LtfIFzb1MKE7Qe81p+/rnl29QDg==", + "source_artifact_sha256": "49dbd40897c1bf5714a6e032fc07ef378207978f4db7ee347783daf9bfba90ca", + "verified_at": "2026-08-18T11:14:00Z", "verified_projection": { - "attempt_id_sha256": "f5e96a2e9a580376b18beabf57798b8761e772a0c4d112877045780bb12b3720", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "ad76dacfe19a4421ef1f128d4eef1099e846b385d29f17b8588ae5130b487118", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "verifier-unavailable", - "evidence_sha256": "d80e5faa489be940291e74948facb9a38c3f6ce34fbe6fb5c586b966e5c82228", - "run_id_sha256": "e8e89651045a5f5c011c9543ed968e0fe7697a061ed8ad5cedc27d194cb96acb", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "49dbd40897c1bf5714a6e032fc07ef378207978f4db7ee347783daf9bfba90ca", + "facts": {}, + "run_id_sha256": "87014cd8063f5a43ea22c995be03ec41ef5aa613145acacdef71b68c468fc8f1", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, + "trial_index": 3, "verdict": "injected", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "a8b00915dcebc57be31a774634b0371cd299935f86c7c0213fdaf215480cb6c1": { + "a084fd73559d8b3db4eb489627c23d3fbddcb149c5f22bdc0f21b3057fe78fc5": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-d7e1e084be213b01", "receipt_type": "observer", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "Q8GxZwBhG+Kwi6xDGVSqWBJHpxAQPyJGpYb8PtRBdIG8zFVp5sCO1G22I5ErkO823P18Tv6BENoNSlH3A+6NDA==", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "O8+zPNpLrrNfk/Dghwr6uJecLDizKqszIE3i4fX1KEmr8daEZWZ2VPdn5U30n2Ly427p95z31xoxGf4OXEiRBg==", "source_artifact_sha256": "a71340e07f39ce3002adc89f5435ab9eade0ea3cf1426a1e7905df87ae659b41", "verified_at": "2026-08-18T11:12:00Z", "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "f5e96a2e9a580376b18beabf57798b8761e772a0c4d112877045780bb12b3720", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "verifier-unavailable", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", "evidence_sha256": "a71340e07f39ce3002adc89f5435ab9eade0ea3cf1426a1e7905df87ae659b41", + "facts": { + "derived_classifications": { + "collateral_effect_count": 0, + "duplicate_effect_count": 0, + "intended_effect_count": 0, + "wrong_record_count": 0 + }, + "dispatch_state": "not_dispatched", + "effect_inventory": [], + "expected_record_id_sha256": "37b0146870f3d4a319e6446186a285fb632a6f9637d720bcb3139d9fcccd8775", + "expected_transaction_ref_sha256": "04b62fe444529c82e87c0c6d030a1e5674582f4a9fae517882d53328ce0bb12b", + "post_state_evidence_sha256": "7698e71e3b5a9851a6b4d850d356966517b9680e9d65ef611cf9fcfdc97b1c3e", + "pre_state_evidence_sha256": "82d7a352f0e35fce89e927fb469da061cffdde4bcb91098e725ac7a75e9fd266", + "verifier_method": "read_only_system_of_record_query", + "verifier_tier": "independent_system_of_record" + }, "run_id_sha256": "e8e89651045a5f5c011c9543ed968e0fe7697a061ed8ad5cedc27d194cb96acb", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", @@ -3469,109 +4520,49 @@ "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "ab88cfde60ca5548f8b6812e3713c9d2541ba50da220a9b4e6196cba18f94145": { - "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "HXrBGW4KgoA9YWz0N54V9n3YRzqEBd6vDsj6FhPySkcVej+ltVaQghtbd9406rpOAcdaq+GTf6D2BxdZR/RrDA==", - "source_artifact_sha256": "82e77fe44a201615e8f4c27505e4418bc71c0e4706dbe79be35ff085e812e4ad", - "verified_at": "2026-08-18T10:02:00Z", - "verified_projection": { - "attempt_id_sha256": "679af5a8dedceb8c696719e73f82a698c230cd8fc98bb61769f0883202c0b637", - "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-01", - "evidence_sha256": "82e77fe44a201615e8f4c27505e4418bc71c0e4706dbe79be35ff085e812e4ad", - "run_id_sha256": "0b5bda916a0808165159166955a9563cf9c2303949f762a18eb037f41b44a6dc", - "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "task": "execute-acceptance", - "trial_index": 1, - "verdict": "delivered", - "workflow_version_id": "44444444-4444-4444-8444-444444444444" - } - }, - "abca187283c219dbc776aaae8d38842e8ef0ae7b56007f5a6708f27e161e997a": { + "a1e2cf48ee6a452726941504cdfcb692d395b1d31133f828215e77c2ac8228b5": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "gPMZce379O0g1Cf4GDEXfRwz28ZnCblDrRnMCu8bL/1RRJvUhygk1owWd/3KCa580WtG8Mt4tDTuchBplDg6AA==", - "source_artifact_sha256": "ce46f3e2c640383fa7d86f238289722cb7a1f00c5ee3ba8994a54c6a140ad8d4", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "QJFy8sbOeKKjy5JQ2f5Afh46XYojolwTL/JwjENRUpcKvBO/bf2Yiaue91tQGY4CmhbYSb+CoyNx0bfKQ1YoBg==", + "source_artifact_sha256": "0e28a6c49ce0c22f0e6a0220a2c3340d4e956f0f9a29511f0c44e7492d004a89", "verified_at": "2026-08-18T11:13:00Z", "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "42259dbb767ced4c25ad8bd40edc209720a748897194c925ed9bd2e27b2258b2", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "verifier-unavailable", - "evidence_sha256": "ce46f3e2c640383fa7d86f238289722cb7a1f00c5ee3ba8994a54c6a140ad8d4", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "0e28a6c49ce0c22f0e6a0220a2c3340d4e956f0f9a29511f0c44e7492d004a89", + "facts": {}, "run_id_sha256": "4af84f2608a25a27e6252a5800263a238bb70fb3bec65148601ddcdddbf3e03c", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, - "verdict": "halted", - "workflow_version_id": "44444444-4444-4444-8444-444444444444" - } - }, - "acbcfae15099ebc8a2d63b87be87a0431e560968cb06899ee82754ccecec1b9f": { - "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "eSNCqqamlXhNy002/zhHakF1HV3pEbVKuPrXExS0/1Qdi8IEGL3B/YWNCdST1BaGLKUKr68/1/FhF7QWoJzCDA==", - "source_artifact_sha256": "5b97c09965f50b433ebd2e38459a56f0ae35537b2267b3e89faf7125ea0c2e25", - "verified_at": "2026-08-18T11:23:00Z", - "verified_projection": { - "attempt_id_sha256": "eb52fb1b1bf2fac92d8f3a444bb5081161be8b3d0ef457c5065e7b79e96df770", - "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "weak-effect-only", - "evidence_sha256": "5b97c09965f50b433ebd2e38459a56f0ae35537b2267b3e89faf7125ea0c2e25", - "run_id_sha256": "794033f9da2a42448254a478fb6de954898b1e544148708ad30264efdc255431", - "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "task": "execute-acceptance", - "trial_index": 2, "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "acf6d491add27b4b7a31a472243d873a000b70e758fd0adb6625e279dfa05dd3": { + "a4f8f64f3037b61213ea0e1e562cce78f79c336de874f207224906d671a84531": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-d92d542a589844dd", "receipt_type": "cleanup_absence", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "vJETRQECumt9uEVqT1708m5ONCfT1SK1yJzxWu2gx025hYJsNGI9oM6/xcxGZnvUGUhYomiC+9xlsouC17U9DQ==", - "source_artifact_sha256": "11cdb7bd9282bd8b9c10b25bd5e552c14ca6658cb559b133ce7e6b8dfc17f0f3", - "verified_at": "2026-08-18T10:42:00Z", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "Urn1GeBqY/R2cqz2OH+iBqNsnheddn0hc41Fz+0bnM4XIsaul5d5nwPCas2LYQozQ3quNYu0dY/UFdM5LYQxAQ==", + "source_artifact_sha256": "0aefdcb48f524cd1122dc1bfffdbcea74cc3d239411590ae1b6c6b5d0ca845b4", + "verified_at": "2026-08-18T10:43:00Z", "verified_projection": { - "attempt_id_sha256": "e93521e706ad90d799dcd4e8cac15229c5da6aec1638540606f5fab4efce59fc", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "6b0e5c10d55fc92c1ff8576392270a24fb65722414cf58ff9a51b8ce9ef88587", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "wrong-reference", - "evidence_sha256": "11cdb7bd9282bd8b9c10b25bd5e552c14ca6658cb559b133ce7e6b8dfc17f0f3", - "run_id_sha256": "ee82112f55e5e6c86cfd6e16df8c8b652549a8bd72de492f435d8255eb3dd252", - "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "task": "execute-acceptance", - "trial_index": 1, - "verdict": "absent", - "workflow_version_id": "44444444-4444-4444-8444-444444444444" - } - }, - "ad21ee460923f6b34bab8405db2f256e8b3318e31797a5d256c274c0e0407bf0": { - "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "bxJcCJK64fH/4m4IAxSi7w2uYdrmVIPDM4Vuh0JIPihT6EzEGzWyVc6LYb3lTuAP793TGjl9ESWHHA4NDlm1Bw==", - "source_artifact_sha256": "7cfb7c321bd76fc1bf31a8453b02adde00c9bde35f22ce38726f169660f2b323", - "verified_at": "2026-08-18T10:23:00Z", - "verified_projection": { - "attempt_id_sha256": "2601335b1101424105277997a67850a8a60aa45f59637b7679c1f32af463c460", - "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-03", - "evidence_sha256": "7cfb7c321bd76fc1bf31a8453b02adde00c9bde35f22ce38726f169660f2b323", - "run_id_sha256": "237a0b7d1cafb64b1d113dca6699e6eefeaaf0b18679138545c3695495b901d5", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "0aefdcb48f524cd1122dc1bfffdbcea74cc3d239411590ae1b6c6b5d0ca845b4", + "facts": {}, + "run_id_sha256": "577e37b10b1c87fd9c1b5d320888b736d272824657fd59a012e85a284ee88540", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, @@ -3579,152 +4570,163 @@ "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "ada29f53b414f7aa7dd00232151d90f5f36d0f7d0c99f06d3c4e552088cc446e": { + "a568e4172ae077650c03fe76891b0f0592699afd2e87c9e60ff669d78c484cd4": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "2lKbu7ptol40ie5dpZBo9E9DrvIQrVMkpieMs/sC+DkfKJBuISdZ+D/LOt+zs5HDzWj6yn2vphYzo0jAdVaOCw==", - "source_artifact_sha256": "072e0fd54863672011c83e29fe39c24ea7e477fb77ad912967512a7e5d7ffa65", - "verified_at": "2026-08-18T10:24:00Z", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "pO3K/ic4z9liXLhz4dxTrtgDuAVxiMSzBOaT2SGkrKhoFHK5hzsynOXBX/1ZXSG0kEQJsH6MRZZ40tlYuimhDg==", + "source_artifact_sha256": "19bdab0320cb59b56b35ff49a7413fec8a975d93a0f54d88dbb5ccb742efafcf", + "verified_at": "2026-08-18T10:22:00Z", "verified_projection": { - "attempt_id_sha256": "7573925adbd8a7a4a3b98bb0379549d77aa8ed46e312c1cd940c05b8587a039e", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "fc097c8b2e6ece94544a19b8d81f5c4a9367a89059e3dd4b2f746ab06a2fc930", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "healthy-03", - "evidence_sha256": "072e0fd54863672011c83e29fe39c24ea7e477fb77ad912967512a7e5d7ffa65", - "run_id_sha256": "784a0a94e581700a3d93581e7ce5bac0d3bc53c58f3e73198b896b5da9a819b0", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "19bdab0320cb59b56b35ff49a7413fec8a975d93a0f54d88dbb5ccb742efafcf", + "facts": {}, + "run_id_sha256": "28768f565659133f5bf1170e638b81de4d7ca38dfecacd09ccf462a35344432b", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "verified", + "trial_index": 1, + "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "ae73206f663e332e61d69c76ec221fa5e456e5c8b847b5b21543900b03f93105": { + "a940f273dc2d98ad1504d3a5308e8a53af1d16f8801c2a15efaacbe548ec3efd": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d7e1e084be213b01", - "receipt_type": "observer", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "H8z+NcvqI7n2qKP5tIJtG7F/ucJqRod1bzYX3mX/ustcB6NnvPP8sXnU1t7XN602Ll3+Pnr8ZAaR6t7/v9AECw==", - "source_artifact_sha256": "b4cd01f298514b82ac8baafbaf99475b073f39bad0a7c9ad414d5fdd8fe5ccd5", - "verified_at": "2026-08-18T10:43:00Z", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "41IhWU6s0CCItj9L04QvrDWu9rsUnsMAU2Xzt7PW5E3P23B3+aeLVTf7egjxB5kIkTuKdHmwosxPbFUiIl4+DQ==", + "source_artifact_sha256": "d132a667b9a158fba09b3f6dca9d0d1ef2f87570aba4df8bc3f9fa30778693c1", + "verified_at": "2026-08-18T10:53:00Z", "verified_projection": { - "attempt_id_sha256": "6b0e5c10d55fc92c1ff8576392270a24fb65722414cf58ff9a51b8ce9ef88587", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "f5df4d6e64a2d38ffa8e320c87ad05d04025de267a8e152a755d3f1928ded120", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "wrong-reference", - "evidence_sha256": "b4cd01f298514b82ac8baafbaf99475b073f39bad0a7c9ad414d5fdd8fe5ccd5", - "run_id_sha256": "577e37b10b1c87fd9c1b5d320888b736d272824657fd59a012e85a284ee88540", + "condition": "stale-session", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "d132a667b9a158fba09b3f6dca9d0d1ef2f87570aba4df8bc3f9fa30778693c1", + "facts": {}, + "run_id_sha256": "fd3a041b705d8c6277ce26134dc0018e866218cfa3fadd16ac29d1ad498965a3", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, - "verdict": "satisfied", + "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "af535e76d2f849ee84e5d54123508736219c482ac68737053ba110dc5330ad2e": { + "aa9087e68e6a8479b57a4463ffc5c56b32f86c74f9b79f6a507b816a68ed843e": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "VB4XOeQGtIijBZSsCUMQ9Wz1KkBu9/KD+TGyE3ii4lgivv57KJtbnJmka19nZ17GHeSqLRosmAiQI+38ysayDw==", - "source_artifact_sha256": "9ee6e57b75e164f5f91625d37f3d8286db558d96de0fe27acfcfc45c1288fda5", - "verified_at": "2026-08-18T11:03:00Z", + "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", + "receipt_type": "fault", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "fKhaaK6wutYSCQwYUOHmIisqpcLvvZk47NMy6RMVMOt61pfEj2djgqQHNG0vgsj8q4UcmBKqfM8Bsgkd8QumCg==", + "source_artifact_sha256": "18258b93a65383507d1a93b2de83059c8074fd781add23d4f4d40911bf56b059", + "verified_at": "2026-08-18T11:13:00Z", "verified_projection": { - "attempt_id_sha256": "1ec11a9862ede3ac701af71835ac28c551d604a026b5bab7d776dbcdf288394e", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "42259dbb767ced4c25ad8bd40edc209720a748897194c925ed9bd2e27b2258b2", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "ambiguous-target", - "evidence_sha256": "9ee6e57b75e164f5f91625d37f3d8286db558d96de0fe27acfcfc45c1288fda5", - "run_id_sha256": "43f0a1c00950c390b0676fab55a2aa98c354d028f2347c461661e6cdb72f717e", + "condition": "verifier-unavailable", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "18258b93a65383507d1a93b2de83059c8074fd781add23d4f4d40911bf56b059", + "facts": {}, + "run_id_sha256": "4af84f2608a25a27e6252a5800263a238bb70fb3bec65148601ddcdddbf3e03c", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, - "verdict": "absent", + "verdict": "injected", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "b1ceae7aa3fdcfabe16c842627a0b05f92894b90653fc43682f45975a9a69c4c": { + "ad0a42eb042759c673eb9a940f4924f8b054fbf2ecc5b9d6bdf9e16bb1996caf": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-138dfa227234ea5f", "receipt_type": "cleanup", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "BhnCj0y+qxoCBTZ3AaQMU8xfccGoWIeu2VGeyDr1u4aJtEVj6icbdD4PPAIldrvO79YzzoE6FAMYahvRE7xcAA==", - "source_artifact_sha256": "d8c7b50d16df0a959a2fd2323040253e31e95b612b1ab829e460e68e6ad935b1", - "verified_at": "2026-08-18T10:52:00Z", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "TPCauGpn9mTV7gvO07gVE5NvQPtaczWVj/uABTZajANJsNH5DDZ/tAjZitjmOKX+tUMCto5h5RJTXhB1C9nTCg==", + "source_artifact_sha256": "c51fe4dc79cc2e8b749809c818af5f63c67cbe6e82656cb990d1bc7b13a0b6eb", + "verified_at": "2026-08-18T10:34:00Z", "verified_projection": { - "attempt_id_sha256": "fbfce2be9ce964be8b668aa518a310fe4a89e5c014f42bd0ea81401bd83bfd7a", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "3aee8ad755c7f4bec71cc194bcfaa805e0ea29cf8b830ed0782f8263dd9620ca", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "stale-session", - "evidence_sha256": "d8c7b50d16df0a959a2fd2323040253e31e95b612b1ab829e460e68e6ad935b1", - "run_id_sha256": "d9270fd4c85e4226a9347ecf703e876b9ffdc330f60c7fb8bed8f9321ea30225", + "condition": "idempotency-replay", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "c51fe4dc79cc2e8b749809c818af5f63c67cbe6e82656cb990d1bc7b13a0b6eb", + "facts": {}, + "run_id_sha256": "3df83453126754a62d00ed10837720542d0469799bb8a88cb5257ac5f477a919", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, + "trial_index": 3, "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "b650e56035131f355c13d2d3948cc452fce8dae01d5bf2dd7ea3435c0b013e87": { - "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "ZQBeQvMVWsrgxZVECkDgbxWpJlqshGMbh/QHDjgHWG8HX6cJRyhwJUJfeC9w17sys6EbXfuLcqT5nLOgRJCIAA==", - "source_artifact_sha256": "051bac821eaa3486034f245101d6c1f831d659444be87a3b5d774a9abaea05ff", - "verified_at": "2026-08-18T11:02:00Z", - "verified_projection": { - "attempt_id_sha256": "60ee9db05b1126cfaa3b31c13bc3fab4755ac09c44e846b4d07ee51865dfa7b1", - "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "ambiguous-target", - "evidence_sha256": "051bac821eaa3486034f245101d6c1f831d659444be87a3b5d774a9abaea05ff", - "run_id_sha256": "628f991a182613b8700294d7483b5a4c06872cb9d5ca6047ea552b8ab6585357", - "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "task": "execute-acceptance", - "trial_index": 1, - "verdict": "absent", - "workflow_version_id": "44444444-4444-4444-8444-444444444444" - } - }, - "b881269a603f7e323a56c17fd2d2f6db9e20485ee7687ece93f22aa12b7ea69d": { + "ae850dfd7e4e0688962457aa9c6277ca031ff48e9046ecd1339ba5ac3a8bc8fb": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "uGykKP6H5w8ZcHCO6AajCMIoUM1V297jfiROKNtmySZikBTvsHOMRoBWpscQT/kCe3bmv4C9bXySSEC3jWayCA==", - "source_artifact_sha256": "e5dea576ba929b469a889784b3eb264880f21206f61c472ea33b1b5b59d161cf", - "verified_at": "2026-08-18T11:14:00Z", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "lilfIKgICvQ33dLgx6dNmv0LKg9oBt9sRNz9CVKh92tQhVXP+U82jhlGhJsU8Ri/M+DYFu4skh+gysO9EiWaDg==", + "source_artifact_sha256": "7783dfcd8f2e57ff07c7bd69c17fa37665760981171e801c30d76e22a8d5802a", + "verified_at": "2026-08-18T11:13:00Z", "verified_projection": { - "attempt_id_sha256": "ad76dacfe19a4421ef1f128d4eef1099e846b385d29f17b8588ae5130b487118", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "42259dbb767ced4c25ad8bd40edc209720a748897194c925ed9bd2e27b2258b2", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "verifier-unavailable", - "evidence_sha256": "e5dea576ba929b469a889784b3eb264880f21206f61c472ea33b1b5b59d161cf", - "run_id_sha256": "87014cd8063f5a43ea22c995be03ec41ef5aa613145acacdef71b68c468fc8f1", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "7783dfcd8f2e57ff07c7bd69c17fa37665760981171e801c30d76e22a8d5802a", + "facts": { + "derived_classifications": { + "collateral_effect_count": 0, + "duplicate_effect_count": 0, + "intended_effect_count": 0, + "wrong_record_count": 0 + }, + "dispatch_state": "not_dispatched", + "effect_inventory": [], + "expected_record_id_sha256": "876c2932bfee2296fa4602d5f63194e6a399e970ba2009ab631e69cfb123d88e", + "expected_transaction_ref_sha256": "f91fb48f273432eb9696a65fec9e78725e79d54198a301868ccac2fb331ff740", + "post_state_evidence_sha256": "a5789c10e5a561103b525e51001bdcdd8023c7154d3ae6ef8a72a3f861ba5243", + "pre_state_evidence_sha256": "ae6f097e196a0806234cb6ca907ba6618d65ceb3c1e701576ccede89f0bd22d9", + "verifier_method": "read_only_system_of_record_query", + "verifier_tier": "independent_system_of_record" + }, + "run_id_sha256": "4af84f2608a25a27e6252a5800263a238bb70fb3bec65148601ddcdddbf3e03c", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "delivered", + "trial_index": 2, + "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "b8f596a87c49f45f75a055ed31e6c86f591fefd2cda6c1778bdd3212b4175e0b": { + "b33cd0b3700716aed5d44075b7e26be191c809331d4cd3e25212c307e43655e5": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-d92d542a589844dd", "receipt_type": "cleanup_absence", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "t3zZjQ7Za3xHKjlG6sgxG7l7BUy7M/EWIsGAe30XthsKlAau5QIpd7nFIfk7+kQpsVVSmQgD4wJlKEgbFhCRBQ==", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "5G9mt0a3etH1opsXkY9dz6aNtu2yEH6z4z/m2Ix+VIIezM8tpHXhPMXOLgYAdQLBivH72KmH5FEquFsx1YOQBw==", "source_artifact_sha256": "e7aa152d2f5d093083e644c448c30ba167727eb53ae1e0892f97cecc1e233fb5", "verified_at": "2026-08-18T11:24:00Z", "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "aa7d6be4f25a8992c0a22649ba7e703d6955abf5fece9f8322f560149cf09776", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "weak-effect-only", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", "evidence_sha256": "e7aa152d2f5d093083e644c448c30ba167727eb53ae1e0892f97cecc1e233fb5", + "facts": {}, "run_id_sha256": "b974de9da8ef77c8dc9a7662114cc51023ab8c131c488681eeebb7d4c435c8d0", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", @@ -3733,350 +4735,482 @@ "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "b92631c4736c084b0a8f01f7dee8d27672b7cffab352fca684f025b0e9f66b02": { + "b6148432883a666f0099767e8e3a51c46b65e8f765b75afc9106ceccec1c2e5a": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-d7e1e084be213b01", "receipt_type": "observer", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "dWD+6dY16blKDKe22SDooL/7+mT9A2yZAI8/gcaroLQzP30SUbix+6UMz5znT20TuGA/91CrQbE1VRWU42J4DQ==", - "source_artifact_sha256": "58703c8fb721c8bd010e150d01acbc91a664c3273b9d1b85d945398148b6ff87", - "verified_at": "2026-08-18T11:23:00Z", - "verified_projection": { - "attempt_id_sha256": "eb52fb1b1bf2fac92d8f3a444bb5081161be8b3d0ef457c5065e7b79e96df770", - "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "weak-effect-only", - "evidence_sha256": "58703c8fb721c8bd010e150d01acbc91a664c3273b9d1b85d945398148b6ff87", - "run_id_sha256": "794033f9da2a42448254a478fb6de954898b1e544148708ad30264efdc255431", - "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "task": "execute-acceptance", - "trial_index": 2, - "verdict": "satisfied", - "workflow_version_id": "44444444-4444-4444-8444-444444444444" - } - }, - "b9e0d9c9f9ce5387a9cca061a4fd13f9f4dce4558a4295c86a2641ff038a4dbc": { - "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "FsUVGOLMi4cZnXQCRf3/Ft8/b/yl0++CJrX71QxaatddwH08kEbJnY3T2bTDIiOv07AhDG3FRImzgKMJdJcsDw==", - "source_artifact_sha256": "f9e70034e68ce8783bb50fb2f53e6c7f8f5ed238916ab72298bcc5068ba7cef8", - "verified_at": "2026-08-18T10:24:00Z", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "FJ9qoL4IuKWUSnT51BZjpdeIRJsf9U9aTBdaSi1zG+H9NUdDZ2TEih8exl2fynK+Vs/I77piVWCx0miSys7GAA==", + "source_artifact_sha256": "79805e89b0f4e3d696c11dc8e97714ea0bcdca545f81356e0ed760612fe2925e", + "verified_at": "2026-08-18T10:44:00Z", "verified_projection": { - "attempt_id_sha256": "7573925adbd8a7a4a3b98bb0379549d77aa8ed46e312c1cd940c05b8587a039e", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "7c910764b2dcc6f05261d609082f75474e4638c3f356006307212b8fed4a2eb7", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-03", - "evidence_sha256": "f9e70034e68ce8783bb50fb2f53e6c7f8f5ed238916ab72298bcc5068ba7cef8", - "run_id_sha256": "784a0a94e581700a3d93581e7ce5bac0d3bc53c58f3e73198b896b5da9a819b0", + "condition": "wrong-reference", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "79805e89b0f4e3d696c11dc8e97714ea0bcdca545f81356e0ed760612fe2925e", + "facts": { + "derived_classifications": { + "collateral_effect_count": 0, + "duplicate_effect_count": 0, + "intended_effect_count": 0, + "wrong_record_count": 0 + }, + "dispatch_state": "not_dispatched", + "effect_inventory": [], + "expected_record_id_sha256": "0dc6218bdc8bf4591648aa33d57dff0688022d50b9056737ceed0685bbbf7e90", + "expected_transaction_ref_sha256": "d148dd9153e31c2d04b5dcdde5965456e7e3e1f0109b358519450847da148f59", + "post_state_evidence_sha256": "f5464e6e0f54cdf1afc377b423019b32f05125c5f5f85920a729408ecb6eb187", + "pre_state_evidence_sha256": "32bfcef60ea6496a047480ecb2cafe23403fde0a50d0f928378d3165f6243ff4", + "verifier_method": "read_only_system_of_record_query", + "verifier_tier": "independent_system_of_record" + }, + "run_id_sha256": "fe98ce7f0e66b885201f4667875fd38f5890ffddb575d68bd4cd5a66f8d53ca8", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, - "verdict": "delivered", + "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "bb54c9fee035e3fcf5c9daa6f6fc08bc1e5d3cffb2b0aa0b047b1006727c7918": { + "b661cb27d6061e177a2d7305a99de342ccf5336168bafbe9d0356c0ad65c92b8": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "15bqUZBe3enN5Puwj+LM1cdgrCiXDlT5aPY4tmQgAy0/MX1GfA2deagbMkEi6JcnxbiSOzDbAqMca8dHtGVhAQ==", - "source_artifact_sha256": "2fc83a9ad4cdeaa8faf4176f24cd5390e451a993166626508572a5c6a7663659", - "verified_at": "2026-08-18T10:13:00Z", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "+zJEOrA//KYPzqgVZhL5t9uVk8PlhN8R/4YeUaMKF2SiyLShy58cNUOf+jwV8OmdtFxi5Hk/cCXDIBLwIi2rAw==", + "source_artifact_sha256": "3f1ce2b52c8b8ed56bc485f70b885b295f43f601b14c7834ee455b982154a6e5", + "verified_at": "2026-08-18T11:02:00Z", "verified_projection": { - "attempt_id_sha256": "3d42601a69ef46cc44f57b51762affef4ccd829ffde30125619a6e582af00dab", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "60ee9db05b1126cfaa3b31c13bc3fab4755ac09c44e846b4d07ee51865dfa7b1", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-02", - "evidence_sha256": "2fc83a9ad4cdeaa8faf4176f24cd5390e451a993166626508572a5c6a7663659", - "run_id_sha256": "091e13ed70dab439b31cb506cf3bba1ddf6476696531cf891c39a924a928b7a1", + "condition": "ambiguous-target", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "3f1ce2b52c8b8ed56bc485f70b885b295f43f601b14c7834ee455b982154a6e5", + "facts": { + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "3f1ce2b52c8b8ed56bc485f70b885b295f43f601b14c7834ee455b982154a6e5", + "source": "runner_signed_flow_report_and_enforced_egress_policy" + }, + "operator_intervention_ids_sha256": [] + }, + "run_id_sha256": "628f991a182613b8700294d7483b5a4c06872cb9d5ca6047ea552b8ab6585357", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "absent", + "trial_index": 1, + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "bcefc56da8f7c303f207023baadc506246d85c8e9f140de46f1e28cbc5bae278": { + "b6865344d649c442168a1a23f725bde6cecc3c2a2ac876c58aae1f28ed3fa044": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-138dfa227234ea5f", "receipt_type": "cleanup", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "H+1r6eGJtY5U58Icrj2Qqq3aqVEsU88mzgX/AAns/Cpn+5KMvwRs25YI43wvOEaGcpgl79eiZQJMVxCLjAE1Bg==", - "source_artifact_sha256": "4b49c957d7eeb5d558fc4b83415475999503aa48aa8d8be5ec00a745b6c78701", - "verified_at": "2026-08-18T10:13:00Z", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "NthuQ04+OrO6tA+ishaITksSmAhI9UppY/qHD8dOyg9Dj8h0f6/NntZ1wfEM+natGXLB9D9pV5EunAmov/tRDg==", + "source_artifact_sha256": "0c3d68b46266286eb32f09365d96174863b4fe9cac3fb3f91625fcbb4f521e71", + "verified_at": "2026-08-18T11:04:00Z", "verified_projection": { - "attempt_id_sha256": "3d42601a69ef46cc44f57b51762affef4ccd829ffde30125619a6e582af00dab", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "491a544656d05aea37920e5c7e2ad65a9452eac8d6e100268a599aeebd41187a", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-02", - "evidence_sha256": "4b49c957d7eeb5d558fc4b83415475999503aa48aa8d8be5ec00a745b6c78701", - "run_id_sha256": "091e13ed70dab439b31cb506cf3bba1ddf6476696531cf891c39a924a928b7a1", + "condition": "ambiguous-target", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "0c3d68b46266286eb32f09365d96174863b4fe9cac3fb3f91625fcbb4f521e71", + "facts": {}, + "run_id_sha256": "aa62c7a17701a7ef01ea1d3519b4c1f90d357495b329fdda3054cc24c581a593", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, + "trial_index": 3, "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "bcf1ed30725b2853e7f37119a06ccb2838942b32c14d4d0a69378932349f5620": { + "b69c63d7548ba4bcd6870077e4a5baedd402af5d7528845cfb9187913a26e46c": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "fxxCm+zd4D3sKX2GjqysBetm5n9cdeYy8i2OrHmC45ju/+ZKmeHEctSZDbxL/mbYloyE12Vk17QKKw1XWOvfDQ==", - "source_artifact_sha256": "05601e1e28046d813b5d1fc7fc6f90292c7397fe2bfacb1b27e302242c388659", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "SYh+yUpwrRop8IRERnFpspiUCAt8pLCA2rwcylBhRbXUqOQJnpqwlEXzZws77ezfo8I7cFzH/2boI/LlG6e6Dw==", + "source_artifact_sha256": "f2226cc85e803eb3cf39a88aa39b32d75a3910acc381cbd3197767c9c0b75b5b", "verified_at": "2026-08-18T11:14:00Z", "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "ad76dacfe19a4421ef1f128d4eef1099e846b385d29f17b8588ae5130b487118", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "verifier-unavailable", - "evidence_sha256": "05601e1e28046d813b5d1fc7fc6f90292c7397fe2bfacb1b27e302242c388659", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "f2226cc85e803eb3cf39a88aa39b32d75a3910acc381cbd3197767c9c0b75b5b", + "facts": { + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "f2226cc85e803eb3cf39a88aa39b32d75a3910acc381cbd3197767c9c0b75b5b", + "source": "runner_signed_flow_report_and_enforced_egress_policy" + }, + "operator_intervention_ids_sha256": [] + }, "run_id_sha256": "87014cd8063f5a43ea22c995be03ec41ef5aa613145acacdef71b68c468fc8f1", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, - "verdict": "absent", + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "be295e21b91bb577b764151cd66a1a1aaf4302809b9a52766361d108611afe74": { + "b87015226ef172a5e717616fc75a97661c343124e5a17bcc3fb8c5c32a4a5a03": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d7e1e084be213b01", - "receipt_type": "observer", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "yAIQbqVuWY4OVxyAdbD+JHT0g4l8u9JfnnWweWLtFJu0QzEbUIE1dtSrlNGlZd8Zh8bQjqnQF09tH1wCUDZ3DQ==", - "source_artifact_sha256": "24e69a5639acfa91d8833695390d6df6885bdfd9c998f69d8042b203ac41fade", - "verified_at": "2026-08-18T11:14:00Z", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "3Gl37wMAvg+nO9Ojw4hmKdnN5t+wOsngujAE96ob6MIz55/tQttisnBL+U1lNPIJXrVPYirI44taOOjjXobFDg==", + "source_artifact_sha256": "7edf6488f59115500b130e22484d3834f8757bc027ac738d8616461b11f6c2c5", + "verified_at": "2026-08-18T10:04:00Z", "verified_projection": { - "attempt_id_sha256": "ad76dacfe19a4421ef1f128d4eef1099e846b385d29f17b8588ae5130b487118", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "4c352a6999f77707e8837adebb4fc2b7451c2ef6de5145190b33a5c5645e47eb", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "verifier-unavailable", - "evidence_sha256": "24e69a5639acfa91d8833695390d6df6885bdfd9c998f69d8042b203ac41fade", - "run_id_sha256": "87014cd8063f5a43ea22c995be03ec41ef5aa613145acacdef71b68c468fc8f1", + "condition": "healthy-01", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "7edf6488f59115500b130e22484d3834f8757bc027ac738d8616461b11f6c2c5", + "facts": {}, + "run_id_sha256": "4ee2bb61fb883cc8e77d636fb471aa3c0ce9ef0c0a8abd9682214bf0a8f16f26", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, - "verdict": "satisfied", + "verdict": "verified", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "bebd124852a24da854264263989ce3eb2a81dc7583641e725b882317634cd656": { + "b8cc1d45257e2e92b93bff7e19fbd9cb80a18ba97f174f5b2983ff73ba8f627a": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "sDAaHuZBZhF7UiuXzNqFcS9xExKdrcwXBmFjDrYE0TBzikZDkPLyARng9QT5SjjcYFr0NfQdynBmj+Vl9UXRDA==", - "source_artifact_sha256": "f48a35f45e70951886d40904c131ba517e46acb12368169e31b1c47de7ee6a8c", - "verified_at": "2026-08-18T10:12:00Z", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "1iLnfcJpYhrXDWaegQ3p5W32ob2ypPYdkdnBTTBLOFNx838evj9TK0decdiHJL1bYDns+ntfTlXFSnqSKcf6AQ==", + "source_artifact_sha256": "ffae42ea2ab78a78ef0b9b71e9b8a63f6b470d949ecfd892d84ebc512c1b64b9", + "verified_at": "2026-08-18T10:52:00Z", "verified_projection": { - "attempt_id_sha256": "940d3ca125ff87ce7539740fbae29d2d64fec839328b0639127e1d197d2485d8", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "fbfce2be9ce964be8b668aa518a310fe4a89e5c014f42bd0ea81401bd83bfd7a", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-02", - "evidence_sha256": "f48a35f45e70951886d40904c131ba517e46acb12368169e31b1c47de7ee6a8c", - "run_id_sha256": "bbb9312ce4682b23580eced0f8d19438d8266b222555df85fb27eef22ad5afe2", + "condition": "stale-session", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "ffae42ea2ab78a78ef0b9b71e9b8a63f6b470d949ecfd892d84ebc512c1b64b9", + "facts": {}, + "run_id_sha256": "d9270fd4c85e4226a9347ecf703e876b9ffdc330f60c7fb8bed8f9321ea30225", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, - "verdict": "absent", - "workflow_version_id": "44444444-4444-4444-8444-444444444444" - } - }, - "bfdd995c0709fd95a59fd044664d11d88fc4d51b2df6b3525c384df39504e087": { - "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", - "receipt_type": "fault", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "SYxVUnaJibveWSELqr+2L3VULbYViY8NPQWl5At+FIibk3ftDpj6OkWNqe+B1zykO6pibDvLNlp5QI9Vi8yADA==", - "source_artifact_sha256": "c483629c37faa74e65b11335e5d15e741a5a1d5a7af2f6a4757767a446b00a34", - "verified_at": "2026-08-18T11:24:00Z", - "verified_projection": { - "attempt_id_sha256": "aa7d6be4f25a8992c0a22649ba7e703d6955abf5fece9f8322f560149cf09776", - "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "weak-effect-only", - "evidence_sha256": "c483629c37faa74e65b11335e5d15e741a5a1d5a7af2f6a4757767a446b00a34", - "run_id_sha256": "b974de9da8ef77c8dc9a7662114cc51023ab8c131c488681eeebb7d4c435c8d0", - "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "task": "execute-acceptance", - "trial_index": 3, - "verdict": "injected", + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "bffc584cb4cb04d08a01698a8700bab8c812bece8884d7d1f4fe57081b46b5dd": { + "b90646d3845ffaf972be53d7d891abfa78c60975dbdf1aae85f55340ff5d6ba1": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "hEoHJGgl8UuT78Q99+JQ0vjHwGY9ndgYlE26K1PGMBYlUR1ZHfjzYNOvKk07ZWAuigLsS6k2sYOQ4CluMhd0Bw==", - "source_artifact_sha256": "0f409e89e3eb515df85e6adff2f2e9067dd70007afab83b7da6b7dce22e1824b", - "verified_at": "2026-08-18T10:23:00Z", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "U8LwQ+GNI4+Zv6maGiCN3kwFOLLWC4fbG3hG9+n2Cdvo6wdkSGGfLx+Gs9aLaNkyfQ9/+JvRs/fwbneVMTefAQ==", + "source_artifact_sha256": "559774dcac1bab02176edb36d9e7bb92abae9655472d718dbc04d72660cf6323", + "verified_at": "2026-08-18T10:03:00Z", "verified_projection": { - "attempt_id_sha256": "2601335b1101424105277997a67850a8a60aa45f59637b7679c1f32af463c460", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "fdad940f245d690750ad647fac25c7e76aac2f474db49732fec8129051750186", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-03", - "evidence_sha256": "0f409e89e3eb515df85e6adff2f2e9067dd70007afab83b7da6b7dce22e1824b", - "run_id_sha256": "237a0b7d1cafb64b1d113dca6699e6eefeaaf0b18679138545c3695495b901d5", + "condition": "healthy-01", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "559774dcac1bab02176edb36d9e7bb92abae9655472d718dbc04d72660cf6323", + "facts": { + "derived_classifications": { + "collateral_effect_count": 0, + "duplicate_effect_count": 0, + "intended_effect_count": 1, + "wrong_record_count": 0 + }, + "dispatch_state": "dispatched", + "effect_inventory": [ + { + "effect_id_sha256": "7d8bc663be7e1ff5498453ccb36ae1ef29b47bc8edcc20e36bb6005c0f8fe43d", + "record_id_sha256": "42389eaf0a7d527f14832b69fa924fff489f520c440233231716580d5414c1d9", + "transaction_ref_sha256": "1aef511ee7f75cb0a5dd7867025826284c31f5746c859cb3667996c3a75051ae" + } + ], + "expected_record_id_sha256": "42389eaf0a7d527f14832b69fa924fff489f520c440233231716580d5414c1d9", + "expected_transaction_ref_sha256": "1aef511ee7f75cb0a5dd7867025826284c31f5746c859cb3667996c3a75051ae", + "post_state_evidence_sha256": "61e0b378e51b606efacc737d0582181948f8d4eebb1c9f61ee4aa0b23227b8ff", + "pre_state_evidence_sha256": "ec2ea8e3b0da2a07f5246174bd32f75f8dc31eed4f2c3ca30d894fc442ea98f5", + "verifier_method": "read_only_system_of_record_query", + "verifier_tier": "independent_system_of_record" + }, + "run_id_sha256": "3739043a92a8781376cfbd022460c03aba40f92a800b3885ebc046321437bc40", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, - "verdict": "verified", + "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "c1d15f47a1fad41c545fa9c0c26422c179518fea0841d1f3551ab1070a4669d9": { + "bc7e85e0380e3c790a86bec2d4ddda704fb1ae1db4979ec6d91aa0562ccdbb9c": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-138dfa227234ea5f", - "receipt_type": "cleanup", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "vNOzxYL6DWevfpUPvb7iEqxS7PJB83cEOOozgGGuFbbI1X4ycOWVeAnPuhmuGeS+k/IWGYRIUEJo4DhxFtnQBQ==", - "source_artifact_sha256": "f9f54cc3691f84eaf5543a39f915bc4b888249e20be389e737f07cc048fc796b", - "verified_at": "2026-08-18T11:24:00Z", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "z6NisFuUCZVWk8UwLsiFhTnIvJolUI3PS4iKSb7EjewSPii1XlTNLO8s9ihzlQdrY8aTMiFzWxv1eotydOvKDQ==", + "source_artifact_sha256": "b54d78461c69265574bc5e0a08e1ae1f2c53150056399d8de419de8d50868c80", + "verified_at": "2026-08-18T10:04:00Z", "verified_projection": { - "attempt_id_sha256": "aa7d6be4f25a8992c0a22649ba7e703d6955abf5fece9f8322f560149cf09776", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "4c352a6999f77707e8837adebb4fc2b7451c2ef6de5145190b33a5c5645e47eb", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "weak-effect-only", - "evidence_sha256": "f9f54cc3691f84eaf5543a39f915bc4b888249e20be389e737f07cc048fc796b", - "run_id_sha256": "b974de9da8ef77c8dc9a7662114cc51023ab8c131c488681eeebb7d4c435c8d0", + "condition": "healthy-01", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "b54d78461c69265574bc5e0a08e1ae1f2c53150056399d8de419de8d50868c80", + "facts": { + "derived_classifications": { + "collateral_effect_count": 0, + "duplicate_effect_count": 0, + "intended_effect_count": 1, + "wrong_record_count": 0 + }, + "dispatch_state": "dispatched", + "effect_inventory": [ + { + "effect_id_sha256": "c726d2d313227693bf81a5f01f93a582a3d0c43496f5de19f4d8cb59fad1448d", + "record_id_sha256": "a8d41df87db795f2a38d1c60293e20b89783fce022fce572a546d4a9fb01507e", + "transaction_ref_sha256": "7af984839a1cb25da6ce1ee403c32fb6ec07143cc001f21610f94d3911bbc819" + } + ], + "expected_record_id_sha256": "a8d41df87db795f2a38d1c60293e20b89783fce022fce572a546d4a9fb01507e", + "expected_transaction_ref_sha256": "7af984839a1cb25da6ce1ee403c32fb6ec07143cc001f21610f94d3911bbc819", + "post_state_evidence_sha256": "23107cdffa1eb0a03751c72823ccea43c3f5cc46a99a5df03b5523464379e632", + "pre_state_evidence_sha256": "dfd9a16f8fb84edd62fe6bb1819a6e88a497b30b9e131cd6c853cf12632f149b", + "verifier_method": "read_only_system_of_record_query", + "verifier_tier": "independent_system_of_record" + }, + "run_id_sha256": "4ee2bb61fb883cc8e77d636fb471aa3c0ce9ef0c0a8abd9682214bf0a8f16f26", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, - "verdict": "completed", + "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "c2f2b635cde60b553f1722c8593bb95ad7ed7023307693e3f024ffb125165db6": { + "be17be06d1fa1a089368e219302e3a4e142173b4c72e574c40410477d4dc2a2d": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "ReLHgYwoOu/Ma7j2bz+qBRiAioJwc9ordb+7ExBWFQsulEZrgBh1r13KeaCoffF5um8OUCwqNosS+j1/SyJfBQ==", - "source_artifact_sha256": "98f3bd644c3f5baa2083f90afb499c9a29160c8160a518c2d6fac7d9a3cf3792", - "verified_at": "2026-08-18T11:12:00Z", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "EI8LeNA/vSz4ZjRSzYGZ24fOPndG7k/fnCh7HDwNtPPK0w/8cLP4Aa7OIq2/CpyRzQ1POHVuEuOLFBreHroHDA==", + "source_artifact_sha256": "79566ede5f64ddd1b0c40fdfcfdb0f7500d96abb5c46c9abdabddca1500c599d", + "verified_at": "2026-08-18T10:34:00Z", "verified_projection": { - "attempt_id_sha256": "f5e96a2e9a580376b18beabf57798b8761e772a0c4d112877045780bb12b3720", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "3aee8ad755c7f4bec71cc194bcfaa805e0ea29cf8b830ed0782f8263dd9620ca", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "verifier-unavailable", - "evidence_sha256": "98f3bd644c3f5baa2083f90afb499c9a29160c8160a518c2d6fac7d9a3cf3792", - "run_id_sha256": "e8e89651045a5f5c011c9543ed968e0fe7697a061ed8ad5cedc27d194cb96acb", + "condition": "idempotency-replay", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "79566ede5f64ddd1b0c40fdfcfdb0f7500d96abb5c46c9abdabddca1500c599d", + "facts": { + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "79566ede5f64ddd1b0c40fdfcfdb0f7500d96abb5c46c9abdabddca1500c599d", + "source": "runner_signed_flow_report_and_enforced_egress_policy" + }, + "operator_intervention_ids_sha256": [] + }, + "run_id_sha256": "3df83453126754a62d00ed10837720542d0469799bb8a88cb5257ac5f477a919", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, - "verdict": "absent", + "trial_index": 3, + "verdict": "verified", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "c8eacb7caeaa9125a97121ca8bfdfe848cf5d658a0c88b163b326c9db99949f8": { + "be4bcc0de90d3e47d83b3285b71c911aab5367c05949bc04f422a1fb60ec606b": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", - "receipt_type": "fault", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "32yxqJOU4oyx3wdbazkR6rWo88FCxlw7ywKpNSmaN7WwRC5hs+wHeO4d9IarrtFIV2CC3ELPSDTZhWtLw27aDQ==", - "source_artifact_sha256": "7d54c11699d0fc258007146c754f3dd04a68594dea5bf0402d10aa55a04b514d", - "verified_at": "2026-08-18T11:02:00Z", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "Axj94BWscOwRfh/xEEwKSARe4g4BAD/C6aA+9cEJ6cVKuR6ItU3HS/qWpZgJONSmQKDV+7MvoQKffwv6YrvHDg==", + "source_artifact_sha256": "aa76163afc05d85e7c2925d286aa8e9c2abda820aa88bcddb1c2a8d525a8be2b", + "verified_at": "2026-08-18T11:03:00Z", "verified_projection": { - "attempt_id_sha256": "60ee9db05b1126cfaa3b31c13bc3fab4755ac09c44e846b4d07ee51865dfa7b1", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "1ec11a9862ede3ac701af71835ac28c551d604a026b5bab7d776dbcdf288394e", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "ambiguous-target", - "evidence_sha256": "7d54c11699d0fc258007146c754f3dd04a68594dea5bf0402d10aa55a04b514d", - "run_id_sha256": "628f991a182613b8700294d7483b5a4c06872cb9d5ca6047ea552b8ab6585357", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "aa76163afc05d85e7c2925d286aa8e9c2abda820aa88bcddb1c2a8d525a8be2b", + "facts": { + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "aa76163afc05d85e7c2925d286aa8e9c2abda820aa88bcddb1c2a8d525a8be2b", + "source": "runner_signed_flow_report_and_enforced_egress_policy" + }, + "operator_intervention_ids_sha256": [] + }, + "run_id_sha256": "43f0a1c00950c390b0676fab55a2aa98c354d028f2347c461661e6cdb72f717e", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, - "verdict": "injected", + "trial_index": 2, + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "ca4213a203a9c2047c114c5bbd18837bf2d44fd2a9741b850ca6abf26e4934a9": { + "c0f41eadbf7b50c360fb45ee132b23ba8b45bbb4d32cc7a96517d8a82abd9afe": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", - "receipt_type": "fault", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "VBy0vmZcXj6la6amDRv56hRCq/3mnPdn46HFayEpk7bvI3nBzbqDOHED6vF+FLe+5++MwhrG2wgcmqMJ0e1gBw==", - "source_artifact_sha256": "0a6f7475010857b4c4c0c9f660926588236800ef17f86e670e163c98fa71c3a5", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "hDMFtnnqZDBG0kQcsPCekyHzOJJUczzUT/vTz1gY57enwcdAUIpbI4H+qzUpSESFOvfkIpoe7UZNPKe5YpATDg==", + "source_artifact_sha256": "ff1fd4393986dfb3dd0e3e75fe379c4dfa4b424938dac23ab436e1e31f594225", "verified_at": "2026-08-18T10:44:00Z", "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "7c910764b2dcc6f05261d609082f75474e4638c3f356006307212b8fed4a2eb7", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "wrong-reference", - "evidence_sha256": "0a6f7475010857b4c4c0c9f660926588236800ef17f86e670e163c98fa71c3a5", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "ff1fd4393986dfb3dd0e3e75fe379c4dfa4b424938dac23ab436e1e31f594225", + "facts": {}, "run_id_sha256": "fe98ce7f0e66b885201f4667875fd38f5890ffddb575d68bd4cd5a66f8d53ca8", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, - "verdict": "injected", + "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "caf4bdd8d724820689f50a52d92a1280fbc90215c7b12991b3681541fd8c2206": { + "c2803318f01695a40e402726d0ed4cf471c4f579a3b7c9dcdecb0cfbd3cee666": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d7e1e084be213b01", - "receipt_type": "observer", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "VWOQ/823uDgOVvfdQ8XIP0D0aEaw9/igkygV/2gNdgB0QIAs+TCcPZCBtcRAcUgm7HQtu+KQIgrC4TIG475AAw==", - "source_artifact_sha256": "57e3d1b277db5cbe456c303c9cb64859db7dc268807b185a31e35936e13ee8c3", - "verified_at": "2026-08-18T11:22:00Z", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "PJTL9/goXJdjKLejB66s1C6t4BXZA6ydun0/xw4D2Y3nwmRAoHbTNljieBwscqOqeiSrOlAMVdcsjFIqYfZ8DQ==", + "source_artifact_sha256": "7f144d0ed131ef44fd7db0ba5d3d03e685d681ea76df6a87fcf8bc20073786fe", + "verified_at": "2026-08-18T11:13:00Z", "verified_projection": { - "attempt_id_sha256": "73a097b8b20bab7794369384f7ca1d7d711aad07967b7e1292373babbb7ff1b7", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "42259dbb767ced4c25ad8bd40edc209720a748897194c925ed9bd2e27b2258b2", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "weak-effect-only", - "evidence_sha256": "57e3d1b277db5cbe456c303c9cb64859db7dc268807b185a31e35936e13ee8c3", - "run_id_sha256": "b44783e70a980ec5b3cf3752bd5d1d01b2ff29f5a6892cba0c1c939d8aeb7c02", + "condition": "verifier-unavailable", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "7f144d0ed131ef44fd7db0ba5d3d03e685d681ea76df6a87fcf8bc20073786fe", + "facts": {}, + "run_id_sha256": "4af84f2608a25a27e6252a5800263a238bb70fb3bec65148601ddcdddbf3e03c", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, - "verdict": "satisfied", + "trial_index": 2, + "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "ce56478b940c828f034cfd1c6ebc41185771a3154a621076db6d36a4d706b413": { + "c48a078a0d240e39cf8193c9c14a3719048553cf39278f3d0656aaa1caccd55f": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "pBAvHegabeoclr14Bkb4Q6ltzQhCe14uHpFKM/Va4z6r1YXRz2P6f0RoTe5J8pBNnGWfkyvhxP8rDquX4pVlCQ==", - "source_artifact_sha256": "1bd19a3201a6b9102580819cf704a60ff2d91a1648a1ad38c4dc40806c809b38", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "H9QSo0jHjrYaze9AkweGhodA3RwIEP+3PaNqm6e6ptXm1kXCr+fQIx/Ave0E1LhmyKwQBeJwZn3elmlX8pa2Aw==", + "source_artifact_sha256": "8085128f824c52e7f957276980e2ec8ed181e15094c1a551c251a21e07009829", "verified_at": "2026-08-18T11:22:00Z", "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "73a097b8b20bab7794369384f7ca1d7d711aad07967b7e1292373babbb7ff1b7", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "weak-effect-only", - "evidence_sha256": "1bd19a3201a6b9102580819cf704a60ff2d91a1648a1ad38c4dc40806c809b38", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "8085128f824c52e7f957276980e2ec8ed181e15094c1a551c251a21e07009829", + "facts": {}, "run_id_sha256": "b44783e70a980ec5b3cf3752bd5d1d01b2ff29f5a6892cba0c1c939d8aeb7c02", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, - "verdict": "delivered", + "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "cf9b127576b09758cdc73a384992a995d372c5e5eb2ad814c25e4b7ac4f2c343": { + "c83d86c9abcf943cba78206214f7d9fe7088e46167c0f37f5caea0a48554c82e": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-d7e1e084be213b01", "receipt_type": "observer", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "emfLDQtld00DkrrwXC8n9cyMSLOXfUayuD9hopc0KDlBRAQc1t5a18XzXS6kQIvib/4DNz44BEPoV9x/stCPDA==", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "lgvYjNtLOW9erX7rcUIAxz7jAlivmms+fe39iTRAKu9H/cS1itUMBfT9s5lE79dNfqYH4eXdH2Pvq+mr8OAgCg==", "source_artifact_sha256": "3d1fc9371e1623ec11f20518ce702cb97dd2336df830ce8143c419fac0bae157", "verified_at": "2026-08-18T10:22:00Z", "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "fc097c8b2e6ece94544a19b8d81f5c4a9367a89059e3dd4b2f746ab06a2fc930", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "healthy-03", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", "evidence_sha256": "3d1fc9371e1623ec11f20518ce702cb97dd2336df830ce8143c419fac0bae157", + "facts": { + "derived_classifications": { + "collateral_effect_count": 0, + "duplicate_effect_count": 0, + "intended_effect_count": 1, + "wrong_record_count": 0 + }, + "dispatch_state": "dispatched", + "effect_inventory": [ + { + "effect_id_sha256": "a91846a30c53a237665dd255d69c1469ec67a380cd6a5c452ff954d3b5c67c14", + "record_id_sha256": "697f29481764fb661a736c86f19f80bc542433d3738c384c457338f57ebf9b8f", + "transaction_ref_sha256": "0283a6ca27c79953fbafd963e0489de38177725eb7559f51f84625a79db97f49" + } + ], + "expected_record_id_sha256": "697f29481764fb661a736c86f19f80bc542433d3738c384c457338f57ebf9b8f", + "expected_transaction_ref_sha256": "0283a6ca27c79953fbafd963e0489de38177725eb7559f51f84625a79db97f49", + "post_state_evidence_sha256": "32235684a3f75866ab34c6cc9044779f7db5299bae160d15b31132149e3ea80c", + "pre_state_evidence_sha256": "67360382287d023330ff329bc48478121c00fd065cd946af67a84edd62aae6b7", + "verifier_method": "read_only_system_of_record_query", + "verifier_tier": "independent_system_of_record" + }, "run_id_sha256": "28768f565659133f5bf1170e638b81de4d7ca38dfecacd09ccf462a35344432b", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", @@ -4085,109 +5219,139 @@ "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "cff75b636a312f1bb5f2e99eb6935abe16347884df3077f72780662d31804a38": { + "cb6c8afc587772aa8efc94807c1572115c22e8a1eca478dc2977cf785f7e4771": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", - "receipt_type": "fault", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "xhjjFSHfpLVWLb2WaFUYTlAnZcy8d/FBxcsl1GuTqJme8vq4pNOLpEs/9b0Vyz2QU5xIKu0gWx9BgiGAuttoAw==", - "source_artifact_sha256": "226019cc9a5778388b2bfe87bde12f7a08f8b33074eadc925d3e79197245a493", - "verified_at": "2026-08-18T10:54:00Z", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "XFM+BRFvQfUZ6ubL2axPpBFX9XY1xufvopqrvOIxUQZWWnRgb6RKp1dVsqfp78Kp2h+jQK2Q3dQv/crPPJtvCQ==", + "source_artifact_sha256": "e02b4733d09ac9c9e6e5d98ba7fc6645738e022e2f137f73feded4d27f3925e9", + "verified_at": "2026-08-18T10:02:00Z", "verified_projection": { - "attempt_id_sha256": "958342a9ddca98a83b82b662f52f404239d583afe7ed70634760e1b8dd592f3b", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "679af5a8dedceb8c696719e73f82a698c230cd8fc98bb61769f0883202c0b637", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "stale-session", - "evidence_sha256": "226019cc9a5778388b2bfe87bde12f7a08f8b33074eadc925d3e79197245a493", - "run_id_sha256": "6f2fb10bc2018c9f78e9702d5ccac0bedd78ee3b2e9d2a6ad779fba72d90ae50", + "condition": "healthy-01", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "e02b4733d09ac9c9e6e5d98ba7fc6645738e022e2f137f73feded4d27f3925e9", + "facts": {}, + "run_id_sha256": "0b5bda916a0808165159166955a9563cf9c2303949f762a18eb037f41b44a6dc", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "injected", + "trial_index": 1, + "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "d1146664cafb846d4dece5833facbe37778ae7f7ccece97b7fe6f3e7cabd8c27": { + "cbe1607f5b948d288e9fdb6ab638d5f3cde433d739670d52bfd0a1426d560300": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "5xZmGMcy/03vt6w5HzhLG3X4gisPBRKzgA0T2+gJqXfHUyXmL4Ap0II5kxKx6pcH+Z2+atPT5wzBVmP6dYzVDg==", - "source_artifact_sha256": "fc34b2087c0ac5df3a7283f31412b0a354de6d6f9a21946e56ad9f8cd42edfd6", - "verified_at": "2026-08-18T10:03:00Z", + "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", + "receipt_type": "fault", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "4dFt+AAERjAVMafsPGChjgQ0dSwnqMKK5jFW1aPOh+YZtVep6zJWRyOA71hdmFqS8dKXmD9Z88c3uO21N4xEAA==", + "source_artifact_sha256": "d80e5faa489be940291e74948facb9a38c3f6ce34fbe6fb5c586b966e5c82228", + "verified_at": "2026-08-18T11:12:00Z", "verified_projection": { - "attempt_id_sha256": "fdad940f245d690750ad647fac25c7e76aac2f474db49732fec8129051750186", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "f5e96a2e9a580376b18beabf57798b8761e772a0c4d112877045780bb12b3720", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-01", - "evidence_sha256": "fc34b2087c0ac5df3a7283f31412b0a354de6d6f9a21946e56ad9f8cd42edfd6", - "run_id_sha256": "3739043a92a8781376cfbd022460c03aba40f92a800b3885ebc046321437bc40", + "condition": "verifier-unavailable", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "d80e5faa489be940291e74948facb9a38c3f6ce34fbe6fb5c586b966e5c82228", + "facts": {}, + "run_id_sha256": "e8e89651045a5f5c011c9543ed968e0fe7697a061ed8ad5cedc27d194cb96acb", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "absent", + "trial_index": 1, + "verdict": "injected", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "d36db3d72f05e9e0142a41e47eb4f413fd585a3de836ddd991067e03b6c2fd4b": { + "cc5c198782b833eac26154a61cbae483021dd950daa665f0e9633a57ee14931b": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-d7e1e084be213b01", "receipt_type": "observer", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "tWFzx1QR43gRy5dgsnSOALSlLiFTXftVkMMA1R33PPRD/hTgfjmBLMM/TybE9K2Ptc32RKLUXilZRkzy04EaCg==", - "source_artifact_sha256": "559774dcac1bab02176edb36d9e7bb92abae9655472d718dbc04d72660cf6323", - "verified_at": "2026-08-18T10:03:00Z", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "DqGhTPxpVBbGDwvh7uk1gOFmseQDlLEO+IQbmKICZ1iMQl01iCsmunZUHpmSZqiI4rWcZEqw44FeTwr4DXh3BA==", + "source_artifact_sha256": "24e69a5639acfa91d8833695390d6df6885bdfd9c998f69d8042b203ac41fade", + "verified_at": "2026-08-18T11:14:00Z", "verified_projection": { - "attempt_id_sha256": "fdad940f245d690750ad647fac25c7e76aac2f474db49732fec8129051750186", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "ad76dacfe19a4421ef1f128d4eef1099e846b385d29f17b8588ae5130b487118", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-01", - "evidence_sha256": "559774dcac1bab02176edb36d9e7bb92abae9655472d718dbc04d72660cf6323", - "run_id_sha256": "3739043a92a8781376cfbd022460c03aba40f92a800b3885ebc046321437bc40", + "condition": "verifier-unavailable", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "24e69a5639acfa91d8833695390d6df6885bdfd9c998f69d8042b203ac41fade", + "facts": { + "derived_classifications": { + "collateral_effect_count": 0, + "duplicate_effect_count": 0, + "intended_effect_count": 0, + "wrong_record_count": 0 + }, + "dispatch_state": "not_dispatched", + "effect_inventory": [], + "expected_record_id_sha256": "15667bd46a6b2a68c33d091a7cdb820efc8c7bc525b84a19df86f11a4b15c348", + "expected_transaction_ref_sha256": "8c2fa32d2ef5dc92756e014ebd4047b72f071156d39dd5040118ee69acf9a0fa", + "post_state_evidence_sha256": "1568879b7f568dd40270fdacb3a76a253577307b7f8c522c02e19b4d1656a6b1", + "pre_state_evidence_sha256": "e7aa4d479e6a7046141e1a00904cac2d9c2ba674e0754c47be79418161b8f1bf", + "verifier_method": "read_only_system_of_record_query", + "verifier_tier": "independent_system_of_record" + }, + "run_id_sha256": "87014cd8063f5a43ea22c995be03ec41ef5aa613145acacdef71b68c468fc8f1", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, + "trial_index": 3, "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "d5ec8f549f8730997d735287bc83fa1d1e008de2960d14ebcbb4b140ff1fdd8a": { + "cf1810125ebf9f6238ab3d93015329a48e69eeb4c925ad2cf6d658d08b492b3f": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "1vVuwFRm9vuK4jHsFZPJaO6O0o2oJTRj/2T+rMFy7ia6Qx2BrRXcgUS2X1qxpjvLkKd/xf+x4dgMckni2470CA==", - "source_artifact_sha256": "dc043aee537d3d9f2971b9f6f507101da11be20d6c62347dddc91b4c9eeb8fdc", - "verified_at": "2026-08-18T11:24:00Z", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "ViM5gLPMUBTUqTNG8B7b2CX3UxCrDO7u7XkZkVenlXs2Ab6RVYd6f6rHxN73GwjEXM86P/5Oj+gw4qt5OUjwAQ==", + "source_artifact_sha256": "ce46f3e2c640383fa7d86f238289722cb7a1f00c5ee3ba8994a54c6a140ad8d4", + "verified_at": "2026-08-18T11:13:00Z", "verified_projection": { - "attempt_id_sha256": "aa7d6be4f25a8992c0a22649ba7e703d6955abf5fece9f8322f560149cf09776", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "42259dbb767ced4c25ad8bd40edc209720a748897194c925ed9bd2e27b2258b2", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "weak-effect-only", - "evidence_sha256": "dc043aee537d3d9f2971b9f6f507101da11be20d6c62347dddc91b4c9eeb8fdc", - "run_id_sha256": "b974de9da8ef77c8dc9a7662114cc51023ab8c131c488681eeebb7d4c435c8d0", + "condition": "verifier-unavailable", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "ce46f3e2c640383fa7d86f238289722cb7a1f00c5ee3ba8994a54c6a140ad8d4", + "facts": {}, + "run_id_sha256": "4af84f2608a25a27e6252a5800263a238bb70fb3bec65148601ddcdddbf3e03c", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "delivered", + "trial_index": 2, + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "d5f9ea3188b044838ce9bee71ae6243bd2ad81b684d7c1e1b537bbce00e4d99b": { + "cfd92154fe2f468fa965ab716b63dfdffaab97240c67cda15b262e993ccc3b08": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-138dfa227234ea5f", "receipt_type": "cleanup", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "Bz7cdtGgvLRL4I8gbXLsixEw8thvDeRvYvZsh6RdoV0Bo8nZ12WXjodMtEjNB98O52cy9Xo4iIMV2oYxqtYvDw==", - "source_artifact_sha256": "e7e294aaa63908c75e3513aee7e29b3bd24623d3fda8d6fe6fbb9dd04227630f", - "verified_at": "2026-08-18T10:23:00Z", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "yYdaU1nomYi+S8rnIXm4REYTPEB+ZEBt39JYeEQwDUQ9hNuGxzKD5K7ya7jYkf9qTWWns/jY9ydhp5QjGYwGBA==", + "source_artifact_sha256": "27c78ad5d0a8808752297aff7a4618ed4a5fb67e9ad3f7cb237a202a19a83282", + "verified_at": "2026-08-18T11:03:00Z", "verified_projection": { - "attempt_id_sha256": "2601335b1101424105277997a67850a8a60aa45f59637b7679c1f32af463c460", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "1ec11a9862ede3ac701af71835ac28c551d604a026b5bab7d776dbcdf288394e", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-03", - "evidence_sha256": "e7e294aaa63908c75e3513aee7e29b3bd24623d3fda8d6fe6fbb9dd04227630f", - "run_id_sha256": "237a0b7d1cafb64b1d113dca6699e6eefeaaf0b18679138545c3695495b901d5", + "condition": "ambiguous-target", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "27c78ad5d0a8808752297aff7a4618ed4a5fb67e9ad3f7cb237a202a19a83282", + "facts": {}, + "run_id_sha256": "43f0a1c00950c390b0676fab55a2aa98c354d028f2347c461661e6cdb72f717e", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, @@ -4195,65 +5359,143 @@ "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "d71287d6a633a01d9edcc3f0c7552799e586aa942dff0330cc13238333f676cf": { + "d11f22309560ed2a7f681efe767e871d45348f2d0a1d80616d8e4dd7012e0044": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "y0VtEXaHH1mVKNwMAeG/w0ej2wA5f6qgmh1SiFlFLAaWXPjfoyKLxFUw0LwooLcCjpiz5h13xNL2WQ5oRUPpDQ==", + "source_artifact_sha256": "8558af088d566bf88f4efb53d9cea316fe8385eb40828881aa49418896707c6b", + "verified_at": "2026-08-18T11:03:00Z", + "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "1ec11a9862ede3ac701af71835ac28c551d604a026b5bab7d776dbcdf288394e", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "ambiguous-target", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "8558af088d566bf88f4efb53d9cea316fe8385eb40828881aa49418896707c6b", + "facts": { + "derived_classifications": { + "collateral_effect_count": 0, + "duplicate_effect_count": 0, + "intended_effect_count": 0, + "wrong_record_count": 0 + }, + "dispatch_state": "not_dispatched", + "effect_inventory": [], + "expected_record_id_sha256": "59fe7a772d3e5d4b6a0a7be45fee58a47c5f24f07c74194b30706733181154f2", + "expected_transaction_ref_sha256": "a8be1e17d0c4cc50bfa8b553cb0a6bea871938fac049f422d0806509a899d877", + "post_state_evidence_sha256": "e9b273e8e69522994820556ecbdf86e2b18858d6711bd9b4d62803a129c1023d", + "pre_state_evidence_sha256": "1c882102464e5733c3b705fd1eeb2cb7c0a634a5f654b5b736bd09798f555afe", + "verifier_method": "read_only_system_of_record_query", + "verifier_tier": "independent_system_of_record" + }, + "run_id_sha256": "43f0a1c00950c390b0676fab55a2aa98c354d028f2347c461661e6cdb72f717e", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "satisfied", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "d67f951f5150477f5b6f23fd49cfb5dfb983c77c6f000ed977da83aa142ef62b": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", "receipt_type": "runner", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "Caj7jLI3vNH13TAMQpPMBUMFB4AT4/BEq4Wav+ABuOoZEdWWImAXgay0l+mIXQjsEWIb8f/aXjMnJZ/kYLYeDw==", - "source_artifact_sha256": "cfa32a5a84ca628c634a548be23b97ffb53dc187e1e8b479a30dba14275ec44a", - "verified_at": "2026-08-18T11:13:00Z", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "thRMAnSS+CpGKJ1Z8rA2Vmcn8QzCAyCKbNbw07VfbUhXPesSZFV5W+XJVtQu5LL98b6Ec3IWRvcimw1lDP8dBg==", + "source_artifact_sha256": "41b0b0f3cb3d31cd294283b6d49a4982e36b7f34033f72e83a81354f0aa54a47", + "verified_at": "2026-08-18T11:12:00Z", "verified_projection": { - "attempt_id_sha256": "42259dbb767ced4c25ad8bd40edc209720a748897194c925ed9bd2e27b2258b2", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "f5e96a2e9a580376b18beabf57798b8761e772a0c4d112877045780bb12b3720", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "verifier-unavailable", - "evidence_sha256": "cfa32a5a84ca628c634a548be23b97ffb53dc187e1e8b479a30dba14275ec44a", - "run_id_sha256": "4af84f2608a25a27e6252a5800263a238bb70fb3bec65148601ddcdddbf3e03c", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "41b0b0f3cb3d31cd294283b6d49a4982e36b7f34033f72e83a81354f0aa54a47", + "facts": { + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "41b0b0f3cb3d31cd294283b6d49a4982e36b7f34033f72e83a81354f0aa54a47", + "source": "runner_signed_flow_report_and_enforced_egress_policy" + }, + "operator_intervention_ids_sha256": [] + }, + "run_id_sha256": "e8e89651045a5f5c011c9543ed968e0fe7697a061ed8ad5cedc27d194cb96acb", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, + "trial_index": 1, "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "d7ea0a0b1670116dd9bd45378335199d7805fd2c8b56b2e52b7d8b8df1a2d376": { + "d798a4e28710daf65f49160ea167bc715efaea32bfab50c3d577df9d45bbad8d": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-138dfa227234ea5f", - "receipt_type": "cleanup", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "wzM6dOwLwWDCpnSCNvbjJlBNMCo5PiIqTJ3K+/5F1VGQEex0KRTSd+QtvzGM1yimRChspYLoFtSvI/FHFl+CBA==", - "source_artifact_sha256": "7d89d8f99f5fd27361d5750bd99439b0669933179a8e2ce8e3c66d7f551cf8c3", - "verified_at": "2026-08-18T10:43:00Z", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "P2HYePnYFqg/SfdNfjsLTGNx1UrWCci1MXWVNFzheZequrOH05drHMdhCrt5H1q2DN4KsPlwdEgW/Uquz9cNBQ==", + "source_artifact_sha256": "6be0b951a73718afe96c480af0f29cc328de4d1d636fbaf54a6f89ba686a0158", + "verified_at": "2026-08-18T10:52:00Z", "verified_projection": { - "attempt_id_sha256": "6b0e5c10d55fc92c1ff8576392270a24fb65722414cf58ff9a51b8ce9ef88587", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "fbfce2be9ce964be8b668aa518a310fe4a89e5c014f42bd0ea81401bd83bfd7a", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "wrong-reference", - "evidence_sha256": "7d89d8f99f5fd27361d5750bd99439b0669933179a8e2ce8e3c66d7f551cf8c3", - "run_id_sha256": "577e37b10b1c87fd9c1b5d320888b736d272824657fd59a012e85a284ee88540", + "condition": "stale-session", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "6be0b951a73718afe96c480af0f29cc328de4d1d636fbaf54a6f89ba686a0158", + "facts": { + "derived_classifications": { + "collateral_effect_count": 0, + "duplicate_effect_count": 0, + "intended_effect_count": 0, + "wrong_record_count": 0 + }, + "dispatch_state": "not_dispatched", + "effect_inventory": [], + "expected_record_id_sha256": "11c08ea44660ba4cd68dde056a3a33382ef9b2fab17d1a2ac0899ba89e3a06bb", + "expected_transaction_ref_sha256": "85cb9b53b37f373d46c90484e326aa99c41b13772cf3868c1552d3a5b13aad79", + "post_state_evidence_sha256": "52241460ac478f2828fb3c39fb8c608ea57a42dc778807e1d54ee6c80d7aa415", + "pre_state_evidence_sha256": "fd54b5eabca5a36d2a785dfd38d6322321f46d60b3389cd6bcff4f45bd19545e", + "verifier_method": "read_only_system_of_record_query", + "verifier_tier": "independent_system_of_record" + }, + "run_id_sha256": "d9270fd4c85e4226a9347ecf703e876b9ffdc330f60c7fb8bed8f9321ea30225", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "completed", + "trial_index": 1, + "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "d9553baf538c005d37d0fa044211857d6a24114de97b70462fdac8fe97be3400": { + "d8c483eb7b08e73b722f6a305a73fd8d2a4e36cf0339e42774d7fd5b64650c5c": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-e37abcd79efd08db", "receipt_type": "replay", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "8lDDqyUAxC8gjB2yVLMm+RQRTgpVFn+2iU+CKJKmgME/TM0AYwGZbZ2Os2RoOGv3Pgj4LpSlhdLMpiJZ9DCnBw==", - "source_artifact_sha256": "63a797c26af0607f83fd33dbce35617c4061915381435f3fbbd782b3554c15dc", - "verified_at": "2026-08-18T10:13:00Z", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "N4yEf2/WOWU1YSU+NKOQ7iRUpsrvnnQG5rXTqIZF8lr1HI/B5NhPNlg/L7jIFWqRtnLoWWJVardmNS87q+flAg==", + "source_artifact_sha256": "343f637659566d84e7014bb1c057b6f9363086e8d04e122e7df754c45b3367d3", + "verified_at": "2026-08-18T10:33:00Z", "verified_projection": { - "attempt_id_sha256": "3d42601a69ef46cc44f57b51762affef4ccd829ffde30125619a6e582af00dab", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "4667302b580ff7ceb223dbb15eb6d029969a8f6a54bcd33e8df5b6bff41f41ad", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-02", - "evidence_sha256": "63a797c26af0607f83fd33dbce35617c4061915381435f3fbbd782b3554c15dc", - "run_id_sha256": "091e13ed70dab439b31cb506cf3bba1ddf6476696531cf891c39a924a928b7a1", + "condition": "idempotency-replay", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "343f637659566d84e7014bb1c057b6f9363086e8d04e122e7df754c45b3367d3", + "facts": {}, + "run_id_sha256": "33e0ad9bf64e477f24d46508fa432123e046dcd1c5853d5cc60b7cde1bce7537", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, @@ -4261,21 +5503,38 @@ "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "d9a6d4aa7064e5bfba2fb43680aa1891a29249aa899b5c4e7d2858aa8b27825b": { + "d8c7108342370f14c1531094e3fdaeecea401a7608d17e2873dbe1ac63b71982": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "MgAx8UoKWVwBpx5w+AUaufoMrSoMzFtEGtyaNgh61GjemKSKfN+7wNa9EW73c64wlVsZaIRkxq1TpdLSr8FOCA==", - "source_artifact_sha256": "94f304fac630bb580a17d9bcc9e35a0c85e9d873543699c6e9b5668ec6c6ea4b", - "verified_at": "2026-08-18T11:03:00Z", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "efh1rHZZCq7EROMDGbGAFxdIfqHRsPenzTPuEF1j58xhK7Od/6ujIc9UJnCZY/eAzY91eHEnfSdZfpnGBXs0AA==", + "source_artifact_sha256": "17bb1d69cfdd94f6150054ac594fc42cd59a8d09b780ee0103962cd549f157ef", + "verified_at": "2026-08-18T10:53:00Z", "verified_projection": { - "attempt_id_sha256": "1ec11a9862ede3ac701af71835ac28c551d604a026b5bab7d776dbcdf288394e", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "f5df4d6e64a2d38ffa8e320c87ad05d04025de267a8e152a755d3f1928ded120", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "ambiguous-target", - "evidence_sha256": "94f304fac630bb580a17d9bcc9e35a0c85e9d873543699c6e9b5668ec6c6ea4b", - "run_id_sha256": "43f0a1c00950c390b0676fab55a2aa98c354d028f2347c461661e6cdb72f717e", + "condition": "stale-session", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "17bb1d69cfdd94f6150054ac594fc42cd59a8d09b780ee0103962cd549f157ef", + "facts": { + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "17bb1d69cfdd94f6150054ac594fc42cd59a8d09b780ee0103962cd549f157ef", + "source": "runner_signed_flow_report_and_enforced_egress_policy" + }, + "operator_intervention_ids_sha256": [] + }, + "run_id_sha256": "fd3a041b705d8c6277ce26134dc0018e866218cfa3fadd16ac29d1ad498965a3", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, @@ -4283,65 +5542,88 @@ "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "dc7048a424e18471caed8bd57b168512101197f3accf144c4d19acc40d01bf6a": { + "d8db564da881ce1888bee8e886f149da4ab06239ff1325fac6f2402738c33480": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d7e1e084be213b01", - "receipt_type": "observer", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "NJjBJyezW3A63VJR8PXvMj657FZGkMkQQswu3/c6aAJ0TXzV4jF2wqyvlz5B/v5kjvRfV7D4i/5hAiKUqxacBQ==", - "source_artifact_sha256": "e0ce2fefc18a96fdbe4db27543f31525ec9852a94a94d757559ccdd960f8faf9", - "verified_at": "2026-08-18T10:13:00Z", + "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", + "receipt_type": "fault", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "6IlPa7b4zT0OJ8OJLmSHtzuS5ypSdSstbVs6RUX8TkqTk2vBrHV4KimbQBv0khzcpTWNHbfnhBxd/S6D1JxNAA==", + "source_artifact_sha256": "e7f1dc034e24ac6d0aad3990e694aa281baa8c3e11415deb28fdd2e98bbdd313", + "verified_at": "2026-08-18T10:43:00Z", "verified_projection": { - "attempt_id_sha256": "3d42601a69ef46cc44f57b51762affef4ccd829ffde30125619a6e582af00dab", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "6b0e5c10d55fc92c1ff8576392270a24fb65722414cf58ff9a51b8ce9ef88587", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-02", - "evidence_sha256": "e0ce2fefc18a96fdbe4db27543f31525ec9852a94a94d757559ccdd960f8faf9", - "run_id_sha256": "091e13ed70dab439b31cb506cf3bba1ddf6476696531cf891c39a924a928b7a1", + "condition": "wrong-reference", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "e7f1dc034e24ac6d0aad3990e694aa281baa8c3e11415deb28fdd2e98bbdd313", + "facts": {}, + "run_id_sha256": "577e37b10b1c87fd9c1b5d320888b736d272824657fd59a012e85a284ee88540", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, - "verdict": "satisfied", + "verdict": "injected", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "dee002824b0aacb73e258cbf2ffce66cdb8870f871b0f750e7d299102e153341": { + "db47eb5e8daad06624900c87959770bf1bddc5e74e391b0e7a7e31ce9521e8dc": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d7e1e084be213b01", - "receipt_type": "observer", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "ppBPUAUP2edGtKfwlDgV07wnv1e8xfPGaQtBnGolDa4DtokxRk/vrLmnYOOceVI+msXPLBu1qujWdzo/v2EnDA==", - "source_artifact_sha256": "669b90f52ab8347c72f46f47c7493d314fafe014431fa4d576db6a8d42eeb0dd", - "verified_at": "2026-08-18T11:04:00Z", + "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", + "receipt_type": "fault", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "zt7SJkyQiNerf3E3wMEA3mkKMcMneWLjM36DQhXzIEuqjcTwhqqXkXSuxzDTxMQVcU7P6nKK1mM6j45+GS8hAQ==", + "source_artifact_sha256": "0a6f7475010857b4c4c0c9f660926588236800ef17f86e670e163c98fa71c3a5", + "verified_at": "2026-08-18T10:44:00Z", "verified_projection": { - "attempt_id_sha256": "491a544656d05aea37920e5c7e2ad65a9452eac8d6e100268a599aeebd41187a", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "7c910764b2dcc6f05261d609082f75474e4638c3f356006307212b8fed4a2eb7", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "ambiguous-target", - "evidence_sha256": "669b90f52ab8347c72f46f47c7493d314fafe014431fa4d576db6a8d42eeb0dd", - "run_id_sha256": "aa62c7a17701a7ef01ea1d3519b4c1f90d357495b329fdda3054cc24c581a593", + "condition": "wrong-reference", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "0a6f7475010857b4c4c0c9f660926588236800ef17f86e670e163c98fa71c3a5", + "facts": {}, + "run_id_sha256": "fe98ce7f0e66b885201f4667875fd38f5890ffddb575d68bd4cd5a66f8d53ca8", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, - "verdict": "satisfied", + "verdict": "injected", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "dfcca365e78d63d5b6107cff019f577018420e7e4e6863991f92dbcb51ad4406": { + "db5e2e6a02b80563230b4d36825d863af418ec707ae81789cc9001052351cc8a": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", "receipt_type": "runner", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "uDwUUPcB3hMMle3g6PzMD+bg6dmHHdqTZ605pEmMtr5QrlQyGlbIZoZ7lyXtxjOv1xeMW5UqLtfuETQS5ExHCw==", - "source_artifact_sha256": "41b0b0f3cb3d31cd294283b6d49a4982e36b7f34033f72e83a81354f0aa54a47", - "verified_at": "2026-08-18T11:12:00Z", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "FNH6rTHjQa60qW4dkvO+P/eoEMjuSaOCz7h5no0sImyPowD04iU8YL9qB+43HVQtpk+iMIHXC74fW8PExP8BCg==", + "source_artifact_sha256": "d216e429bd0611ac65b285ab73297d037fa3aeb3adb76d299da0c91d2559f159", + "verified_at": "2026-08-18T10:42:00Z", "verified_projection": { - "attempt_id_sha256": "f5e96a2e9a580376b18beabf57798b8761e772a0c4d112877045780bb12b3720", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "e93521e706ad90d799dcd4e8cac15229c5da6aec1638540606f5fab4efce59fc", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "verifier-unavailable", - "evidence_sha256": "41b0b0f3cb3d31cd294283b6d49a4982e36b7f34033f72e83a81354f0aa54a47", - "run_id_sha256": "e8e89651045a5f5c011c9543ed968e0fe7697a061ed8ad5cedc27d194cb96acb", + "condition": "wrong-reference", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "d216e429bd0611ac65b285ab73297d037fa3aeb3adb76d299da0c91d2559f159", + "facts": { + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "d216e429bd0611ac65b285ab73297d037fa3aeb3adb76d299da0c91d2559f159", + "source": "runner_signed_flow_report_and_enforced_egress_policy" + }, + "operator_intervention_ids_sha256": [] + }, + "run_id_sha256": "ee82112f55e5e6c86cfd6e16df8c8b652549a8bd72de492f435d8255eb3dd252", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, @@ -4349,285 +5631,413 @@ "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "e0e3d981c9ba2d0cf3195944e46a1c95815d42f5f69057fef276ee9ad794e4c6": { + "dc770cb91c01b638000f8f540bc2f3b6496f492d80b0aefed750b134a19bfe84": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", - "receipt_type": "runner", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "VfmpXtbQ8gDR5DTqratGO549605SVfvwrujClSR+XPzVokaWYqx7wdu7LR5wRHmXvoluvd3wUmTflOZ/kW19DQ==", - "source_artifact_sha256": "40933d309a18fba8094517dfd195dd4feea0486e031db26f66ff09699477bda9", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "pS+/Uwog+rPNeDxvdFYW48jGf9guYjdkPlA0unne2hDWInv5hpmfewEljXzU5PP2AtK05vDW4SZ8dMk+HzXGBQ==", + "source_artifact_sha256": "2a8bec5d9988588a24b36ed1499927f102d61b5867aad99f171fb4a89ce595bf", "verified_at": "2026-08-18T10:12:00Z", "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "940d3ca125ff87ce7539740fbae29d2d64fec839328b0639127e1d197d2485d8", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "healthy-02", - "evidence_sha256": "40933d309a18fba8094517dfd195dd4feea0486e031db26f66ff09699477bda9", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "2a8bec5d9988588a24b36ed1499927f102d61b5867aad99f171fb4a89ce595bf", + "facts": { + "derived_classifications": { + "collateral_effect_count": 0, + "duplicate_effect_count": 0, + "intended_effect_count": 1, + "wrong_record_count": 0 + }, + "dispatch_state": "dispatched", + "effect_inventory": [ + { + "effect_id_sha256": "e45a708944b07484bedb1335618bb2857bff8fb3811b74e83938a3bdbc92954d", + "record_id_sha256": "4df580e44d7b5f5a68d9c2d8f8daa26c2026e2c1e0f00065d08fe22fa1dadfcf", + "transaction_ref_sha256": "0be7d7c67da1fcabbc08e5839af8f39802bd2f3ff7457b26f8723e000f65e968" + } + ], + "expected_record_id_sha256": "4df580e44d7b5f5a68d9c2d8f8daa26c2026e2c1e0f00065d08fe22fa1dadfcf", + "expected_transaction_ref_sha256": "0be7d7c67da1fcabbc08e5839af8f39802bd2f3ff7457b26f8723e000f65e968", + "post_state_evidence_sha256": "4fe967939f22b92004b65dc7ff985026be9b8bc32c59f69686c3672398bfffd3", + "pre_state_evidence_sha256": "4e350e2dcc8aa5ace5ee271d20a892b406060a57a6607b1875cb917f9857f32d", + "verifier_method": "read_only_system_of_record_query", + "verifier_tier": "independent_system_of_record" + }, "run_id_sha256": "bbb9312ce4682b23580eced0f8d19438d8266b222555df85fb27eef22ad5afe2", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, - "verdict": "verified", + "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "e37d0a752e30a9964257bb1bc5def9409f3902ef3d739aa88b0a91048e9715e3": { + "de26659e031f4d186faf99c91d5b4506cf77d4cc82723581f5f163519c82b032": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d7e1e084be213b01", - "receipt_type": "observer", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "k58ZxGpXg0OTslcVbqwLw3HkIWV2wMTrSGaj5ZObBgGIL0YExDYyWEk531sYCZ3DqZEFYDLOoFzfFvO1BU2MBQ==", - "source_artifact_sha256": "8f3a90b44ab62c40384d697eeb5664143c64378dc1162f48f40843beeb892c40", - "verified_at": "2026-08-18T10:53:00Z", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "G4L95k7Qu5+iW+fNrlaPBmbxdrgxfO+DxDzpei5g9H+b7oyy/RC0uGS08S4aI+Fd6rWsUAoFIkZaYLrFcJdbAA==", + "source_artifact_sha256": "f48a35f45e70951886d40904c131ba517e46acb12368169e31b1c47de7ee6a8c", + "verified_at": "2026-08-18T10:12:00Z", "verified_projection": { - "attempt_id_sha256": "f5df4d6e64a2d38ffa8e320c87ad05d04025de267a8e152a755d3f1928ded120", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "940d3ca125ff87ce7539740fbae29d2d64fec839328b0639127e1d197d2485d8", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "stale-session", - "evidence_sha256": "8f3a90b44ab62c40384d697eeb5664143c64378dc1162f48f40843beeb892c40", - "run_id_sha256": "fd3a041b705d8c6277ce26134dc0018e866218cfa3fadd16ac29d1ad498965a3", + "condition": "healthy-02", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "f48a35f45e70951886d40904c131ba517e46acb12368169e31b1c47de7ee6a8c", + "facts": {}, + "run_id_sha256": "bbb9312ce4682b23580eced0f8d19438d8266b222555df85fb27eef22ad5afe2", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "satisfied", + "trial_index": 1, + "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "e4a4e9961ad6f679f61438dfadc80c1c45d213a25e9a508d1f3008fc2c652f9e": { + "de88bb941c8dcaf4123f41230b235a5097a327e4408dd496c8a658bba071fc6b": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "p22H2x33Up/DDl8UAMYyPuMs5lkS2B6IcZwOBIKO+I91KwUEhcRaz0oesD73qKsvMIZ7VNZaSlzPJqpe33IPBg==", - "source_artifact_sha256": "8085128f824c52e7f957276980e2ec8ed181e15094c1a551c251a21e07009829", - "verified_at": "2026-08-18T11:22:00Z", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "OK0eyBzGpm3xX05nkaMb91MJWZK/htHXk49QG0HqABJ170hpEgyFYGff2es0uRZqs3beaQ6AALnyoQWkG7BSBA==", + "source_artifact_sha256": "26eef6795405076a78c4a1d95d85251e7454d3059e296b07b2cf612e7b6231a2", + "verified_at": "2026-08-18T11:12:00Z", "verified_projection": { - "attempt_id_sha256": "73a097b8b20bab7794369384f7ca1d7d711aad07967b7e1292373babbb7ff1b7", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "f5e96a2e9a580376b18beabf57798b8761e772a0c4d112877045780bb12b3720", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "weak-effect-only", - "evidence_sha256": "8085128f824c52e7f957276980e2ec8ed181e15094c1a551c251a21e07009829", - "run_id_sha256": "b44783e70a980ec5b3cf3752bd5d1d01b2ff29f5a6892cba0c1c939d8aeb7c02", + "condition": "verifier-unavailable", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "26eef6795405076a78c4a1d95d85251e7454d3059e296b07b2cf612e7b6231a2", + "facts": {}, + "run_id_sha256": "e8e89651045a5f5c011c9543ed968e0fe7697a061ed8ad5cedc27d194cb96acb", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, - "verdict": "absent", + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "e559276a48fe1c67b3d827bf49a6fa86b069834a9ac294c570b0e429410aabd5": { + "deda444b535e16e5e8c0b26f674bb9facf018b808a1c734a23d2b75101819f47": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-d92d542a589844dd", "receipt_type": "cleanup_absence", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "up9eEGPlf6SNr/CmnPD5u/F79jLKRzRxGIqpADGGVa5kLM82sjurPmrYh6+NbYUt0uVnpQXY38IkkMOPkMS/DA==", - "source_artifact_sha256": "0aefdcb48f524cd1122dc1bfffdbcea74cc3d239411590ae1b6c6b5d0ca845b4", - "verified_at": "2026-08-18T10:43:00Z", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "pcnMpOk8rb/NSgWv3/vabv09JwnpMM1m5J1KtJolFQgSIN99z9ERtfwqZ616kBEPysMaAlRwx2owjvWNvoJ/DQ==", + "source_artifact_sha256": "23708d813c5434c08faf44e36a798621030200b33f634d785750d86cf7fb96d7", + "verified_at": "2026-08-18T10:52:00Z", "verified_projection": { - "attempt_id_sha256": "6b0e5c10d55fc92c1ff8576392270a24fb65722414cf58ff9a51b8ce9ef88587", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "fbfce2be9ce964be8b668aa518a310fe4a89e5c014f42bd0ea81401bd83bfd7a", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "wrong-reference", - "evidence_sha256": "0aefdcb48f524cd1122dc1bfffdbcea74cc3d239411590ae1b6c6b5d0ca845b4", - "run_id_sha256": "577e37b10b1c87fd9c1b5d320888b736d272824657fd59a012e85a284ee88540", + "condition": "stale-session", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "23708d813c5434c08faf44e36a798621030200b33f634d785750d86cf7fb96d7", + "facts": {}, + "run_id_sha256": "d9270fd4c85e4226a9347ecf703e876b9ffdc330f60c7fb8bed8f9321ea30225", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, + "trial_index": 1, "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" - } - }, - "e7de3e25e41b185b7d787423eb75096f31c60c53bb16339deb6cc1d34631dcb3": { - "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", - "receipt_type": "fault", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "e+38pGZnBUb86YZjcc7dB6libke4qt2hMsYWa4hzZQSzdCxrCYkE3mbtp6rJdclcaXAL+XQ5tm8MicnqtTp+Cg==", - "source_artifact_sha256": "0eafb7867b5bb7cf68f39f40315893e1d694dd3566b71331a554025c69b9504f", - "verified_at": "2026-08-18T10:42:00Z", + } + }, + "def8a0faa88928a2b87804705ece6f712edd9aeb7ca4fed4e066fdaea75229ca": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "Llxo9aweTrBl+MQyPqgZYRWWmXOc2gzHFO62vlGfEgfT3q5oaKT79u9EBFRxEAafIwiCCErCKrQz35R9sTcXBA==", + "source_artifact_sha256": "fe35b956dbe29b97bcbf293cf40b9c9c9c6eac8466925d706e684648b3d43d9b", + "verified_at": "2026-08-18T10:43:00Z", "verified_projection": { - "attempt_id_sha256": "e93521e706ad90d799dcd4e8cac15229c5da6aec1638540606f5fab4efce59fc", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "6b0e5c10d55fc92c1ff8576392270a24fb65722414cf58ff9a51b8ce9ef88587", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "wrong-reference", - "evidence_sha256": "0eafb7867b5bb7cf68f39f40315893e1d694dd3566b71331a554025c69b9504f", - "run_id_sha256": "ee82112f55e5e6c86cfd6e16df8c8b652549a8bd72de492f435d8255eb3dd252", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "fe35b956dbe29b97bcbf293cf40b9c9c9c6eac8466925d706e684648b3d43d9b", + "facts": {}, + "run_id_sha256": "577e37b10b1c87fd9c1b5d320888b736d272824657fd59a012e85a284ee88540", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, - "verdict": "injected", + "trial_index": 2, + "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "e824c2cd52e7d2ff5ecfa797b7d2e53fa7986c0a5ea5e77204511d9460662047": { + "df5539d0273ef7fe8dad28520de2664d6cb1434aa1bc7973d5099129ea8e9fb3": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", - "receipt_type": "runner", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "nPTOZ+20bHMTk8lQ2zSuY0fY/NFtOZyRmg5dTkmeCOQ7wect3fb87ETn4zyqVAGR4+o4UCtrvqQKR9OHv9taAg==", - "source_artifact_sha256": "5a34e35fec7ee614b3ae06606f9778a2e11d5c8b34ca4792f79b0fc127c7d95a", - "verified_at": "2026-08-18T10:24:00Z", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "Veo5DttSA+B85eGTldyhZXGLTF0LTSnrktezVFo1oIRUGI20v5lxX53M/n7OqeX3p4nU7tQqjvMbLR3mFrBbBQ==", + "source_artifact_sha256": "dcdc96c4f09e390d61f558318a74baef2f65d601e71808bdbf922fcc7f4d5bbf", + "verified_at": "2026-08-18T10:03:00Z", "verified_projection": { - "attempt_id_sha256": "7573925adbd8a7a4a3b98bb0379549d77aa8ed46e312c1cd940c05b8587a039e", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "fdad940f245d690750ad647fac25c7e76aac2f474db49732fec8129051750186", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-03", - "evidence_sha256": "5a34e35fec7ee614b3ae06606f9778a2e11d5c8b34ca4792f79b0fc127c7d95a", - "run_id_sha256": "784a0a94e581700a3d93581e7ce5bac0d3bc53c58f3e73198b896b5da9a819b0", + "condition": "healthy-01", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "dcdc96c4f09e390d61f558318a74baef2f65d601e71808bdbf922fcc7f4d5bbf", + "facts": {}, + "run_id_sha256": "3739043a92a8781376cfbd022460c03aba40f92a800b3885ebc046321437bc40", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, + "trial_index": 2, "verdict": "verified", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "ea2c537ac99f78c9175fc41640fc030b6139c33c02ffa964597672932f1bc149": { + "e326380f27a42e658689cce26a59cdfb4867f512ba7016355487954a99eeaebe": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-d7e1e084be213b01", "receipt_type": "observer", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "bowS/inBRQZkWmtZpPUQgjHlnR/E+WhJ575n2s0vZ4iUpxSny7OrbjQW5KVZicHU2KdpIuoxnH3vhMdfD1y1Dw==", - "source_artifact_sha256": "6be0b951a73718afe96c480af0f29cc328de4d1d636fbaf54a6f89ba686a0158", - "verified_at": "2026-08-18T10:52:00Z", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "7HYw2QGFquf1FBbLF99jPcv9V+9kLVNGuD4QMXtAYZx+izTLv4GA4Vcn8T+Aqqn9eyTU8KiePNkPkHiwq/JTAw==", + "source_artifact_sha256": "bd93f6e9d767166a948c91db13a6d6ebf759630b605e6ecf130420e0511ee3a4", + "verified_at": "2026-08-18T11:24:00Z", "verified_projection": { - "attempt_id_sha256": "fbfce2be9ce964be8b668aa518a310fe4a89e5c014f42bd0ea81401bd83bfd7a", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "aa7d6be4f25a8992c0a22649ba7e703d6955abf5fece9f8322f560149cf09776", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "stale-session", - "evidence_sha256": "6be0b951a73718afe96c480af0f29cc328de4d1d636fbaf54a6f89ba686a0158", - "run_id_sha256": "d9270fd4c85e4226a9347ecf703e876b9ffdc330f60c7fb8bed8f9321ea30225", + "condition": "weak-effect-only", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "bd93f6e9d767166a948c91db13a6d6ebf759630b605e6ecf130420e0511ee3a4", + "facts": { + "derived_classifications": { + "collateral_effect_count": 0, + "duplicate_effect_count": 0, + "intended_effect_count": 0, + "wrong_record_count": 0 + }, + "dispatch_state": "not_dispatched", + "effect_inventory": [], + "expected_record_id_sha256": "91f268174be0ceea4f27f6197630a299cc2f5dc0379f1859cda04db7338cc8a1", + "expected_transaction_ref_sha256": "fa34ce5dcf42475c8fa7fd73aa540e619bfcdd17cf7d0918a856e509e97519dc", + "post_state_evidence_sha256": "8fd9d8558584962f398038ede8eaf254e6895128716fa04aedef64b87739d1dc", + "pre_state_evidence_sha256": "4419443833f8d0cc9306d316ad6ddc83f67571cc61f83fad22133b179cb5ff1c", + "verifier_method": "read_only_system_of_record_query", + "verifier_tier": "independent_system_of_record" + }, + "run_id_sha256": "b974de9da8ef77c8dc9a7662114cc51023ab8c131c488681eeebb7d4c435c8d0", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, + "trial_index": 3, "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "ea37aba51876e0039f1a875d74bb647b694a67625b103458c1c5001c94015409": { + "e3d0a44d6733f68ad2f52b4ebe689b65537b49e3e2d2b06c7599db54a93a36b9": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d7e1e084be213b01", - "receipt_type": "observer", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "VdtWsQXiFfqWesmd2G13PxnnlqBtQ5dMcgAlrLkbDGQYV1mA0yn2ToSDTMZq1eB0Zpy16Fwm4HlfQbuMQD1TAg==", - "source_artifact_sha256": "a8a94089ae42720eff6c8154fd7ed91674171e6a51ac522db76f1d69704673d6", - "verified_at": "2026-08-18T10:23:00Z", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "wwxdABdepAUpLm1Y5tZ+O0o+Ga3qN355W+imb7TWguJYy1waVYhqUzAfUUjKQwcUP+wZa1ZUQkLAqd1+NmaIAw==", + "source_artifact_sha256": "11f183b9a6fd7d20a3cfc66e95960832da64804b9d3f6980ee365679b3a1793f", + "verified_at": "2026-08-18T11:13:00Z", "verified_projection": { - "attempt_id_sha256": "2601335b1101424105277997a67850a8a60aa45f59637b7679c1f32af463c460", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "42259dbb767ced4c25ad8bd40edc209720a748897194c925ed9bd2e27b2258b2", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-03", - "evidence_sha256": "a8a94089ae42720eff6c8154fd7ed91674171e6a51ac522db76f1d69704673d6", - "run_id_sha256": "237a0b7d1cafb64b1d113dca6699e6eefeaaf0b18679138545c3695495b901d5", + "condition": "verifier-unavailable", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "11f183b9a6fd7d20a3cfc66e95960832da64804b9d3f6980ee365679b3a1793f", + "facts": {}, + "run_id_sha256": "4af84f2608a25a27e6252a5800263a238bb70fb3bec65148601ddcdddbf3e03c", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, - "verdict": "satisfied", + "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "eb31e3c8e4d77a0dcc9e9204ce5c8761e52cd666cae9cdf2c79ff209ea3a6e22": { + "e3d1c240c70aaf5b49945c1a2cfef7f1c7f1c61de81e67dde515b07827a87bb2": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "cbLFP5QQDHE8BEq4BBCtICaS7tyUnt/yElUog7FzPCuBSxQ0oYUe731RjSMCsqx4zrkwzsWxBjUMZntWakJjCA==", - "source_artifact_sha256": "7f144d0ed131ef44fd7db0ba5d3d03e685d681ea76df6a87fcf8bc20073786fe", - "verified_at": "2026-08-18T11:13:00Z", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "6L4LwODFHNex4to54t1Yzaoqvmc1tIbtA0cfE2YdrJfRIP3Is1hpvuqOAR7tXxmUAHj0mH45/6Bo8M25CRX8BQ==", + "source_artifact_sha256": "2fc83a9ad4cdeaa8faf4176f24cd5390e451a993166626508572a5c6a7663659", + "verified_at": "2026-08-18T10:13:00Z", "verified_projection": { - "attempt_id_sha256": "42259dbb767ced4c25ad8bd40edc209720a748897194c925ed9bd2e27b2258b2", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "3d42601a69ef46cc44f57b51762affef4ccd829ffde30125619a6e582af00dab", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "verifier-unavailable", - "evidence_sha256": "7f144d0ed131ef44fd7db0ba5d3d03e685d681ea76df6a87fcf8bc20073786fe", - "run_id_sha256": "4af84f2608a25a27e6252a5800263a238bb70fb3bec65148601ddcdddbf3e03c", + "condition": "healthy-02", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "2fc83a9ad4cdeaa8faf4176f24cd5390e451a993166626508572a5c6a7663659", + "facts": {}, + "run_id_sha256": "091e13ed70dab439b31cb506cf3bba1ddf6476696531cf891c39a924a928b7a1", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, - "verdict": "delivered", + "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "ec0a1bc99a2e3e8249dafda43f54e76d647c86464d87e1caf40480f35f460868": { + "e5448eebaa458e6a8c2750acff6634232de77856d5c9920769cb1c3c90ab7b56": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-138dfa227234ea5f", - "receipt_type": "cleanup", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "0vMtW+mcAdLNYXNL93MBs6lpSNMLs/fvfAGKS9I1Rd6xX8EYZTLlSZO4usRYTemwHXwh5JyEr4B2lEIx19fYDg==", - "source_artifact_sha256": "6f4098a4cb069c24d492715c73eabdf78d759e24953b88a134df911d06fd36f5", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "dw398/e7OLLUAimKKztwLjRctYuv4Y2aMlDpG31j4tEH5f4YOWhFE6X5ZJKcENxP0aadEHNpK3huR1kaomfJBA==", + "source_artifact_sha256": "c5d1d4394bb4197462d6bb136e8e249ac9d8c283bf8563a8ffbd0b7e0141795f", "verified_at": "2026-08-18T10:54:00Z", "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "958342a9ddca98a83b82b662f52f404239d583afe7ed70634760e1b8dd592f3b", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "stale-session", - "evidence_sha256": "6f4098a4cb069c24d492715c73eabdf78d759e24953b88a134df911d06fd36f5", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "c5d1d4394bb4197462d6bb136e8e249ac9d8c283bf8563a8ffbd0b7e0141795f", + "facts": {}, "run_id_sha256": "6f2fb10bc2018c9f78e9702d5ccac0bedd78ee3b2e9d2a6ad779fba72d90ae50", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, - "verdict": "completed", + "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "ed82b83288101e083452346de7469ed7b1fd050e29e6bafac2e7691a37a8992b": { + "e5d91e9b772fc407fe311e48b7b354f267782156817273b26f6906c7ef225ef3": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-138dfa227234ea5f", - "receipt_type": "cleanup", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "xoKWB2eN+qSapCSnbS7KrtZxyqa8vH3yiacgb+3h6UYWQdfcQkFkr1XjlRCK99S9tAi2Ft9XJPmYR+KQ5x6SBg==", - "source_artifact_sha256": "9aff04082026c9a005b5b56eb7078d056d424b5024e1034aa161c875b0f71b80", - "verified_at": "2026-08-18T11:23:00Z", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "BRoKF7FySZgp2nHXrIj6jUF+PaHrpD3rqDW1KLlXOCkq/YAtFuFsYtOfo9sYnKpzpzAGcRg3Pw4ehlu6xFmUCg==", + "source_artifact_sha256": "e1dd07c3df4aed8ff42376ff74a3f68c13ebb7fb509304a544b0e8bde5b1f4ed", + "verified_at": "2026-08-18T10:02:00Z", "verified_projection": { - "attempt_id_sha256": "eb52fb1b1bf2fac92d8f3a444bb5081161be8b3d0ef457c5065e7b79e96df770", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "679af5a8dedceb8c696719e73f82a698c230cd8fc98bb61769f0883202c0b637", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "weak-effect-only", - "evidence_sha256": "9aff04082026c9a005b5b56eb7078d056d424b5024e1034aa161c875b0f71b80", - "run_id_sha256": "794033f9da2a42448254a478fb6de954898b1e544148708ad30264efdc255431", + "condition": "healthy-01", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "e1dd07c3df4aed8ff42376ff74a3f68c13ebb7fb509304a544b0e8bde5b1f4ed", + "facts": { + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "e1dd07c3df4aed8ff42376ff74a3f68c13ebb7fb509304a544b0e8bde5b1f4ed", + "source": "runner_signed_flow_report_and_enforced_egress_policy" + }, + "operator_intervention_ids_sha256": [] + }, + "run_id_sha256": "0b5bda916a0808165159166955a9563cf9c2303949f762a18eb037f41b44a6dc", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "completed", + "trial_index": 1, + "verdict": "verified", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "f0b50a9ab49377989815466eb28721d01c8ee89bff2b37a4a5f3c1901ce1cfc1": { + "e7523a67b0d470b2e2f7d4ade8435b4fb6b5d1289862b50a57b7be2be42a84ee": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d7e1e084be213b01", - "receipt_type": "observer", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "8nNitAnSH1cOqMm2tHTz60dnY0franc30n3uFlTlylvi/1fOHe8S4+BIRkEOahRqyMDv9ni1Fn+N+uGg5Bm9DA==", - "source_artifact_sha256": "ed51ba8ee340b00da87808f45e1ed935c200be0ed41ea55cba8ebcc8e4b3872f", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "YfZW8IzZfe9JEtG91pxEGIH1sT54Dm/GUBiDQbT+hpMrjh+Dm12KXqF+nIdtnICMk5AXplfwPSlIzNBfvyNiCA==", + "source_artifact_sha256": "13d5f53016f80b5ba9f95ceaa4d79970bbf9870cc12470744d0291bbef3a1cda", "verified_at": "2026-08-18T10:24:00Z", "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "7573925adbd8a7a4a3b98bb0379549d77aa8ed46e312c1cd940c05b8587a039e", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "healthy-03", - "evidence_sha256": "ed51ba8ee340b00da87808f45e1ed935c200be0ed41ea55cba8ebcc8e4b3872f", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "13d5f53016f80b5ba9f95ceaa4d79970bbf9870cc12470744d0291bbef3a1cda", + "facts": {}, "run_id_sha256": "784a0a94e581700a3d93581e7ce5bac0d3bc53c58f3e73198b896b5da9a819b0", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, - "verdict": "satisfied", + "verdict": "completed", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "eb27d821b05fccea7ed8b1568a4607b8de8b629e8f50cba1e543e4af416045f0": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "hdQXHoKq6LxzgS2wL/JC8LvV3V1Y52IZodJBwxayoDUU9ztE0dEwlt07CV8xb7qy/RrS4e8/idl+tc7SugzVDA==", + "source_artifact_sha256": "11df3fb01cf5dba128c9a69827676bb2d78cf90dedf8bd2071bcea42c25916e5", + "verified_at": "2026-08-18T10:33:00Z", + "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "4667302b580ff7ceb223dbb15eb6d029969a8f6a54bcd33e8df5b6bff41f41ad", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "idempotency-replay", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "11df3fb01cf5dba128c9a69827676bb2d78cf90dedf8bd2071bcea42c25916e5", + "facts": { + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "11df3fb01cf5dba128c9a69827676bb2d78cf90dedf8bd2071bcea42c25916e5", + "source": "runner_signed_flow_report_and_enforced_egress_policy" + }, + "operator_intervention_ids_sha256": [] + }, + "run_id_sha256": "33e0ad9bf64e477f24d46508fa432123e046dcd1c5853d5cc60b7cde1bce7537", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "verified", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "f100bd4634c9eb9fa4bed44602c35082221c7369d661daee343d30cb1df16e45": { + "f23a094951b21e87b4bf29d155bd5ec7826dd97188a34bd5899c9e0c9e36aafb": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", "receipt_type": "webhook", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "51lJ1pp8CD+oS7ZCSSwsPCFa7sjpKAovRjm+ngvJtZovq36dFqIIAn2JQt17Ln2lZkTSRcJdiTFGBUshQYGpBA==", - "source_artifact_sha256": "12e1cf402efb1b543738dbf0096014533d4c1324c94e1af43a90e76c161e34d4", - "verified_at": "2026-08-18T10:04:00Z", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "ozqOEokMASNRViTX7ckGRMdSc+PueH8RYL59tqCzxMMX6oM+1KtS51fbJUGhuFqWg7ElCCipyM1gQm8YR1adBA==", + "source_artifact_sha256": "5774a782f9ec582ec3f9a710ccfee0a6b3fd6076d73029b33889cbb99d0526ed", + "verified_at": "2026-08-18T10:14:00Z", "verified_projection": { - "attempt_id_sha256": "4c352a6999f77707e8837adebb4fc2b7451c2ef6de5145190b33a5c5645e47eb", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "019dd96e9a771ccc01ebafab321d7d3a8314df8b2d6465bcfc5fa14cbdeabdf2", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-01", - "evidence_sha256": "12e1cf402efb1b543738dbf0096014533d4c1324c94e1af43a90e76c161e34d4", - "run_id_sha256": "4ee2bb61fb883cc8e77d636fb471aa3c0ce9ef0c0a8abd9682214bf0a8f16f26", + "condition": "healthy-02", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "5774a782f9ec582ec3f9a710ccfee0a6b3fd6076d73029b33889cbb99d0526ed", + "facts": {}, + "run_id_sha256": "16cb8df40654c6a1b55ea0e50e772d8c6e6d4f0d8205bd1f8296be27d0af83eb", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, @@ -4635,138 +6045,171 @@ "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "f35aeb8c55ead7bbe677fd5fc293f41185ff75aa21101128a8c0d9fa4a591f05": { + "f308095e47a50231e48617fde6819ea8f160be521f2583b601c6f3c9918d3761": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", - "receipt_type": "runner", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "NQa2/aNn4Z6DjJpaC01u3LXsSzXlZr+Unh+OjSvfn82+bGUbWcFR0m4sy0tSkgmvmTin0ajbSFeNuvmJEx0tCQ==", - "source_artifact_sha256": "a19b4b67cbeff4e08ebe9a0818d950e8d1ebeec5dec837efe97635b5fb541ea0", - "verified_at": "2026-08-18T10:52:00Z", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "lrngc1F/AV2utzoTMsRGMXelCGvUS9zrLWJiCML3Z7iHznvM5+s6XfVXe3WykL0AWCpnNizn0GOn3AoNdHITDw==", + "source_artifact_sha256": "ae52f89326f6a1eaced707ed240c61ddf62d1abbd3ac6891f3dc097aef1451cb", + "verified_at": "2026-08-18T11:12:00Z", "verified_projection": { - "attempt_id_sha256": "fbfce2be9ce964be8b668aa518a310fe4a89e5c014f42bd0ea81401bd83bfd7a", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "f5e96a2e9a580376b18beabf57798b8761e772a0c4d112877045780bb12b3720", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "stale-session", - "evidence_sha256": "a19b4b67cbeff4e08ebe9a0818d950e8d1ebeec5dec837efe97635b5fb541ea0", - "run_id_sha256": "d9270fd4c85e4226a9347ecf703e876b9ffdc330f60c7fb8bed8f9321ea30225", + "condition": "verifier-unavailable", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "ae52f89326f6a1eaced707ed240c61ddf62d1abbd3ac6891f3dc097aef1451cb", + "facts": {}, + "run_id_sha256": "e8e89651045a5f5c011c9543ed968e0fe7697a061ed8ad5cedc27d194cb96acb", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, - "verdict": "halted", + "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "f8c79e22c64f0b26775b0c105f8087f5fa147fa7cb3e7888bfcd6f6499cea2e3": { + "f3f0ca82ea31420f48cdc9b1c4cf01adf4e929df1a1b0a54506b4ab4a782de8e": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", "receipt_type": "webhook", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "M/oAIz9goGtIuHzxLOoqpTjzqtSVjI4G4bRz0eoLWR/JafOcMyDTF/jrZYl/D8glwdreVjmDN3N41wR3sHKtCg==", - "source_artifact_sha256": "b6355ed63a5d7f1df450f75bb77fdcf81321616662fe3728a6da23d2a8957ce5", - "verified_at": "2026-08-18T10:34:00Z", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "4N5Dizov/Qq7wAooiKOfdJtIJSs/aeg2DuELnCWhjTz8LEpk/53lnBY2Oa0t1RQ5IlZMIOgfr/+u/UC0NaZuBQ==", + "source_artifact_sha256": "1bd19a3201a6b9102580819cf704a60ff2d91a1648a1ad38c4dc40806c809b38", + "verified_at": "2026-08-18T11:22:00Z", "verified_projection": { - "attempt_id_sha256": "3aee8ad755c7f4bec71cc194bcfaa805e0ea29cf8b830ed0782f8263dd9620ca", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "73a097b8b20bab7794369384f7ca1d7d711aad07967b7e1292373babbb7ff1b7", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "idempotency-replay", - "evidence_sha256": "b6355ed63a5d7f1df450f75bb77fdcf81321616662fe3728a6da23d2a8957ce5", - "run_id_sha256": "3df83453126754a62d00ed10837720542d0469799bb8a88cb5257ac5f477a919", + "condition": "weak-effect-only", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "1bd19a3201a6b9102580819cf704a60ff2d91a1648a1ad38c4dc40806c809b38", + "facts": {}, + "run_id_sha256": "b44783e70a980ec5b3cf3752bd5d1d01b2ff29f5a6892cba0c1c939d8aeb7c02", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, + "trial_index": 1, "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "fb7adef7d6907ae3e36182ff1a4574e6d2900ba700648928333295be904cedc5": { + "f415d84e6709d0d41f1a9df63018d95b34554defd6ca273b9ae24fb389b0d675": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", - "receipt_type": "runner", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "YHjzb4gKy3+p3o1XWT7vmdExdeQnkq5nDpe+EnJ64AOvb5PMfFXouraK5WME+BrN+V9G4z7Rk5AHUFrtlF12BQ==", - "source_artifact_sha256": "c20ee28b4875041089aace249d6634176c0ed5050228c8c0fba2b37db74b7632", - "verified_at": "2026-08-18T10:43:00Z", + "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", + "receipt_type": "fault", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "PTRUsvBA/6bGAMrMH4BxKex348JCbwjJMtitCr//7liQ1ZSecX4zD+JgWJy+93Vcje/e4N4kvlrI4Grl/Xx+Dw==", + "source_artifact_sha256": "3e1b6e01581eb35f1854a259db0f29c5efdebe4507aefb8ab6d4b0201182593c", + "verified_at": "2026-08-18T11:23:00Z", "verified_projection": { - "attempt_id_sha256": "6b0e5c10d55fc92c1ff8576392270a24fb65722414cf58ff9a51b8ce9ef88587", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "eb52fb1b1bf2fac92d8f3a444bb5081161be8b3d0ef457c5065e7b79e96df770", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "wrong-reference", - "evidence_sha256": "c20ee28b4875041089aace249d6634176c0ed5050228c8c0fba2b37db74b7632", - "run_id_sha256": "577e37b10b1c87fd9c1b5d320888b736d272824657fd59a012e85a284ee88540", + "condition": "weak-effect-only", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "3e1b6e01581eb35f1854a259db0f29c5efdebe4507aefb8ab6d4b0201182593c", + "facts": {}, + "run_id_sha256": "794033f9da2a42448254a478fb6de954898b1e544148708ad30264efdc255431", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, - "verdict": "halted", + "verdict": "injected", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "fcc4e2987962120108fd11d6baf6c9d8c4c9b0bc5a2c6bce166f3bae1d328b50": { + "f7051979b50415fc22bf21c2e154a96b44c6e20344ac9a11cf02a7ed66576f23": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "tuZC4HOTIOaFym8ws2WmQGgdMpfyG4liQ4fcp8AmgMeS44XnUDUtS/nfQjyqX3m66Ao97Qd6ccK+1qUhoxZuAg==", - "source_artifact_sha256": "450c89cbaa5a936d700d26b432db8bd4bbdbc51112a84e99abd73954c0897001", - "verified_at": "2026-08-18T11:04:00Z", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "meHOeild4X7djQxSaiI1jwFq3kHjnOcHUDjAe3q71F+HheX5KTP8DxfnbmImbtmB4k6a3xs1gRNZUh+8YOZdDw==", + "source_artifact_sha256": "94f304fac630bb580a17d9bcc9e35a0c85e9d873543699c6e9b5668ec6c6ea4b", + "verified_at": "2026-08-18T11:03:00Z", "verified_projection": { - "attempt_id_sha256": "491a544656d05aea37920e5c7e2ad65a9452eac8d6e100268a599aeebd41187a", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "1ec11a9862ede3ac701af71835ac28c551d604a026b5bab7d776dbcdf288394e", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "ambiguous-target", - "evidence_sha256": "450c89cbaa5a936d700d26b432db8bd4bbdbc51112a84e99abd73954c0897001", - "run_id_sha256": "aa62c7a17701a7ef01ea1d3519b4c1f90d357495b329fdda3054cc24c581a593", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "94f304fac630bb580a17d9bcc9e35a0c85e9d873543699c6e9b5668ec6c6ea4b", + "facts": {}, + "run_id_sha256": "43f0a1c00950c390b0676fab55a2aa98c354d028f2347c461661e6cdb72f717e", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "absent", + "trial_index": 2, + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "fdb2a16e80f05e06a44ff752694761a289fa386ea14642e5412033c0636b48bf": { + "f805590013237b1a309cbe766022724f3d5d0b02262b5aa432bfd9347dd7a458": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "p5PQIF8t+WmVbuviiEWGBM8+ENaUZ+O4dUzvWb8prEeIjKHYgdREBSi6IUQHNm1sE40q6P3MvFHd0behDYsMAw==", - "source_artifact_sha256": "c68ae5d22981662c17338c01af40177a0e375c993c4e4dcefc9aaf4df2d5366d", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "dGoMRnb3hpxdYwhkajfdocgvO5gKVas8qSkIwM/xLM/Ls/Sf3qp2ml8eVUm+I/NVsJKdPvam2eQm09bdYw7RCQ==", + "source_artifact_sha256": "43d2d3f884205de0a56e566e84429edcbc2e0a31f4904212f36f787c3ea8df6a", "verified_at": "2026-08-18T10:23:00Z", "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "2601335b1101424105277997a67850a8a60aa45f59637b7679c1f32af463c460", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "healthy-03", - "evidence_sha256": "c68ae5d22981662c17338c01af40177a0e375c993c4e4dcefc9aaf4df2d5366d", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "43d2d3f884205de0a56e566e84429edcbc2e0a31f4904212f36f787c3ea8df6a", + "facts": { + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "43d2d3f884205de0a56e566e84429edcbc2e0a31f4904212f36f787c3ea8df6a", + "source": "runner_signed_flow_report_and_enforced_egress_policy" + }, + "operator_intervention_ids_sha256": [] + }, "run_id_sha256": "237a0b7d1cafb64b1d113dca6699e6eefeaaf0b18679138545c3695495b901d5", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, - "verdict": "delivered", + "verdict": "verified", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "ff7446448b7ca80801834d31758eb31968c04d7c27fb137b992ab574ff157cdd": { + "fe7e801fb8e3d5bfbe488815493a91fbf89f99a730cc2544e841f5373b49782d": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d7e1e084be213b01", - "receipt_type": "observer", - "schema_version": "openadapt.qualification-evidence-receipt/v1", - "signature": "39c+nma2DZy5G2mJS/svto0I5xOethfTi2s8EJhvUldHQ+xURfuCzhva7U5TIb5C/XhXXGiJPjCqkA1iZWgXDQ==", - "source_artifact_sha256": "237359293198c0bcf55e931c23b25d4af0950bb1488672f69a6d6260eb2aee06", - "verified_at": "2026-08-18T10:02:00Z", + "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", + "receipt_type": "fault", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "fTwd1e4h5KsUD+GY3yfD0iNe6LYFWjCXnRVdIAQcGG4iSZn7U/HgbL/oMcJnG3MVPNhjlnOmtkFjNNHqZXs8Bw==", + "source_artifact_sha256": "753ac5d5256a729ac572debdef63e5a8acd11b2b6ef909f8efb94d885f37d065", + "verified_at": "2026-08-18T11:22:00Z", "verified_projection": { - "attempt_id_sha256": "679af5a8dedceb8c696719e73f82a698c230cd8fc98bb61769f0883202c0b637", + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "73a097b8b20bab7794369384f7ca1d7d711aad07967b7e1292373babbb7ff1b7", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-01", - "evidence_sha256": "237359293198c0bcf55e931c23b25d4af0950bb1488672f69a6d6260eb2aee06", - "run_id_sha256": "0b5bda916a0808165159166955a9563cf9c2303949f762a18eb037f41b44a6dc", + "condition": "weak-effect-only", + "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_sha256": "753ac5d5256a729ac572debdef63e5a8acd11b2b6ef909f8efb94d885f37d065", + "facts": {}, + "run_id_sha256": "b44783e70a980ec5b3cf3752bd5d1d01b2ff29f5a6892cba0c1c939d8aeb7c02", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, - "verdict": "satisfied", + "verdict": "injected", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } } }, - "schema_version": "openadapt.qualification-campaign/v1" + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "schema_version": "openadapt.qualification-campaign/v2" } diff --git a/tests/test_import_production_acceptance.py b/tests/test_import_production_acceptance.py index 74476ad..87b438e 100644 --- a/tests/test_import_production_acceptance.py +++ b/tests/test_import_production_acceptance.py @@ -97,6 +97,85 @@ def _resign_admission( _sign_admission_payload(admission) +def _rebind_evidence_identity( + certificate: dict[str, object], + campaign: dict[str, object], + admission: dict[str, object], +) -> None: + from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey + + payload = admission["payload"] + assert isinstance(payload, dict) + identity = payload["evidence_identity"] + assert isinstance(identity, dict) + old_identity_digest = MODULE.evidence_identity_sha256(identity) + identity["campaign_id"] = campaign["campaign_id"] + identity["campaign_contract_sha256"] = MODULE.canonical_sha256( + campaign["qualification_contract"] + ).removeprefix("sha256:") + identity["oracle_contract_sha256"] = MODULE.canonical_sha256( + campaign["oracle_contract"] + ).removeprefix("sha256:") + identity_digest = MODULE.evidence_identity_sha256(identity) + campaign["admission_id"] = payload["admission_id"] + campaign["runtime_validation_id"] = payload["runtime_validation_id"] + campaign["evidence_identity_sha256"] = identity_digest + qualification = certificate["qualification"] + assert isinstance(qualification, dict) + qualification["evidence_identity_sha256"] = "sha256:" + identity_digest + if identity_digest == old_identity_digest: + return + old_envelopes = campaign["receipt_envelopes"] + assert isinstance(old_envelopes, dict) + new_envelopes: dict[str, object] = {} + conditions = campaign["conditions"] + assert isinstance(conditions, list) + for condition in conditions: + assert isinstance(condition, dict) + trials = condition["trials"] + assert isinstance(trials, list) + for row in trials: + assert isinstance(row, dict) + row["admission_id"] = payload["admission_id"] + row["runtime_validation_id"] = payload["runtime_validation_id"] + row["evidence_identity_sha256"] = identity_digest + for receipt_type, row_field in MODULE._RECEIPT_ROW_FIELDS.items(): + old_digest = row[row_field] + if old_digest is None: + continue + assert isinstance(old_digest, str) + envelope = copy.deepcopy(old_envelopes[old_digest]) + assert isinstance(envelope, dict) + projection = envelope["verified_projection"] + assert isinstance(projection, dict) + projection["admission_id"] = payload["admission_id"] + projection["runtime_validation_id"] = payload["runtime_validation_id"] + projection["evidence_identity_sha256"] = identity_digest + if receipt_type == "runner": + facts = projection["facts"] + assert isinstance(facts, dict) + counter = facts["model_call_counter"] + assert isinstance(counter, dict) + counter["report_sha256"] = envelope["source_artifact_sha256"] + counter["egress_policy_sha256"] = identity[ + "network_policy_sha256" + ] + private = Ed25519PrivateKey.from_private_bytes( + bytes([20 + MODULE._RECEIPT_TYPES.index(receipt_type)]) * 32 + ) + signed = {key: envelope[key] for key in MODULE._RECEIPT_SIGNED_KEYS} + envelope["signature"] = base64.b64encode( + private.sign( + MODULE.RECEIPT_SIGNATURE_DOMAIN + + MODULE.canonical_json(signed).encode("utf-8") + ) + ).decode("ascii") + new_digest = MODULE.canonical_sha256(envelope).removeprefix("sha256:") + new_envelopes[new_digest] = envelope + row[row_field] = new_digest + campaign["receipt_envelopes"] = new_envelopes + + def _sign_admission_payload(admission: dict[str, object]) -> None: from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey @@ -117,6 +196,7 @@ def _rebind( admission: dict[str, object] | None = None, ) -> dict[str, object]: admission = admission or _admission() + _rebind_evidence_identity(certificate, campaign, admission) _resign_admission(admission, campaign) qualification = certificate["qualification"] assert isinstance(qualification, dict) @@ -733,6 +813,7 @@ def test_rejects_certificate_with_a_different_admission_digest() -> None: "field", [ "admission_id_sha256", + "campaign_id_sha256", "runtime_validation_id_sha256", "workflow_version_id_sha256", ], @@ -940,7 +1021,7 @@ def test_rejects_unknown_or_revoked_admission_signer() -> None: key_id = issuer["key_id"] assert isinstance(key_id, str) - with pytest.raises(MODULE.AcceptanceError, match="signer is not trusted"): + with pytest.raises(MODULE.AcceptanceError, match="signer registry keys differ"): _derive(admission=admission, trusted_admission_signers={}) with pytest.raises(MODULE.AcceptanceError, match="signer is revoked"): _derive(admission=admission, revoked_admission_signer_key_ids={key_id}) @@ -1114,6 +1195,11 @@ def mutate(envelope: dict[str, object]) -> None: projection = envelope["verified_projection"] assert isinstance(projection, dict) projection["evidence_sha256"] = source_digest + facts = projection["facts"] + assert isinstance(facts, dict) + counter = facts["model_call_counter"] + assert isinstance(counter, dict) + counter["report_sha256"] = source_digest _replace_receipt_envelope( campaign, @@ -1366,6 +1452,381 @@ def run(command: list[str], **_: object) -> subprocess.CompletedProcess[str]: MODULE.verify_github_attestation(certificate_path, bundle_path, "f" * 40, run=run) +@pytest.mark.parametrize( + "section,field,value", + [ + (("product", "flow"), "version", "9.9.9"), + (("product", "flow"), "release_commit", "b" * 40), + (("product", "flow"), "wheel_sha256", "sha256:" + "b" * 64), + ( + ("product", "managed_runtime"), + "manifest_sha256", + "sha256:" + "b" * 64, + ), + (("product", "managed_runtime"), "runner_build", "different-runner"), + ( + ("product", "managed_runtime"), + "runner_artifact_sha256", + "sha256:" + "b" * 64, + ), + (("product", "managed_runtime"), "playwright_version", "9.9.9"), + ( + ("product", "managed_runtime"), + "browser_base_image", + "python:3.12@sha256:" + "b" * 64, + ), + (("qualification",), "workflow_digest", "sha256:" + "b" * 64), + (("qualification",), "environment_digest", "sha256:" + "b" * 64), + ( + ("identities",), + "managed_runner_signer_sha256", + "sha256:" + "b" * 64, + ), + ], +) +def test_rejects_each_unbound_certificate_execution_identity_field( + section: tuple[str, ...], + field: str, + value: str, +) -> None: + certificate = _certificate() + target: dict[str, object] = certificate + for key in section: + next_target = target[key] + assert isinstance(next_target, dict) + target = next_target + target[field] = value + + with pytest.raises(MODULE.AcceptanceError, match="execution identity differs"): + _derive(certificate=certificate) + + +@pytest.mark.parametrize( + "field", + [ + "application_contract_sha256", + "substrate_contract_sha256", + "environment_contract_sha256", + "runtime_environment_sha256", + "runtime_contract_sha256", + "governed_authorization_template_sha256", + "input_policy_sha256", + "action_policy_sha256", + "network_policy_sha256", + "identity_contract_sha256", + "effect_contract_sha256", + "operator_contract_sha256", + ], +) +def test_rejects_each_admission_contract_outside_shared_identity(field: str) -> None: + certificate = _certificate() + admission = _admission() + payload = admission["payload"] + assert isinstance(payload, dict) + payload[field] = "9" * 64 + _sign_admission_payload(admission) + qualification = certificate["qualification"] + assert isinstance(qualification, dict) + qualification["qualification_admission_sha256"] = MODULE.canonical_sha256(admission) + + with pytest.raises(MODULE.AcceptanceError, match=f"{field} differs from admission"): + _derive(certificate=certificate, admission=admission) + + +def test_rejects_equal_raw_admission_and_runtime_validation_ids() -> None: + admission = _admission() + payload = admission["payload"] + assert isinstance(payload, dict) + payload["admission_id"] = payload["runtime_validation_id"] + + with pytest.raises(MODULE.AcceptanceError, match="equals the runtime-validation ID"): + _derive(admission=admission) + + +@pytest.mark.parametrize( + "surface", + ["campaign", "trial", "receipt"], +) +def test_rejects_raw_admission_id_mismatch_on_every_private_surface(surface: str) -> None: + certificate = _certificate() + campaign = _campaign() + replacement = "99999999-9999-4999-8999-999999999999" + if surface == "campaign": + campaign["admission_id"] = replacement + elif surface == "trial": + _trial(campaign)["admission_id"] = replacement + else: + _replace_receipt_envelope( + campaign, + receipt_type="runner", + mutate=lambda envelope: envelope["verified_projection"].__setitem__( + "admission_id", replacement + ), + resign=True, + ) + admission = _admission() if surface == "campaign" else _rebind(certificate, campaign) + + with pytest.raises(MODULE.AcceptanceError, match="admission|projection"): + _derive(certificate, campaign, admission) + + +@pytest.mark.parametrize("surface", ["campaign", "trial", "receipt"]) +def test_rejects_shared_identity_mismatch_on_every_private_surface(surface: str) -> None: + certificate = _certificate() + campaign = _campaign() + if surface == "campaign": + campaign["evidence_identity_sha256"] = "0" * 64 + elif surface == "trial": + _trial(campaign)["evidence_identity_sha256"] = "0" * 64 + else: + _replace_receipt_envelope( + campaign, + receipt_type="observer", + mutate=lambda envelope: envelope["verified_projection"].__setitem__( + "evidence_identity_sha256", "0" * 64 + ), + resign=True, + ) + admission = _admission() if surface == "campaign" else _rebind(certificate, campaign) + + with pytest.raises(MODULE.AcceptanceError, match="evidence identity|projection"): + _derive(certificate, campaign, admission) + + +def test_rejects_mixed_old_campaign_and_new_certificate_identity() -> None: + certificate = _certificate() + campaign = _campaign() + admission = _admission() + payload = admission["payload"] + assert isinstance(payload, dict) + identity = payload["evidence_identity"] + assert isinstance(identity, dict) + runtime = identity["runtime_build_identity"] + assert isinstance(runtime, dict) + runtime["flow_version"] = "9.9.9" + identity_digest = MODULE.evidence_identity_sha256(identity) + certificate["product"]["flow"]["version"] = "9.9.9" + certificate["qualification"]["evidence_identity_sha256"] = "sha256:" + identity_digest + _sign_admission_payload(admission) + certificate["qualification"]["qualification_admission_sha256"] = ( + MODULE.canonical_sha256(admission) + ) + + with pytest.raises(MODULE.AcceptanceError, match="campaign evidence identity differs"): + _derive(certificate, campaign, admission) + + +def test_rejects_identity_that_selects_more_than_one_runtime_detail() -> None: + admission = _admission() + identity = admission["payload"]["evidence_identity"] + runtime = identity["runtime_build_identity"] + runtime["native_desktop"] = { + "desktop_version": "1.0.0", + "desktop_release_commit": "a" * 40, + "desktop_artifact_sha256": "a" * 64, + "os_family": "windows", + "runtime_boundary_sha256": "b" * 64, + } + + with pytest.raises(MODULE.AcceptanceError, match="exactly one substrate detail"): + _derive(admission=admission) + + +def test_rejects_fixed_admission_policy_digest_mutation() -> None: + admission = _admission() + admission["payload"]["evidence_identity"]["admission_policy_sha256"] = "0" * 64 + + with pytest.raises(MODULE.AcceptanceError, match="admission policy differs"): + _derive(admission=admission) + + +def test_rejects_signer_registry_digest_and_lifetime_mutations() -> None: + registry = _admission_trust() + registry["revision"] = 2 + with pytest.raises(MODULE.AcceptanceError, match="registry differs from admission"): + _derive(trusted_admission_signers=registry) + + registry = _admission_trust() + registry["expires_at"] = "2026-08-26T11:50:01Z" + with pytest.raises(MODULE.AcceptanceError, match="registry lifetime is invalid"): + _derive(trusted_admission_signers=registry) + + +def test_rejects_signer_registry_revision_substitution_in_admission() -> None: + admission = _admission() + admission["payload"]["evidence_identity"][ + "qualification_signer_registry_revision" + ] = 2 + + with pytest.raises( + MODULE.AcceptanceError, + match="registry revision differs from admission", + ): + _derive(admission=admission) + + +def _replace_healthy_observer_effect_facts( + campaign: dict[str, object], + failure: str, +) -> None: + def mutate(envelope: dict[str, object]) -> None: + projection = envelope["verified_projection"] + assert isinstance(projection, dict) + facts = projection["facts"] + assert isinstance(facts, dict) + expected_record = facts["expected_record_id_sha256"] + expected_transaction = facts["expected_transaction_ref_sha256"] + effects = facts["effect_inventory"] + assert isinstance(effects, list) + if failure == "wrong_record": + facts["effect_inventory"] = [ + { + "effect_id_sha256": "8" * 64, + "record_id_sha256": "9" * 64, + "transaction_ref_sha256": expected_transaction, + } + ] + facts["derived_classifications"] = { + "intended_effect_count": 0, + "wrong_record_count": 1, + "duplicate_effect_count": 0, + "collateral_effect_count": 0, + } + elif failure == "duplicate_effect": + effects.append( + { + "effect_id_sha256": "8" * 64, + "record_id_sha256": expected_record, + "transaction_ref_sha256": expected_transaction, + } + ) + facts["derived_classifications"] = { + "intended_effect_count": 2, + "wrong_record_count": 0, + "duplicate_effect_count": 1, + "collateral_effect_count": 0, + } + else: + effects.append( + { + "effect_id_sha256": "8" * 64, + "record_id_sha256": expected_record, + "transaction_ref_sha256": "9" * 64, + } + ) + facts["derived_classifications"] = { + "intended_effect_count": 1, + "wrong_record_count": 0, + "duplicate_effect_count": 0, + "collateral_effect_count": 1, + } + + _replace_receipt_envelope( + campaign, + receipt_type="observer", + mutate=mutate, + resign=True, + ) + _trial(campaign)["failure_class"] = failure + + +@pytest.mark.parametrize( + "failure", + ["wrong_record", "duplicate_effect", "collateral_effect"], +) +def test_rejects_each_effect_failure_derived_from_signed_inventory(failure: str) -> None: + certificate = _certificate() + campaign = _campaign() + _replace_healthy_observer_effect_facts(campaign, failure) + admission = _rebind(certificate, campaign) + + with pytest.raises(MODULE.AcceptanceError, match="production-acceptance failures") as exc: + _derive(certificate, campaign, admission) + assert failure in str(exc.value) + + +def test_rejects_operator_intervention_derived_from_signed_inventory() -> None: + certificate = _certificate() + campaign = _campaign() + + def mutate(envelope: dict[str, object]) -> None: + facts = envelope["verified_projection"]["facts"] + facts["operator_intervention_ids_sha256"] = ["8" * 64] + + _replace_receipt_envelope( + campaign, receipt_type="runner", mutate=mutate, resign=True + ) + _trial(campaign)["failure_class"] = "operator_intervention" + admission = _rebind(certificate, campaign) + + with pytest.raises(MODULE.AcceptanceError, match="operator_intervention"): + _derive(certificate, campaign, admission) + + +def _add_signed_model_call(campaign: dict[str, object], *, condition: int) -> None: + def mutate(envelope: dict[str, object]) -> None: + facts = envelope["verified_projection"]["facts"] + counter = facts["model_call_counter"] + counter.update( + { + "attempted": 1, + "completed": 1, + "input_tokens": 10, + "output_tokens": 5, + "cost_microusd": 2, + "call_ids_sha256": ["8" * 64], + "provider_models": [{"provider": "fixture", "model": "fixture-v1"}], + } + ) + + _replace_receipt_envelope( + campaign, + receipt_type="runner", + mutate=mutate, + resign=True, + condition=condition, + ) + + +def test_rejects_healthy_path_model_call_derived_from_signed_counter() -> None: + certificate = _certificate() + campaign = _campaign() + _add_signed_model_call(campaign, condition=0) + _trial(campaign)["failure_class"] = "healthy_path_model_call" + admission = _rebind(certificate, campaign) + + with pytest.raises(MODULE.AcceptanceError, match="healthy_path_model_call"): + _derive(certificate, campaign, admission) + + +def test_counts_governed_halt_model_call_instead_of_hard_coding_zero() -> None: + certificate = _certificate() + campaign = _campaign() + _add_signed_model_call(campaign, condition=4) + admission = _rebind(certificate, campaign) + + result = _derive(certificate, campaign, admission) + + assert result["reliability"]["model_call_count"] == 1 + + +def test_rejects_declared_effect_classification_not_derived_from_inventory() -> None: + certificate = _certificate() + campaign = _campaign() + + def mutate(envelope: dict[str, object]) -> None: + facts = envelope["verified_projection"]["facts"] + facts["derived_classifications"]["wrong_record_count"] = 1 + + _replace_receipt_envelope( + campaign, receipt_type="observer", mutate=mutate, resign=True + ) + admission = _rebind(certificate, campaign) + + with pytest.raises(MODULE.AcceptanceError, match="differ from its inventory"): + _derive(certificate, campaign, admission) + + def test_mutation_helpers_do_not_modify_committed_fixtures() -> None: certificate = _certificate() campaign = _campaign() diff --git a/tests/test_published_evidence_freshness.py b/tests/test_published_evidence_freshness.py index 85505db..e52e179 100644 --- a/tests/test_published_evidence_freshness.py +++ b/tests/test_published_evidence_freshness.py @@ -328,6 +328,32 @@ def test_evidence_binding_refuses_any_bound_file_mutation(tmp_path: Path, path: assert MODULE.check_evidence_manifest(entry, tmp_path) +def test_safe_file_rejects_leaf_symlink_to_external_private_file(tmp_path: Path) -> None: + repo_root = tmp_path / "repo" + outside = tmp_path / "private" + repo_root.mkdir() + outside.mkdir() + private_campaign = outside / "qualification-campaign.json" + private_campaign.write_text("{}\n", encoding="utf-8") + (repo_root / "campaign.json").symlink_to(private_campaign) + + assert MODULE._safe_file(repo_root, "campaign.json") is None + + +def test_safe_file_rejects_parent_directory_symlink(tmp_path: Path) -> None: + repo_root = tmp_path / "repo" + outside = tmp_path / "private" + repo_root.mkdir() + outside.mkdir() + (outside / "qualification-admission.json").write_text("{}\n", encoding="utf-8") + (repo_root / "linked-private").symlink_to(outside, target_is_directory=True) + + assert ( + MODULE._safe_file(repo_root, "linked-private/qualification-admission.json") + is None + ) + + def test_campaign_cannot_promote_numeric_metrics_to_production(tmp_path: Path) -> None: entry, manifest_path, binding = _valid_bound_evidence(tmp_path) result_path = tmp_path / "evidence" / "results.json" From 49a69a5b2ae6a752a385ae651caccb6e754bcbe3 Mon Sep 17 00:00:00 2001 From: abrichr Date: Tue, 18 Aug 2026 15:29:45 -0400 Subject: [PATCH 3/4] Align acceptance identity grammar with Cloud --- scripts/import_production_acceptance.py | 21 ++++----- tests/test_import_production_acceptance.py | 53 ++++++++++++++++++++++ 2 files changed, 61 insertions(+), 13 deletions(-) diff --git a/scripts/import_production_acceptance.py b/scripts/import_production_acceptance.py index 92f7dec..2bb0f94 100644 --- a/scripts/import_production_acceptance.py +++ b/scripts/import_production_acceptance.py @@ -67,6 +67,7 @@ _SEMVER = re.compile(r"^[0-9]+\.[0-9]+\.[0-9]+(?:[-+][0-9A-Za-z.-]+)?$") _POSITIVE_DECIMAL = re.compile(r"^[1-9][0-9]*$") _UNPREFIXED_SHA256 = re.compile(r"^[a-f0-9]{64}$") +_PINNED_IMAGE = re.compile(r"^[a-z0-9][a-z0-9._/:-]{0,255}@sha256:[a-f0-9]{64}$") _ADMISSION_REF = re.compile(r"^refs/heads/main@[a-f0-9]{40}$") _ADMISSION_KEY_ID = re.compile(r"^qa-ed25519-[a-f0-9]{16}$") _RECEIPT_KEY_ID = re.compile(r"^qe-ed25519-[a-f0-9]{16}$") @@ -669,7 +670,11 @@ def _canonical_uuid(value: Any, label: str) -> str: parsed = uuid.UUID(value) except ValueError as exc: raise AcceptanceError(f"{label} must be a canonical UUID") from exc - if str(parsed) != value: + if ( + str(parsed) != value + or parsed.variant != uuid.RFC_4122 + or parsed.version not in range(1, 9) + ): raise AcceptanceError(f"{label} must be a canonical UUID") return value @@ -762,12 +767,7 @@ def _validate_evidence_identity( detail["browser_base_image"], "qualification evidence identity browser image", ) - image_name, separator, image_digest = browser_image.rpartition("@sha256:") - if ( - not image_name - or separator != "@sha256:" - or _UNPREFIXED_SHA256.fullmatch(image_digest) is None - ): + if _PINNED_IMAGE.fullmatch(browser_image) is None: raise AcceptanceError( "qualification evidence identity browser image is not digest-pinned" ) @@ -1316,10 +1316,7 @@ def _validate_certificate( ) is None: raise AcceptanceError("certificate Playwright version is not exact") browser_image = _nonempty(runtime["browser_base_image"], "certificate browser image") - image_name, separator, image_digest = browser_image.rpartition("@sha256:") - if not image_name or separator != "@sha256:" or re.fullmatch( - r"[a-f0-9]{64}", image_digest - ) is None: + if _PINNED_IMAGE.fullmatch(browser_image) is None: raise AcceptanceError("certificate browser image is not digest-pinned") qualification = _closed( @@ -2064,8 +2061,6 @@ def _validate_campaign( if campaign["schema_version"] != CAMPAIGN_SCHEMA: raise AcceptanceError("campaign schema is not supported") campaign_id = _canonical_uuid(campaign["campaign_id"], "campaign ID") - if uuid.UUID(campaign_id).version != 4: - raise AcceptanceError("campaign ID must be a UUIDv4") if campaign["decision"] != "admitted": raise AcceptanceError("campaign decision is not admitted") for key in ("admission_id", "runtime_validation_id"): diff --git a/tests/test_import_production_acceptance.py b/tests/test_import_production_acceptance.py index 87b438e..edc9d50 100644 --- a/tests/test_import_production_acceptance.py +++ b/tests/test_import_production_acceptance.py @@ -745,6 +745,9 @@ def test_rejects_unhashed_workflow_binding() -> None: "python:3.11-slim@sha256:" + "g" * 64, "@sha256:" + "4" * 64, "python:3.11@sha256:" + "4" * 64 + "-suffix", + "Python:3.11-slim@sha256:" + "4" * 64, + "python:3.11-SLIM@sha256:" + "4" * 64, + "python :3.11-slim@sha256:" + "4" * 64, ], ) def test_rejects_malformed_browser_image_digest(image: str) -> None: @@ -755,6 +758,50 @@ def test_rejects_malformed_browser_image_digest(image: str) -> None: _derive(certificate) +@pytest.mark.parametrize( + "image", + [ + "Python:3.11-slim@sha256:" + "4" * 64, + "python:3.11-SLIM@sha256:" + "4" * 64, + "python:3.11-slim@sha256:" + "A" * 64, + "python:3.11-slim @sha256:" + "4" * 64, + ], +) +def test_rejects_noncanonical_browser_image_in_admitted_runtime(image: str) -> None: + admission = _admission() + admission["payload"]["evidence_identity"]["runtime_build_identity"][ + "managed_browser" + ]["browser_base_image"] = image + + with pytest.raises(MODULE.AcceptanceError, match="browser image is not digest-pinned"): + _derive(admission=admission) + + +@pytest.mark.parametrize( + "value", + [ + "11111111-1111-1111-8111-111111111111", + "88888888-8888-8888-8888-888888888888", + ], +) +def test_accepts_canonical_rfc_uuid_versions_one_through_eight(value: str) -> None: + assert MODULE._canonical_uuid(value, "test UUID") == value + + +@pytest.mark.parametrize( + "value", + [ + "11111111-1111-4111-8111-11111111111A", + "11111111-1111-0111-8111-111111111111", + "11111111-1111-9111-8111-111111111111", + "11111111-1111-4111-7111-111111111111", + ], +) +def test_rejects_uuid_outside_cloud_canonical_rfc_grammar(value: str) -> None: + with pytest.raises(MODULE.AcceptanceError, match="must be a canonical UUID"): + MODULE._canonical_uuid(value, "test UUID") + + def test_rejects_unknown_certificate_fields() -> None: certificate = _certificate() certificate["production_ready"] = True @@ -1640,6 +1687,12 @@ def test_rejects_fixed_admission_policy_digest_mutation() -> None: _derive(admission=admission) +def test_fixed_admission_policy_digest_matches_cloud_v2() -> None: + assert MODULE.admission_policy_sha256() == ( + "2d3969d8c5fcfe0c0a967f775562802ca20b6598a8a3199185d0da6b7a36fb6b" + ) + + def test_rejects_signer_registry_digest_and_lifetime_mutations() -> None: registry = _admission_trust() registry["revision"] = 2 From d8e0d4fbad9a6b95ec23410b81ff05dd07d03ac3 Mon Sep 17 00:00:00 2001 From: Richard Abrich Date: Tue, 18 Aug 2026 16:49:23 -0400 Subject: [PATCH 4/4] feat: build target-neutral production acceptance manifest from verified evidence - Rename the shared signer field to evidence_runner_signer_sha256 across the importer, derived-result bindings, fixtures, tests, and docs so the identity grammar matches Cloud evidence v2. - Bind campaign-outcomes and oracle-contract digests plus validated task, condition, required-trial, and observed-trial counts into the derived result; report task and condition identities as campaign-scoped hashes and keep all eleven failure-taxonomy counts. - Add a pure, I/O-free builder and validator for the closed openadapt.production-acceptance/v1 manifest with a fixed target->claim scope map, two separate policy digests, and a Flow lifecycle release verifier that binds raw policy bytes, the exact commit URL, and one sorted PyPI sdist+wheel into an immutable verified-release object. - Cloud stays fail-closed until a reviewed deployment-manifest binding exists; other targets refuse without their own evidence adapter. - Export/import of real evidence stays disabled. Tests: 265 focused (acceptance importer + evidence freshness) pass; full CI suite 2410 passed, 56 skipped; ruff, source-boundary check, and git diff --check pass. Co-Authored-By: Claude Fable 5 --- docs/eval_results/PRODUCTION_READINESS.md | 60 + scripts/import_production_acceptance.py | 1064 ++- .../live-certificate.json | 10 +- .../qualification-admission.json | 8 +- .../qualification-campaign.json | 5980 ++++++++--------- tests/test_import_production_acceptance.py | 815 ++- 6 files changed, 4907 insertions(+), 3030 deletions(-) diff --git a/docs/eval_results/PRODUCTION_READINESS.md b/docs/eval_results/PRODUCTION_READINESS.md index 9173921..6d0549c 100644 --- a/docs/eval_results/PRODUCTION_READINESS.md +++ b/docs/eval_results/PRODUCTION_READINESS.md @@ -89,6 +89,11 @@ condition in the bound qualification contract and at least three unique trials for each condition. Trial indexes are one-based and contiguous. Attempt IDs and run IDs cannot repeat. An excluded or hidden trial causes refusal. +The shared identity calls the receipt authority +`evidence_runner_signer_sha256`. This name applies to browser, native Desktop, +BYOC, RDP, Citrix, and offline customer-controlled evidence. It does not imply +that the evidence runner is an OpenAdapt-managed browser runner. + Each `openadapt.qualification-trial-row/v2` trial refers to hash-keyed `openadapt.qualification-evidence-receipt/v2` Ed25519 envelopes for the runner, independent observer, webhook, replay, cleanup, and cleanup-absence result. @@ -108,6 +113,59 @@ that permits a model call, healthy-path model call, silent incorrect success, over-halt, wrong-record effect, duplicate effect, collateral effect, uncertain delivery, platform failure, or operator intervention. +The derived result binds the certificate's campaign-outcomes and independent +oracle-contract digests. It repeats the validated task, condition, required +trial, and observed trial counts. It includes every closed failure-taxonomy +count used for the verdict. Task and condition identities use domain-separated +SHA-256 values. The public result does not contain the private task or condition +labels. The derived-result file digest therefore changes after a one-field +change to a binding, count, or privacy-safe identity. + +## Target-neutral acceptance manifest + +The importer contains a pure builder and validator for the closed +`openadapt.production-acceptance/v1` manifest. The mechanism does not write, +sign, export, attest, or publish a manifest. It accepts only a complete accepted +private result. It binds the target and its exact claim scope in both the fixed +policy and the manifest. + +| Target | Exact claim scope | +| --- | --- | +| `agent` | `qualified_agent_bridge_release` | +| `capture` | `qualified_native_recorder_release` | +| `cloud` | `qualified_workflow_control_plane_deployment` | +| `desktop` | `qualified_native_workflow_desktop_release` | +| `docs` | `production_documentation_deployment` | +| `flow` | `qualified_workflow_runtime_release` | +| `openadapt` | `qualified_workflow_launcher_release` | + +The current browser evidence adapter can build only the Flow target manifest. +The other targets require their own evidence adapter. Cloud also requires a +reviewed deployment-manifest binding. The builder refuses Cloud until that +binding exists. It does not emit a placeholder or failed record when an adapter +is absent. + +For Flow, a separate lifecycle verifier accepts the exact raw lifecycle-policy +bytes, one closed public-package release, and the PyPI release metadata. It +requires the exact GitHub source-commit URL. It requires one sorted sdist and +one wheel. Each artifact includes its authority, kind, name, URL, size, and +SHA-256 digest. The verifier matches each field to exactly one non-yanked PyPI +file. It then returns an immutable verified-release object. A caller-supplied +mapping or digest cannot replace this object. + +The pure manifest builder accepts only this verified-release object. It matches +the Flow version, source commit, and wheel digest to the private result. It +binds the complete sdist and wheel inventory. It uses the same release and +artifact digest domains as the Production lifecycle validator. The manifest +contains two separate policy digests. The acceptance-policy digest covers the +fixed Evals acceptance rules. The lifecycle-policy digest covers the exact raw +lifecycle-policy bytes. + +The public qualification section contains aggregate trial counts and one +campaign-scoped task-condition inventory digest. It does not publish task or +condition labels. The closed source-result digest remains the authority for the +hidden per-condition inventory. + When the private-export gate opens, the output claim will be only `qualified_browser_workflow_on_bound_environment`. It is not a general product production-readiness claim. The checker can accept `production_acceptance: true` @@ -127,6 +185,8 @@ retention alone does not satisfy this contract. ## What the current public Evals set establishes The Flow 1.31.0 set contains four campaigns. Every condition has three trials. +This set is development evidence. It is not a Production lifecycle admission, +and this change does not emit a Production record for it. | Campaign | Environment | What it measures | Production acceptance | | --- | --- | --- | --- | diff --git a/scripts/import_production_acceptance.py b/scripts/import_production_acceptance.py index 2bb0f94..b59fbb9 100644 --- a/scripts/import_production_acceptance.py +++ b/scripts/import_production_acceptance.py @@ -29,12 +29,34 @@ from datetime import datetime, timedelta, timezone from pathlib import Path from typing import Any, Callable, Mapping, Sequence +from urllib.parse import urlsplit CERTIFICATE_SCHEMA = "openadapt.execute-live-acceptance-record/v2" CAMPAIGN_SCHEMA = "openadapt.qualification-campaign/v2" TRIAL_SCHEMA = "openadapt.qualification-trial-row/v2" RESULT_SCHEMA = "openadapt.evals-derived-production-acceptance/v1" CLAIM_SCOPE = "qualified_browser_workflow_on_bound_environment" +PRODUCTION_ACCEPTANCE_SCHEMA = "openadapt.production-acceptance/v1" +PRODUCTION_ACCEPTANCE_POLICY_SCHEMA = "openadapt.production-acceptance-policy/v1" +PRODUCTION_ACCEPTANCE_POLICY_DOMAIN = b"OpenAdapt production acceptance policy v1\0" +PRODUCTION_LIFECYCLE_POLICY_SCHEMA = "openadapt.production-lifecycle-policy/v1" +PRODUCTION_LIFECYCLE_POLICY_PATH = "schemas/production-lifecycle-policy.schema.json" +PRODUCTION_LIFECYCLE_TARGET_RELEASE_DOMAIN = ( + b"OpenAdapt production lifecycle target release v1\0" +) +PRODUCTION_LIFECYCLE_ARTIFACT_INVENTORY_DOMAIN = ( + b"OpenAdapt production lifecycle artifact inventory v1\0" +) +PRODUCTION_ACCEPTANCE_TARGET_SCOPES = { + "agent": "qualified_agent_bridge_release", + "capture": "qualified_native_recorder_release", + "cloud": "qualified_workflow_control_plane_deployment", + "desktop": "qualified_native_workflow_desktop_release", + "docs": "production_documentation_deployment", + "flow": "qualified_workflow_runtime_release", + "openadapt": "qualified_workflow_launcher_release", +} +_BROWSER_SOURCE_TARGETS = {"cloud", "flow"} ADMISSION_SCHEMA = "openadapt.qualification-admission/v2" ADMISSION_SIGNATURE_DOMAIN_TEXT = "openadapt-qualification-admission-v2\\0" ADMISSION_SIGNATURE_DOMAIN = b"openadapt-qualification-admission-v2\0" @@ -74,6 +96,7 @@ _WHOLE_SECOND_UTC = re.compile( r"^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}Z$" ) +_ARTIFACT_NAME = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._+-]{0,127}$") _CERTIFICATE_KEYS = { "schema_version", @@ -172,7 +195,7 @@ "producer", "target_observer_signer_sha256", "target_attestation_signer_sha256", - "managed_runner_signer_sha256", + "evidence_runner_signer_sha256", "organization_id_sha256", "workflow_id_sha256", "verifier", @@ -214,6 +237,52 @@ "acceptance_verified_at", "provenance_attestation", } +_PRODUCTION_ACCEPTANCE_KEYS = { + "schema_version", + "target", + "claim_scope", + "verdict", + "acceptance_policy_sha256", + "lifecycle_policy_sha256", + "target_release_sha256", + "target_artifact_inventory_sha256", + "evidence_identity_sha256", + "source_evidence", + "qualification", + "failure_taxonomy_counts", + "reliability", + "retention", +} +_PRODUCTION_SOURCE_EVIDENCE_KEYS = { + "source_result_sha256", + "certificate_sha256", + "campaign_sha256", + "qualification_admission_sha256", + "attestation_sha256", + "attestation_bundle_sha256", +} +_PRODUCTION_QUALIFICATION_KEYS = { + "campaign_contract_sha256", + "campaign_outcomes_sha256", + "oracle_contract_sha256", + "task_count", + "condition_count", + "required_trial_count", + "observed_trial_count", + "minimum_trials_per_condition", + "excluded_trial_count", + "task_condition_inventory_sha256", +} +_RELIABILITY_KEYS = { + "silent_incorrect_success_count", + "over_halt_count", + "wrong_record_count", + "duplicate_effect_count", + "collateral_effect_count", + "operator_intervention_count", + "uncertain_delivery_count", + "model_call_count", +} _CAMPAIGN_KEYS = { "schema_version", @@ -397,7 +466,7 @@ _EVIDENCE_IDENTITY_KEYS = { "schema_version", "runtime_build_identity", - "managed_runner_signer_sha256", + "evidence_runner_signer_sha256", "tenant_id", "workflow_id", "workflow_version_id", @@ -548,6 +617,76 @@ "healthy_path_model_call", ) _PRODUCTION_FAILURES = set(_FAILURE_TAXONOMY) - {"verified", "safe_halt"} +_DERIVED_RESULT_KEYS = { + "schema_version", + "verdict", + "evidence_class", + "claim_scope", + "bindings", + "source_evidence", + "trial_inventory", + "derived_outcomes", + "reliability", + "retention", + "claim_limit", +} +_DERIVED_BINDING_KEYS = { + "runtime_validation_id_sha256", + "admission_id_sha256", + "campaign_id_sha256", + "workflow_version_id_sha256", + "workflow_digest", + "environment_digest", + "evidence_identity_sha256", + "cloud_source_commit", + "cloud_target_build_sha256", + "flow_version", + "flow_release_commit", + "flow_wheel_sha256", + "managed_runtime_manifest_sha256", + "runner_artifact_sha256", + "runner_build", + "substrate", + "playwright_version", + "browser_base_image", + "campaign_contract_sha256", + "campaign_outcomes_sha256", + "oracle_contract_sha256", + "task_count", + "condition_count", + "required_trial_count", + "observed_trial_count", + "evidence_runner_signer_sha256", + "target_attestation_signer_sha256", + "target_observer_signer_sha256", + "target_attestation_sha256", + "organization_id_sha256", + "workflow_id_sha256", +} +_DERIVED_SOURCE_EVIDENCE_KEYS = { + "certificate_sha256", + "campaign_sha256", + "qualification_admission_sha256", + "qualification_authority", + "attestation", + "approved_cloud_source_commit", +} +_DERIVED_TRIAL_INVENTORY_KEYS = { + "task_count", + "condition_count", + "required_trial_count", + "observed_trial_count", + "trial_count", + "minimum_trials_per_condition", + "conditions", + "excluded_trial_count", +} +_DERIVED_CONDITION_KEYS = { + "task_id_sha256", + "condition_id_sha256", + "required_trial_count", + "observed_trial_count", +} class AcceptanceError(ValueError): @@ -560,6 +699,61 @@ def canonical_json(value: Any) -> str: return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":")) +class VerifiedProductionLifecycleRelease: + """An immutable release that passed the lifecycle and authority checks.""" + + __slots__ = ( + "_artifacts_json", + "_claim_scope", + "_lifecycle_policy_sha256", + "_release_json", + "_target", + ) + _CONSTRUCTION_SEAL = object() + + def __init__( + self, + *, + target: str, + claim_scope: str, + lifecycle_policy_sha256: str, + release: Mapping[str, Any], + artifacts: Sequence[Mapping[str, Any]], + _seal: object, + ) -> None: + if _seal is not self._CONSTRUCTION_SEAL: + raise TypeError( + "VerifiedProductionLifecycleRelease can only be created by the " + "lifecycle verifier" + ) + object.__setattr__(self, "_target", target) + object.__setattr__(self, "_claim_scope", claim_scope) + object.__setattr__(self, "_lifecycle_policy_sha256", lifecycle_policy_sha256) + object.__setattr__(self, "_release_json", canonical_json(release)) + object.__setattr__(self, "_artifacts_json", canonical_json(artifacts)) + + def __setattr__(self, name: str, value: object) -> None: + raise AttributeError("verified lifecycle releases are immutable") + + @property + def target(self) -> str: + return self._target + + @property + def claim_scope(self) -> str: + return self._claim_scope + + @property + def lifecycle_policy_sha256(self) -> str: + return self._lifecycle_policy_sha256 + + def release(self) -> dict[str, Any]: + return json.loads(self._release_json) + + def artifacts(self) -> list[dict[str, Any]]: + return json.loads(self._artifacts_json) + + def canonical_sha256(value: Any) -> str: return "sha256:" + hashlib.sha256(canonical_json(value).encode("utf-8")).hexdigest() @@ -608,6 +802,60 @@ def admission_policy_sha256() -> str: ).hexdigest() +def production_acceptance_policy() -> dict[str, Any]: + """Return the fixed target-neutral public-manifest policy.""" + + return { + "schema_version": PRODUCTION_ACCEPTANCE_POLICY_SCHEMA, + "manifest_schema": PRODUCTION_ACCEPTANCE_SCHEMA, + "source_result_schema": RESULT_SCHEMA, + "accepted_verdict": "accepted", + "target_claim_scopes": dict(sorted(PRODUCTION_ACCEPTANCE_TARGET_SCOPES.items())), + "failure_taxonomy": sorted(_FAILURE_TAXONOMY), + "minimum_trials_per_condition": 3, + "excluded_trial_count": 0, + "zero_failure_counts_required": sorted(_PRODUCTION_FAILURES), + "required_retention_mode": "COMPLIANCE", + "required_retention_provenance": "github-artifact-attestation-v4", + "minimum_retention_days": 365, + "maximum_retention_days": 3650, + "browser_evidence_target_set": sorted(_BROWSER_SOURCE_TARGETS), + "enabled_browser_builder_targets": ["flow"], + "pending_target_bindings": { + "cloud": "reviewed_deployment_manifest_binding_required" + }, + "release_binding_rules": { + "flow": "verified_lifecycle_public_package_sdist_and_wheel_v1", + "cloud": "private_deployment_release_and_reviewed_manifest_v1", + }, + "acceptance_policy_digest": "domain-separated-canonical-json-sha256-v1", + "lifecycle_policy_digest": "exact-raw-bytes-sha256-v1", + "target_release_digest_domain": ( + "OpenAdapt production lifecycle target release v1\\0" + ), + "artifact_inventory_digest_domain": ( + "OpenAdapt production lifecycle artifact inventory v1\\0" + ), + "lifecycle_authority_metadata_required": True, + "complete_source_result_required": True, + "target_evidence_adapter_required": True, + "privacy_safe_task_condition_identity_required": True, + } + + +def production_acceptance_policy_sha256() -> str: + return "sha256:" + hashlib.sha256( + PRODUCTION_ACCEPTANCE_POLICY_DOMAIN + + canonical_json(production_acceptance_policy()).encode("utf-8") + ).hexdigest() + + +def _domain_sha256(domain: bytes, value: Any) -> str: + return "sha256:" + hashlib.sha256( + domain + canonical_json(value).encode("utf-8") + ).hexdigest() + + def file_sha256(path: Path) -> str: return "sha256:" + hashlib.sha256(path.read_bytes()).hexdigest() @@ -619,6 +867,25 @@ def opaque_binding_sha256(domain: str, value: str) -> str: return "sha256:" + hashlib.sha256(payload).hexdigest() +def privacy_safe_campaign_label_sha256( + label_kind: str, + campaign_id: str, + value: str, +) -> str: + """Bind a private task or condition label without publishing the label.""" + + domain = f"OpenAdapt acceptance private {label_kind} identity v1\0".encode( + "utf-8" + ) + payload = canonical_json( + { + "campaign_id": campaign_id, + "value": value, + } + ).encode("utf-8") + return "sha256:" + hashlib.sha256(domain + payload).hexdigest() + + def _mapping(value: Any, label: str) -> Mapping[str, Any]: if not isinstance(value, dict): raise AcceptanceError(f"{label} must be an object") @@ -803,7 +1070,7 @@ def _validate_evidence_identity( }: _canonical_uuid(identity[key], f"qualification evidence identity {key}") for key in { - "managed_runner_signer_sha256", + "evidence_runner_signer_sha256", "workflow_digest", "bundle_artifact_sha256", "bundle_content_digest", @@ -1429,8 +1696,8 @@ def _validate_certificate( "certificate target attestation signer", ) runner_signer = _digest( - identities["managed_runner_signer_sha256"], - "certificate managed runner signer", + identities["evidence_runner_signer_sha256"], + "certificate evidence runner signer", ) _digest(identities["organization_id_sha256"], "certificate organization identity") _digest(identities["workflow_id_sha256"], "certificate workflow identity") @@ -1708,8 +1975,14 @@ def _binding_pairs(certificate: Mapping[str, Any]) -> dict[str, Any]: "playwright_version": product["managed_runtime"]["playwright_version"], "browser_base_image": product["managed_runtime"]["browser_base_image"], "campaign_contract_sha256": qualification["campaign_contract_sha256"], - "managed_runner_signer_sha256": certificate["identities"][ - "managed_runner_signer_sha256" + "campaign_outcomes_sha256": qualification["campaign_outcomes_sha256"], + "oracle_contract_sha256": qualification["oracle_contract_sha256"], + "task_count": qualification["task_count"], + "condition_count": qualification["condition_count"], + "required_trial_count": qualification["required_trial_count"], + "observed_trial_count": qualification["observed_trial_count"], + "evidence_runner_signer_sha256": certificate["identities"][ + "evidence_runner_signer_sha256" ], "target_attestation_signer_sha256": certificate["identities"][ "target_attestation_signer_sha256" @@ -2095,7 +2368,7 @@ def _validate_campaign( authorities = _validate_authority_contract(campaign["authority_contract"]) runner_public_key = authorities["runner"][1] runner_fingerprint = hashlib.sha256(runner_public_key).hexdigest() - if runner_fingerprint != evidence_identity["managed_runner_signer_sha256"]: + if runner_fingerprint != evidence_identity["evidence_runner_signer_sha256"]: raise AcceptanceError("campaign runner signer differs from admission") envelopes = _mapping(campaign["receipt_envelopes"], "campaign receipt envelopes") for digest in envelopes: @@ -2672,8 +2945,8 @@ def derive_production_acceptance( "environment_digest": certificate["qualification"][ "environment_digest" ].removeprefix("sha256:"), - "managed_runner_signer_sha256": certificate["identities"][ - "managed_runner_signer_sha256" + "evidence_runner_signer_sha256": certificate["identities"][ + "evidence_runner_signer_sha256" ].removeprefix("sha256:"), } expected_identity_projection = { @@ -2688,8 +2961,8 @@ def derive_production_acceptance( "browser_base_image": managed_browser["browser_base_image"], "workflow_digest": evidence_identity["workflow_digest"], "environment_digest": evidence_identity["environment_digest"], - "managed_runner_signer_sha256": evidence_identity[ - "managed_runner_signer_sha256" + "evidence_runner_signer_sha256": evidence_identity[ + "evidence_runner_signer_sha256" ], } if certificate_identity_projection != expected_identity_projection: @@ -2777,6 +3050,26 @@ def derive_production_acceptance( ) counted_taxonomy = {name: taxonomy.get(name, 0) for name in _FAILURE_TAXONOMY} total_trials = observed_trial_count + privacy_safe_conditions = [ + { + "task_id_sha256": privacy_safe_campaign_label_sha256( + "qualification task", + campaign["campaign_id"], + campaign["qualification_contract"]["task_id"], + ), + "condition_id_sha256": privacy_safe_campaign_label_sha256( + "qualification condition", + campaign["campaign_id"], + condition["condition_id"], + ), + "required_trial_count": condition["required_trials"], + "observed_trial_count": trials_per_condition[condition["condition_id"]], + } + for condition in sorted( + campaign["conditions"], + key=lambda value: value["condition_id"], + ) + ] return { "schema_version": RESULT_SCHEMA, "verdict": "accepted", @@ -2792,10 +3085,13 @@ def derive_production_acceptance( "approved_cloud_source_commit": expected_cloud_source_commit, }, "trial_inventory": { + "task_count": expected_certificate_counts["task_count"], "condition_count": len(trials_per_condition), + "required_trial_count": required_trial_count, + "observed_trial_count": observed_trial_count, "trial_count": total_trials, "minimum_trials_per_condition": min(trials_per_condition.values()), - "trials_per_condition": dict(sorted(trials_per_condition.items())), + "conditions": privacy_safe_conditions, "excluded_trial_count": 0, }, "derived_outcomes": counted_taxonomy, @@ -2818,6 +3114,748 @@ def derive_production_acceptance( } +def _validated_manifest_source(value: Mapping[str, Any]) -> dict[str, Any]: + """Validate the complete private result used by the public manifest builder.""" + + source = dict(_closed(value, _DERIVED_RESULT_KEYS, "production acceptance source")) + if ( + source["schema_version"] != RESULT_SCHEMA + or source["verdict"] != "accepted" + or source["evidence_class"] != "qualified_browser_production_acceptance" + or source["claim_scope"] != CLAIM_SCOPE + or source["claim_limit"] != "not_general_product_production_readiness" + ): + raise AcceptanceError("production acceptance source is not an accepted browser result") + + bindings = _closed( + source["bindings"], + _DERIVED_BINDING_KEYS, + "production acceptance source bindings", + ) + for key in ( + "runtime_validation_id_sha256", + "admission_id_sha256", + "campaign_id_sha256", + "workflow_version_id_sha256", + "workflow_digest", + "environment_digest", + "evidence_identity_sha256", + "cloud_target_build_sha256", + "flow_wheel_sha256", + "managed_runtime_manifest_sha256", + "runner_artifact_sha256", + "campaign_contract_sha256", + "campaign_outcomes_sha256", + "oracle_contract_sha256", + "evidence_runner_signer_sha256", + "target_attestation_signer_sha256", + "target_observer_signer_sha256", + "target_attestation_sha256", + "organization_id_sha256", + "workflow_id_sha256", + ): + _digest(bindings[key], f"production acceptance source binding {key}") + if not isinstance(bindings["cloud_source_commit"], str) or _HEX_40.fullmatch( + bindings["cloud_source_commit"] + ) is None: + raise AcceptanceError("production acceptance source Cloud commit is invalid") + if not isinstance(bindings["flow_release_commit"], str) or _HEX_40.fullmatch( + bindings["flow_release_commit"] + ) is None: + raise AcceptanceError("production acceptance source Flow commit is invalid") + if not isinstance(bindings["flow_version"], str) or _SEMVER.fullmatch( + bindings["flow_version"] + ) is None: + raise AcceptanceError("production acceptance source Flow version is invalid") + if bindings["substrate"] != "web": + raise AcceptanceError("production acceptance source substrate is not web") + if not isinstance(bindings["browser_base_image"], str) or _PINNED_IMAGE.fullmatch( + bindings["browser_base_image"] + ) is None: + raise AcceptanceError("production acceptance source browser image is invalid") + + evidence = _closed( + source["source_evidence"], + _DERIVED_SOURCE_EVIDENCE_KEYS, + "production acceptance source evidence", + ) + for key in ( + "certificate_sha256", + "campaign_sha256", + "qualification_admission_sha256", + ): + _digest(evidence[key], f"production acceptance source evidence {key}") + if evidence["approved_cloud_source_commit"] != bindings["cloud_source_commit"]: + raise AcceptanceError("production acceptance source Cloud approval differs") + attestation = _closed( + evidence["attestation"], + { + "repository", + "workflow", + "certificate_identity", + "source_commit", + "bundle_sha256", + }, + "production acceptance source attestation", + ) + if ( + attestation["repository"] != CLOUD_REPOSITORY + or attestation["workflow"] != CLOUD_WORKFLOW + or attestation["certificate_identity"] != CLOUD_CERTIFICATE_IDENTITY + or attestation["source_commit"] != bindings["cloud_source_commit"] + ): + raise AcceptanceError("production acceptance source attestation differs") + _digest( + attestation["bundle_sha256"], + "production acceptance source attestation bundle", + ) + authority = _closed( + evidence["qualification_authority"], + { + "artifact_sha256", + "signer_key_id", + "issuer_workflow", + "issuer_ref", + "expires_at", + "evidence_identity_sha256", + }, + "production acceptance source qualification authority", + ) + _digest( + authority["artifact_sha256"], + "production acceptance source qualification authority artifact", + ) + if authority["artifact_sha256"] != evidence["qualification_admission_sha256"]: + raise AcceptanceError("production acceptance source admission digest differs") + if authority["evidence_identity_sha256"] != bindings[ + "evidence_identity_sha256" + ].removeprefix("sha256:"): + raise AcceptanceError("production acceptance source evidence identity differs") + + inventory = _closed( + source["trial_inventory"], + _DERIVED_TRIAL_INVENTORY_KEYS, + "production acceptance source trial inventory", + ) + counts = { + key: _count(inventory[key], f"production acceptance source inventory {key}") + for key in ( + "task_count", + "condition_count", + "required_trial_count", + "observed_trial_count", + "trial_count", + "minimum_trials_per_condition", + "excluded_trial_count", + ) + } + if ( + counts["task_count"] < 1 + or counts["condition_count"] < counts["task_count"] + or counts["required_trial_count"] < 3 + or counts["observed_trial_count"] < counts["required_trial_count"] + or counts["trial_count"] != counts["observed_trial_count"] + or counts["minimum_trials_per_condition"] < 3 + or counts["excluded_trial_count"] != 0 + ): + raise AcceptanceError("production acceptance source inventory is incomplete") + for key in ( + "task_count", + "condition_count", + "required_trial_count", + "observed_trial_count", + ): + if bindings[key] != counts[key]: + raise AcceptanceError(f"production acceptance source binding {key} differs") + conditions = inventory["conditions"] + if not isinstance(conditions, list) or len(conditions) != counts["condition_count"]: + raise AcceptanceError("production acceptance source condition inventory is incomplete") + seen_conditions: set[str] = set() + seen_tasks: set[str] = set() + required_total = 0 + observed_total = 0 + observed_minimum: int | None = None + for index, item in enumerate(conditions): + condition = _closed( + item, + _DERIVED_CONDITION_KEYS, + f"production acceptance source condition {index}", + ) + task_digest = _digest( + condition["task_id_sha256"], + f"production acceptance source condition {index} task", + ) + condition_digest = _digest( + condition["condition_id_sha256"], + f"production acceptance source condition {index} identity", + ) + if condition_digest in seen_conditions: + raise AcceptanceError("production acceptance source condition is duplicate") + seen_conditions.add(condition_digest) + seen_tasks.add(task_digest) + required = _count( + condition["required_trial_count"], + f"production acceptance source condition {index} required trials", + ) + observed = _count( + condition["observed_trial_count"], + f"production acceptance source condition {index} observed trials", + ) + if required < 3 or observed < required: + raise AcceptanceError("production acceptance source condition is incomplete") + required_total += required + observed_total += observed + observed_minimum = observed if observed_minimum is None else min( + observed_minimum, + observed, + ) + if ( + len(seen_tasks) != counts["task_count"] + or required_total != counts["required_trial_count"] + or observed_total != counts["observed_trial_count"] + or observed_minimum != counts["minimum_trials_per_condition"] + ): + raise AcceptanceError("production acceptance source condition counts differ") + + taxonomy = _closed( + source["derived_outcomes"], + set(_FAILURE_TAXONOMY), + "production acceptance source failure taxonomy", + ) + counted_taxonomy = { + key: _count(value, f"production acceptance source failure taxonomy {key}") + for key, value in taxonomy.items() + } + if sum(counted_taxonomy.values()) != counts["observed_trial_count"]: + raise AcceptanceError("production acceptance source taxonomy count differs") + if any(counted_taxonomy[name] for name in _PRODUCTION_FAILURES): + raise AcceptanceError("production acceptance source contains a production failure") + + reliability = _closed( + source["reliability"], + _RELIABILITY_KEYS, + "production acceptance source reliability", + ) + for key, value in reliability.items(): + _count(value, f"production acceptance source reliability {key}") + expected_reliability = { + "silent_incorrect_success_count": counted_taxonomy[ + "silent_incorrect_success" + ], + "over_halt_count": counted_taxonomy["over_halt"], + "wrong_record_count": counted_taxonomy["wrong_record"], + "duplicate_effect_count": counted_taxonomy["duplicate_effect"], + "collateral_effect_count": counted_taxonomy["collateral_effect"], + "operator_intervention_count": counted_taxonomy["operator_intervention"], + "uncertain_delivery_count": counted_taxonomy["uncertain_delivery"], + } + if any(reliability[key] != value for key, value in expected_reliability.items()): + raise AcceptanceError("production acceptance source reliability differs") + + retention = _closed( + source["retention"], + _RETENTION_KEYS, + "production acceptance source retention", + ) + for key in ( + "ciphertext_sha256", + "candidate_sha256", + "private_envelope_sha256", + "store_attestation_sha256", + "storage_identity_sha256", + "object_version_sha256", + "private_locator_version_sha256", + "kms_key_identity_sha256", + "uploader_identity_sha256", + ): + _digest(retention[key], f"production acceptance source retention {key}") + for key in ( + "upload_verified", + "head_verified", + "object_lock_verified", + "private_locator_recorded", + ): + if retention[key] is not True: + raise AcceptanceError(f"production acceptance source retention {key} is false") + if retention["retention_mode"] != "COMPLIANCE": + raise AcceptanceError("production acceptance source retention is not COMPLIANCE") + if not isinstance(retention["receipt_id"], str) or re.fullmatch( + r"retention:[a-f0-9]{32}", retention["receipt_id"] + ) is None: + raise AcceptanceError("production acceptance source retention receipt ID is invalid") + if retention["provenance_attestation"] != "github-artifact-attestation-v4": + raise AcceptanceError( + "production acceptance source retention provenance is invalid" + ) + acceptance_verified_at = _timestamp( + retention["acceptance_verified_at"], + "production acceptance source retention acceptance_verified_at", + ) + retained_at = _timestamp( + retention["retained_at"], + "production acceptance source retention retained_at", + ) + retention_until = _timestamp( + retention["retention_until"], + "production acceptance source retention retention_until", + ) + retention_period = retention_until - retained_at + if not timedelta(days=365) <= retention_period <= timedelta(days=3650): + raise AcceptanceError( + "production acceptance source retention period is outside policy" + ) + if not acceptance_verified_at <= retained_at < retention_until: + raise AcceptanceError("production acceptance source retention chronology is invalid") + return source + + +def _reject_duplicate_json_pairs(pairs: list[tuple[str, Any]]) -> dict[str, Any]: + value: dict[str, Any] = {} + for key, item in pairs: + if key in value: + raise AcceptanceError( + f"production lifecycle policy contains duplicate key {key!r}" + ) + value[key] = item + return value + + +def _validated_flow_lifecycle_policy(policy_bytes: bytes) -> dict[str, Any]: + if not isinstance(policy_bytes, bytes) or not policy_bytes: + raise AcceptanceError("production lifecycle policy must be non-empty bytes") + try: + value = json.loads( + policy_bytes.decode("utf-8"), + object_pairs_hook=_reject_duplicate_json_pairs, + ) + except (UnicodeDecodeError, json.JSONDecodeError) as exc: + raise AcceptanceError("production lifecycle policy is not valid UTF-8 JSON") from exc + policy = _closed( + value, + { + "$schema", + "schema_version", + "revision", + "maximum_admission_days", + "summary_authority", + "targets", + }, + "production lifecycle policy", + ) + if ( + policy["$schema"] != PRODUCTION_LIFECYCLE_POLICY_PATH + or policy["schema_version"] != PRODUCTION_LIFECYCLE_POLICY_SCHEMA + ): + raise AcceptanceError("production lifecycle policy schema is not supported") + if ( + not isinstance(policy["revision"], int) + or isinstance(policy["revision"], bool) + or policy["revision"] < 1 + ): + raise AcceptanceError("production lifecycle policy revision is invalid") + maximum_days = policy["maximum_admission_days"] + if ( + not isinstance(maximum_days, int) + or isinstance(maximum_days, bool) + or not 1 <= maximum_days <= 30 + ): + raise AcceptanceError("production lifecycle admission duration is invalid") + if not isinstance(policy["summary_authority"], dict): + raise AcceptanceError("production lifecycle summary authority is invalid") + targets = policy["targets"] + if not isinstance(targets, list) or len(targets) != len( + PRODUCTION_ACCEPTANCE_TARGET_SCOPES + ): + raise AcceptanceError("production lifecycle target inventory is incomplete") + target_keys = { + "id", + "display_name", + "lifecycle_scope", + "lifecycle_subject", + "source_repository", + "release_kind", + "required_claim_scope", + "required_artifact_kinds", + "package_index_project", + "artifact_authority_by_kind", + } + target_map: dict[str, dict[str, Any]] = {} + for index, item in enumerate(targets): + declared = dict( + _closed(item, target_keys, f"production lifecycle target {index}") + ) + target_id = declared["id"] + if not isinstance(target_id, str) or target_id in target_map: + raise AcceptanceError("production lifecycle target identity is invalid") + target_map[target_id] = declared + if set(target_map) != set(PRODUCTION_ACCEPTANCE_TARGET_SCOPES): + raise AcceptanceError("production lifecycle target inventory differs") + expected_flow = { + "id": "flow", + "display_name": "OpenAdapt Flow", + "lifecycle_scope": "repository", + "lifecycle_subject": "openadapt-flow", + "source_repository": "OpenAdaptAI/openadapt-flow", + "release_kind": "public_package", + "required_claim_scope": PRODUCTION_ACCEPTANCE_TARGET_SCOPES["flow"], + "required_artifact_kinds": ["sdist", "wheel"], + "package_index_project": "openadapt-flow", + "artifact_authority_by_kind": {"sdist": "pypi", "wheel": "pypi"}, + } + if target_map["flow"] != expected_flow: + raise AcceptanceError("Flow production lifecycle policy differs") + return target_map["flow"] + + +def _clean_https_url(value: object, label: str) -> str: + url = _nonempty(value, label) + parsed = urlsplit(url) + if ( + parsed.scheme != "https" + or not parsed.netloc + or parsed.username + or parsed.password + or parsed.query + or parsed.fragment + ): + raise AcceptanceError(f"{label} must be a clean HTTPS URL") + return url + + +def verify_production_lifecycle_release( + lifecycle_policy_bytes: bytes, + target: str, + target_release: Mapping[str, Any], + *, + pypi_release_metadata: Mapping[str, Any], +) -> VerifiedProductionLifecycleRelease: + """Verify one exact release against lifecycle policy and PyPI metadata.""" + + if target != "flow": + if target in PRODUCTION_ACCEPTANCE_TARGET_SCOPES: + raise AcceptanceError( + f"production lifecycle target {target!r} requires its own verifier" + ) + raise AcceptanceError("production lifecycle target is not supported") + target_policy = _validated_flow_lifecycle_policy(lifecycle_policy_bytes) + release = dict( + _closed( + target_release, + { + "kind", + "version", + "tag", + "source_commit", + "immutable_release_url", + "artifacts", + }, + "Flow production lifecycle release", + ) + ) + version = release["version"] + if ( + release["kind"] != "public_package" + or not isinstance(version, str) + or _SEMVER.fullmatch(version) is None + or release["tag"] not in {version, f"v{version}"} + ): + raise AcceptanceError("Flow production lifecycle package identity is invalid") + source_commit = release["source_commit"] + if not isinstance(source_commit, str) or _HEX_40.fullmatch(source_commit) is None: + raise AcceptanceError("Flow production lifecycle source commit is invalid") + immutable_url = _clean_https_url( + release["immutable_release_url"], + "Flow production lifecycle immutable release URL", + ) + if immutable_url != ( + "https://github.com/OpenAdaptAI/openadapt-flow/commit/" + source_commit + ): + raise AcceptanceError( + "Flow production lifecycle immutable release URL is not the exact commit" + ) + artifacts_value = release["artifacts"] + if not isinstance(artifacts_value, list) or len(artifacts_value) != 2: + raise AcceptanceError( + "Flow production lifecycle release must contain one sdist and one wheel" + ) + artifacts: list[dict[str, Any]] = [] + artifact_identities: list[tuple[str, str]] = [] + for index, item in enumerate(artifacts_value): + artifact = dict( + _closed( + item, + {"authority", "kind", "name", "sha256", "size_bytes", "url"}, + f"Flow production lifecycle artifact {index}", + ) + ) + name = _nonempty(artifact["name"], f"Flow lifecycle artifact {index} name") + if _ARTIFACT_NAME.fullmatch(name) is None: + raise AcceptanceError(f"Flow lifecycle artifact {index} name is invalid") + kind = artifact["kind"] + if kind not in {"sdist", "wheel"} or artifact["authority"] != "pypi": + raise AcceptanceError( + f"Flow lifecycle artifact {index} kind or authority is invalid" + ) + _digest(artifact["sha256"], f"Flow lifecycle artifact {index} digest") + size = artifact["size_bytes"] + if not isinstance(size, int) or isinstance(size, bool) or size < 1: + raise AcceptanceError(f"Flow lifecycle artifact {index} size is invalid") + artifact_url = _clean_https_url( + artifact["url"], f"Flow lifecycle artifact {index} URL" + ) + if urlsplit(artifact_url).netloc != "files.pythonhosted.org": + raise AcceptanceError(f"Flow lifecycle artifact {index} is not from PyPI") + artifact_identities.append((kind, name)) + artifacts.append(artifact) + if artifact_identities != sorted(artifact_identities) or { + kind for kind, _name in artifact_identities + } != set(target_policy["required_artifact_kinds"]): + raise AcceptanceError( + "Flow production lifecycle artifacts must be sorted sdist and wheel" + ) + if len(set(artifact_identities)) != len(artifact_identities): + raise AcceptanceError("Flow production lifecycle artifact is duplicate") + if not isinstance(pypi_release_metadata, Mapping): + raise AcceptanceError("PyPI release metadata must be an object") + info = pypi_release_metadata.get("info") + urls = pypi_release_metadata.get("urls") + if not isinstance(info, Mapping) or info.get("version") != version: + raise AcceptanceError("PyPI release metadata version differs") + if not isinstance(urls, list): + raise AcceptanceError("PyPI release metadata files are invalid") + for artifact in artifacts: + matches = [ + item + for item in urls + if isinstance(item, Mapping) + and item.get("filename") == artifact["name"] + and item.get("url") == artifact["url"] + and item.get("size") == artifact["size_bytes"] + and isinstance(item.get("digests"), Mapping) + and item["digests"].get("sha256") + == artifact["sha256"].removeprefix("sha256:") + and item.get("yanked") is False + ] + if len(matches) != 1: + raise AcceptanceError( + f"PyPI does not verify exact artifact {artifact['name']}" + ) + return VerifiedProductionLifecycleRelease( + target=target, + claim_scope=target_policy["required_claim_scope"], + lifecycle_policy_sha256=( + "sha256:" + hashlib.sha256(lifecycle_policy_bytes).hexdigest() + ), + release=release, + artifacts=artifacts, + _seal=VerifiedProductionLifecycleRelease._CONSTRUCTION_SEAL, + ) + + +def _validated_target_lifecycle( + source: Mapping[str, Any], + target: str, + lifecycle_release: VerifiedProductionLifecycleRelease, +) -> tuple[dict[str, Any], list[dict[str, Any]], str]: + if type(lifecycle_release) is not VerifiedProductionLifecycleRelease: + raise AcceptanceError( + "production acceptance requires a verifier-derived lifecycle release" + ) + if ( + lifecycle_release.target != target + or lifecycle_release.claim_scope != PRODUCTION_ACCEPTANCE_TARGET_SCOPES[target] + ): + raise AcceptanceError("production acceptance lifecycle target differs") + release = lifecycle_release.release() + artifacts = lifecycle_release.artifacts() + if release.get("artifacts") != artifacts: + raise AcceptanceError("production acceptance lifecycle artifacts differ") + bindings = source["bindings"] + if ( + release["version"] != bindings["flow_version"] + or release["source_commit"] != bindings["flow_release_commit"] + ): + raise AcceptanceError( + "Flow production acceptance lifecycle release differs from verified evidence" + ) + wheels = [item for item in artifacts if item["kind"] == "wheel"] + if ( + len(wheels) != 1 + or wheels[0]["sha256"] != bindings["flow_wheel_sha256"] + ): + raise AcceptanceError( + "Flow production acceptance wheel differs from verified evidence" + ) + _digest( + lifecycle_release.lifecycle_policy_sha256, + "production lifecycle policy digest", + ) + return release, artifacts, lifecycle_release.lifecycle_policy_sha256 + + +def _build_production_acceptance_manifest( + source: Mapping[str, Any], + target: str, + lifecycle_release: VerifiedProductionLifecycleRelease, +) -> dict[str, Any]: + if target not in _BROWSER_SOURCE_TARGETS: + if target in PRODUCTION_ACCEPTANCE_TARGET_SCOPES: + raise AcceptanceError( + f"production acceptance target {target!r} requires its own evidence adapter" + ) + raise AcceptanceError("production acceptance target is not supported") + if target == "cloud": + raise AcceptanceError( + "Cloud production acceptance requires a reviewed deployment-manifest binding" + ) + bindings = source["bindings"] + evidence = source["source_evidence"] + inventory = source["trial_inventory"] + release_descriptor, artifact_inventory, lifecycle_policy_sha256 = ( + _validated_target_lifecycle( + source, + target, + lifecycle_release, + ) + ) + return { + "schema_version": PRODUCTION_ACCEPTANCE_SCHEMA, + "target": target, + "claim_scope": PRODUCTION_ACCEPTANCE_TARGET_SCOPES[target], + "verdict": "accepted", + "acceptance_policy_sha256": production_acceptance_policy_sha256(), + "lifecycle_policy_sha256": lifecycle_policy_sha256, + "target_release_sha256": _domain_sha256( + PRODUCTION_LIFECYCLE_TARGET_RELEASE_DOMAIN, + { + "target": target, + "claim_scope": PRODUCTION_ACCEPTANCE_TARGET_SCOPES[target], + "release": release_descriptor, + }, + ), + "target_artifact_inventory_sha256": _domain_sha256( + PRODUCTION_LIFECYCLE_ARTIFACT_INVENTORY_DOMAIN, + { + "target": target, + "claim_scope": PRODUCTION_ACCEPTANCE_TARGET_SCOPES[target], + "artifacts": artifact_inventory, + }, + ), + "evidence_identity_sha256": bindings["evidence_identity_sha256"], + "source_evidence": { + "source_result_sha256": canonical_sha256(source), + "certificate_sha256": evidence["certificate_sha256"], + "campaign_sha256": evidence["campaign_sha256"], + "qualification_admission_sha256": evidence[ + "qualification_admission_sha256" + ], + "attestation_sha256": canonical_sha256(evidence["attestation"]), + "attestation_bundle_sha256": evidence["attestation"]["bundle_sha256"], + }, + "qualification": { + "campaign_contract_sha256": bindings["campaign_contract_sha256"], + "campaign_outcomes_sha256": bindings["campaign_outcomes_sha256"], + "oracle_contract_sha256": bindings["oracle_contract_sha256"], + "task_count": inventory["task_count"], + "condition_count": inventory["condition_count"], + "required_trial_count": inventory["required_trial_count"], + "observed_trial_count": inventory["observed_trial_count"], + "minimum_trials_per_condition": inventory[ + "minimum_trials_per_condition" + ], + "excluded_trial_count": inventory["excluded_trial_count"], + "task_condition_inventory_sha256": _domain_sha256( + b"OpenAdapt production acceptance task-condition inventory v1\0", + inventory["conditions"], + ), + }, + "failure_taxonomy_counts": dict(source["derived_outcomes"]), + "reliability": dict(source["reliability"]), + "retention": dict(source["retention"]), + } + + +def validate_production_acceptance_manifest( + value: Mapping[str, Any], + verified_source_result: Mapping[str, Any], + *, + lifecycle_release: VerifiedProductionLifecycleRelease, +) -> dict[str, Any]: + """Validate one target manifest against the complete verified private result.""" + + source = _validated_manifest_source(verified_source_result) + manifest = dict( + _closed(value, _PRODUCTION_ACCEPTANCE_KEYS, "production acceptance manifest") + ) + target = manifest["target"] + if not isinstance(target, str): + raise AcceptanceError("production acceptance manifest target is invalid") + expected = _build_production_acceptance_manifest( + source, + target, + lifecycle_release, + ) + if manifest != expected: + raise AcceptanceError( + "production acceptance manifest differs from its verified source result" + ) + for key in ( + "acceptance_policy_sha256", + "lifecycle_policy_sha256", + "target_release_sha256", + "target_artifact_inventory_sha256", + "evidence_identity_sha256", + ): + _digest(manifest[key], f"production acceptance manifest {key}") + _closed( + manifest["source_evidence"], + _PRODUCTION_SOURCE_EVIDENCE_KEYS, + "production acceptance manifest source evidence", + ) + _closed( + manifest["qualification"], + _PRODUCTION_QUALIFICATION_KEYS, + "production acceptance manifest qualification", + ) + _closed( + manifest["failure_taxonomy_counts"], + set(_FAILURE_TAXONOMY), + "production acceptance manifest failure taxonomy", + ) + _closed( + manifest["reliability"], + _RELIABILITY_KEYS, + "production acceptance manifest reliability", + ) + _closed( + manifest["retention"], + _RETENTION_KEYS, + "production acceptance manifest retention", + ) + return manifest + + +def build_production_acceptance_manifest( + verified_source_result: Mapping[str, Any], + target: str, + *, + lifecycle_release: VerifiedProductionLifecycleRelease, +) -> dict[str, Any]: + """Build, without I/O, one accepted target manifest from verified evidence.""" + + source = _validated_manifest_source(verified_source_result) + manifest = _build_production_acceptance_manifest( + source, + target, + lifecycle_release, + ) + return validate_production_acceptance_manifest( + manifest, + source, + lifecycle_release=lifecycle_release, + ) + + def import_files( certificate_path: Path, campaign_path: Path, diff --git a/tests/fixtures/production_acceptance/live-certificate.json b/tests/fixtures/production_acceptance/live-certificate.json index 79f94b6..956e2f8 100644 --- a/tests/fixtures/production_acceptance/live-certificate.json +++ b/tests/fixtures/production_acceptance/live-certificate.json @@ -19,7 +19,7 @@ "zero_model_healthy_path": true }, "identities": { - "managed_runner_signer_sha256": "sha256:7300c0ae1429cd153252736a781b78f404f4738f17db195dbef533b74a45ec86", + "evidence_runner_signer_sha256": "sha256:7300c0ae1429cd153252736a781b78f404f4738f17db195dbef533b74a45ec86", "organization_id_sha256": "sha256:0ecd004dcbed992e16d1f90fbb2b2ae5433e32ed62e563f6fc53caa277516648", "producer": { "kind": "github_oidc_attested_workflow", @@ -75,17 +75,17 @@ "issuer_workflow": "OpenAdaptAI/openadapt-internal/.github/workflows/production-qualification-admission.yml", "key_id": "qa-ed25519-34750f98bd59fcfc" }, - "campaign_artifact_sha256": "sha256:ed685043a835a14f4990cab8b7646de63bbb4e757df89d09e4331c24ae7734c2", + "campaign_artifact_sha256": "sha256:792a675ba485a1fb8cc36d43a16bf04d90828ef3ebda9514abbbcc79cadc85b3", "campaign_contract_sha256": "sha256:02b706e8251719c9ed4c62e3c9807074952f5ffe350a382fa61bb7d3832cfe41", "campaign_id_sha256": "sha256:0c72b77f9c560be2306048462f681f01dbe27db818243d8e792c56afccca0a38", - "campaign_outcomes_sha256": "sha256:a7f5dd6c92774a487ffe8c57822f464dd5b84e94f92e01899acbbb61b580ab19", + "campaign_outcomes_sha256": "sha256:3dd11000b63392f09f8105fd83f0fb7d68d526bb2e083e297dde05b05100aaae", "condition_count": 9, "environment_digest": "sha256:eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee", - "evidence_identity_sha256": "sha256:e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_identity_sha256": "sha256:58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", "minimum_trials_per_condition": 3, "observed_trial_count": 27, "oracle_contract_sha256": "sha256:a9d87b5deaa24c553e65aa0237136398fe7821ae7d226fc20d48c500765bc1e0", - "qualification_admission_sha256": "sha256:c978f962afbe278c0f49cb51c41fa20cedea7981d15110d19aff1ec780843ba7", + "qualification_admission_sha256": "sha256:9481e6de04bac906d55fb11df4434df96c8cb44beb88407bac11c37ef0914a93", "required_trial_count": 27, "runtime_validation_id_sha256": "sha256:4b0c7cd12b36f177beb4e28ab9fb4fa4da0d4d033274233d654bd5615758908f", "task_count": 1, diff --git a/tests/fixtures/production_acceptance/qualification-admission.json b/tests/fixtures/production_acceptance/qualification-admission.json index e59c101..332a85c 100644 --- a/tests/fixtures/production_acceptance/qualification-admission.json +++ b/tests/fixtures/production_acceptance/qualification-admission.json @@ -8,7 +8,7 @@ "bundle_content_digest": "2222222222222222222222222222222222222222222222222222222222222222", "bundle_version_id": "55555555-5555-4555-8555-555555555555", "campaign": { - "artifact_sha256": "ed685043a835a14f4990cab8b7646de63bbb4e757df89d09e4331c24ae7734c2", + "artifact_sha256": "792a675ba485a1fb8cc36d43a16bf04d90828ef3ebda9514abbbcc79cadc85b3", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "contract_sha256": "02b706e8251719c9ed4c62e3c9807074952f5ffe350a382fa61bb7d3832cfe41", "decision": "admitted", @@ -27,7 +27,7 @@ ], "oracle_contract_sha256": "a9d87b5deaa24c553e65aa0237136398fe7821ae7d226fc20d48c500765bc1e0", "oracle_id": "openadapt.execute-acceptance-campaign-oracle/v1", - "outcomes_sha256": "a7f5dd6c92774a487ffe8c57822f464dd5b84e94f92e01899acbbb61b580ab19", + "outcomes_sha256": "3dd11000b63392f09f8105fd83f0fb7d68d526bb2e083e297dde05b05100aaae", "tasks": [ { "condition": "ambiguous-target", @@ -100,10 +100,10 @@ "effect_contract_sha256": "2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d", "environment_contract_sha256": "2626262626262626262626262626262626262626262626262626262626262626", "environment_digest": "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee", + "evidence_runner_signer_sha256": "7300c0ae1429cd153252736a781b78f404f4738f17db195dbef533b74a45ec86", "governed_authorization_template_sha256": "2323232323232323232323232323232323232323232323232323232323232323", "identity_contract_sha256": "2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c2c", "input_policy_sha256": "2929292929292929292929292929292929292929292929292929292929292929", - "managed_runner_signer_sha256": "7300c0ae1429cd153252736a781b78f404f4738f17db195dbef533b74a45ec86", "network_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", "operator_contract_sha256": "2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e", "oracle_contract_sha256": "a9d87b5deaa24c553e65aa0237136398fe7821ae7d226fc20d48c500765bc1e0", @@ -160,5 +160,5 @@ "workflow_id": "33333333-3333-4333-8333-333333333333", "workflow_version_id": "44444444-4444-4444-8444-444444444444" }, - "signature": "0slsNbAvAmflJs3XaskOMaCCmyD7YbQSEAQKKIJ4SYkWo+uOXzlxopCxJo+ZP5SYRdmmTb6F+VI18B139Cu4Bw==" + "signature": "DxQtjy3Su77j//oDu3jG9bwAC8nz6hIQxfH9EncM0ly8fJLbftQru03OC7rTHkyZysyxCw551tBHeMpYKHq0BQ==" } diff --git a/tests/fixtures/production_acceptance/qualification-campaign.json b/tests/fixtures/production_acceptance/qualification-campaign.json index 772fe0f..7273b5f 100644 --- a/tests/fixtures/production_acceptance/qualification-campaign.json +++ b/tests/fixtures/production_acceptance/qualification-campaign.json @@ -62,75 +62,75 @@ "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "679af5a8dedceb8c696719e73f82a698c230cd8fc98bb61769f0883202c0b637", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "1618244896b44c013eeedf931ce4d2ad0899fed5c9ed7f6812c9d17d62003c6b", - "cleanup_receipt_sha256": "cb6c8afc587772aa8efc94807c1572115c22e8a1eca478dc2977cf785f7e4771", + "cleanup_absence_proof_sha256": "326425236f07d21b2b95f99f3849e2eab4720679adc160b8fa15599a6d69f5bc", + "cleanup_receipt_sha256": "4571f26328bd6bc5137100074f608fc8f33876a2ca368d42404848f3847b0770", "completed_at": "2026-08-18T10:02:00Z", "condition": "healthy-01", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", "execution_outcome": "verified", "failure_class": "verified", "fault_receipt_sha256": null, - "observer_receipt_sha256": "7955935e031e774f701302635fe41d80f3cb44696a61234b7849200d253a24e3", + "observer_receipt_sha256": "04fd815c9af5d936db6820dc9c2ed8c2d5035b8280457b939f84877ff9446292", "oracle_verdict": "satisfied", - "replay_report_sha256": "47a57ac3a76f6d6769d612a5d478882242a2354fce1255ed9ea6f3a1e4fdbb15", + "replay_report_sha256": "9153aff7978db8adadbd8fd7ffd462d72c487ab458e8ccfd385712722acc256f", "run_id_sha256": "0b5bda916a0808165159166955a9563cf9c2303949f762a18eb037f41b44a6dc", - "runner_receipt_sha256": "e5d91e9b772fc407fe311e48b7b354f267782156817273b26f6906c7ef225ef3", + "runner_receipt_sha256": "8f4f18d06faedba5e1d8644e0014528818b79fff8c944bc88b0b452784ee2ce1", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T10:01:00Z", "task": "execute-acceptance", "trial_index": 1, - "webhook_receipt_sha256": "49de0ab8efa7c46b2f4594bf74c916ec99f1694e45b3ec734566913d14b4225f", + "webhook_receipt_sha256": "942df1c36be1e8d4d82b0b70b1c719a1e01853dc3a8bd76e703d0ddd57b88ca3", "workflow_version_id": "44444444-4444-4444-8444-444444444444" }, { "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "fdad940f245d690750ad647fac25c7e76aac2f474db49732fec8129051750186", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "78b6fbcd45afdcab40cc88b65a9c53caea37e18ea8df239812cfb2922fd26df4", - "cleanup_receipt_sha256": "76e7394342df02acda6f125c6069601220ea6de460350b3746e09b4b55cfa461", + "cleanup_absence_proof_sha256": "807bf8e238a171e94d0a61e5d2f7ecacef62042842047274b982d67de9956727", + "cleanup_receipt_sha256": "7aa8397c5de967f8e81eabecfe52c021b1e07871d713156463a1b3b1db1855de", "completed_at": "2026-08-18T10:03:00Z", "condition": "healthy-01", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", "execution_outcome": "verified", "failure_class": "verified", "fault_receipt_sha256": null, - "observer_receipt_sha256": "b90646d3845ffaf972be53d7d891abfa78c60975dbdf1aae85f55340ff5d6ba1", + "observer_receipt_sha256": "c289460164fdddf98ef17bfbc4762e2d890358f9bd590aa057f0bcd8382dcc47", "oracle_verdict": "satisfied", - "replay_report_sha256": "df5539d0273ef7fe8dad28520de2664d6cb1434aa1bc7973d5099129ea8e9fb3", + "replay_report_sha256": "690e9a06f4247ffb8bb5dc38a360e35ed40c03c817ea2242c42b944a706a0511", "run_id_sha256": "3739043a92a8781376cfbd022460c03aba40f92a800b3885ebc046321437bc40", - "runner_receipt_sha256": "94480255df8b3ebf0a824b340d666a28d5fff75dc3d668d6ed30b4c69d06590b", + "runner_receipt_sha256": "a36da032e4dd06563a3377f89fe60b791b21e70cdb776c73df15e6935c7c7399", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T10:02:00Z", "task": "execute-acceptance", "trial_index": 2, - "webhook_receipt_sha256": "22401bb3f7cdbee8cc0fdd6ce84eb60a63cfce66db20f3cf5cc51e55f10055a6", + "webhook_receipt_sha256": "8dbfb683596b52b2263a3cc9a97148b7d4787eb0e7780d71e3349c4d2cac8dd4", "workflow_version_id": "44444444-4444-4444-8444-444444444444" }, { "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "4c352a6999f77707e8837adebb4fc2b7451c2ef6de5145190b33a5c5645e47eb", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "0009aee64285ed2cb340ab6c8923ebd0a9f3603db3cbe1bf8e593bdea6aa22a3", - "cleanup_receipt_sha256": "4408783aba57a0ec3124a3265f3a7eb34eeb429fcef2e60a955c91d84e2e91d2", + "cleanup_absence_proof_sha256": "e282152bb5eadade961a097c4e8008c9873da535ecf4bd66a9f93b48b4c12b2c", + "cleanup_receipt_sha256": "7602e3cdeee8a9d03aaa5ca0cf40be1f760d55237f8e286e419e168dc1e09c8a", "completed_at": "2026-08-18T10:04:00Z", "condition": "healthy-01", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", "execution_outcome": "verified", "failure_class": "verified", "fault_receipt_sha256": null, - "observer_receipt_sha256": "bc7e85e0380e3c790a86bec2d4ddda704fb1ae1db4979ec6d91aa0562ccdbb9c", + "observer_receipt_sha256": "388d67a8082fd8096b3197a038ad5bc717f5d093119c5b97cbde40f32ffa94a7", "oracle_verdict": "satisfied", - "replay_report_sha256": "b87015226ef172a5e717616fc75a97661c343124e5a17bcc3fb8c5c32a4a5a03", + "replay_report_sha256": "3d756ad6d044b1ea28155d7015aac704333e4de653d478fd77bac565b6e1ef88", "run_id_sha256": "4ee2bb61fb883cc8e77d636fb471aa3c0ce9ef0c0a8abd9682214bf0a8f16f26", - "runner_receipt_sha256": "93325b31e545651925604b95ea62b9327da8cb98905734f4925ca5d77aa5d1ed", + "runner_receipt_sha256": "729648debeebf209f4ab45315cebd2de9bd4fc3ba7e2497ab41441954b3044dd", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T10:03:00Z", "task": "execute-acceptance", "trial_index": 3, - "webhook_receipt_sha256": "7fb90d2da8912d351338ac30b3136cfae35c3cfcb21a1be3cefe268eb732696c", + "webhook_receipt_sha256": "c3efe880a31ef3e95bc22e8d585c48737f8f3627bc91c60fe90006a55d8ac764", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } ] @@ -144,75 +144,75 @@ "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "940d3ca125ff87ce7539740fbae29d2d64fec839328b0639127e1d197d2485d8", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "de26659e031f4d186faf99c91d5b4506cf77d4cc82723581f5f163519c82b032", - "cleanup_receipt_sha256": "7b0b7f71536e3d63e9f66ed1e0e47efcb78cd4930e486371ce40dd82d114d035", + "cleanup_absence_proof_sha256": "92d93cf5b7ac9046291713d0ec627b75a2f48c7863677f2255f2b890e2c68c8b", + "cleanup_receipt_sha256": "0e2f51550a263bf5d5f5ac94bc869ab552cb38f963a3fd647b5d08af13400867", "completed_at": "2026-08-18T10:12:00Z", "condition": "healthy-02", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", "execution_outcome": "verified", "failure_class": "verified", "fault_receipt_sha256": null, - "observer_receipt_sha256": "dc770cb91c01b638000f8f540bc2f3b6496f492d80b0aefed750b134a19bfe84", + "observer_receipt_sha256": "2dbec56c2995cef6865f2f09cd3f7eca569c66785c622f569bd198329c91eac8", "oracle_verdict": "satisfied", - "replay_report_sha256": "54c1991cfc25ee0e9c19b42b0901851afed31454ab224132d6ba1f0438543683", + "replay_report_sha256": "970b7b84c37367a963760c209eada9f627004aef2e4c725901e48a995af58dd6", "run_id_sha256": "bbb9312ce4682b23580eced0f8d19438d8266b222555df85fb27eef22ad5afe2", - "runner_receipt_sha256": "0a5102012076aadf70baee8581543ac04d061241192f1ca3c0b12eb6e31473f0", + "runner_receipt_sha256": "8924de4c24e49cc1160cf6e7df60b0ae93ab34d13b4b03073b9981156696dcd2", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T10:11:00Z", "task": "execute-acceptance", "trial_index": 1, - "webhook_receipt_sha256": "84070f921aa2358567527d3ec76d99bad2dd8b589b8c908bde0f717f266ad696", + "webhook_receipt_sha256": "daed8a995ba6fa93c4ea90b3c4abd4fc8e02af4413208a3656a5e89ef27dbecb", "workflow_version_id": "44444444-4444-4444-8444-444444444444" }, { "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "3d42601a69ef46cc44f57b51762affef4ccd829ffde30125619a6e582af00dab", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "e3d1c240c70aaf5b49945c1a2cfef7f1c7f1c61de81e67dde515b07827a87bb2", - "cleanup_receipt_sha256": "74c0ad2e902682f3f0c36c859ab514c9d2ca0c5e62a6efd3054713b92dc094e6", + "cleanup_absence_proof_sha256": "0b28572f4d609deaae0e5f96aabd078806efb490feb49896d15d3ae274adaeaa", + "cleanup_receipt_sha256": "e672f1eff631061fb1f20abeff4f9fb5665c21c0e955eeae412756c51214a1b8", "completed_at": "2026-08-18T10:13:00Z", "condition": "healthy-02", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", "execution_outcome": "verified", "failure_class": "verified", "fault_receipt_sha256": null, - "observer_receipt_sha256": "7822fdf37dfcdd3dac8232707e1237c777e0fe82d4d6ef3424dff0c260b6ab18", + "observer_receipt_sha256": "048ca4c88caf565040b46035db509ff38e849d95e9e4199e092f4565f5fa2f90", "oracle_verdict": "satisfied", - "replay_report_sha256": "93a820891c954075ce0f99539579a121345fc59129f8465a37c3937e401c5c7f", + "replay_report_sha256": "d70c74f1d0238a775c431b4fef499d5fb69de66dbf971bfc1338164bb9c4ad87", "run_id_sha256": "091e13ed70dab439b31cb506cf3bba1ddf6476696531cf891c39a924a928b7a1", - "runner_receipt_sha256": "4ca3d5eb8e380f12fb327214dadcf889acb28d7970b29fca53bf9f8f85700ae1", + "runner_receipt_sha256": "cbcd6b8ca83036e297d4610df2527be9ad842ebaa6c59a0636289c47d9454af1", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T10:12:00Z", "task": "execute-acceptance", "trial_index": 2, - "webhook_receipt_sha256": "85e7b8b6b58819ab3b4574721e4263084e66b3a3aa505c1a0d5fe04e5df8cda8", + "webhook_receipt_sha256": "20aa8f54ef97930dc960d96c5e562f463483444038695a27caf9e4ae8325aba0", "workflow_version_id": "44444444-4444-4444-8444-444444444444" }, { "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "019dd96e9a771ccc01ebafab321d7d3a8314df8b2d6465bcfc5fa14cbdeabdf2", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "95d12087d75ba87fd4915c47e5b83e12371fac79a045b1fd1ac7f778089a16ff", - "cleanup_receipt_sha256": "3c917b1de8297d9d1578795470d6a379a5bc0171ac1488d5468cb201099865b7", + "cleanup_absence_proof_sha256": "1a563d5cd99282e7c58ec0490687e29f4dae999b8b7bdb5061775b1265d85b82", + "cleanup_receipt_sha256": "b4ca3d26a2ebbe59ba3f50a127d16ba717aad436cd6577fcb08a15900f6c01c8", "completed_at": "2026-08-18T10:14:00Z", "condition": "healthy-02", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", "execution_outcome": "verified", "failure_class": "verified", "fault_receipt_sha256": null, - "observer_receipt_sha256": "86565ed67acb88cd35e0a34cf2639b54eedf257f0391a7fcaa9ecc29b98fd533", + "observer_receipt_sha256": "086cc4cf45a4b8d6c7e833e6f0ef674ff8caddc81aab2e1830aa7ba2b2f015ed", "oracle_verdict": "satisfied", - "replay_report_sha256": "2f5e6b2f5830a2af96d4caaa4154d8df09aad535e981334f256ac161509da31d", + "replay_report_sha256": "e55fc92a3febcc53207995f1a919d397f5dbd2c4ace7d0c24adf3ac6f81d01a4", "run_id_sha256": "16cb8df40654c6a1b55ea0e50e772d8c6e6d4f0d8205bd1f8296be27d0af83eb", - "runner_receipt_sha256": "97a4c47d8a841b03b91b1cbcf6df1d4c9c5cf9f11d5073d7c3586e835d872801", + "runner_receipt_sha256": "154cf5160bab5bf25271d138af78a770a3cac1d0a1250750e59a80d5de46883c", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T10:13:00Z", "task": "execute-acceptance", "trial_index": 3, - "webhook_receipt_sha256": "f23a094951b21e87b4bf29d155bd5ec7826dd97188a34bd5899c9e0c9e36aafb", + "webhook_receipt_sha256": "5b8eecb4df0fdf0057010f3a8245c8a05b96ff9f6eaee02149f1e9654a87cb26", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } ] @@ -226,75 +226,75 @@ "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "fc097c8b2e6ece94544a19b8d81f5c4a9367a89059e3dd4b2f746ab06a2fc930", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "84e5195b0a66b7c41b3bd1424059ba26346faa8012fc4ab9d569e108e3553615", - "cleanup_receipt_sha256": "96ebae402e023ee731b31211979466c1ba782490d54bbf69f6e9741f6f3177a2", + "cleanup_absence_proof_sha256": "153beaa2eb0cc516c545cf381d97cdef26df24fd51ff1aba481310d865148020", + "cleanup_receipt_sha256": "4272da024bd259baf9bf745ef4e33a71535f2af24bcad2dcb720a98b16ea1804", "completed_at": "2026-08-18T10:22:00Z", "condition": "healthy-03", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", "execution_outcome": "verified", "failure_class": "verified", "fault_receipt_sha256": null, - "observer_receipt_sha256": "c83d86c9abcf943cba78206214f7d9fe7088e46167c0f37f5caea0a48554c82e", + "observer_receipt_sha256": "b2ecb4573f5039a6a1cc1dfab8558a0f999e1382ff0c7ff5a258c9153fbd7914", "oracle_verdict": "satisfied", - "replay_report_sha256": "932ee45a17ff8efd7ce9813d4b02db10de4b9020f03797a2ee56d95c5d517366", + "replay_report_sha256": "ad0d51bc368a7760c871b7d88eaa18c6c0d4c4f42e20abc46d4914935d69728d", "run_id_sha256": "28768f565659133f5bf1170e638b81de4d7ca38dfecacd09ccf462a35344432b", - "runner_receipt_sha256": "0559c67e2109bea9b527eaaeef98992c12c687c01e8906dec8a87d24c626e792", + "runner_receipt_sha256": "1aa0752945c71b8e17838c6162a3a67911fec9a49344b67c0933235a67aa803e", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T10:21:00Z", "task": "execute-acceptance", "trial_index": 1, - "webhook_receipt_sha256": "a568e4172ae077650c03fe76891b0f0592699afd2e87c9e60ff669d78c484cd4", + "webhook_receipt_sha256": "b6d3dcfcf35b033f7905b3655232cc403aefc0c7ae0265d08e9c684a20be3042", "workflow_version_id": "44444444-4444-4444-8444-444444444444" }, { "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "2601335b1101424105277997a67850a8a60aa45f59637b7679c1f32af463c460", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "8aec61997da4bb5f9445dd4625b2d07f5a94688dd77d182d32b47cc064f12902", - "cleanup_receipt_sha256": "61152c7946d6e0b701c6ff999dc1b1b63b0bdee8c4754077ce1909f5b6d279bd", + "cleanup_absence_proof_sha256": "9d87353a1de7c009237dbe68a433c36c485ec2ba6741e274c0b7afa5fdf57056", + "cleanup_receipt_sha256": "754e94df2f1696ba724d94b2a9251bd21cbdd4a00fd7a7438a2ec3ca84a44b6c", "completed_at": "2026-08-18T10:23:00Z", "condition": "healthy-03", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", "execution_outcome": "verified", "failure_class": "verified", "fault_receipt_sha256": null, - "observer_receipt_sha256": "7bd04520d9af9cf9f2f39acffd0fda362dd5e762823fcc38102fb847a1b803e8", + "observer_receipt_sha256": "0cad49aac81954a3956a1d83e7a515d56f5ac826780f3014d4a798939c2170d8", "oracle_verdict": "satisfied", - "replay_report_sha256": "46db9b4b3f93076b0958db1375ebda5a9fec42081d32df4d1bec5e0b45bd39c0", + "replay_report_sha256": "b3d5d2cd580d1b11ec8ed73f8e9a1eeb228c8ceccf80344956742cb0291c124d", "run_id_sha256": "237a0b7d1cafb64b1d113dca6699e6eefeaaf0b18679138545c3695495b901d5", - "runner_receipt_sha256": "f805590013237b1a309cbe766022724f3d5d0b02262b5aa432bfd9347dd7a458", + "runner_receipt_sha256": "abf35f66135e4a90f2ed209bfdea0e216caea560808882a9aefeefb726b18cd1", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T10:22:00Z", "task": "execute-acceptance", "trial_index": 2, - "webhook_receipt_sha256": "64044bd99feae9406b2089417a4e5b33dca8a65bc8c4c0227b47594912bf71c1", + "webhook_receipt_sha256": "93baab109d6523059e7d4a73e9d1fc956a9044e9db22d1cad206bedfd3103cae", "workflow_version_id": "44444444-4444-4444-8444-444444444444" }, { "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "7573925adbd8a7a4a3b98bb0379549d77aa8ed46e312c1cd940c05b8587a039e", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "2e9e8e01ec1be899f4e038599fc64adbc3942c35c0565bb67e17d382bc5ca8a8", - "cleanup_receipt_sha256": "e7523a67b0d470b2e2f7d4ade8435b4fb6b5d1289862b50a57b7be2be42a84ee", + "cleanup_absence_proof_sha256": "2d0a8725e625c8e184f24040e567926e25ed8581cdd81b8fdd6fd3a541ae654f", + "cleanup_receipt_sha256": "1232a18cee15367a5d3ce78845fcf11596d663db51ab52cfea03af806cec8e3b", "completed_at": "2026-08-18T10:24:00Z", "condition": "healthy-03", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", "execution_outcome": "verified", "failure_class": "verified", "fault_receipt_sha256": null, - "observer_receipt_sha256": "3cce0307da3bad33d18f117ca01623c6baea1b925048bef9a82fbb3ea576df62", + "observer_receipt_sha256": "c24f3d6cfc59c474c462107d22c1a2e6c07f9dcf011e9fd6e0675431f07845ce", "oracle_verdict": "satisfied", - "replay_report_sha256": "4c3a2f062bd550c473b950f0dffd59d3526f54fadca154c653cc7f0011b9d31c", + "replay_report_sha256": "4e237911933aebbe68ebbcecf56b199605ac887e6a533d2e5a77144a40cd29e3", "run_id_sha256": "784a0a94e581700a3d93581e7ce5bac0d3bc53c58f3e73198b896b5da9a819b0", - "runner_receipt_sha256": "18343a300dbb47883fd932d0819e5b92aeaa6ad60dfa82ee8b66c6ac3190fbed", + "runner_receipt_sha256": "0a477211aca518342785bbb8cc7c46f335d3975275c11ed82db007b3fa29aa40", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T10:23:00Z", "task": "execute-acceptance", "trial_index": 3, - "webhook_receipt_sha256": "23f53c85f34d6013ca5c2961470deddd7bc790d5096380b677a9bf5e83951335", + "webhook_receipt_sha256": "0260e65a8dee1f8fb0b832612e9802162774e2564001103b70488d986f76a481", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } ] @@ -308,75 +308,75 @@ "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "3142933f4f168c98b8e89f2ae9d78fd3129e0a9975cbbaa60ddba853eee7d53c", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "623ae0f6cc3220ffa04c016943dc42361acb180e7f5649b4b410e3661063a450", - "cleanup_receipt_sha256": "74bf2158a084de1057a2f9332e58a275be7e26aac5b1ff5ccdb29efb49923593", + "cleanup_absence_proof_sha256": "4d7d0b8647873a25e83f461377d89e4fe37b6f853636de8b383e90af2dd8c1e8", + "cleanup_receipt_sha256": "5b03fb13947284792725f63b6c77618288359007132179709aff2d05013fb5b4", "completed_at": "2026-08-18T10:32:00Z", "condition": "idempotency-replay", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", "execution_outcome": "verified", "failure_class": "verified", "fault_receipt_sha256": null, - "observer_receipt_sha256": "4975d0d0574f5e4ed180eae087569cfb1b53445945a9e03f7bdc0b51aa40bfa4", + "observer_receipt_sha256": "966cc812c23ff6b11a0a6222f12c32a89fe0a2874a50afd756d52ace26fdbc9a", "oracle_verdict": "satisfied", - "replay_report_sha256": "7680aca959060d5c6c03586cd4555132a94bbec661dd09cb82aa51f0fdea9746", + "replay_report_sha256": "451799703f325f594a96b3388bd3c5c554d64c1aa25994d905195b7a0ea5790c", "run_id_sha256": "6cdff0cf50d0164fe1eee9c4b7db0b969c24f9b960f5653b516313a913c90a0f", - "runner_receipt_sha256": "1cfb44a34276ac71b453562485ff70fb3b5f0c5d0718632601a8f05f62280cd5", + "runner_receipt_sha256": "b5dd17365119ad6646ff53896c26124d41a307dba088e230d63fd6858fd4d7b0", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T10:31:00Z", "task": "execute-acceptance", "trial_index": 1, - "webhook_receipt_sha256": "914f5d551d662ec06a7dd8f330bd5256cf317ed0d280fe1da10fdb296c9e9b5f", + "webhook_receipt_sha256": "ad2b550928fbb0369b1d1da2f2d50964d55c396ef7766f46f6578e52326c8af4", "workflow_version_id": "44444444-4444-4444-8444-444444444444" }, { "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "4667302b580ff7ceb223dbb15eb6d029969a8f6a54bcd33e8df5b6bff41f41ad", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "2cc546bd37198e76ce6746f03869d3382b12582987ca76354cb1f4c0b913325a", - "cleanup_receipt_sha256": "67aef634540cce7bb70a512081e96ebc7edd41e8bb8835891ce1378efd425557", + "cleanup_absence_proof_sha256": "33d268608af6e0d7ab9a6106fb8fe52196d02b1185ec764489a6f629a852727b", + "cleanup_receipt_sha256": "d34a532ac4e131739dbe4b1a354fb69615588aba68d7b32ece1a67e6475d1de3", "completed_at": "2026-08-18T10:33:00Z", "condition": "idempotency-replay", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", "execution_outcome": "verified", "failure_class": "verified", "fault_receipt_sha256": null, - "observer_receipt_sha256": "76f7d5b5fc039b3ce624e887fb4e076bfc10f32577f8a3c72566678942ff8bea", + "observer_receipt_sha256": "91f0b4623e063b41aebdd6454810950e8ae05b8f33422268de99a3aa158705b7", "oracle_verdict": "satisfied", - "replay_report_sha256": "d8c483eb7b08e73b722f6a305a73fd8d2a4e36cf0339e42774d7fd5b64650c5c", + "replay_report_sha256": "b1ca427c5147430f04e14f2f6ce94a864ef58c1216b5614b8b8f6738e6fd1140", "run_id_sha256": "33e0ad9bf64e477f24d46508fa432123e046dcd1c5853d5cc60b7cde1bce7537", - "runner_receipt_sha256": "eb27d821b05fccea7ed8b1568a4607b8de8b629e8f50cba1e543e4af416045f0", + "runner_receipt_sha256": "a58bfd664642a35143e96f9bc279f6cfafd4888aa3bf2538f07d7cb82495c2f5", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T10:32:00Z", "task": "execute-acceptance", "trial_index": 2, - "webhook_receipt_sha256": "50c2a328d61a13cb7fd97b9eafe0e28fea69e930de081ac511e2023f3596a15c", + "webhook_receipt_sha256": "e066293a7cb20f3bccf77602b6bfe1176453620852f969fb0c66ef9eea7d4d1e", "workflow_version_id": "44444444-4444-4444-8444-444444444444" }, { "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "3aee8ad755c7f4bec71cc194bcfaa805e0ea29cf8b830ed0782f8263dd9620ca", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "64adf7272b03ff909a4d9420d130a4755b4925ea6f6e76341b621a79e975a5d7", - "cleanup_receipt_sha256": "ad0a42eb042759c673eb9a940f4924f8b054fbf2ecc5b9d6bdf9e16bb1996caf", + "cleanup_absence_proof_sha256": "19effcae09225c0b10316238d0b4686931c70297a9d44c913784a5f74e09bad9", + "cleanup_receipt_sha256": "778948228fce99d1ec2f8fc2f17c43e39ad4ec5e59bcc78ca4204f989622c938", "completed_at": "2026-08-18T10:34:00Z", "condition": "idempotency-replay", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", "execution_outcome": "verified", "failure_class": "verified", "fault_receipt_sha256": null, - "observer_receipt_sha256": "3f5b7d5d21d2bd5fdff3bfca3f28f239673753668c9007bb04d6541fb3ef2226", + "observer_receipt_sha256": "281be7f9049010d1e52cb8d54cc76c316126b091df060895e6f8be1b17bf99db", "oracle_verdict": "satisfied", - "replay_report_sha256": "11c3e276c44dd5d91dc79a7c94803e2ee06ae40712905927af21104098792fd4", + "replay_report_sha256": "65e06f16ef02103f69137135bcee9383043a2131983fefa999ce909cd0098be4", "run_id_sha256": "3df83453126754a62d00ed10837720542d0469799bb8a88cb5257ac5f477a919", - "runner_receipt_sha256": "be17be06d1fa1a089368e219302e3a4e142173b4c72e574c40410477d4dc2a2d", + "runner_receipt_sha256": "3eb6d6d2e801576d307357fb896f0ebf571681fc2bbeff7dcc0e922ad0675cb1", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T10:33:00Z", "task": "execute-acceptance", "trial_index": 3, - "webhook_receipt_sha256": "7d63a530b52e8faf6e3476894739e626da62bc5df1ccbe74ee9645b7fc8ef05a", + "webhook_receipt_sha256": "8a53a6788a7e538654cc1512c401949e5fbfd9a44cc4b7e86ac235ab702d35f9", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } ] @@ -390,75 +390,75 @@ "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "e93521e706ad90d799dcd4e8cac15229c5da6aec1638540606f5fab4efce59fc", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "50ff634de0b6e29c4dfec89dae15e01e3872c32eff0ad8473e3eae442ea9f45a", - "cleanup_receipt_sha256": "06483a5a3def1a0eb09b1623870f68ef9ef1f5c923d10e220b4acbbecd3a0ff8", + "cleanup_absence_proof_sha256": "dba84e28fec7d0d05c90b7598eb773e94b04e02bb12c64e8093da4562e1c65a5", + "cleanup_receipt_sha256": "1b1c89891a20c8f3a60fa6a1f5b11b5a46124864a574cac12195ab760a7517ab", "completed_at": "2026-08-18T10:42:00Z", "condition": "wrong-reference", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", "execution_outcome": "halted", "failure_class": "safe_halt", - "fault_receipt_sha256": "61de0f8814b796a5fc827d229ec0a83d37e81a097a8e8a0ab276d0eb1a274ae5", - "observer_receipt_sha256": "7ed9cc546bbca6006bf1cde43b11ded649bc2f080ffbf74b3e820d8775e05170", + "fault_receipt_sha256": "9ba1afa04fd9f4984ec6caa3bb6dfc33139043b0e59e04f1213946d5b6897401", + "observer_receipt_sha256": "646931da47f53dca5a34ab118624a8e7fb42e895b13070a59d42b59870574155", "oracle_verdict": "satisfied", - "replay_report_sha256": "061a034a55abba5d6d8a4b22dbf24c70b016b7c1b06fc24b9fece9a3b1e0c933", + "replay_report_sha256": "16bae61698645915b877891241da1b9f838d5c12f67c3fe9044468a95b46c1c6", "run_id_sha256": "ee82112f55e5e6c86cfd6e16df8c8b652549a8bd72de492f435d8255eb3dd252", - "runner_receipt_sha256": "db5e2e6a02b80563230b4d36825d863af418ec707ae81789cc9001052351cc8a", + "runner_receipt_sha256": "93f8813fd20e587ec1a7c00d318bb5e4267292d2d46f25dda70486cc3204e082", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T10:41:00Z", "task": "execute-acceptance", "trial_index": 1, - "webhook_receipt_sha256": "290c960538dbc38ee2260052e5b97353e41c9ea3572cf627dbb2d7ce1124eb9e", + "webhook_receipt_sha256": "2638fa03d72aedf3ec3b7dad2bc7e804f3298b44262723db23d99f4202ea063c", "workflow_version_id": "44444444-4444-4444-8444-444444444444" }, { "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "6b0e5c10d55fc92c1ff8576392270a24fb65722414cf58ff9a51b8ce9ef88587", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "a4f8f64f3037b61213ea0e1e562cce78f79c336de874f207224906d671a84531", - "cleanup_receipt_sha256": "5653aa19c3b4662ef8d1add74e5911af8f972791895812f4fec40722fd8af7e9", + "cleanup_absence_proof_sha256": "ecd29911d1235cfb8ffe707f0bae080693b68a69ca99339d51f630f37bc637c8", + "cleanup_receipt_sha256": "f25e5c3af01ead7c9c28efa1cb943b21d7784ef24cc55917aac60209f1d84563", "completed_at": "2026-08-18T10:43:00Z", "condition": "wrong-reference", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", "execution_outcome": "halted", "failure_class": "safe_halt", - "fault_receipt_sha256": "d8db564da881ce1888bee8e886f149da4ab06239ff1325fac6f2402738c33480", - "observer_receipt_sha256": "379bdd3e735612de1d2a7c4860a87692e78175e7425ffdbcb65a45e2c205af28", + "fault_receipt_sha256": "c81b91f66fb62f1c5ceb740978670dd0a834edb192cbfbb1d3b693fa680e52d4", + "observer_receipt_sha256": "22bff5bcdee9fa55620524338cb0a162bb592e0c237c0ff33c3eb83ffc26f1a6", "oracle_verdict": "satisfied", - "replay_report_sha256": "14233009f4f65cd0a0fa81a233f4d0cc48d7f6c9b8d6f9ef8e2c12b8593047d3", + "replay_report_sha256": "84b89d7009d9583a5dcb13564ec0ec9264603f2ea4bc102c3d5c1b426ce7696c", "run_id_sha256": "577e37b10b1c87fd9c1b5d320888b736d272824657fd59a012e85a284ee88540", - "runner_receipt_sha256": "272e2c3c224b19f532d7a894d08b28f94782824ed6cdf90a3b216b2ded828210", + "runner_receipt_sha256": "61d2951f335e53f8920a7f84739d8a458a61fb758ee671e8066dffc6377bff66", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T10:42:00Z", "task": "execute-acceptance", "trial_index": 2, - "webhook_receipt_sha256": "def8a0faa88928a2b87804705ece6f712edd9aeb7ca4fed4e066fdaea75229ca", + "webhook_receipt_sha256": "fdf2bedb4e2aaa2f2d45e711f95e827d4ca19cab6eb6718d496a7475806c0d86", "workflow_version_id": "44444444-4444-4444-8444-444444444444" }, { "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "7c910764b2dcc6f05261d609082f75474e4638c3f356006307212b8fed4a2eb7", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "c0f41eadbf7b50c360fb45ee132b23ba8b45bbb4d32cc7a96517d8a82abd9afe", - "cleanup_receipt_sha256": "24a0e21ab6813638a727b551149261a2220c7d3543d655234d685fc9d3bb4133", + "cleanup_absence_proof_sha256": "147acdafbac824c94ff5329bef4d95efb8d3a4df3beb51e9c7488b8ac6346598", + "cleanup_receipt_sha256": "fca88ce0fba3856df363b1ba4579be6793c2855585ebdabea4ba802d9cc8f0e3", "completed_at": "2026-08-18T10:44:00Z", "condition": "wrong-reference", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", "execution_outcome": "halted", "failure_class": "safe_halt", - "fault_receipt_sha256": "db47eb5e8daad06624900c87959770bf1bddc5e74e391b0e7a7e31ce9521e8dc", - "observer_receipt_sha256": "b6148432883a666f0099767e8e3a51c46b65e8f765b75afc9106ceccec1c2e5a", + "fault_receipt_sha256": "5622ec557cc98e8c2ca579e0777675c67934fb50b3559142125d7eec48c2d105", + "observer_receipt_sha256": "d8023b701bb9ddd9447290b34a26f019d4d699127273f0fce20637e6df56dc77", "oracle_verdict": "satisfied", - "replay_report_sha256": "01e0e1e9f8d50d08a1e6a52833cbfb490ad0541a2b67b47528ff6d0fcd4a0219", + "replay_report_sha256": "f55bdbcd08d65a4b50cc7672431077eb7b800690a249ed624dbfee53e9b54269", "run_id_sha256": "fe98ce7f0e66b885201f4667875fd38f5890ffddb575d68bd4cd5a66f8d53ca8", - "runner_receipt_sha256": "41c5089c652797dd8892e0d7ada46912cf69f72bcd43bee7170b65f3ef278f7e", + "runner_receipt_sha256": "1d1c84e8e6603fb4ba62b0596df7282e207a1fde10e6549424ae32b6e0aa22ee", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T10:43:00Z", "task": "execute-acceptance", "trial_index": 3, - "webhook_receipt_sha256": "624fbbdd7880133c85ef5e91662bd815d4f451b168876822f76ac149caba0b11", + "webhook_receipt_sha256": "ad5d7b5de720923a39775e10003814af4faa1d83050c2111e02108e2d7197eb9", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } ] @@ -472,75 +472,75 @@ "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "fbfce2be9ce964be8b668aa518a310fe4a89e5c014f42bd0ea81401bd83bfd7a", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "deda444b535e16e5e8c0b26f674bb9facf018b808a1c734a23d2b75101819f47", - "cleanup_receipt_sha256": "532808072697066585e9e78c84eb3df8a14d22f57a3499cd47a1a26c61062330", + "cleanup_absence_proof_sha256": "4b87f6f4552386044d98c2368ce0de712ddf4ca52825630502500be29a04081f", + "cleanup_receipt_sha256": "ad51ef4fd9a3c9bc18b6ff60954b969f569425362fae180e6a79f41ef2ca8f52", "completed_at": "2026-08-18T10:52:00Z", "condition": "stale-session", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", "execution_outcome": "halted", "failure_class": "safe_halt", - "fault_receipt_sha256": "57af80b4f9c67ba20ca7749c4d68e814cf91aba0141012d9f7385b7d9ec3f60f", - "observer_receipt_sha256": "d798a4e28710daf65f49160ea167bc715efaea32bfab50c3d577df9d45bbad8d", + "fault_receipt_sha256": "eca7232d2c8d672f305cd7abf41def93d615c0e5d58c38a64650fca637451c39", + "observer_receipt_sha256": "4278319bd324c7f5a84d181dcf8bda9862df008985b35ece71534aedad24f35d", "oracle_verdict": "satisfied", - "replay_report_sha256": "b8cc1d45257e2e92b93bff7e19fbd9cb80a18ba97f174f5b2983ff73ba8f627a", + "replay_report_sha256": "ed607c93d7fd7a73cc0b3b1209196d79e3c6b4b2a85e3ec6e42832071e531fbb", "run_id_sha256": "d9270fd4c85e4226a9347ecf703e876b9ffdc330f60c7fb8bed8f9321ea30225", - "runner_receipt_sha256": "873af0327d6a3360731e326c236f2b05e1220aa18a00a83d0c42b6d5012f0c08", + "runner_receipt_sha256": "fcb2bf205f9e28e2bf93fc9ec2221798ea7ca0c49030c9f54ab594c5230ea767", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T10:51:00Z", "task": "execute-acceptance", "trial_index": 1, - "webhook_receipt_sha256": "6af0a975d21278b3a18e55ee5036101ea423eb08313a1923528755ab608c889d", + "webhook_receipt_sha256": "7676355320476b68f3da156c4eb5cd44d8ec709d9cd850dfa56d43a2af507ed7", "workflow_version_id": "44444444-4444-4444-8444-444444444444" }, { "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "f5df4d6e64a2d38ffa8e320c87ad05d04025de267a8e152a755d3f1928ded120", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "1ca68224ff7ed710e02c185155a819a937f0297aed33d249c351ae3145706b27", - "cleanup_receipt_sha256": "a940f273dc2d98ad1504d3a5308e8a53af1d16f8801c2a15efaacbe548ec3efd", + "cleanup_absence_proof_sha256": "107427555cd22ed38dfb6f47a853efa8afbbcb2ef008438d77a34b4fb0a21098", + "cleanup_receipt_sha256": "bec2c6b69f200513b28114242c99b368f4421b170db03818198c02d41687b223", "completed_at": "2026-08-18T10:53:00Z", "condition": "stale-session", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", "execution_outcome": "halted", "failure_class": "safe_halt", - "fault_receipt_sha256": "6944fec3e81116c5e5fa95147eeb513a8d68d388d64b0269fa617cde342b9f4f", - "observer_receipt_sha256": "741bb99666db76220c53c49c9729b0f8b75036e458f2d75542760ad6581184fc", + "fault_receipt_sha256": "0f613cfb3e22315db9a58ecacb76b19af191682f66c3597be808174bb448c050", + "observer_receipt_sha256": "5786a390d019271aab73fe18af1d56a98967bc512203af57de551696d5059a50", "oracle_verdict": "satisfied", - "replay_report_sha256": "9db2b18e2dc3cf9b5d36401b3b39deff53f42376f1ef0e4db7e5bf74f8a2d41c", + "replay_report_sha256": "4a888f9ee89279affe45292f04fa94f912699b1f6baa7d920ec69dd76d2d10b9", "run_id_sha256": "fd3a041b705d8c6277ce26134dc0018e866218cfa3fadd16ac29d1ad498965a3", - "runner_receipt_sha256": "d8c7108342370f14c1531094e3fdaeecea401a7608d17e2873dbe1ac63b71982", + "runner_receipt_sha256": "8596b07cf41f10f0fbe9aa0ca392ee4145c40ebd7f72bf8a0ef96d533c597128", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T10:52:00Z", "task": "execute-acceptance", "trial_index": 2, - "webhook_receipt_sha256": "4830780f8c7ad36604ef1bd4935ae8ef598ac06c766368c7cadd8576a1d293e5", + "webhook_receipt_sha256": "2620b39835a746527f83d880cf3f1b0374cca47780af38a4efc1ba747be084c0", "workflow_version_id": "44444444-4444-4444-8444-444444444444" }, { "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "958342a9ddca98a83b82b662f52f404239d583afe7ed70634760e1b8dd592f3b", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "65fba274ba6ef5364ee1212f448cacfa222246d4c278b29535b3569b9bfd699b", - "cleanup_receipt_sha256": "9a7ff6004d469b48ff0888078d491586e9590f75f13abd4764fd6295eb6aabb7", + "cleanup_absence_proof_sha256": "aa03bb52368f1cfa082d5cf602622bb97606d6132a20cd3bd61b9c291b35aa2c", + "cleanup_receipt_sha256": "02047c3a76ee4b185641a5abcb6aa06f7d8ba94f538fae3a094e3a17cd7fdb54", "completed_at": "2026-08-18T10:54:00Z", "condition": "stale-session", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", "execution_outcome": "halted", "failure_class": "safe_halt", - "fault_receipt_sha256": "4649e4901902dd6aadb3108e0f89bd75854f5b64b0d59a28e567596a4ee75d58", - "observer_receipt_sha256": "2798955cd738b419669697b8db8cfc4ef28861e4a00851f5addcb2967214c10f", + "fault_receipt_sha256": "1e197551aad35da7b62616ed2064350f16c22455affd1520be245a8b408daa49", + "observer_receipt_sha256": "c4e832e3ce0b587c8402ac1ca08e46d5176e306066a5a5c9d913928f133d4c79", "oracle_verdict": "satisfied", - "replay_report_sha256": "0eb5ab24ba6f40dd5d6e9c060f3a241672cde509dc3483dda42ef27fd76ff9cf", + "replay_report_sha256": "4b71aea00cb2a8373d5f2a1534c5c48ac189ca863ad55ad8c9720579afb6fe7e", "run_id_sha256": "6f2fb10bc2018c9f78e9702d5ccac0bedd78ee3b2e9d2a6ad779fba72d90ae50", - "runner_receipt_sha256": "83a40647d6d151da844fcff4f96c40516ee57ceae72f370078106244e2efb750", + "runner_receipt_sha256": "83a6ec6781549ddd4a7798e1c2434de963dc5e7c9589022d8f811c96c56b98ba", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T10:53:00Z", "task": "execute-acceptance", "trial_index": 3, - "webhook_receipt_sha256": "e5448eebaa458e6a8c2750acff6634232de77856d5c9920769cb1c3c90ab7b56", + "webhook_receipt_sha256": "3528e48ccd24590f11280fa664f1d115109d55bbbadcd5fbe6eecf184bfca700", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } ] @@ -554,75 +554,75 @@ "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "60ee9db05b1126cfaa3b31c13bc3fab4755ac09c44e846b4d07ee51865dfa7b1", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "2a78ce1f942edcd37931679bf672ad893a1cfea2a6a027c0210f53380c083cb4", - "cleanup_receipt_sha256": "39a0a13faa3fbc11b08573ce721f16a0312f03f22fd3f8066c1ff74a34445b22", + "cleanup_absence_proof_sha256": "7a6bbef1d68871f1e8195e05991b676613334e8a201812dd911532a7e4f6c209", + "cleanup_receipt_sha256": "9ac20993310eb294d1c4cb9e279d8c5aaf11ee59cd3e506d5ccbf5943ed67e16", "completed_at": "2026-08-18T11:02:00Z", "condition": "ambiguous-target", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", "execution_outcome": "halted", "failure_class": "safe_halt", - "fault_receipt_sha256": "9842d656d4d92597e76248af6b34e1577d204588dd9b446cc98424630c4ba79f", - "observer_receipt_sha256": "695743910a9a3fc4f38f7cef21f960b3ad157b1c971cb6d5858c866f10eecb7f", + "fault_receipt_sha256": "334274a59422c99002bc020a2553b59795600d288e3c0f376d7f3aca64207e6d", + "observer_receipt_sha256": "7907acbc65d0fcf1f5e8f336840294521ef04443d50decf218803f0c83c5678c", "oracle_verdict": "satisfied", - "replay_report_sha256": "23f4a977cecbb6af1ccef4d88c9bd19fc9c474c0a382a0e22ce7bec1aeb706de", + "replay_report_sha256": "b7f1ff5698484b8a9212e8b144b29a955afef9165666f9ae0ac3ec662400d967", "run_id_sha256": "628f991a182613b8700294d7483b5a4c06872cb9d5ca6047ea552b8ab6585357", - "runner_receipt_sha256": "b661cb27d6061e177a2d7305a99de342ccf5336168bafbe9d0356c0ad65c92b8", + "runner_receipt_sha256": "22c39ce4d6ef15d6eb6243bfc69a7275e58db27312b1d7d930a1536078d2dd1b", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T11:01:00Z", "task": "execute-acceptance", "trial_index": 1, - "webhook_receipt_sha256": "1d8f4884ac384317209d4a4116a19a597a60f7483bacacc99a81adcd01c666c5", + "webhook_receipt_sha256": "8f202eff0bbb187e9a61ca28eba51b60540b7de0e437ff036eea34c416bc8418", "workflow_version_id": "44444444-4444-4444-8444-444444444444" }, { "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "1ec11a9862ede3ac701af71835ac28c551d604a026b5bab7d776dbcdf288394e", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "620ac6e3d7907f00bc17a13c98a6f49d1b6e5f4be2f45e348f07b8cb680f1f81", - "cleanup_receipt_sha256": "cfd92154fe2f468fa965ab716b63dfdffaab97240c67cda15b262e993ccc3b08", + "cleanup_absence_proof_sha256": "2767e751b8937c1513ae768a938b63cd93762cc38ffeffdee4817f7f6d37ca26", + "cleanup_receipt_sha256": "d60014d00d95de05d2aa6c483badfdc804e23c55ae4507eebe8631460453bd80", "completed_at": "2026-08-18T11:03:00Z", "condition": "ambiguous-target", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", "execution_outcome": "halted", "failure_class": "safe_halt", - "fault_receipt_sha256": "42e108a2f781e3945e94c43caabc5314a03d47af1caf8380b032300a206a914c", - "observer_receipt_sha256": "d11f22309560ed2a7f681efe767e871d45348f2d0a1d80616d8e4dd7012e0044", + "fault_receipt_sha256": "d4ff41fa574ae654044232a2f68be2a6088f2fca4634e84f2c9bca25f0fd095a", + "observer_receipt_sha256": "e99df9ae7a8e510d9ec14c8726238fb981612f4b41b0fb4bf26290627f367e5c", "oracle_verdict": "satisfied", - "replay_report_sha256": "f7051979b50415fc22bf21c2e154a96b44c6e20344ac9a11cf02a7ed66576f23", + "replay_report_sha256": "afded6110d5028aa1b83ed86fd9ecdb3c150b78499a205edb43a22fec07cc910", "run_id_sha256": "43f0a1c00950c390b0676fab55a2aa98c354d028f2347c461661e6cdb72f717e", - "runner_receipt_sha256": "be4bcc0de90d3e47d83b3285b71c911aab5367c05949bc04f422a1fb60ec606b", + "runner_receipt_sha256": "195462d5c56f99e872198cfd32853dc2a4a2cfd6405ed76810fd873f3c186004", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T11:02:00Z", "task": "execute-acceptance", "trial_index": 2, - "webhook_receipt_sha256": "0b700db3525db248fddd3cde06607a194c809c76d5cece6a56745202ff8f707b", + "webhook_receipt_sha256": "3400693bec4a39f928c7fc0cfb11b395da48132fdef98e7f945c08beaa11ab68", "workflow_version_id": "44444444-4444-4444-8444-444444444444" }, { "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "491a544656d05aea37920e5c7e2ad65a9452eac8d6e100268a599aeebd41187a", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "9b67f51c4c82736ce53e697d96f9d24851bd56aaf11882d44ded060ea9417a8c", - "cleanup_receipt_sha256": "b6865344d649c442168a1a23f725bde6cecc3c2a2ac876c58aae1f28ed3fa044", + "cleanup_absence_proof_sha256": "b86debd9b84efec758faa9783e4217377e236001ddf878af9777e6f21edf56aa", + "cleanup_receipt_sha256": "f913628ac65d83f9342958c04e19732192bb7f2193f33071135bcc5f9c493e0a", "completed_at": "2026-08-18T11:04:00Z", "condition": "ambiguous-target", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", "execution_outcome": "halted", "failure_class": "safe_halt", - "fault_receipt_sha256": "353a8e94bb09676bab144917696e954ea6351cb3cd171add5e2abb6c7134d61e", - "observer_receipt_sha256": "35fde2e03b3dc98d4b7cd66082f330ce9f3501d4d236e4c5394348d85e7f176c", + "fault_receipt_sha256": "5f681c1375640e41f164a53a2464f560799ba45eab374a2400d9b42eecdbf320", + "observer_receipt_sha256": "c46270bf2176e320a219266b0ae6d15e66d0fb995a15eb52265d3623119ce6cd", "oracle_verdict": "satisfied", - "replay_report_sha256": "1aeb42c46a7567c1fa5436e662dea85f649029f4a03e573907f477dab40e9653", + "replay_report_sha256": "de2c701e952f9671103a4393bd10eeba2584ca9fc6cca70316ae7c641e5b85a8", "run_id_sha256": "aa62c7a17701a7ef01ea1d3519b4c1f90d357495b329fdda3054cc24c581a593", - "runner_receipt_sha256": "49e6a4db6325d7245a2f8be4ae4d3defe236bf45fe8cf7775e5126575652a805", + "runner_receipt_sha256": "635dec4af95b2901a525ee8229fb3c403325e977f6ec35fea5460e7664b00a68", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T11:03:00Z", "task": "execute-acceptance", "trial_index": 3, - "webhook_receipt_sha256": "9ad9415421ff129296360281cd537671da5f6894ab31b17254eb0d15aa976584", + "webhook_receipt_sha256": "5e2329eff39ff0461a3a4a814a167dacb574c45421ac5bd23b76a3b0045cfc4b", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } ] @@ -636,75 +636,75 @@ "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "f5e96a2e9a580376b18beabf57798b8761e772a0c4d112877045780bb12b3720", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "3e7ffe28a48816b6b63017f4d4e4fd2f3c387841bc5e8bfc14fa4f749653cf85", - "cleanup_receipt_sha256": "f308095e47a50231e48617fde6819ea8f160be521f2583b601c6f3c9918d3761", + "cleanup_absence_proof_sha256": "dd5e5c33b9db56b55fc0ccb1af376a113efa131da3bea56b565aef3ff5759516", + "cleanup_receipt_sha256": "a1ca7dc9135e1a2ebff6416e6b80fa32b44f88a9fc5e30c9a2acb86997245739", "completed_at": "2026-08-18T11:12:00Z", "condition": "verifier-unavailable", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", "execution_outcome": "halted", "failure_class": "safe_halt", - "fault_receipt_sha256": "cbe1607f5b948d288e9fdb6ab638d5f3cde433d739670d52bfd0a1426d560300", - "observer_receipt_sha256": "a084fd73559d8b3db4eb489627c23d3fbddcb149c5f22bdc0f21b3057fe78fc5", + "fault_receipt_sha256": "8d6cd13595cc62db5abf7d5b868ef4662660977e235bb3c49ea6cc607eb6137f", + "observer_receipt_sha256": "892e05f5233be53abbedfeb5c739f527a72cd00aa5588b7cd85b38d79e3be395", "oracle_verdict": "satisfied", - "replay_report_sha256": "de88bb941c8dcaf4123f41230b235a5097a327e4408dd496c8a658bba071fc6b", + "replay_report_sha256": "97063a395176b12f541ebd423aa15347f5dfe018b77bfa1ee882140113d2a59e", "run_id_sha256": "e8e89651045a5f5c011c9543ed968e0fe7697a061ed8ad5cedc27d194cb96acb", - "runner_receipt_sha256": "d67f951f5150477f5b6f23fd49cfb5dfb983c77c6f000ed977da83aa142ef62b", + "runner_receipt_sha256": "767088dbd029bd114a97ac8b4aead8dd3684260f29a510f17247e869a1638c79", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T11:11:00Z", "task": "execute-acceptance", "trial_index": 1, - "webhook_receipt_sha256": "5c27733530c91746965049d5f68a6941c1b64018aa0272eb8eca9a1a086386fe", + "webhook_receipt_sha256": "60421bc90fb169912a5e28939426e583aa946aed608688d2bc8d6826f584697b", "workflow_version_id": "44444444-4444-4444-8444-444444444444" }, { "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "42259dbb767ced4c25ad8bd40edc209720a748897194c925ed9bd2e27b2258b2", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "a1e2cf48ee6a452726941504cdfcb692d395b1d31133f828215e77c2ac8228b5", - "cleanup_receipt_sha256": "e3d0a44d6733f68ad2f52b4ebe689b65537b49e3e2d2b06c7599db54a93a36b9", + "cleanup_absence_proof_sha256": "74228591b612613ec96863c47e901cc6cd28a58b97a1499c42c95d38ebb1aa17", + "cleanup_receipt_sha256": "6e98856f3363123ebb77e70e55b34aa80b64121bdf434d4784907d8565c88ab3", "completed_at": "2026-08-18T11:13:00Z", "condition": "verifier-unavailable", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", "execution_outcome": "halted", "failure_class": "safe_halt", - "fault_receipt_sha256": "aa9087e68e6a8479b57a4463ffc5c56b32f86c74f9b79f6a507b816a68ed843e", - "observer_receipt_sha256": "ae850dfd7e4e0688962457aa9c6277ca031ff48e9046ecd1339ba5ac3a8bc8fb", + "fault_receipt_sha256": "9a75b4d66f9d29893a765a475b5379c6a8f7fe61aad00dd7e2155dec590910cb", + "observer_receipt_sha256": "9ce0903a48e097fdfbefd60e74faf245a965a2522af782e3bf1281bca4ce21c3", "oracle_verdict": "satisfied", - "replay_report_sha256": "cf1810125ebf9f6238ab3d93015329a48e69eeb4c925ad2cf6d658d08b492b3f", + "replay_report_sha256": "e8bbd93c51bc2e86b09e750273dd69c2d90b06a93d4eca6f1511246a32021c49", "run_id_sha256": "4af84f2608a25a27e6252a5800263a238bb70fb3bec65148601ddcdddbf3e03c", - "runner_receipt_sha256": "5634cde23250446592813e4ebf81ff20cffd3b116818f8d8a4297d175e993be7", + "runner_receipt_sha256": "cfb9cb21f36c357208d9826a4ea328a04ecde3ec93ae64fcc5e8b4315a618b04", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T11:12:00Z", "task": "execute-acceptance", "trial_index": 2, - "webhook_receipt_sha256": "c2803318f01695a40e402726d0ed4cf471c4f579a3b7c9dcdecb0cfbd3cee666", + "webhook_receipt_sha256": "d03bdf838754ad1716d2cf35911017b3a40e8d485f1427dbc0f213b1feb0337a", "workflow_version_id": "44444444-4444-4444-8444-444444444444" }, { "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "ad76dacfe19a4421ef1f128d4eef1099e846b385d29f17b8588ae5130b487118", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "1bcc8b374768c067cecc0c817d1b424a1823529f712ced903d54b8963338c37c", - "cleanup_receipt_sha256": "08fcec4f61b57e84172aa5e0c0780487ef97b93bdac4801f3f5fdefd8419802c", + "cleanup_absence_proof_sha256": "8abeb7be0161592573418934ec1635b2461315692b4b18164ff0b0cc9eccf479", + "cleanup_receipt_sha256": "97b41e4ab722b2046be90098c4daa16abe2a157b05235cc7d8dd4caebd66cbf4", "completed_at": "2026-08-18T11:14:00Z", "condition": "verifier-unavailable", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", "execution_outcome": "halted", "failure_class": "safe_halt", - "fault_receipt_sha256": "9ecd01ee39fd20d52a6ac0015f2d41508e79bdae57d936cbadc31dddf3f9a1a6", - "observer_receipt_sha256": "cc5c198782b833eac26154a61cbae483021dd950daa665f0e9633a57ee14931b", + "fault_receipt_sha256": "5da9c9bbd77d8909da94a5a1c659e455b60e29c3922b1ce0a0a59d76a637fa02", + "observer_receipt_sha256": "8a166a11aa8642427f58ae8e9690bca1f58db1631d0b837ed72e79cb823267ef", "oracle_verdict": "satisfied", - "replay_report_sha256": "2e9cd2761799c0bf0feef8b9bba65cfb1b5f888d314a2663a33d49cae4834122", + "replay_report_sha256": "dc9ed744fcf4545fe79ed0ec6711dc10c9f4e72adee96bc7f6b2136318dbdba0", "run_id_sha256": "87014cd8063f5a43ea22c995be03ec41ef5aa613145acacdef71b68c468fc8f1", - "runner_receipt_sha256": "b69c63d7548ba4bcd6870077e4a5baedd402af5d7528845cfb9187913a26e46c", + "runner_receipt_sha256": "515a3fd0b57430577ff4d89d14b0c0057e68e3469d547a224f74dab304ea242c", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T11:13:00Z", "task": "execute-acceptance", "trial_index": 3, - "webhook_receipt_sha256": "3f720f6c3da1e29759c17b9ff24984dbbf64bf8aeed6f8d0d33777b54f65498f", + "webhook_receipt_sha256": "b0958e2c3585413ee6257ad04f32a2ddb9303bb999131741c6aed903c7c3e3ee", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } ] @@ -718,82 +718,82 @@ "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "73a097b8b20bab7794369384f7ca1d7d711aad07967b7e1292373babbb7ff1b7", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "c48a078a0d240e39cf8193c9c14a3719048553cf39278f3d0656aaa1caccd55f", - "cleanup_receipt_sha256": "0c1c0a6fd5f726600fcadfc64d5a34e027d4b36d00382877d841b3261360f336", + "cleanup_absence_proof_sha256": "09e51d5a41d651c6bfaafc83cc05e17da95f74b7999f88f07e9179b5eff36608", + "cleanup_receipt_sha256": "998a4c1dd4573e7e7376bfb34aba3b66ad245d8fcbe756e1a860d506dddbde97", "completed_at": "2026-08-18T11:22:00Z", "condition": "weak-effect-only", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", "execution_outcome": "halted", "failure_class": "safe_halt", - "fault_receipt_sha256": "fe7e801fb8e3d5bfbe488815493a91fbf89f99a730cc2544e841f5373b49782d", - "observer_receipt_sha256": "399969b28d2a8a4508e5aba7deeb80a5d10271732c45ec8b771afca68c5019c2", + "fault_receipt_sha256": "225622bb5ee4826536bdfc78065e01c0325dbbb427bb377638308ed5e4ddb423", + "observer_receipt_sha256": "51fb530a271d85665d41cc116eaab112f43985fa0ce8d2937d327e63900d6d07", "oracle_verdict": "satisfied", - "replay_report_sha256": "9c2d9af1bfda87a93cd19e5f83962d6c0332255f487fd35b5a494468cee86b32", + "replay_report_sha256": "77bfbb23e1d36f068e036695786c1e798bc5f5914a3419d3635c2098c0f68402", "run_id_sha256": "b44783e70a980ec5b3cf3752bd5d1d01b2ff29f5a6892cba0c1c939d8aeb7c02", - "runner_receipt_sha256": "8a046aaef8eff4fe4e86a69ef8ef2c0b035131876b0628a7fd6258cc34f1976b", + "runner_receipt_sha256": "8c30814ef7ae80cf5d940cc3a2850d248027e7db11ed074e7a893cc95a8984c3", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T11:21:00Z", "task": "execute-acceptance", "trial_index": 1, - "webhook_receipt_sha256": "f3f0ca82ea31420f48cdc9b1c4cf01adf4e929df1a1b0a54506b4ab4a782de8e", + "webhook_receipt_sha256": "ba2563fdd6d4d4f127a50dbd4697f2c94573f49fd8fe75d24fac23c466ebbcd7", "workflow_version_id": "44444444-4444-4444-8444-444444444444" }, { "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "eb52fb1b1bf2fac92d8f3a444bb5081161be8b3d0ef457c5065e7b79e96df770", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "0cef130f26153da53089908b85e93a0d3d471c44d0216fabfc4beff90f62bb69", - "cleanup_receipt_sha256": "5cfada7a9502dc0499d3b9d2ab92a6ad84e6b2a5b1298a05e006fdac34e9fbb5", + "cleanup_absence_proof_sha256": "99742de45b63e3669313b1cd5df2f410fe373937cdb51d87c05ec816ef88ed00", + "cleanup_receipt_sha256": "ba31661dac19addcaafc411907dd5452099139027ce1e7e342735124bae3f375", "completed_at": "2026-08-18T11:23:00Z", "condition": "weak-effect-only", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", "execution_outcome": "halted", "failure_class": "safe_halt", - "fault_receipt_sha256": "f415d84e6709d0d41f1a9df63018d95b34554defd6ca273b9ae24fb389b0d675", - "observer_receipt_sha256": "960800964e484e67a3e76cdcc336b8b620f46d64b6fce87bdd6475c66097416c", + "fault_receipt_sha256": "dd40330fb969ed01f2c8bcc4a1fa780efd5c451f60561b8d1e9e0ffb63a1e3e4", + "observer_receipt_sha256": "be6d35b6d06072bb8c9bc0947e9799aff922dc96d53d2e315fba4464d04ca1ac", "oracle_verdict": "satisfied", - "replay_report_sha256": "97d0bac2c04b176b3a168f9692a80308b7a473fe021aa8e3936ba660c7425eab", + "replay_report_sha256": "b311d4ac01445d6fb90500804fbd1f833b407fe03fecf1d61c216125bef95540", "run_id_sha256": "794033f9da2a42448254a478fb6de954898b1e544148708ad30264efdc255431", - "runner_receipt_sha256": "36112ed5002c4c5621bcfe60eb7e41873051625d844ff153a403684b410467a7", + "runner_receipt_sha256": "68743fb138f5b0323c8780ae12c25625f8bd94215e079453148bb3ccc1e321bb", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T11:22:00Z", "task": "execute-acceptance", "trial_index": 2, - "webhook_receipt_sha256": "4f32c6974bf19b3fcf9871beed963b99ec03ac9347a55059e9f5451333cb5b50", + "webhook_receipt_sha256": "1c7da3a1d54d0dfc9ce34ef02375c63a02592ce150bea7c95af03ae37a22e019", "workflow_version_id": "44444444-4444-4444-8444-444444444444" }, { "admission_id": "11111111-1111-4111-8111-111111111111", "attempt_id_sha256": "aa7d6be4f25a8992c0a22649ba7e703d6955abf5fece9f8322f560149cf09776", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "cleanup_absence_proof_sha256": "b33cd0b3700716aed5d44075b7e26be191c809331d4cd3e25212c307e43655e5", - "cleanup_receipt_sha256": "26c7adab527c721616e340b24605509062c669f64c41ec24cc5041f32bad0bfc", + "cleanup_absence_proof_sha256": "55fc4d13c0302e911e6f154818e6d5f2b5bfc4840e388ee8a622ab0e091c11cf", + "cleanup_receipt_sha256": "fad513ff2c4d607d0cc89c2968562e199833a6369c89dd645e63e2c594b0c113", "completed_at": "2026-08-18T11:24:00Z", "condition": "weak-effect-only", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", "execution_outcome": "halted", "failure_class": "safe_halt", - "fault_receipt_sha256": "1d7c6883d52086c9398b6bd05b4b95dbd7d764e1e0291eb8f7ac0311ec8e4daa", - "observer_receipt_sha256": "e326380f27a42e658689cce26a59cdfb4867f512ba7016355487954a99eeaebe", + "fault_receipt_sha256": "e33062130a56980962cdd45e00ac2d71db223760ed14c5acb2f5821872eb4220", + "observer_receipt_sha256": "1977a51552dd57b163e8dbeaf31996a21006d83637ba74c976439e85ac033241", "oracle_verdict": "satisfied", - "replay_report_sha256": "369bbe15a24b28d16d87482480bed7ee9b4ab2cedef0a051a930e3f95ec39a1a", + "replay_report_sha256": "f8f48e9e3248c7d0ff5743aaded0337b4a5bf5b5e10dc56f6d182ba2238e2909", "run_id_sha256": "b974de9da8ef77c8dc9a7662114cc51023ab8c131c488681eeebb7d4c435c8d0", - "runner_receipt_sha256": "4938c27207a78a9be3803dd7c6889dcba7f8be5af7ed4adc9cb6193dc1364b4f", + "runner_receipt_sha256": "9750eaae943a1633bae0501398d43b221c7ec4a552ef4ad604615427f14e4550", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "schema_version": "openadapt.qualification-trial-row/v2", "started_at": "2026-08-18T11:23:00Z", "task": "execute-acceptance", "trial_index": 3, - "webhook_receipt_sha256": "6ce64d58e69df317d74e94e480a3952ba89133053a77da3f7fcbb51e22da53ce", + "webhook_receipt_sha256": "705af4a02c6cb6c96be1b72ec3decc34e2e2f13f9a35a2e7e50d6e7f774a369a", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } ] } ], "decision": "admitted", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", "excluded_trials": [], "generated_at": "2026-08-18T11:55:00Z", "invariants": [ @@ -929,186 +929,235 @@ "task_id": "execute-acceptance" }, "receipt_envelopes": { - "0009aee64285ed2cb340ab6c8923ebd0a9f3603db3cbe1bf8e593bdea6aa22a3": { + "02047c3a76ee4b185641a5abcb6aa06f7d8ba94f538fae3a094e3a17cd7fdb54": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "eAesV1L/oMvhDVq81dZ+zhHVFs4oPhHVG/qq+ynwgM2m6J8xoW1Kzntbzl34n3G2GqCpawJ1HCPG1NzGiTEnBw==", - "source_artifact_sha256": "f48ec4e4f6e1af9e9a55730fef4ff0bc364683d1c08d1e0399281699f0f49444", - "verified_at": "2026-08-18T10:04:00Z", + "signature": "xGChtMQB0V0GgEFFRz4pBQKOiEio2gjl/mTMv58foHGI9FN3p9167f9w4dDhqra/SCys7GkNeTxk0HxQ8eGyBg==", + "source_artifact_sha256": "6f4098a4cb069c24d492715c73eabdf78d759e24953b88a134df911d06fd36f5", + "verified_at": "2026-08-18T10:54:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "4c352a6999f77707e8837adebb4fc2b7451c2ef6de5145190b33a5c5645e47eb", + "attempt_id_sha256": "958342a9ddca98a83b82b662f52f404239d583afe7ed70634760e1b8dd592f3b", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-01", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "f48ec4e4f6e1af9e9a55730fef4ff0bc364683d1c08d1e0399281699f0f49444", + "condition": "stale-session", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "6f4098a4cb069c24d492715c73eabdf78d759e24953b88a134df911d06fd36f5", "facts": {}, - "run_id_sha256": "4ee2bb61fb883cc8e77d636fb471aa3c0ce9ef0c0a8abd9682214bf0a8f16f26", + "run_id_sha256": "6f2fb10bc2018c9f78e9702d5ccac0bedd78ee3b2e9d2a6ad779fba72d90ae50", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, - "verdict": "absent", + "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "01e0e1e9f8d50d08a1e6a52833cbfb490ad0541a2b67b47528ff6d0fcd4a0219": { + "0260e65a8dee1f8fb0b832612e9802162774e2564001103b70488d986f76a481": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "uzBk9CFlcVbRcHw8+13Rp5JbscF4T0yRP26uRSfOGFfC+PZ60fwohtms6jofcKeR9iYH0xfe2PsB/TA9NMQWAg==", - "source_artifact_sha256": "f0e1b62eb7c877e3b75f5be31a69021e88bedc4ccfd95d69395483193bb5669f", - "verified_at": "2026-08-18T10:44:00Z", + "signature": "eKY3mPMJPzIw3cIBPIWlsKBXnoj0hufXtnySKDqCR1eaaz7/LpA/SY7cUFVHetxtDE5lmC8wqpNH3srxc6KcAw==", + "source_artifact_sha256": "f9e70034e68ce8783bb50fb2f53e6c7f8f5ed238916ab72298bcc5068ba7cef8", + "verified_at": "2026-08-18T10:24:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "7c910764b2dcc6f05261d609082f75474e4638c3f356006307212b8fed4a2eb7", + "attempt_id_sha256": "7573925adbd8a7a4a3b98bb0379549d77aa8ed46e312c1cd940c05b8587a039e", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "wrong-reference", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "f0e1b62eb7c877e3b75f5be31a69021e88bedc4ccfd95d69395483193bb5669f", + "condition": "healthy-03", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "f9e70034e68ce8783bb50fb2f53e6c7f8f5ed238916ab72298bcc5068ba7cef8", "facts": {}, - "run_id_sha256": "fe98ce7f0e66b885201f4667875fd38f5890ffddb575d68bd4cd5a66f8d53ca8", + "run_id_sha256": "784a0a94e581700a3d93581e7ce5bac0d3bc53c58f3e73198b896b5da9a819b0", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, - "verdict": "halted", + "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "0559c67e2109bea9b527eaaeef98992c12c687c01e8906dec8a87d24c626e792": { + "048ca4c88caf565040b46035db509ff38e849d95e9e4199e092f4565f5fa2f90": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", - "receipt_type": "runner", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "4+DyP3Ag/eh/m59/mSZaCzzzRf7Mr7d+Fbk5Wd7Mxw3T7TPP/17Y+dv2X3ObHQp7DhpenzH7j7YgbKBuP4h/Bw==", - "source_artifact_sha256": "009c1c1e67709868ad5218f72fe47f2fe26660be981c32e064da92de8bc4e85e", - "verified_at": "2026-08-18T10:22:00Z", + "signature": "I/IlxcuIn1zwfSRJn6jZLHaEOBduJjeTdS+/P5tHxC2oGdGaM2FYCpdSmezuonm8vYPcosfqWwo939dKJ3NqDg==", + "source_artifact_sha256": "e0ce2fefc18a96fdbe4db27543f31525ec9852a94a94d757559ccdd960f8faf9", + "verified_at": "2026-08-18T10:13:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "fc097c8b2e6ece94544a19b8d81f5c4a9367a89059e3dd4b2f746ab06a2fc930", + "attempt_id_sha256": "3d42601a69ef46cc44f57b51762affef4ccd829ffde30125619a6e582af00dab", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-03", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "009c1c1e67709868ad5218f72fe47f2fe26660be981c32e064da92de8bc4e85e", + "condition": "healthy-02", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "e0ce2fefc18a96fdbe4db27543f31525ec9852a94a94d757559ccdd960f8faf9", "facts": { - "model_call_counter": { - "attempted": 0, - "call_ids_sha256": [], - "completed": 0, - "cost_microusd": 0, - "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", - "input_tokens": 0, - "output_tokens": 0, - "provider_models": [], - "report_sha256": "009c1c1e67709868ad5218f72fe47f2fe26660be981c32e064da92de8bc4e85e", - "source": "runner_signed_flow_report_and_enforced_egress_policy" + "derived_classifications": { + "collateral_effect_count": 0, + "duplicate_effect_count": 0, + "intended_effect_count": 1, + "wrong_record_count": 0 }, - "operator_intervention_ids_sha256": [] + "dispatch_state": "dispatched", + "effect_inventory": [ + { + "effect_id_sha256": "8b445acee6aae04feb051f8c04d3c5983b50b60075a530553e9ef68a94339497", + "record_id_sha256": "d11cba9b016242b077f75fca7a6ba081ffcd42685c539aae24aa6a6a345873ae", + "transaction_ref_sha256": "9e9fc97defc5a1352a121bbb49532d28352f7488b87f5ffe23650890cc1828b3" + } + ], + "expected_record_id_sha256": "d11cba9b016242b077f75fca7a6ba081ffcd42685c539aae24aa6a6a345873ae", + "expected_transaction_ref_sha256": "9e9fc97defc5a1352a121bbb49532d28352f7488b87f5ffe23650890cc1828b3", + "post_state_evidence_sha256": "688116b3cbe3b2c66b24588c90a8240bcabbaf0aac8f1aadd8a8294e31114f32", + "pre_state_evidence_sha256": "b604ab87a04cc6869af9c1991b242920aa576870d7f254ec9169294c5ff9f13b", + "verifier_method": "read_only_system_of_record_query", + "verifier_tier": "independent_system_of_record" }, - "run_id_sha256": "28768f565659133f5bf1170e638b81de4d7ca38dfecacd09ccf462a35344432b", + "run_id_sha256": "091e13ed70dab439b31cb506cf3bba1ddf6476696531cf891c39a924a928b7a1", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, - "verdict": "verified", + "trial_index": 2, + "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "061a034a55abba5d6d8a4b22dbf24c70b016b7c1b06fc24b9fece9a3b1e0c933": { + "04fd815c9af5d936db6820dc9c2ed8c2d5035b8280457b939f84877ff9446292": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "VupDb7mixihZzBE0zHONmTR5NTx9LjV+j2LqWzM/d8ljO15wAaKOKiUHP5OgHhKWyqKAiLHgMIponzkJoexzCA==", - "source_artifact_sha256": "3a27387e7fb8b622f0150b1da9c81b97bbbf046c3e6be1dd3360f203fb460925", - "verified_at": "2026-08-18T10:42:00Z", + "signature": "5keeSYdFybxsd/qH2YY+7SeV61DgVXkiIzHcu0q6MCVu8Ew+d5Q+zTeH1epZn0I1B2HkxPBdzke5XZlDgtEnAA==", + "source_artifact_sha256": "237359293198c0bcf55e931c23b25d4af0950bb1488672f69a6d6260eb2aee06", + "verified_at": "2026-08-18T10:02:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "e93521e706ad90d799dcd4e8cac15229c5da6aec1638540606f5fab4efce59fc", + "attempt_id_sha256": "679af5a8dedceb8c696719e73f82a698c230cd8fc98bb61769f0883202c0b637", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "wrong-reference", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "3a27387e7fb8b622f0150b1da9c81b97bbbf046c3e6be1dd3360f203fb460925", - "facts": {}, - "run_id_sha256": "ee82112f55e5e6c86cfd6e16df8c8b652549a8bd72de492f435d8255eb3dd252", + "condition": "healthy-01", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "237359293198c0bcf55e931c23b25d4af0950bb1488672f69a6d6260eb2aee06", + "facts": { + "derived_classifications": { + "collateral_effect_count": 0, + "duplicate_effect_count": 0, + "intended_effect_count": 1, + "wrong_record_count": 0 + }, + "dispatch_state": "dispatched", + "effect_inventory": [ + { + "effect_id_sha256": "07635412bdd073f2f53c0be32e8df7b16940124d3693645e5af379b76ecebbc1", + "record_id_sha256": "22bafa5f842de0c2269205fd3478833f83c5c6f54d0066a5af6b89940f1564e9", + "transaction_ref_sha256": "7ac0c694e5cb88e5efd44ea972cad8449b7292b86e10a54bba4982f8e26078a4" + } + ], + "expected_record_id_sha256": "22bafa5f842de0c2269205fd3478833f83c5c6f54d0066a5af6b89940f1564e9", + "expected_transaction_ref_sha256": "7ac0c694e5cb88e5efd44ea972cad8449b7292b86e10a54bba4982f8e26078a4", + "post_state_evidence_sha256": "5a7aef9cfd51033988dd21227fdbc210ca4c54128fa825521f5d56ad71f4ae44", + "pre_state_evidence_sha256": "03f1c91bf767df95663ac91cb91323fe712c1f5284c789c96ad65f5f94d1c090", + "verifier_method": "read_only_system_of_record_query", + "verifier_tier": "independent_system_of_record" + }, + "run_id_sha256": "0b5bda916a0808165159166955a9563cf9c2303949f762a18eb037f41b44a6dc", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, - "verdict": "halted", + "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "06483a5a3def1a0eb09b1623870f68ef9ef1f5c923d10e220b4acbbecd3a0ff8": { + "086cc4cf45a4b8d6c7e833e6f0ef674ff8caddc81aab2e1830aa7ba2b2f015ed": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-138dfa227234ea5f", - "receipt_type": "cleanup", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "P23MElFH0hSlJtDj0f1otOGpVLSz3LU4tby5nKKneBkUmLvo0rViAJtwwIzxR9mnm8ElTtW1O1/x07BJ1RmlAw==", - "source_artifact_sha256": "c99ff9e16fc08dfa2947c8baa3cd32d837e5e3c19ebbf6ce751821e33ee578f5", - "verified_at": "2026-08-18T10:42:00Z", + "signature": "2S5PPdBRHI6GDd+BP3+Kp7Q0KSPAxYUwYqqX7LeZOYAU7letjY+pZcoxqzGL0xv/R5p3AfrCStfsyQpCiLpQAA==", + "source_artifact_sha256": "e92cda8b4f49cc4af5827dbf65d991b60d7bdb9a894000c57505f7fe072616ce", + "verified_at": "2026-08-18T10:14:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "e93521e706ad90d799dcd4e8cac15229c5da6aec1638540606f5fab4efce59fc", + "attempt_id_sha256": "019dd96e9a771ccc01ebafab321d7d3a8314df8b2d6465bcfc5fa14cbdeabdf2", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "wrong-reference", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "c99ff9e16fc08dfa2947c8baa3cd32d837e5e3c19ebbf6ce751821e33ee578f5", - "facts": {}, - "run_id_sha256": "ee82112f55e5e6c86cfd6e16df8c8b652549a8bd72de492f435d8255eb3dd252", + "condition": "healthy-02", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "e92cda8b4f49cc4af5827dbf65d991b60d7bdb9a894000c57505f7fe072616ce", + "facts": { + "derived_classifications": { + "collateral_effect_count": 0, + "duplicate_effect_count": 0, + "intended_effect_count": 1, + "wrong_record_count": 0 + }, + "dispatch_state": "dispatched", + "effect_inventory": [ + { + "effect_id_sha256": "d5f1622c2956d2563fb993ded150f7a36e0a79b51f070beec032b8bb5acab8a2", + "record_id_sha256": "168a687e3fd8fbed76d59d0f70899eab30f82058098fc47ba24a1d253c425d62", + "transaction_ref_sha256": "bf754d98ea2b40b05ef93a4212b0285b205b20e9d30b402bc9fdeae969a8503a" + } + ], + "expected_record_id_sha256": "168a687e3fd8fbed76d59d0f70899eab30f82058098fc47ba24a1d253c425d62", + "expected_transaction_ref_sha256": "bf754d98ea2b40b05ef93a4212b0285b205b20e9d30b402bc9fdeae969a8503a", + "post_state_evidence_sha256": "bf2a04f127fef945d393aee65f6c924165667c723fcfd86b2073084b3b1fcd2b", + "pre_state_evidence_sha256": "8c1ec681950f04f1b3509f2a0add5b414c992fc27f3f9604378a7512ecdb510f", + "verifier_method": "read_only_system_of_record_query", + "verifier_tier": "independent_system_of_record" + }, + "run_id_sha256": "16cb8df40654c6a1b55ea0e50e772d8c6e6d4f0d8205bd1f8296be27d0af83eb", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, - "verdict": "completed", + "trial_index": 3, + "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "08fcec4f61b57e84172aa5e0c0780487ef97b93bdac4801f3f5fdefd8419802c": { + "09e51d5a41d651c6bfaafc83cc05e17da95f74b7999f88f07e9179b5eff36608": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-138dfa227234ea5f", - "receipt_type": "cleanup", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "ubGCmrju+BqItO33xCWn1cDZzFMJtwL16l9d4fyLF0VQ/8OPTujGdY4/H7HzBxg5INTFZKv45i3lP+tQM1KKAQ==", - "source_artifact_sha256": "a28ad5edfe12f8c387974db36928b3aa5aa2bded20b70ce40baeea09eb16b8e1", - "verified_at": "2026-08-18T11:14:00Z", + "signature": "czo6mWcJpQAIN+KKbrXkmco1vz8YXi5BlbSbeiU8OGwmnEDQG7IEXRheYHPHMQbh3v+w3Piv95jPvRF+hxb0CQ==", + "source_artifact_sha256": "8085128f824c52e7f957276980e2ec8ed181e15094c1a551c251a21e07009829", + "verified_at": "2026-08-18T11:22:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "ad76dacfe19a4421ef1f128d4eef1099e846b385d29f17b8588ae5130b487118", + "attempt_id_sha256": "73a097b8b20bab7794369384f7ca1d7d711aad07967b7e1292373babbb7ff1b7", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "verifier-unavailable", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "a28ad5edfe12f8c387974db36928b3aa5aa2bded20b70ce40baeea09eb16b8e1", + "condition": "weak-effect-only", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "8085128f824c52e7f957276980e2ec8ed181e15094c1a551c251a21e07009829", "facts": {}, - "run_id_sha256": "87014cd8063f5a43ea22c995be03ec41ef5aa613145acacdef71b68c468fc8f1", + "run_id_sha256": "b44783e70a980ec5b3cf3752bd5d1d01b2ff29f5a6892cba0c1c939d8aeb7c02", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "completed", + "trial_index": 1, + "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "0a5102012076aadf70baee8581543ac04d061241192f1ca3c0b12eb6e31473f0": { + "0a477211aca518342785bbb8cc7c46f335d3975275c11ed82db007b3fa29aa40": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", "receipt_type": "runner", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "ZfZyk+k5pryV9IMoHkc3e4tPICZvuMHLoqHzcvC0IyR030i2wXlAtmHehdsBL0H4XUfAoXJaqFyzbkyPjNNkCA==", - "source_artifact_sha256": "40933d309a18fba8094517dfd195dd4feea0486e031db26f66ff09699477bda9", - "verified_at": "2026-08-18T10:12:00Z", + "signature": "KfieyqE5LOAhwm1o5GNvwxWW+WnXdYxxMET2Mp3/RVJikwXzYW6FMntBE69nVolc4mGOu14s4pvcxA9YqzPUDg==", + "source_artifact_sha256": "5a34e35fec7ee614b3ae06606f9778a2e11d5c8b34ca4792f79b0fc127c7d95a", + "verified_at": "2026-08-18T10:24:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "940d3ca125ff87ce7539740fbae29d2d64fec839328b0639127e1d197d2485d8", + "attempt_id_sha256": "7573925adbd8a7a4a3b98bb0379549d77aa8ed46e312c1cd940c05b8587a039e", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-02", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "40933d309a18fba8094517dfd195dd4feea0486e031db26f66ff09699477bda9", + "condition": "healthy-03", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "5a34e35fec7ee614b3ae06606f9778a2e11d5c8b34ca4792f79b0fc127c7d95a", "facts": { "model_call_counter": { "attempted": 0, @@ -1119,187 +1168,233 @@ "input_tokens": 0, "output_tokens": 0, "provider_models": [], - "report_sha256": "40933d309a18fba8094517dfd195dd4feea0486e031db26f66ff09699477bda9", + "report_sha256": "5a34e35fec7ee614b3ae06606f9778a2e11d5c8b34ca4792f79b0fc127c7d95a", "source": "runner_signed_flow_report_and_enforced_egress_policy" }, "operator_intervention_ids_sha256": [] }, - "run_id_sha256": "bbb9312ce4682b23580eced0f8d19438d8266b222555df85fb27eef22ad5afe2", + "run_id_sha256": "784a0a94e581700a3d93581e7ce5bac0d3bc53c58f3e73198b896b5da9a819b0", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, + "trial_index": 3, "verdict": "verified", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "0b700db3525db248fddd3cde06607a194c809c76d5cece6a56745202ff8f707b": { + "0b28572f4d609deaae0e5f96aabd078806efb490feb49896d15d3ae274adaeaa": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "Ls87poqS/6vCPEhXkuYt70u/cpJZ41GuXtjbanB+woIE/wM+/gtVT2kiiG3MjCMDIp/CSF19zgliiFICzcStBQ==", - "source_artifact_sha256": "5d0a6686e8f1d277c080d35d24db5e2f371ce4a69ee7b9d275d63a34af50f9d2", - "verified_at": "2026-08-18T11:03:00Z", + "signature": "ztV/1gCRK/Y2afKQklfVNjW32IXppI3g7AczB09J6alWjWOcl4T74CGbPFVn//Q2fe4tMowfo5EJKGhIdyZ7BA==", + "source_artifact_sha256": "2fc83a9ad4cdeaa8faf4176f24cd5390e451a993166626508572a5c6a7663659", + "verified_at": "2026-08-18T10:13:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "1ec11a9862ede3ac701af71835ac28c551d604a026b5bab7d776dbcdf288394e", + "attempt_id_sha256": "3d42601a69ef46cc44f57b51762affef4ccd829ffde30125619a6e582af00dab", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "ambiguous-target", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "5d0a6686e8f1d277c080d35d24db5e2f371ce4a69ee7b9d275d63a34af50f9d2", + "condition": "healthy-02", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "2fc83a9ad4cdeaa8faf4176f24cd5390e451a993166626508572a5c6a7663659", "facts": {}, - "run_id_sha256": "43f0a1c00950c390b0676fab55a2aa98c354d028f2347c461661e6cdb72f717e", + "run_id_sha256": "091e13ed70dab439b31cb506cf3bba1ddf6476696531cf891c39a924a928b7a1", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, - "verdict": "delivered", + "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "0c1c0a6fd5f726600fcadfc64d5a34e027d4b36d00382877d841b3261360f336": { + "0cad49aac81954a3956a1d83e7a515d56f5ac826780f3014d4a798939c2170d8": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-138dfa227234ea5f", - "receipt_type": "cleanup", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "qFi27q/tG+6eQ5Wne2mAcozWt2qs+pb34zk9APKkz0sFTwwS7T9stnX/Yp/I2/xyBS5d9AKoY83dowR7ZmWRCQ==", - "source_artifact_sha256": "82558495613e411f7ace5490f50e22b445058f1f1d0661f39959e3fa8d25a742", - "verified_at": "2026-08-18T11:22:00Z", + "signature": "jaybPcSy2I50Zyo86XuYYC3C7h7MoijXizxpr/2Ixs+oKR8KA35hGmL7Eds6DzPXKs8TjX46EuiZJsd/8Q6dCQ==", + "source_artifact_sha256": "a8a94089ae42720eff6c8154fd7ed91674171e6a51ac522db76f1d69704673d6", + "verified_at": "2026-08-18T10:23:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "73a097b8b20bab7794369384f7ca1d7d711aad07967b7e1292373babbb7ff1b7", + "attempt_id_sha256": "2601335b1101424105277997a67850a8a60aa45f59637b7679c1f32af463c460", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "weak-effect-only", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "82558495613e411f7ace5490f50e22b445058f1f1d0661f39959e3fa8d25a742", - "facts": {}, - "run_id_sha256": "b44783e70a980ec5b3cf3752bd5d1d01b2ff29f5a6892cba0c1c939d8aeb7c02", - "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "task": "execute-acceptance", - "trial_index": 1, - "verdict": "completed", - "workflow_version_id": "44444444-4444-4444-8444-444444444444" - } - }, - "0cef130f26153da53089908b85e93a0d3d471c44d0216fabfc4beff90f62bb69": { - "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", - "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "iIfiSNLkUzbK8soZC45T6XItwUvuI/zRqPhCuPLBIZQ/QB4v4Nrl9x/9RgPj0pmlUX6M2xn/dn3v1YADJi4nCA==", - "source_artifact_sha256": "5b97c09965f50b433ebd2e38459a56f0ae35537b2267b3e89faf7125ea0c2e25", - "verified_at": "2026-08-18T11:23:00Z", - "verified_projection": { - "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "eb52fb1b1bf2fac92d8f3a444bb5081161be8b3d0ef457c5065e7b79e96df770", - "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "condition": "healthy-03", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "a8a94089ae42720eff6c8154fd7ed91674171e6a51ac522db76f1d69704673d6", + "facts": { + "derived_classifications": { + "collateral_effect_count": 0, + "duplicate_effect_count": 0, + "intended_effect_count": 1, + "wrong_record_count": 0 + }, + "dispatch_state": "dispatched", + "effect_inventory": [ + { + "effect_id_sha256": "4cb3b1b2bddf9bab2ecc70f350793a5c08d1ef6995f03d83613414232aa67915", + "record_id_sha256": "376b86277507af8309dd9c7ee34843c68aa8000b6cb6246f3df9311e1a157a57", + "transaction_ref_sha256": "a8dcbf41043fdea74256844cddce6df4cb244c53ad6021edac20c136e24f7ffe" + } + ], + "expected_record_id_sha256": "376b86277507af8309dd9c7ee34843c68aa8000b6cb6246f3df9311e1a157a57", + "expected_transaction_ref_sha256": "a8dcbf41043fdea74256844cddce6df4cb244c53ad6021edac20c136e24f7ffe", + "post_state_evidence_sha256": "d186e527afc60846f97057220efa366ccf99dc2bf1c32e246bc947602bce5487", + "pre_state_evidence_sha256": "a7b5943eb7e95bc4d94fc9bdf6bb5650e69e23b75c5d1a0a1abc572fdc20060c", + "verifier_method": "read_only_system_of_record_query", + "verifier_tier": "independent_system_of_record" + }, + "run_id_sha256": "237a0b7d1cafb64b1d113dca6699e6eefeaaf0b18679138545c3695495b901d5", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "satisfied", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "0e2f51550a263bf5d5f5ac94bc869ab552cb38f963a3fd647b5d08af13400867": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "yiUGsG0h//07lW3KVyTMh39/XPWpnF7MiujeoKj7QwwUQfgZW/cV/c3Q5tLzwLRPj69THlSrkDeEKrI25BiQAQ==", + "source_artifact_sha256": "9003f18eed9ca02f5288ee8e9b498e2a7792375249a68b2444ff5d147b9c24d2", + "verified_at": "2026-08-18T10:12:00Z", + "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "940d3ca125ff87ce7539740fbae29d2d64fec839328b0639127e1d197d2485d8", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "weak-effect-only", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "5b97c09965f50b433ebd2e38459a56f0ae35537b2267b3e89faf7125ea0c2e25", + "condition": "healthy-02", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "9003f18eed9ca02f5288ee8e9b498e2a7792375249a68b2444ff5d147b9c24d2", "facts": {}, - "run_id_sha256": "794033f9da2a42448254a478fb6de954898b1e544148708ad30264efdc255431", + "run_id_sha256": "bbb9312ce4682b23580eced0f8d19438d8266b222555df85fb27eef22ad5afe2", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "completed", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "0f613cfb3e22315db9a58ecacb76b19af191682f66c3597be808174bb448c050": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", + "receipt_type": "fault", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "JgftYEHdOlGoGx9AjFRWJmj/+JAScJlwiK2hURHi5GJIjnCrdsGsGb14EGdlygXoyu7TjTYzgUatcrHR6UwuBA==", + "source_artifact_sha256": "002efaa296dd38b0596e300894d23a4d0a9ceda1480bd302602a34e6d5d6b884", + "verified_at": "2026-08-18T10:53:00Z", + "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "f5df4d6e64a2d38ffa8e320c87ad05d04025de267a8e152a755d3f1928ded120", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "stale-session", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "002efaa296dd38b0596e300894d23a4d0a9ceda1480bd302602a34e6d5d6b884", + "facts": {}, + "run_id_sha256": "fd3a041b705d8c6277ce26134dc0018e866218cfa3fadd16ac29d1ad498965a3", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, - "verdict": "absent", + "verdict": "injected", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "0eb5ab24ba6f40dd5d6e9c060f3a241672cde509dc3483dda42ef27fd76ff9cf": { + "107427555cd22ed38dfb6f47a853efa8afbbcb2ef008438d77a34b4fb0a21098": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "yoNzlruvZrZuOZQudl686kxk6H7Z1ns+cm/wFdsdrrOlnxpvfqYawUVw0ffY4EUKgtGgud6GB3XdKB3+rvOxDA==", - "source_artifact_sha256": "32974d92bebc7e4e4d26c3f6df9b0cd6dfb4e7f0f23baa1df91fa850acf666da", - "verified_at": "2026-08-18T10:54:00Z", + "signature": "SkU2/khfhVdo105vy+yyyzgpqNWfKlkJ7Chm+VDES2kwiSlW2+GVDXPkU1ebUNkXUFy8/GQ45tI/Wvv3jLstDw==", + "source_artifact_sha256": "2a7ccbc187c0627ad574c752f1aea534e5f283859d8b8e6fcdeaad3e603d4386", + "verified_at": "2026-08-18T10:53:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "958342a9ddca98a83b82b662f52f404239d583afe7ed70634760e1b8dd592f3b", + "attempt_id_sha256": "f5df4d6e64a2d38ffa8e320c87ad05d04025de267a8e152a755d3f1928ded120", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "stale-session", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "32974d92bebc7e4e4d26c3f6df9b0cd6dfb4e7f0f23baa1df91fa850acf666da", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "2a7ccbc187c0627ad574c752f1aea534e5f283859d8b8e6fcdeaad3e603d4386", "facts": {}, - "run_id_sha256": "6f2fb10bc2018c9f78e9702d5ccac0bedd78ee3b2e9d2a6ad779fba72d90ae50", + "run_id_sha256": "fd3a041b705d8c6277ce26134dc0018e866218cfa3fadd16ac29d1ad498965a3", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "halted", + "trial_index": 2, + "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "11c3e276c44dd5d91dc79a7c94803e2ee06ae40712905927af21104098792fd4": { + "1232a18cee15367a5d3ce78845fcf11596d663db51ab52cfea03af806cec8e3b": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "IcBi+2cC5wWAQpga/nxgljX7LdsVO6MZnXQP5OqOYkaEL9A/bLS7+luQJqPYhkFR7kjgSddCTCvidC5qMtVcAg==", - "source_artifact_sha256": "5715c0e7be0a23b342d074947567c9aab924b43b2318265f28013a0d5715506f", - "verified_at": "2026-08-18T10:34:00Z", + "signature": "JVfzREDrLOJmDhKmIeJUzzki0TH4qvmZOwLjx5PQ6NOUg20pSfWIObD3L9JqYadccyPJQBBGLziEV9yCBL3WDA==", + "source_artifact_sha256": "13d5f53016f80b5ba9f95ceaa4d79970bbf9870cc12470744d0291bbef3a1cda", + "verified_at": "2026-08-18T10:24:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "3aee8ad755c7f4bec71cc194bcfaa805e0ea29cf8b830ed0782f8263dd9620ca", + "attempt_id_sha256": "7573925adbd8a7a4a3b98bb0379549d77aa8ed46e312c1cd940c05b8587a039e", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "idempotency-replay", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "5715c0e7be0a23b342d074947567c9aab924b43b2318265f28013a0d5715506f", + "condition": "healthy-03", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "13d5f53016f80b5ba9f95ceaa4d79970bbf9870cc12470744d0291bbef3a1cda", "facts": {}, - "run_id_sha256": "3df83453126754a62d00ed10837720542d0469799bb8a88cb5257ac5f477a919", + "run_id_sha256": "784a0a94e581700a3d93581e7ce5bac0d3bc53c58f3e73198b896b5da9a819b0", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, - "verdict": "verified", + "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "14233009f4f65cd0a0fa81a233f4d0cc48d7f6c9b8d6f9ef8e2c12b8593047d3": { + "147acdafbac824c94ff5329bef4d95efb8d3a4df3beb51e9c7488b8ac6346598": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "Jbs5uOzZ/Rmlro77e7WWF8+rzwA0z/PTbMzYL177PqSHLdiT3ErvDumkwZhUECVtGMnfhw/YxvDhXKVZbGwOAA==", - "source_artifact_sha256": "ce0aa45ff0449ef101823a15d86eaad2e81cfaedb64c35017e27146adae0a845", - "verified_at": "2026-08-18T10:43:00Z", + "signature": "fw41Vs2oA5gK7Wsh6oPlNkhZDtMOAOeXDipP0tSPKgI9LNExpETUQR6nS1lVHH+5KQOKeaakZHKB6wVk1ROyAA==", + "source_artifact_sha256": "ff1fd4393986dfb3dd0e3e75fe379c4dfa4b424938dac23ab436e1e31f594225", + "verified_at": "2026-08-18T10:44:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "6b0e5c10d55fc92c1ff8576392270a24fb65722414cf58ff9a51b8ce9ef88587", + "attempt_id_sha256": "7c910764b2dcc6f05261d609082f75474e4638c3f356006307212b8fed4a2eb7", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "wrong-reference", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "ce0aa45ff0449ef101823a15d86eaad2e81cfaedb64c35017e27146adae0a845", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "ff1fd4393986dfb3dd0e3e75fe379c4dfa4b424938dac23ab436e1e31f594225", "facts": {}, - "run_id_sha256": "577e37b10b1c87fd9c1b5d320888b736d272824657fd59a012e85a284ee88540", + "run_id_sha256": "fe98ce7f0e66b885201f4667875fd38f5890ffddb575d68bd4cd5a66f8d53ca8", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "halted", + "trial_index": 3, + "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "1618244896b44c013eeedf931ce4d2ad0899fed5c9ed7f6812c9d17d62003c6b": { + "153beaa2eb0cc516c545cf381d97cdef26df24fd51ff1aba481310d865148020": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-d92d542a589844dd", "receipt_type": "cleanup_absence", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "xnpvMNsYFBJQtrtL9RpBfZ/3SQNgiLDiRcAaGipAJ1IpnoeYxzI/siRUyZnN4akE7Gjp4ucYvIUELcH5leiBCg==", - "source_artifact_sha256": "738fb82696e36887119e66c49386fc345003080f8417dcd4157684ca9a820236", - "verified_at": "2026-08-18T10:02:00Z", + "signature": "WmoR+zg+u4wScEzVSnvJ+UoDbKFkOIyO//RdUQBeomiEVp408RNeOlqJak/50E/AYWuK9RrzOpraZs7qBx84Cw==", + "source_artifact_sha256": "f8152ccb0471b92317861ddb7fabeae5fcf740530b8b050510e29e1da130d3e3", + "verified_at": "2026-08-18T10:22:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "679af5a8dedceb8c696719e73f82a698c230cd8fc98bb61769f0883202c0b637", + "attempt_id_sha256": "fc097c8b2e6ece94544a19b8d81f5c4a9367a89059e3dd4b2f746ab06a2fc930", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-01", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "738fb82696e36887119e66c49386fc345003080f8417dcd4157684ca9a820236", + "condition": "healthy-03", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "f8152ccb0471b92317861ddb7fabeae5fcf740530b8b050510e29e1da130d3e3", "facts": {}, - "run_id_sha256": "0b5bda916a0808165159166955a9563cf9c2303949f762a18eb037f41b44a6dc", + "run_id_sha256": "28768f565659133f5bf1170e638b81de4d7ca38dfecacd09ccf462a35344432b", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, @@ -1307,22 +1402,22 @@ "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "18343a300dbb47883fd932d0819e5b92aeaa6ad60dfa82ee8b66c6ac3190fbed": { + "154cf5160bab5bf25271d138af78a770a3cac1d0a1250750e59a80d5de46883c": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", "receipt_type": "runner", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "xe9t7baJaylv9NfHEeOHOk7XMg00sUSLE1yCsyvnQz4QMyD8vlCCPuwgcwwPzJ/fXPM6l3o0JpZvxngBrtATBQ==", - "source_artifact_sha256": "5a34e35fec7ee614b3ae06606f9778a2e11d5c8b34ca4792f79b0fc127c7d95a", - "verified_at": "2026-08-18T10:24:00Z", + "signature": "aGys56W/Je+hsvCA9SGGFoA7oF4XfQvrXBoo1iPUmOMrQJn65TtEtwQHrczycMu64w0StkImtBP3FLXkaatpCw==", + "source_artifact_sha256": "f847f556481bc9323fcdfb083e5068e729d1de913f60d34a1f7f7352a95af4a0", + "verified_at": "2026-08-18T10:14:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "7573925adbd8a7a4a3b98bb0379549d77aa8ed46e312c1cd940c05b8587a039e", + "attempt_id_sha256": "019dd96e9a771ccc01ebafab321d7d3a8314df8b2d6465bcfc5fa14cbdeabdf2", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-03", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "5a34e35fec7ee614b3ae06606f9778a2e11d5c8b34ca4792f79b0fc127c7d95a", + "condition": "healthy-02", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "f847f556481bc9323fcdfb083e5068e729d1de913f60d34a1f7f7352a95af4a0", "facts": { "model_call_counter": { "attempted": 0, @@ -1333,12 +1428,12 @@ "input_tokens": 0, "output_tokens": 0, "provider_models": [], - "report_sha256": "5a34e35fec7ee614b3ae06606f9778a2e11d5c8b34ca4792f79b0fc127c7d95a", + "report_sha256": "f847f556481bc9323fcdfb083e5068e729d1de913f60d34a1f7f7352a95af4a0", "source": "runner_signed_flow_report_and_enforced_egress_policy" }, "operator_intervention_ids_sha256": [] }, - "run_id_sha256": "784a0a94e581700a3d93581e7ce5bac0d3bc53c58f3e73198b896b5da9a819b0", + "run_id_sha256": "16cb8df40654c6a1b55ea0e50e772d8c6e6d4f0d8205bd1f8296be27d0af83eb", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, @@ -1346,97 +1441,47 @@ "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "1aeb42c46a7567c1fa5436e662dea85f649029f4a03e573907f477dab40e9653": { + "16bae61698645915b877891241da1b9f838d5c12f67c3fe9044468a95b46c1c6": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-e37abcd79efd08db", "receipt_type": "replay", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "hxkyv9f1hUelPtt7NLZjJSt83DkLBmpt4xOK+tJLbM7BcwJnpPvW8sKtrytu/gXlmh5w7XXOgAVUJTO/IGzlAA==", - "source_artifact_sha256": "8fd27141f1a8f201ab2aff52f1ba0273e506dc25a0fb7567513d140a1cc9a2fa", - "verified_at": "2026-08-18T11:04:00Z", + "signature": "CXwmKsM5oC/ccaz8kkrB4LmkQVtZ9T4lHJZLiv7I/mPOANLCHFoqpDYQC+wFkHEsRB93kHhd6p7RkbVxzy8pCg==", + "source_artifact_sha256": "3a27387e7fb8b622f0150b1da9c81b97bbbf046c3e6be1dd3360f203fb460925", + "verified_at": "2026-08-18T10:42:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "491a544656d05aea37920e5c7e2ad65a9452eac8d6e100268a599aeebd41187a", + "attempt_id_sha256": "e93521e706ad90d799dcd4e8cac15229c5da6aec1638540606f5fab4efce59fc", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "ambiguous-target", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "8fd27141f1a8f201ab2aff52f1ba0273e506dc25a0fb7567513d140a1cc9a2fa", + "condition": "wrong-reference", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "3a27387e7fb8b622f0150b1da9c81b97bbbf046c3e6be1dd3360f203fb460925", "facts": {}, - "run_id_sha256": "aa62c7a17701a7ef01ea1d3519b4c1f90d357495b329fdda3054cc24c581a593", + "run_id_sha256": "ee82112f55e5e6c86cfd6e16df8c8b652549a8bd72de492f435d8255eb3dd252", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, + "trial_index": 1, "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "1bcc8b374768c067cecc0c817d1b424a1823529f712ced903d54b8963338c37c": { - "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", - "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "PD5Jk4JeKjH6IPfx9Ug/yQGXC5/vHi5qXgy6ydMZ5w8JZnalW3M5IwLLcuhHkBTT9aJKJUQ6zYUTyLyhsHwBBA==", - "source_artifact_sha256": "05601e1e28046d813b5d1fc7fc6f90292c7397fe2bfacb1b27e302242c388659", - "verified_at": "2026-08-18T11:14:00Z", - "verified_projection": { - "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "ad76dacfe19a4421ef1f128d4eef1099e846b385d29f17b8588ae5130b487118", - "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "verifier-unavailable", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "05601e1e28046d813b5d1fc7fc6f90292c7397fe2bfacb1b27e302242c388659", - "facts": {}, - "run_id_sha256": "87014cd8063f5a43ea22c995be03ec41ef5aa613145acacdef71b68c468fc8f1", - "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "task": "execute-acceptance", - "trial_index": 3, - "verdict": "absent", - "workflow_version_id": "44444444-4444-4444-8444-444444444444" - } - }, - "1ca68224ff7ed710e02c185155a819a937f0297aed33d249c351ae3145706b27": { - "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", - "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "pShauyfgkXIlvB0KcrCyNEzFIdfEhA1zUE5/1IyckyNJrIp4Uo5wWmOrn+47P314kw9dkjDt66FUus5DmFM9DQ==", - "source_artifact_sha256": "2a7ccbc187c0627ad574c752f1aea534e5f283859d8b8e6fcdeaad3e603d4386", - "verified_at": "2026-08-18T10:53:00Z", - "verified_projection": { - "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "f5df4d6e64a2d38ffa8e320c87ad05d04025de267a8e152a755d3f1928ded120", - "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "stale-session", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "2a7ccbc187c0627ad574c752f1aea534e5f283859d8b8e6fcdeaad3e603d4386", - "facts": {}, - "run_id_sha256": "fd3a041b705d8c6277ce26134dc0018e866218cfa3fadd16ac29d1ad498965a3", - "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "task": "execute-acceptance", - "trial_index": 2, - "verdict": "absent", - "workflow_version_id": "44444444-4444-4444-8444-444444444444" - } - }, - "1cfb44a34276ac71b453562485ff70fb3b5f0c5d0718632601a8f05f62280cd5": { + "195462d5c56f99e872198cfd32853dc2a4a2cfd6405ed76810fd873f3c186004": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", "receipt_type": "runner", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "MQ377O4rgsUrut6UmhAoOFI6/t2FWHj5tJbqZvufk01+zUeGKEQpcNg2iA41yYEsLI6ol70wczG20ROypBE7BQ==", - "source_artifact_sha256": "2939663aad44035d0e4b7f6c59580cd6d7589dc8db1f48abe2e60db3cef03a78", - "verified_at": "2026-08-18T10:32:00Z", + "signature": "cb2yp+piWN2dTXNUh2flBFIJ/f1TbWMTB1eU5EKv2urnTEvJedKUft5LDf75nqajF5d/MdCJoEcbv3M7dXjuCg==", + "source_artifact_sha256": "aa76163afc05d85e7c2925d286aa8e9c2abda820aa88bcddb1c2a8d525a8be2b", + "verified_at": "2026-08-18T11:03:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "3142933f4f168c98b8e89f2ae9d78fd3129e0a9975cbbaa60ddba853eee7d53c", + "attempt_id_sha256": "1ec11a9862ede3ac701af71835ac28c551d604a026b5bab7d776dbcdf288394e", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "idempotency-replay", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "2939663aad44035d0e4b7f6c59580cd6d7589dc8db1f48abe2e60db3cef03a78", + "condition": "ambiguous-target", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "aa76163afc05d85e7c2925d286aa8e9c2abda820aa88bcddb1c2a8d525a8be2b", "facts": { "model_call_counter": { "attempted": 0, @@ -1447,26 +1492,26 @@ "input_tokens": 0, "output_tokens": 0, "provider_models": [], - "report_sha256": "2939663aad44035d0e4b7f6c59580cd6d7589dc8db1f48abe2e60db3cef03a78", + "report_sha256": "aa76163afc05d85e7c2925d286aa8e9c2abda820aa88bcddb1c2a8d525a8be2b", "source": "runner_signed_flow_report_and_enforced_egress_policy" }, "operator_intervention_ids_sha256": [] }, - "run_id_sha256": "6cdff0cf50d0164fe1eee9c4b7db0b969c24f9b960f5653b516313a913c90a0f", + "run_id_sha256": "43f0a1c00950c390b0676fab55a2aa98c354d028f2347c461661e6cdb72f717e", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, - "verdict": "verified", + "trial_index": 2, + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "1d7c6883d52086c9398b6bd05b4b95dbd7d764e1e0291eb8f7ac0311ec8e4daa": { + "1977a51552dd57b163e8dbeaf31996a21006d83637ba74c976439e85ac033241": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", - "receipt_type": "fault", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "Dzqpo2gKDazjCQ88VMx5sYfSI2E65MTRf1Wak+aCF7n4vt9EP+aQurLXkTbg6RU6bLQXKb1sGNSAScAzcfxcCA==", - "source_artifact_sha256": "c483629c37faa74e65b11335e5d15e741a5a1d5a7af2f6a4757767a446b00a34", + "signature": "SnSSCm7em6wUZb3MvkGLFiOgNma8RfMWiparMfKSWVp8OlFX5aeIAO8gyLFtf2pBy+dcauwyPho5Cyo7Zyu6Cw==", + "source_artifact_sha256": "bd93f6e9d767166a948c91db13a6d6ebf759630b605e6ecf130420e0511ee3a4", "verified_at": "2026-08-18T11:24:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", @@ -1474,183 +1519,187 @@ "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "weak-effect-only", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "c483629c37faa74e65b11335e5d15e741a5a1d5a7af2f6a4757767a446b00a34", - "facts": {}, + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "bd93f6e9d767166a948c91db13a6d6ebf759630b605e6ecf130420e0511ee3a4", + "facts": { + "derived_classifications": { + "collateral_effect_count": 0, + "duplicate_effect_count": 0, + "intended_effect_count": 0, + "wrong_record_count": 0 + }, + "dispatch_state": "not_dispatched", + "effect_inventory": [], + "expected_record_id_sha256": "91f268174be0ceea4f27f6197630a299cc2f5dc0379f1859cda04db7338cc8a1", + "expected_transaction_ref_sha256": "fa34ce5dcf42475c8fa7fd73aa540e619bfcdd17cf7d0918a856e509e97519dc", + "post_state_evidence_sha256": "8fd9d8558584962f398038ede8eaf254e6895128716fa04aedef64b87739d1dc", + "pre_state_evidence_sha256": "4419443833f8d0cc9306d316ad6ddc83f67571cc61f83fad22133b179cb5ff1c", + "verifier_method": "read_only_system_of_record_query", + "verifier_tier": "independent_system_of_record" + }, "run_id_sha256": "b974de9da8ef77c8dc9a7662114cc51023ab8c131c488681eeebb7d4c435c8d0", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, - "verdict": "injected", + "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "1d8f4884ac384317209d4a4116a19a597a60f7483bacacc99a81adcd01c666c5": { + "19effcae09225c0b10316238d0b4686931c70297a9d44c913784a5f74e09bad9": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", - "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "1Q8U2lCh/1+7HJORT52QfcAczQ0xzjR4rjQcT5CQ+LcJaZmog1eTxNK/1VNu2m6harvPJrU0/gbIEUwqtgf7Cg==", - "source_artifact_sha256": "7d36fcea2384b6bb28044bc68847492fefb2783909042a96f6416cc457c258c6", - "verified_at": "2026-08-18T11:02:00Z", - "verified_projection": { - "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "60ee9db05b1126cfaa3b31c13bc3fab4755ac09c44e846b4d07ee51865dfa7b1", - "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "ambiguous-target", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "7d36fcea2384b6bb28044bc68847492fefb2783909042a96f6416cc457c258c6", - "facts": {}, - "run_id_sha256": "628f991a182613b8700294d7483b5a4c06872cb9d5ca6047ea552b8ab6585357", - "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "task": "execute-acceptance", - "trial_index": 1, - "verdict": "delivered", - "workflow_version_id": "44444444-4444-4444-8444-444444444444" - } - }, - "22401bb3f7cdbee8cc0fdd6ce84eb60a63cfce66db20f3cf5cc51e55f10055a6": { - "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "d9sSKQsoWcbmbhegtitDx0KFu8s5ODI1gMwkrJJ6/8hn44yGMZLmli0xU3O74TuCA1Kn52rAURfFHJVftd/XDw==", - "source_artifact_sha256": "e8401afc508900868571caae7995d9771884b1f6faac3543a13bc77ce498c1fd", - "verified_at": "2026-08-18T10:03:00Z", + "signature": "EuQA8jdkwIwo+5vC6wMxn/ymEKM25/SvEIsmecnBTlx7RTBGO6ArUSTAtAARxTls9MjysZ/HRJpNCdosrSUsBw==", + "source_artifact_sha256": "b9930bf1c041fb17cb156788d0424c034c6be2711ca5911469fb8791a6c925f4", + "verified_at": "2026-08-18T10:34:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "fdad940f245d690750ad647fac25c7e76aac2f474db49732fec8129051750186", + "attempt_id_sha256": "3aee8ad755c7f4bec71cc194bcfaa805e0ea29cf8b830ed0782f8263dd9620ca", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-01", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "e8401afc508900868571caae7995d9771884b1f6faac3543a13bc77ce498c1fd", + "condition": "idempotency-replay", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "b9930bf1c041fb17cb156788d0424c034c6be2711ca5911469fb8791a6c925f4", "facts": {}, - "run_id_sha256": "3739043a92a8781376cfbd022460c03aba40f92a800b3885ebc046321437bc40", + "run_id_sha256": "3df83453126754a62d00ed10837720542d0469799bb8a88cb5257ac5f477a919", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "delivered", + "trial_index": 3, + "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "23f4a977cecbb6af1ccef4d88c9bd19fc9c474c0a382a0e22ce7bec1aeb706de": { + "1a563d5cd99282e7c58ec0490687e29f4dae999b8b7bdb5061775b1265d85b82": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "YolJuiUCQbpd/IW4hQPiiSftf0IUkswOwkppvD6eHEtu5zN5oSe7u2ayns1/TYCiNLUILz3ABrsh5X+rBYxZBw==", - "source_artifact_sha256": "ddb254eb6e2490fcb9e2b2952775ac00220ba9a95a70f4f784bec71ab5df37b7", - "verified_at": "2026-08-18T11:02:00Z", + "signature": "qUTw9aEKvrWGxki56Km8JfxfFJXFN3O6Au3SOQFu/wVr2UW0LR534Dsga1LH5BlD95DA2y5CpblGp2y7jIbtAQ==", + "source_artifact_sha256": "5a3777b92fabc030635bb4f578eda746f0b307d541bf84a0099314eed54c8d00", + "verified_at": "2026-08-18T10:14:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "60ee9db05b1126cfaa3b31c13bc3fab4755ac09c44e846b4d07ee51865dfa7b1", + "attempt_id_sha256": "019dd96e9a771ccc01ebafab321d7d3a8314df8b2d6465bcfc5fa14cbdeabdf2", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "ambiguous-target", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "ddb254eb6e2490fcb9e2b2952775ac00220ba9a95a70f4f784bec71ab5df37b7", + "condition": "healthy-02", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "5a3777b92fabc030635bb4f578eda746f0b307d541bf84a0099314eed54c8d00", "facts": {}, - "run_id_sha256": "628f991a182613b8700294d7483b5a4c06872cb9d5ca6047ea552b8ab6585357", + "run_id_sha256": "16cb8df40654c6a1b55ea0e50e772d8c6e6d4f0d8205bd1f8296be27d0af83eb", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, - "verdict": "halted", + "trial_index": 3, + "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "23f53c85f34d6013ca5c2961470deddd7bc790d5096380b677a9bf5e83951335": { + "1aa0752945c71b8e17838c6162a3a67911fec9a49344b67c0933235a67aa803e": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "Pw/4pQgvNhOgpGeEu9+Ctdz9LQXxizNWRWPLksV1KxO2POvl3tgLTC6TwTBAq78Frsc2C9PvaqXHZtJhqBQXBg==", - "source_artifact_sha256": "f9e70034e68ce8783bb50fb2f53e6c7f8f5ed238916ab72298bcc5068ba7cef8", - "verified_at": "2026-08-18T10:24:00Z", + "signature": "m5Iafq3M8yDHGbHIn1IDfhWl2lFed3NJhJlLzBUpd/X4HUtfjNZ1kOsD5dvrfu2umlqZT3hI3FIE7mOvcK74CQ==", + "source_artifact_sha256": "009c1c1e67709868ad5218f72fe47f2fe26660be981c32e064da92de8bc4e85e", + "verified_at": "2026-08-18T10:22:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "7573925adbd8a7a4a3b98bb0379549d77aa8ed46e312c1cd940c05b8587a039e", + "attempt_id_sha256": "fc097c8b2e6ece94544a19b8d81f5c4a9367a89059e3dd4b2f746ab06a2fc930", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "healthy-03", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "f9e70034e68ce8783bb50fb2f53e6c7f8f5ed238916ab72298bcc5068ba7cef8", - "facts": {}, - "run_id_sha256": "784a0a94e581700a3d93581e7ce5bac0d3bc53c58f3e73198b896b5da9a819b0", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "009c1c1e67709868ad5218f72fe47f2fe26660be981c32e064da92de8bc4e85e", + "facts": { + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "009c1c1e67709868ad5218f72fe47f2fe26660be981c32e064da92de8bc4e85e", + "source": "runner_signed_flow_report_and_enforced_egress_policy" + }, + "operator_intervention_ids_sha256": [] + }, + "run_id_sha256": "28768f565659133f5bf1170e638b81de4d7ca38dfecacd09ccf462a35344432b", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "delivered", + "trial_index": 1, + "verdict": "verified", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "24a0e21ab6813638a727b551149261a2220c7d3543d655234d685fc9d3bb4133": { + "1b1c89891a20c8f3a60fa6a1f5b11b5a46124864a574cac12195ab760a7517ab": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-138dfa227234ea5f", "receipt_type": "cleanup", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "n3mVM2tkoLMvCyKDwZuNlW8uTRA2yF5qykRFsBopDDjmGHHPcg5P3Wd8Icf+SgVILxcl0MHPImwHu019NoBdAQ==", - "source_artifact_sha256": "61e65cf0f747b77668ae9e6632a66d6d32d3dff99318b22ed782df46a78dbf0f", - "verified_at": "2026-08-18T10:44:00Z", + "signature": "GMN+pdJPTrlf6z1zbYW6eOZhyzCoJhFDngTvVwDcLoyt3iVdFgCWZDQyc+g4dzHGKo8ODSCRgcKvifRtQEFDAA==", + "source_artifact_sha256": "c99ff9e16fc08dfa2947c8baa3cd32d837e5e3c19ebbf6ce751821e33ee578f5", + "verified_at": "2026-08-18T10:42:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "7c910764b2dcc6f05261d609082f75474e4638c3f356006307212b8fed4a2eb7", + "attempt_id_sha256": "e93521e706ad90d799dcd4e8cac15229c5da6aec1638540606f5fab4efce59fc", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "wrong-reference", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "61e65cf0f747b77668ae9e6632a66d6d32d3dff99318b22ed782df46a78dbf0f", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "c99ff9e16fc08dfa2947c8baa3cd32d837e5e3c19ebbf6ce751821e33ee578f5", "facts": {}, - "run_id_sha256": "fe98ce7f0e66b885201f4667875fd38f5890ffddb575d68bd4cd5a66f8d53ca8", + "run_id_sha256": "ee82112f55e5e6c86cfd6e16df8c8b652549a8bd72de492f435d8255eb3dd252", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, + "trial_index": 1, "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "26c7adab527c721616e340b24605509062c669f64c41ec24cc5041f32bad0bfc": { + "1c7da3a1d54d0dfc9ce34ef02375c63a02592ce150bea7c95af03ae37a22e019": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-138dfa227234ea5f", - "receipt_type": "cleanup", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "UBoA/r6iXeisgAqxoY2D3Z532nUm1llt3t+4opIehAXo7XJZrdGVv3lJePflEMvGn9xUs7S+XpxXl4MZ/4v+Dg==", - "source_artifact_sha256": "f9f54cc3691f84eaf5543a39f915bc4b888249e20be389e737f07cc048fc796b", - "verified_at": "2026-08-18T11:24:00Z", + "signature": "CoIEwevGPvbQ5JhLd9phuuPZrT4ICKxOXEWsMIutmABv59m9nxXYcMBFec7qs6wYbjUC0vAgZUtvrVZEvdhpDw==", + "source_artifact_sha256": "68f28b4ae7bd66c29ac1d2e3cf594da46ea4d7fa7bfc29557c835bb848cf81d8", + "verified_at": "2026-08-18T11:23:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "aa7d6be4f25a8992c0a22649ba7e703d6955abf5fece9f8322f560149cf09776", + "attempt_id_sha256": "eb52fb1b1bf2fac92d8f3a444bb5081161be8b3d0ef457c5065e7b79e96df770", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "weak-effect-only", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "f9f54cc3691f84eaf5543a39f915bc4b888249e20be389e737f07cc048fc796b", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "68f28b4ae7bd66c29ac1d2e3cf594da46ea4d7fa7bfc29557c835bb848cf81d8", "facts": {}, - "run_id_sha256": "b974de9da8ef77c8dc9a7662114cc51023ab8c131c488681eeebb7d4c435c8d0", + "run_id_sha256": "794033f9da2a42448254a478fb6de954898b1e544148708ad30264efdc255431", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "completed", + "trial_index": 2, + "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "272e2c3c224b19f532d7a894d08b28f94782824ed6cdf90a3b216b2ded828210": { + "1d1c84e8e6603fb4ba62b0596df7282e207a1fde10e6549424ae32b6e0aa22ee": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", "receipt_type": "runner", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "qxsftP76Cj96/Gs+7wNGiK+lFtUmIPkCUh8jkr4K7H4WJQJ/afj0eQWkoF8YK/jPYAg2Fz4fQsUyf5XUXKZGBw==", - "source_artifact_sha256": "c20ee28b4875041089aace249d6634176c0ed5050228c8c0fba2b37db74b7632", - "verified_at": "2026-08-18T10:43:00Z", + "signature": "bsDxJURM5tIs+e3hrvxKJmqC0hkwAeEOXwbbxKxLNHHniFHuQUjOUaQhTf6mfXdEx5ap4ymcLO6EX38ERzFpCA==", + "source_artifact_sha256": "aecd407f56e892dd31846bf13f26f1d2b2683f375928da672b2d04773349cdc0", + "verified_at": "2026-08-18T10:44:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "6b0e5c10d55fc92c1ff8576392270a24fb65722414cf58ff9a51b8ce9ef88587", + "attempt_id_sha256": "7c910764b2dcc6f05261d609082f75474e4638c3f356006307212b8fed4a2eb7", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "wrong-reference", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "c20ee28b4875041089aace249d6634176c0ed5050228c8c0fba2b37db74b7632", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "aecd407f56e892dd31846bf13f26f1d2b2683f375928da672b2d04773349cdc0", "facts": { "model_call_counter": { "attempted": 0, @@ -1661,26 +1710,26 @@ "input_tokens": 0, "output_tokens": 0, "provider_models": [], - "report_sha256": "c20ee28b4875041089aace249d6634176c0ed5050228c8c0fba2b37db74b7632", + "report_sha256": "aecd407f56e892dd31846bf13f26f1d2b2683f375928da672b2d04773349cdc0", "source": "runner_signed_flow_report_and_enforced_egress_policy" }, "operator_intervention_ids_sha256": [] }, - "run_id_sha256": "577e37b10b1c87fd9c1b5d320888b736d272824657fd59a012e85a284ee88540", + "run_id_sha256": "fe98ce7f0e66b885201f4667875fd38f5890ffddb575d68bd4cd5a66f8d53ca8", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, + "trial_index": 3, "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "2798955cd738b419669697b8db8cfc4ef28861e4a00851f5addcb2967214c10f": { + "1e197551aad35da7b62616ed2064350f16c22455affd1520be245a8b408daa49": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d7e1e084be213b01", - "receipt_type": "observer", + "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", + "receipt_type": "fault", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "hmxykqri21ljkcu25p4fzJffG/UA6wMEKyGLsZL0oBNPCvAkCsdr1ioAypRgFUy9BSomVGCnnrykhOiLkyL3Bw==", - "source_artifact_sha256": "086aa3c333f8a4fdf55b0ef09ae301f38faa388075355ba8356b2a2e72f7b80e", + "signature": "+yuIKlu8guo7+B0DIYqFm9XQe/F0UySMFcl2MUctHsLtzewR2SUm4aKKA0unL2lXvazmWNtajMWHadtELdDaAQ==", + "source_artifact_sha256": "226019cc9a5778388b2bfe87bde12f7a08f8b33074eadc925d3e79197245a493", "verified_at": "2026-08-18T10:54:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", @@ -1688,240 +1737,260 @@ "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "stale-session", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "086aa3c333f8a4fdf55b0ef09ae301f38faa388075355ba8356b2a2e72f7b80e", - "facts": { - "derived_classifications": { - "collateral_effect_count": 0, - "duplicate_effect_count": 0, - "intended_effect_count": 0, - "wrong_record_count": 0 - }, - "dispatch_state": "not_dispatched", - "effect_inventory": [], - "expected_record_id_sha256": "e2bfc459a52b773d833645ffe96420a991d4761d31989876840d25b4b302c7aa", - "expected_transaction_ref_sha256": "95a5987fa6dfc58ef200281706e9fd73fc28a1d3d44d7eb278478e065e05d3be", - "post_state_evidence_sha256": "a34e8e155989eb0f32dbaf1dba2758e9355bff86a0d7fda67170ce423fd6fe25", - "pre_state_evidence_sha256": "c6dd473eaf43722b7b24747137e017fe88410937978ed19e9c3c694b01515608", - "verifier_method": "read_only_system_of_record_query", - "verifier_tier": "independent_system_of_record" - }, + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "226019cc9a5778388b2bfe87bde12f7a08f8b33074eadc925d3e79197245a493", + "facts": {}, "run_id_sha256": "6f2fb10bc2018c9f78e9702d5ccac0bedd78ee3b2e9d2a6ad779fba72d90ae50", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, - "verdict": "satisfied", + "verdict": "injected", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "290c960538dbc38ee2260052e5b97353e41c9ea3572cf627dbb2d7ce1124eb9e": { + "20aa8f54ef97930dc960d96c5e562f463483444038695a27caf9e4ae8325aba0": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", "receipt_type": "webhook", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "v6xnygfr/720J08ZrwVSLU+gMrVzqrPqLD0qLU+aYkcWdjchqjrQKtbwHikiTZykzHK5YoEGuPxrUVHlInv+BA==", - "source_artifact_sha256": "6c8e592e4280ffc6dc1202667837a33a8d1f4c8d88f7cde6d24a3d9b3317ad33", - "verified_at": "2026-08-18T10:42:00Z", + "signature": "cf0GsjAqcRXBqB9g4j0qpCqLXAI2TJbM4M6psgDdqxlhcot5KGphaA9XYA54KFn4+mREOxujUrLe426I3mruAA==", + "source_artifact_sha256": "67d2fc6cdd3fbe39ae3cd6003edb1e7069940afea7f0c3b00794713d26646677", + "verified_at": "2026-08-18T10:13:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "e93521e706ad90d799dcd4e8cac15229c5da6aec1638540606f5fab4efce59fc", + "attempt_id_sha256": "3d42601a69ef46cc44f57b51762affef4ccd829ffde30125619a6e582af00dab", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "wrong-reference", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "6c8e592e4280ffc6dc1202667837a33a8d1f4c8d88f7cde6d24a3d9b3317ad33", + "condition": "healthy-02", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "67d2fc6cdd3fbe39ae3cd6003edb1e7069940afea7f0c3b00794713d26646677", "facts": {}, - "run_id_sha256": "ee82112f55e5e6c86cfd6e16df8c8b652549a8bd72de492f435d8255eb3dd252", + "run_id_sha256": "091e13ed70dab439b31cb506cf3bba1ddf6476696531cf891c39a924a928b7a1", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, + "trial_index": 2, "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "2a78ce1f942edcd37931679bf672ad893a1cfea2a6a027c0210f53380c083cb4": { + "225622bb5ee4826536bdfc78065e01c0325dbbb427bb377638308ed5e4ddb423": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", + "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", + "receipt_type": "fault", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "KIFjrwN/K+gcF45dRYNRI1ih8J3oTC6Vlx1twxpquElw2ycn71WDK4OPG5EoBn752pbEQBCwcyLJd/86F3v5Dg==", - "source_artifact_sha256": "051bac821eaa3486034f245101d6c1f831d659444be87a3b5d774a9abaea05ff", - "verified_at": "2026-08-18T11:02:00Z", + "signature": "V3mF0LP1zc63LqSEz0F2SgfvtbMkvgBChkhMSz1yz5sw2Wo3C8hSQy+C2jd43z1jgny1XRBpVYRII53nY0jLBQ==", + "source_artifact_sha256": "753ac5d5256a729ac572debdef63e5a8acd11b2b6ef909f8efb94d885f37d065", + "verified_at": "2026-08-18T11:22:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "60ee9db05b1126cfaa3b31c13bc3fab4755ac09c44e846b4d07ee51865dfa7b1", + "attempt_id_sha256": "73a097b8b20bab7794369384f7ca1d7d711aad07967b7e1292373babbb7ff1b7", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "ambiguous-target", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "051bac821eaa3486034f245101d6c1f831d659444be87a3b5d774a9abaea05ff", + "condition": "weak-effect-only", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "753ac5d5256a729ac572debdef63e5a8acd11b2b6ef909f8efb94d885f37d065", "facts": {}, - "run_id_sha256": "628f991a182613b8700294d7483b5a4c06872cb9d5ca6047ea552b8ab6585357", + "run_id_sha256": "b44783e70a980ec5b3cf3752bd5d1d01b2ff29f5a6892cba0c1c939d8aeb7c02", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, - "verdict": "absent", + "verdict": "injected", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "2cc546bd37198e76ce6746f03869d3382b12582987ca76354cb1f4c0b913325a": { + "22bff5bcdee9fa55620524338cb0a162bb592e0c237c0ff33c3eb83ffc26f1a6": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "lcWmc3jQQ9YeclbmxaWQQHivfzQr1B5uzTLhe0pWbAMioKYsYqVWZIfcDn4+17TC9zO8XVazHja2dpPk1EnGDw==", - "source_artifact_sha256": "1f121d102e5fbb97098da4d1334dfe5ffc8566bedbc601d9a73f719d325e04c3", - "verified_at": "2026-08-18T10:33:00Z", + "signature": "CqvWE6P5NvFyCVwmJVL8TTW8nXDmpcHc41jvy+BG3VgHwjMAh/cGSKHis+oLRdC+qVmsbF5lo8fKjP1iAHK0CQ==", + "source_artifact_sha256": "b4cd01f298514b82ac8baafbaf99475b073f39bad0a7c9ad414d5fdd8fe5ccd5", + "verified_at": "2026-08-18T10:43:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "4667302b580ff7ceb223dbb15eb6d029969a8f6a54bcd33e8df5b6bff41f41ad", + "attempt_id_sha256": "6b0e5c10d55fc92c1ff8576392270a24fb65722414cf58ff9a51b8ce9ef88587", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "idempotency-replay", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "1f121d102e5fbb97098da4d1334dfe5ffc8566bedbc601d9a73f719d325e04c3", - "facts": {}, - "run_id_sha256": "33e0ad9bf64e477f24d46508fa432123e046dcd1c5853d5cc60b7cde1bce7537", + "condition": "wrong-reference", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "b4cd01f298514b82ac8baafbaf99475b073f39bad0a7c9ad414d5fdd8fe5ccd5", + "facts": { + "derived_classifications": { + "collateral_effect_count": 0, + "duplicate_effect_count": 0, + "intended_effect_count": 0, + "wrong_record_count": 0 + }, + "dispatch_state": "not_dispatched", + "effect_inventory": [], + "expected_record_id_sha256": "635a8a05ef43c6aa69c8a658a72f59687ebda6a9799a17db1bd6dfd70abfff15", + "expected_transaction_ref_sha256": "b37ca33f4b6b8162e928b6b03b31d47f3ff044d4947f5e113e1f1a49bd15f40f", + "post_state_evidence_sha256": "6394a575d25ea8199fe4cff9d7fe855ff3c2db94468a69f0165d0759c896b99e", + "pre_state_evidence_sha256": "d254b6167e6ec999ee08c9b3ff18bf1cfa914b0a228603e9062abe5ecb99430c", + "verifier_method": "read_only_system_of_record_query", + "verifier_tier": "independent_system_of_record" + }, + "run_id_sha256": "577e37b10b1c87fd9c1b5d320888b736d272824657fd59a012e85a284ee88540", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, - "verdict": "absent", + "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "2e9cd2761799c0bf0feef8b9bba65cfb1b5f888d314a2663a33d49cae4834122": { + "22c39ce4d6ef15d6eb6243bfc69a7275e58db27312b1d7d930a1536078d2dd1b": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "r9DGqCxk+I4QO0A6k98ggdcmfBk+waTX+zgeBw5o6aQQXqGOEPYoYS/WrUeXYbjWGgskKOzJPFPYiG/1iGDWBg==", - "source_artifact_sha256": "40ce452beafd723531d21b631c3b7710042cff165f085f929b65d07e9575e16b", - "verified_at": "2026-08-18T11:14:00Z", + "signature": "zoLpxOnUXPK+nKyJK4XVi+cysMwb+QdEkM5GPREx45onAbyxYlVnOHXRBt+JpkdG39PHMj0XH6YjS+mJVBWGBg==", + "source_artifact_sha256": "3f1ce2b52c8b8ed56bc485f70b885b295f43f601b14c7834ee455b982154a6e5", + "verified_at": "2026-08-18T11:02:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "ad76dacfe19a4421ef1f128d4eef1099e846b385d29f17b8588ae5130b487118", + "attempt_id_sha256": "60ee9db05b1126cfaa3b31c13bc3fab4755ac09c44e846b4d07ee51865dfa7b1", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "verifier-unavailable", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "40ce452beafd723531d21b631c3b7710042cff165f085f929b65d07e9575e16b", - "facts": {}, - "run_id_sha256": "87014cd8063f5a43ea22c995be03ec41ef5aa613145acacdef71b68c468fc8f1", - "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "task": "execute-acceptance", - "trial_index": 3, - "verdict": "halted", - "workflow_version_id": "44444444-4444-4444-8444-444444444444" - } - }, - "2e9e8e01ec1be899f4e038599fc64adbc3942c35c0565bb67e17d382bc5ca8a8": { - "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", + "condition": "ambiguous-target", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "3f1ce2b52c8b8ed56bc485f70b885b295f43f601b14c7834ee455b982154a6e5", + "facts": { + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "3f1ce2b52c8b8ed56bc485f70b885b295f43f601b14c7834ee455b982154a6e5", + "source": "runner_signed_flow_report_and_enforced_egress_policy" + }, + "operator_intervention_ids_sha256": [] + }, + "run_id_sha256": "628f991a182613b8700294d7483b5a4c06872cb9d5ca6047ea552b8ab6585357", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "halted", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "2620b39835a746527f83d880cf3f1b0374cca47780af38a4efc1ba747be084c0": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "5rzUypB8Maj2Gaj/xyjK+FIxqVwdsnZ6vfUcMk7h1pv1Q8KM0DwZuw9mXKijy8Yv94RJiOQY9JwVWx4xBENICg==", - "source_artifact_sha256": "fac9c9cf16a2c781d6f7c55b241c6266c4fa513744fb05a705c1c8d33e3c7ccf", - "verified_at": "2026-08-18T10:24:00Z", + "signature": "eLQCX1+GFYj8MfROaDXZOAJ+k3DW+2X8DIctPzgXHjI0PV5M1rDJvcMYq5LX0yxzaQ29VyB+feCwXi8hXOovBg==", + "source_artifact_sha256": "ce91f56ef05d03386741ded56d7c2728b371c0ffcd8dc025c0dcad239242f6d5", + "verified_at": "2026-08-18T10:53:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "7573925adbd8a7a4a3b98bb0379549d77aa8ed46e312c1cd940c05b8587a039e", + "attempt_id_sha256": "f5df4d6e64a2d38ffa8e320c87ad05d04025de267a8e152a755d3f1928ded120", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-03", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "fac9c9cf16a2c781d6f7c55b241c6266c4fa513744fb05a705c1c8d33e3c7ccf", + "condition": "stale-session", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "ce91f56ef05d03386741ded56d7c2728b371c0ffcd8dc025c0dcad239242f6d5", "facts": {}, - "run_id_sha256": "784a0a94e581700a3d93581e7ce5bac0d3bc53c58f3e73198b896b5da9a819b0", + "run_id_sha256": "fd3a041b705d8c6277ce26134dc0018e866218cfa3fadd16ac29d1ad498965a3", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "absent", + "trial_index": 2, + "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "2f5e6b2f5830a2af96d4caaa4154d8df09aad535e981334f256ac161509da31d": { + "2638fa03d72aedf3ec3b7dad2bc7e804f3298b44262723db23d99f4202ea063c": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "vbB6/g1ADS1Wa3smWK9pzLD03A6g1gDjjAIv9IwBBSRkijIe6Igy+tPcMlhbmYXPSBnFiwcXo2/yMwkWCdNXDA==", - "source_artifact_sha256": "a46df95e5690b582be425e126233998cf8a82e1db8ea11a5dade90b3cc616b28", - "verified_at": "2026-08-18T10:14:00Z", + "signature": "pguATujqcdSJXKnfLPYmss+Vtn2em5VHN9Ak3CmQX/MjjnFKxXAAdUtGT2ctXAurUs1vpP4S3I1MiDVxMgc0Bg==", + "source_artifact_sha256": "6c8e592e4280ffc6dc1202667837a33a8d1f4c8d88f7cde6d24a3d9b3317ad33", + "verified_at": "2026-08-18T10:42:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "019dd96e9a771ccc01ebafab321d7d3a8314df8b2d6465bcfc5fa14cbdeabdf2", + "attempt_id_sha256": "e93521e706ad90d799dcd4e8cac15229c5da6aec1638540606f5fab4efce59fc", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-02", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "a46df95e5690b582be425e126233998cf8a82e1db8ea11a5dade90b3cc616b28", + "condition": "wrong-reference", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "6c8e592e4280ffc6dc1202667837a33a8d1f4c8d88f7cde6d24a3d9b3317ad33", "facts": {}, - "run_id_sha256": "16cb8df40654c6a1b55ea0e50e772d8c6e6d4f0d8205bd1f8296be27d0af83eb", + "run_id_sha256": "ee82112f55e5e6c86cfd6e16df8c8b652549a8bd72de492f435d8255eb3dd252", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "verified", + "trial_index": 1, + "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "353a8e94bb09676bab144917696e954ea6351cb3cd171add5e2abb6c7134d61e": { + "2767e751b8937c1513ae768a938b63cd93762cc38ffeffdee4817f7f6d37ca26": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", - "receipt_type": "fault", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "4r5Fptluo7tIKyfnfpzaeqmPjXGZPymvfXSEq7w2uPSuKulw3ILbNFF5f7QF2hIgSVUdDEzQNIOqkQipjVc1Dg==", - "source_artifact_sha256": "ac34c209ded7d003e6d99a60a52adc51e65926a708df1a94834a196ba9fe9812", - "verified_at": "2026-08-18T11:04:00Z", + "signature": "mARQvLua5F5/uTxW7UmiuvRGgCv+VeTa3jzwPPBtdDiA+Egd2gtdQslx8SS7v+1xbZPZC9B3boV0A5GnLdJjAQ==", + "source_artifact_sha256": "9ee6e57b75e164f5f91625d37f3d8286db558d96de0fe27acfcfc45c1288fda5", + "verified_at": "2026-08-18T11:03:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "491a544656d05aea37920e5c7e2ad65a9452eac8d6e100268a599aeebd41187a", + "attempt_id_sha256": "1ec11a9862ede3ac701af71835ac28c551d604a026b5bab7d776dbcdf288394e", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "ambiguous-target", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "ac34c209ded7d003e6d99a60a52adc51e65926a708df1a94834a196ba9fe9812", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "9ee6e57b75e164f5f91625d37f3d8286db558d96de0fe27acfcfc45c1288fda5", "facts": {}, - "run_id_sha256": "aa62c7a17701a7ef01ea1d3519b4c1f90d357495b329fdda3054cc24c581a593", + "run_id_sha256": "43f0a1c00950c390b0676fab55a2aa98c354d028f2347c461661e6cdb72f717e", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "injected", + "trial_index": 2, + "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "35fde2e03b3dc98d4b7cd66082f330ce9f3501d4d236e4c5394348d85e7f176c": { + "281be7f9049010d1e52cb8d54cc76c316126b091df060895e6f8be1b17bf99db": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-d7e1e084be213b01", "receipt_type": "observer", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "EGlia6pU8sjqGFo0WaZ9WKemS1xU1sF/Pe7aqsbESdxYNBjrF6A2vMRImSVgCnPhptZeRhRSc/9e2/we6UqWAQ==", - "source_artifact_sha256": "669b90f52ab8347c72f46f47c7493d314fafe014431fa4d576db6a8d42eeb0dd", - "verified_at": "2026-08-18T11:04:00Z", + "signature": "wd9fEIzK98Xzs0TxNAR+j3etRTIQgfmX5PgpTU/kdl37s/Koto9qcHd/S5zVw/up3AAU0XstU3FARwVyeIBHCw==", + "source_artifact_sha256": "c91752eaaac4392dd7aeb24d399c347eb77db07214d1121d39629b13b9dff7a6", + "verified_at": "2026-08-18T10:34:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "491a544656d05aea37920e5c7e2ad65a9452eac8d6e100268a599aeebd41187a", + "attempt_id_sha256": "3aee8ad755c7f4bec71cc194bcfaa805e0ea29cf8b830ed0782f8263dd9620ca", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "ambiguous-target", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "669b90f52ab8347c72f46f47c7493d314fafe014431fa4d576db6a8d42eeb0dd", + "condition": "idempotency-replay", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "c91752eaaac4392dd7aeb24d399c347eb77db07214d1121d39629b13b9dff7a6", "facts": { "derived_classifications": { "collateral_effect_count": 0, "duplicate_effect_count": 0, - "intended_effect_count": 0, + "intended_effect_count": 1, "wrong_record_count": 0 }, - "dispatch_state": "not_dispatched", - "effect_inventory": [], - "expected_record_id_sha256": "c9446a96197759e6626c902a50c333132d48db209984b45b7b664dee186a7578", - "expected_transaction_ref_sha256": "95f52355bde231835ef1b23f37e8ce989bdf4042ee52fd679fc8eeb514949ad1", - "post_state_evidence_sha256": "d71deb3de9d35b282b7ac9eed3feffc5432a6f28295101b520c1cd0943756dd6", - "pre_state_evidence_sha256": "6d640c6c9ca204c38d59f02e48d62e1d9b9eb13080f6ddf18196c807c8770c30", + "dispatch_state": "dispatched", + "effect_inventory": [ + { + "effect_id_sha256": "86bffa79f59e7a839b38edfddced10a0329f7c46625f812b0791062e2975c21f", + "record_id_sha256": "6fc6b4a09a4cb0e71faf8a0b537d308527b4b5f8563a72be9e779ba072bdc954", + "transaction_ref_sha256": "717e0261bd78563991a1f9643d3501a699fe53230ec01c973f42f7b98aa411ac" + } + ], + "expected_record_id_sha256": "6fc6b4a09a4cb0e71faf8a0b537d308527b4b5f8563a72be9e779ba072bdc954", + "expected_transaction_ref_sha256": "717e0261bd78563991a1f9643d3501a699fe53230ec01c973f42f7b98aa411ac", + "post_state_evidence_sha256": "b1e104f5f06bee9c27a2275103156f8eb3274048197efe52f9abc393d9fac129", + "pre_state_evidence_sha256": "813f12a9a620bb94137fe4534de4f1d83e85eadb73e8483267da89c79fd9b984", "verifier_method": "read_only_system_of_record_query", "verifier_tier": "independent_system_of_record" }, - "run_id_sha256": "aa62c7a17701a7ef01ea1d3519b4c1f90d357495b329fdda3054cc24c581a593", + "run_id_sha256": "3df83453126754a62d00ed10837720542d0469799bb8a88cb5257ac5f477a919", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, @@ -1929,157 +1998,109 @@ "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "36112ed5002c4c5621bcfe60eb7e41873051625d844ff153a403684b410467a7": { - "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", - "receipt_type": "runner", - "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "0dHbAZQcnLVtzksOy7CP3Pc82FYynnPy6IePhqHdq1NLY5WFnK8VjO4SjLt9U+jV8WLdFgeGAJmapFy/rLOtAw==", - "source_artifact_sha256": "9e7ce6c0c14f2e05ca217cb2830c9fbdd1205753014ece86f7e77671774081da", - "verified_at": "2026-08-18T11:23:00Z", - "verified_projection": { - "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "eb52fb1b1bf2fac92d8f3a444bb5081161be8b3d0ef457c5065e7b79e96df770", - "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "weak-effect-only", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "9e7ce6c0c14f2e05ca217cb2830c9fbdd1205753014ece86f7e77671774081da", - "facts": { - "model_call_counter": { - "attempted": 0, - "call_ids_sha256": [], - "completed": 0, - "cost_microusd": 0, - "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", - "input_tokens": 0, - "output_tokens": 0, - "provider_models": [], - "report_sha256": "9e7ce6c0c14f2e05ca217cb2830c9fbdd1205753014ece86f7e77671774081da", - "source": "runner_signed_flow_report_and_enforced_egress_policy" - }, - "operator_intervention_ids_sha256": [] - }, - "run_id_sha256": "794033f9da2a42448254a478fb6de954898b1e544148708ad30264efdc255431", - "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "task": "execute-acceptance", - "trial_index": 2, - "verdict": "halted", - "workflow_version_id": "44444444-4444-4444-8444-444444444444" - } - }, - "369bbe15a24b28d16d87482480bed7ee9b4ab2cedef0a051a930e3f95ec39a1a": { + "2d0a8725e625c8e184f24040e567926e25ed8581cdd81b8fdd6fd3a541ae654f": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "Q8dFLP4O1evr+ECPcnlKvLeUcoBiusxLQtaDWXNO2unOqRId1c5UEFEu5V42esnD/4qHCYw0mgbimMy09aIVAA==", - "source_artifact_sha256": "65140882628aea7d2f64f788fcf9fcb6addfd372449a58a0221ac27b0355af3f", - "verified_at": "2026-08-18T11:24:00Z", + "signature": "49FlqI5N8bDenIWfQ7b6Mn3OcqnGtTSKosmiP1rNBKGj72FbW/mL9Uq53vEzvBvOXZUs/J5jyUoMZKJ8B+GgAQ==", + "source_artifact_sha256": "fac9c9cf16a2c781d6f7c55b241c6266c4fa513744fb05a705c1c8d33e3c7ccf", + "verified_at": "2026-08-18T10:24:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "aa7d6be4f25a8992c0a22649ba7e703d6955abf5fece9f8322f560149cf09776", + "attempt_id_sha256": "7573925adbd8a7a4a3b98bb0379549d77aa8ed46e312c1cd940c05b8587a039e", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "weak-effect-only", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "65140882628aea7d2f64f788fcf9fcb6addfd372449a58a0221ac27b0355af3f", + "condition": "healthy-03", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "fac9c9cf16a2c781d6f7c55b241c6266c4fa513744fb05a705c1c8d33e3c7ccf", "facts": {}, - "run_id_sha256": "b974de9da8ef77c8dc9a7662114cc51023ab8c131c488681eeebb7d4c435c8d0", + "run_id_sha256": "784a0a94e581700a3d93581e7ce5bac0d3bc53c58f3e73198b896b5da9a819b0", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, - "verdict": "halted", + "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "379bdd3e735612de1d2a7c4860a87692e78175e7425ffdbcb65a45e2c205af28": { + "2dbec56c2995cef6865f2f09cd3f7eca569c66785c622f569bd198329c91eac8": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-d7e1e084be213b01", "receipt_type": "observer", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "SGMcXAPZ3ItKN8whwqa6y/RRAVx0lbbFCSX+9bmfcH9eUZbXdKr+X/WgRnRosPOpx0Bz4JOcI+IkzwaS8AyBAw==", - "source_artifact_sha256": "b4cd01f298514b82ac8baafbaf99475b073f39bad0a7c9ad414d5fdd8fe5ccd5", - "verified_at": "2026-08-18T10:43:00Z", + "signature": "DkYopG6Q/gLmCrUCkBdJd7RMR45SO/wZ6N5rtZc/YEttFOQog1Gzo4vF1iQCq7W+wr1166VYVsM46dr4VsN2CA==", + "source_artifact_sha256": "2a8bec5d9988588a24b36ed1499927f102d61b5867aad99f171fb4a89ce595bf", + "verified_at": "2026-08-18T10:12:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "6b0e5c10d55fc92c1ff8576392270a24fb65722414cf58ff9a51b8ce9ef88587", + "attempt_id_sha256": "940d3ca125ff87ce7539740fbae29d2d64fec839328b0639127e1d197d2485d8", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "wrong-reference", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "b4cd01f298514b82ac8baafbaf99475b073f39bad0a7c9ad414d5fdd8fe5ccd5", + "condition": "healthy-02", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "2a8bec5d9988588a24b36ed1499927f102d61b5867aad99f171fb4a89ce595bf", "facts": { "derived_classifications": { "collateral_effect_count": 0, "duplicate_effect_count": 0, - "intended_effect_count": 0, + "intended_effect_count": 1, "wrong_record_count": 0 }, - "dispatch_state": "not_dispatched", - "effect_inventory": [], - "expected_record_id_sha256": "635a8a05ef43c6aa69c8a658a72f59687ebda6a9799a17db1bd6dfd70abfff15", - "expected_transaction_ref_sha256": "b37ca33f4b6b8162e928b6b03b31d47f3ff044d4947f5e113e1f1a49bd15f40f", - "post_state_evidence_sha256": "6394a575d25ea8199fe4cff9d7fe855ff3c2db94468a69f0165d0759c896b99e", - "pre_state_evidence_sha256": "d254b6167e6ec999ee08c9b3ff18bf1cfa914b0a228603e9062abe5ecb99430c", + "dispatch_state": "dispatched", + "effect_inventory": [ + { + "effect_id_sha256": "e45a708944b07484bedb1335618bb2857bff8fb3811b74e83938a3bdbc92954d", + "record_id_sha256": "4df580e44d7b5f5a68d9c2d8f8daa26c2026e2c1e0f00065d08fe22fa1dadfcf", + "transaction_ref_sha256": "0be7d7c67da1fcabbc08e5839af8f39802bd2f3ff7457b26f8723e000f65e968" + } + ], + "expected_record_id_sha256": "4df580e44d7b5f5a68d9c2d8f8daa26c2026e2c1e0f00065d08fe22fa1dadfcf", + "expected_transaction_ref_sha256": "0be7d7c67da1fcabbc08e5839af8f39802bd2f3ff7457b26f8723e000f65e968", + "post_state_evidence_sha256": "4fe967939f22b92004b65dc7ff985026be9b8bc32c59f69686c3672398bfffd3", + "pre_state_evidence_sha256": "4e350e2dcc8aa5ace5ee271d20a892b406060a57a6607b1875cb917f9857f32d", "verifier_method": "read_only_system_of_record_query", "verifier_tier": "independent_system_of_record" }, - "run_id_sha256": "577e37b10b1c87fd9c1b5d320888b736d272824657fd59a012e85a284ee88540", + "run_id_sha256": "bbb9312ce4682b23580eced0f8d19438d8266b222555df85fb27eef22ad5afe2", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, + "trial_index": 1, "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "399969b28d2a8a4508e5aba7deeb80a5d10271732c45ec8b771afca68c5019c2": { + "326425236f07d21b2b95f99f3849e2eab4720679adc160b8fa15599a6d69f5bc": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d7e1e084be213b01", - "receipt_type": "observer", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "zrkF3u6yilvhZAHjPYqNM1OVPoUdIQSI6qnNXdIZJjgnh50629XZeXaFeoY6nK+nP2Ese/ZM2vgycya/tueGBg==", - "source_artifact_sha256": "57e3d1b277db5cbe456c303c9cb64859db7dc268807b185a31e35936e13ee8c3", - "verified_at": "2026-08-18T11:22:00Z", + "signature": "Ae03z7MRZeBf10kOC5htxgInfrmohBelbkJs//yerZugHKR16Y5dlFqQZ7TRkwgMbUg+Ry0mXYKvAqfoAW/NBA==", + "source_artifact_sha256": "738fb82696e36887119e66c49386fc345003080f8417dcd4157684ca9a820236", + "verified_at": "2026-08-18T10:02:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "73a097b8b20bab7794369384f7ca1d7d711aad07967b7e1292373babbb7ff1b7", + "attempt_id_sha256": "679af5a8dedceb8c696719e73f82a698c230cd8fc98bb61769f0883202c0b637", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "weak-effect-only", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "57e3d1b277db5cbe456c303c9cb64859db7dc268807b185a31e35936e13ee8c3", - "facts": { - "derived_classifications": { - "collateral_effect_count": 0, - "duplicate_effect_count": 0, - "intended_effect_count": 0, - "wrong_record_count": 0 - }, - "dispatch_state": "not_dispatched", - "effect_inventory": [], - "expected_record_id_sha256": "9834b8ac2ddaa9ad681db17b9bec4f192d28619c87021bce9515e9d2c5c0f4c8", - "expected_transaction_ref_sha256": "7feab8a28dcdcf6a94bb2e1551e37c1ec9443784e191b71faddd012c020fcb93", - "post_state_evidence_sha256": "6c1e8b0581e0efa08372ff5ea57591c559aaa279cf20353418d7e2f21bc53f59", - "pre_state_evidence_sha256": "02df7d1e41ca49f834c03a39fb4403890fb1aad742f41cd014a99926926dc8d5", - "verifier_method": "read_only_system_of_record_query", - "verifier_tier": "independent_system_of_record" - }, - "run_id_sha256": "b44783e70a980ec5b3cf3752bd5d1d01b2ff29f5a6892cba0c1c939d8aeb7c02", + "condition": "healthy-01", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "738fb82696e36887119e66c49386fc345003080f8417dcd4157684ca9a820236", + "facts": {}, + "run_id_sha256": "0b5bda916a0808165159166955a9563cf9c2303949f762a18eb037f41b44a6dc", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, - "verdict": "satisfied", + "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "39a0a13faa3fbc11b08573ce721f16a0312f03f22fd3f8066c1ff74a34445b22": { + "334274a59422c99002bc020a2553b59795600d288e3c0f376d7f3aca64207e6d": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-138dfa227234ea5f", - "receipt_type": "cleanup", + "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", + "receipt_type": "fault", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "so9kStMrXAYl+siUxeR0v9ozOROTB8oSizS5ik/lXZFNTrB8fwyb8+wMM5kOGgn8TJSFoVIQeQU1ejJ6gnFHCw==", - "source_artifact_sha256": "3edf91becb8c50a0a4c4769e60bfd13bf8bfc1727bb05e1737099caba33e651e", + "signature": "y/IhkiinWmw4aMWQSn3rgSYMs9lLnjE5gT8NeSm4ogaChAP7qS9N9ht60EMRAzXmFRf7+ZqPH8a4pwEVoUs9AQ==", + "source_artifact_sha256": "7d54c11699d0fc258007146c754f3dd04a68594dea5bf0402d10aa55a04b514d", "verified_at": "2026-08-18T11:02:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", @@ -2087,129 +2108,108 @@ "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "ambiguous-target", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "3edf91becb8c50a0a4c4769e60bfd13bf8bfc1727bb05e1737099caba33e651e", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "7d54c11699d0fc258007146c754f3dd04a68594dea5bf0402d10aa55a04b514d", "facts": {}, "run_id_sha256": "628f991a182613b8700294d7483b5a4c06872cb9d5ca6047ea552b8ab6585357", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, - "verdict": "completed", + "verdict": "injected", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "3c917b1de8297d9d1578795470d6a379a5bc0171ac1488d5468cb201099865b7": { + "33d268608af6e0d7ab9a6106fb8fe52196d02b1185ec764489a6f629a852727b": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-138dfa227234ea5f", - "receipt_type": "cleanup", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "WCJXjMRnbQxfQRpVeBMmuAKGzT5MDA2jzvNbHmbzPCVBPrkR4VgQTvxe176w166niYYKjPvfG8LmWcYMhIxSAQ==", - "source_artifact_sha256": "1594ca15edbb7755f6b59f1e58383c96dab980507ce5edff073a7a295f07069b", - "verified_at": "2026-08-18T10:14:00Z", + "signature": "cfDapFq8Qnr6AYKp96UaKKOuDT0kdQqel9CMR0q0Bm0LceL77hcNDFSEv5/pd7g+jyySVZqxrKkPkJygGMufAA==", + "source_artifact_sha256": "1f121d102e5fbb97098da4d1334dfe5ffc8566bedbc601d9a73f719d325e04c3", + "verified_at": "2026-08-18T10:33:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "019dd96e9a771ccc01ebafab321d7d3a8314df8b2d6465bcfc5fa14cbdeabdf2", + "attempt_id_sha256": "4667302b580ff7ceb223dbb15eb6d029969a8f6a54bcd33e8df5b6bff41f41ad", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-02", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "1594ca15edbb7755f6b59f1e58383c96dab980507ce5edff073a7a295f07069b", + "condition": "idempotency-replay", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "1f121d102e5fbb97098da4d1334dfe5ffc8566bedbc601d9a73f719d325e04c3", "facts": {}, - "run_id_sha256": "16cb8df40654c6a1b55ea0e50e772d8c6e6d4f0d8205bd1f8296be27d0af83eb", + "run_id_sha256": "33e0ad9bf64e477f24d46508fa432123e046dcd1c5853d5cc60b7cde1bce7537", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "completed", + "trial_index": 2, + "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "3cce0307da3bad33d18f117ca01623c6baea1b925048bef9a82fbb3ea576df62": { + "3400693bec4a39f928c7fc0cfb11b395da48132fdef98e7f945c08beaa11ab68": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d7e1e084be213b01", - "receipt_type": "observer", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "pzdjxS706zUxP+/6MtnvfHX50LXcXi7FMUOMmqnCl2vvB1wWvBX9HxdKK43ufqC+EA9XJ83hdCldd75dEZC2Dw==", - "source_artifact_sha256": "ed51ba8ee340b00da87808f45e1ed935c200be0ed41ea55cba8ebcc8e4b3872f", - "verified_at": "2026-08-18T10:24:00Z", + "signature": "MMNzf536RXJU04Fz/TnHnRYLwhOay/1fZTrMU7BIOknFL8tI2WRBD893iYeW8dUl4bUyru4A3xCqMBiG+P4fBw==", + "source_artifact_sha256": "5d0a6686e8f1d277c080d35d24db5e2f371ce4a69ee7b9d275d63a34af50f9d2", + "verified_at": "2026-08-18T11:03:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "7573925adbd8a7a4a3b98bb0379549d77aa8ed46e312c1cd940c05b8587a039e", + "attempt_id_sha256": "1ec11a9862ede3ac701af71835ac28c551d604a026b5bab7d776dbcdf288394e", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-03", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "ed51ba8ee340b00da87808f45e1ed935c200be0ed41ea55cba8ebcc8e4b3872f", - "facts": { - "derived_classifications": { - "collateral_effect_count": 0, - "duplicate_effect_count": 0, - "intended_effect_count": 1, - "wrong_record_count": 0 - }, - "dispatch_state": "dispatched", - "effect_inventory": [ - { - "effect_id_sha256": "840362150d294fb842a0c430c081c44a514e216c4132f6658b2b0407e8336467", - "record_id_sha256": "5d8c903c632927ac9da078a25888efd1b9f104001bcbbe75434bfff1cb0e89d6", - "transaction_ref_sha256": "58e0d46c681d3c9e62f50fe840b0ccd8c6aa127d05e91bab2f24b530ff550039" - } - ], - "expected_record_id_sha256": "5d8c903c632927ac9da078a25888efd1b9f104001bcbbe75434bfff1cb0e89d6", - "expected_transaction_ref_sha256": "58e0d46c681d3c9e62f50fe840b0ccd8c6aa127d05e91bab2f24b530ff550039", - "post_state_evidence_sha256": "a0c814b977f2af708e63f07584860c9ce3060ae5c2416678d88bf7948a6287a4", - "pre_state_evidence_sha256": "0d2090d7b6d69d898af9f95d735324ff9f05a5f8b24ead01f37df42dcac6ced6", - "verifier_method": "read_only_system_of_record_query", - "verifier_tier": "independent_system_of_record" - }, - "run_id_sha256": "784a0a94e581700a3d93581e7ce5bac0d3bc53c58f3e73198b896b5da9a819b0", + "condition": "ambiguous-target", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "5d0a6686e8f1d277c080d35d24db5e2f371ce4a69ee7b9d275d63a34af50f9d2", + "facts": {}, + "run_id_sha256": "43f0a1c00950c390b0676fab55a2aa98c354d028f2347c461661e6cdb72f717e", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "satisfied", + "trial_index": 2, + "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "3e7ffe28a48816b6b63017f4d4e4fd2f3c387841bc5e8bfc14fa4f749653cf85": { + "3528e48ccd24590f11280fa664f1d115109d55bbbadcd5fbe6eecf184bfca700": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "pICsevbvjG2HMpwKvO/B2rcofr52fkVfSKJVSMg6xyz2VkUoAWPiIuRkq9lcCfrA+89640wIYEHD2Mi54K3ZBw==", - "source_artifact_sha256": "98f3bd644c3f5baa2083f90afb499c9a29160c8160a518c2d6fac7d9a3cf3792", - "verified_at": "2026-08-18T11:12:00Z", + "signature": "iU0mvdijaPh7Zf2TiCjE9SF5ujjZnlSc6bA+DuQz5ABuGqvwQcD1tBzMp01gvgus2Vl0cimPxMklezhTpLACAA==", + "source_artifact_sha256": "c5d1d4394bb4197462d6bb136e8e249ac9d8c283bf8563a8ffbd0b7e0141795f", + "verified_at": "2026-08-18T10:54:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "f5e96a2e9a580376b18beabf57798b8761e772a0c4d112877045780bb12b3720", + "attempt_id_sha256": "958342a9ddca98a83b82b662f52f404239d583afe7ed70634760e1b8dd592f3b", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "verifier-unavailable", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "98f3bd644c3f5baa2083f90afb499c9a29160c8160a518c2d6fac7d9a3cf3792", + "condition": "stale-session", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "c5d1d4394bb4197462d6bb136e8e249ac9d8c283bf8563a8ffbd0b7e0141795f", "facts": {}, - "run_id_sha256": "e8e89651045a5f5c011c9543ed968e0fe7697a061ed8ad5cedc27d194cb96acb", + "run_id_sha256": "6f2fb10bc2018c9f78e9702d5ccac0bedd78ee3b2e9d2a6ad779fba72d90ae50", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, - "verdict": "absent", + "trial_index": 3, + "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "3f5b7d5d21d2bd5fdff3bfca3f28f239673753668c9007bb04d6541fb3ef2226": { + "388d67a8082fd8096b3197a038ad5bc717f5d093119c5b97cbde40f32ffa94a7": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-d7e1e084be213b01", "receipt_type": "observer", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "64RU3ZLFHUM0y64zMz7QYXkOHqFYlCqGn6eY43bDgLfy1NyIWKHoMPdyM4/xP0XlAi0CD+GutVykPR4ScNJ/Bg==", - "source_artifact_sha256": "c91752eaaac4392dd7aeb24d399c347eb77db07214d1121d39629b13b9dff7a6", - "verified_at": "2026-08-18T10:34:00Z", + "signature": "XfN52Ned59lxaLKZ4fUsLFZZtqdEEfcF0VkyWzJre54hYEagdbTpP32r/TqeoiJ6Ict0iqY/3u4y9Sz6OltNDw==", + "source_artifact_sha256": "b54d78461c69265574bc5e0a08e1ae1f2c53150056399d8de419de8d50868c80", + "verified_at": "2026-08-18T10:04:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "3aee8ad755c7f4bec71cc194bcfaa805e0ea29cf8b830ed0782f8263dd9620ca", + "attempt_id_sha256": "4c352a6999f77707e8837adebb4fc2b7451c2ef6de5145190b33a5c5645e47eb", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "idempotency-replay", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "c91752eaaac4392dd7aeb24d399c347eb77db07214d1121d39629b13b9dff7a6", + "condition": "healthy-01", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "b54d78461c69265574bc5e0a08e1ae1f2c53150056399d8de419de8d50868c80", "facts": { "derived_classifications": { "collateral_effect_count": 0, @@ -2220,19 +2220,19 @@ "dispatch_state": "dispatched", "effect_inventory": [ { - "effect_id_sha256": "86bffa79f59e7a839b38edfddced10a0329f7c46625f812b0791062e2975c21f", - "record_id_sha256": "6fc6b4a09a4cb0e71faf8a0b537d308527b4b5f8563a72be9e779ba072bdc954", - "transaction_ref_sha256": "717e0261bd78563991a1f9643d3501a699fe53230ec01c973f42f7b98aa411ac" + "effect_id_sha256": "c726d2d313227693bf81a5f01f93a582a3d0c43496f5de19f4d8cb59fad1448d", + "record_id_sha256": "a8d41df87db795f2a38d1c60293e20b89783fce022fce572a546d4a9fb01507e", + "transaction_ref_sha256": "7af984839a1cb25da6ce1ee403c32fb6ec07143cc001f21610f94d3911bbc819" } ], - "expected_record_id_sha256": "6fc6b4a09a4cb0e71faf8a0b537d308527b4b5f8563a72be9e779ba072bdc954", - "expected_transaction_ref_sha256": "717e0261bd78563991a1f9643d3501a699fe53230ec01c973f42f7b98aa411ac", - "post_state_evidence_sha256": "b1e104f5f06bee9c27a2275103156f8eb3274048197efe52f9abc393d9fac129", - "pre_state_evidence_sha256": "813f12a9a620bb94137fe4534de4f1d83e85eadb73e8483267da89c79fd9b984", + "expected_record_id_sha256": "a8d41df87db795f2a38d1c60293e20b89783fce022fce572a546d4a9fb01507e", + "expected_transaction_ref_sha256": "7af984839a1cb25da6ce1ee403c32fb6ec07143cc001f21610f94d3911bbc819", + "post_state_evidence_sha256": "23107cdffa1eb0a03751c72823ccea43c3f5cc46a99a5df03b5523464379e632", + "pre_state_evidence_sha256": "dfd9a16f8fb84edd62fe6bb1819a6e88a497b30b9e131cd6c853cf12632f149b", "verifier_method": "read_only_system_of_record_query", "verifier_tier": "independent_system_of_record" }, - "run_id_sha256": "3df83453126754a62d00ed10837720542d0469799bb8a88cb5257ac5f477a919", + "run_id_sha256": "4ee2bb61fb883cc8e77d636fb471aa3c0ce9ef0c0a8abd9682214bf0a8f16f26", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, @@ -2240,47 +2240,47 @@ "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "3f720f6c3da1e29759c17b9ff24984dbbf64bf8aeed6f8d0d33777b54f65498f": { + "3d756ad6d044b1ea28155d7015aac704333e4de653d478fd77bac565b6e1ef88": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "9JqztUim2dDE0WUb5gLWRsXyh0goxAGeyzGWT2dD8UYM/oGgvpIyI+pN8q7rZ94OIqlsrAGfKwv5hkiyf0jFAw==", - "source_artifact_sha256": "e5dea576ba929b469a889784b3eb264880f21206f61c472ea33b1b5b59d161cf", - "verified_at": "2026-08-18T11:14:00Z", + "signature": "0ZBbwAVKwxnjkPR1kv0Mlhb6tyTt3qjJtRkF3iW87p3KX1sITpJ7tNYu4oaJoh82a3UEwlHu7E+jxTXmu+pHAw==", + "source_artifact_sha256": "7edf6488f59115500b130e22484d3834f8757bc027ac738d8616461b11f6c2c5", + "verified_at": "2026-08-18T10:04:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "ad76dacfe19a4421ef1f128d4eef1099e846b385d29f17b8588ae5130b487118", + "attempt_id_sha256": "4c352a6999f77707e8837adebb4fc2b7451c2ef6de5145190b33a5c5645e47eb", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "verifier-unavailable", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "e5dea576ba929b469a889784b3eb264880f21206f61c472ea33b1b5b59d161cf", + "condition": "healthy-01", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "7edf6488f59115500b130e22484d3834f8757bc027ac738d8616461b11f6c2c5", "facts": {}, - "run_id_sha256": "87014cd8063f5a43ea22c995be03ec41ef5aa613145acacdef71b68c468fc8f1", + "run_id_sha256": "4ee2bb61fb883cc8e77d636fb471aa3c0ce9ef0c0a8abd9682214bf0a8f16f26", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, - "verdict": "delivered", + "verdict": "verified", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "41c5089c652797dd8892e0d7ada46912cf69f72bcd43bee7170b65f3ef278f7e": { + "3eb6d6d2e801576d307357fb896f0ebf571681fc2bbeff7dcc0e922ad0675cb1": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", "receipt_type": "runner", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "l9yAor66F5lPm327s5ZL0sQrLyDuaIqKcwaadDf6WsXaWeKtCqnA8ERzojSagv4r+iV/BR1ONMMqcP52LcMRAg==", - "source_artifact_sha256": "aecd407f56e892dd31846bf13f26f1d2b2683f375928da672b2d04773349cdc0", - "verified_at": "2026-08-18T10:44:00Z", + "signature": "unNtd2mO5PEw+uyRTF2uXwbpqleFdjLUNhjkThZeR9ss8xCuSSjtGvWpgGW5P0G0vmEEDJtquAuQ8ZP7emNcAg==", + "source_artifact_sha256": "79566ede5f64ddd1b0c40fdfcfdb0f7500d96abb5c46c9abdabddca1500c599d", + "verified_at": "2026-08-18T10:34:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "7c910764b2dcc6f05261d609082f75474e4638c3f356006307212b8fed4a2eb7", + "attempt_id_sha256": "3aee8ad755c7f4bec71cc194bcfaa805e0ea29cf8b830ed0782f8263dd9620ca", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "wrong-reference", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "aecd407f56e892dd31846bf13f26f1d2b2683f375928da672b2d04773349cdc0", + "condition": "idempotency-replay", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "79566ede5f64ddd1b0c40fdfcfdb0f7500d96abb5c46c9abdabddca1500c599d", "facts": { "model_call_counter": { "attempted": 0, @@ -2291,126 +2291,116 @@ "input_tokens": 0, "output_tokens": 0, "provider_models": [], - "report_sha256": "aecd407f56e892dd31846bf13f26f1d2b2683f375928da672b2d04773349cdc0", + "report_sha256": "79566ede5f64ddd1b0c40fdfcfdb0f7500d96abb5c46c9abdabddca1500c599d", "source": "runner_signed_flow_report_and_enforced_egress_policy" }, "operator_intervention_ids_sha256": [] }, - "run_id_sha256": "fe98ce7f0e66b885201f4667875fd38f5890ffddb575d68bd4cd5a66f8d53ca8", + "run_id_sha256": "3df83453126754a62d00ed10837720542d0469799bb8a88cb5257ac5f477a919", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, - "verdict": "halted", - "workflow_version_id": "44444444-4444-4444-8444-444444444444" - } - }, - "42e108a2f781e3945e94c43caabc5314a03d47af1caf8380b032300a206a914c": { - "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", - "receipt_type": "fault", - "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "CopvvatCU+3mhUJG2j9yJEus4yGc3frpm/EEJbrPzDRYJAuGENr/sBa1Oh5w1SMSZOrKJ9hiQR2zZgE+Xps3AA==", - "source_artifact_sha256": "99fd8516daeb8b22c42479814dbed2b01d63985db824c0237ed8ac83efd0dca0", - "verified_at": "2026-08-18T11:03:00Z", - "verified_projection": { - "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "1ec11a9862ede3ac701af71835ac28c551d604a026b5bab7d776dbcdf288394e", - "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "ambiguous-target", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "99fd8516daeb8b22c42479814dbed2b01d63985db824c0237ed8ac83efd0dca0", - "facts": {}, - "run_id_sha256": "43f0a1c00950c390b0676fab55a2aa98c354d028f2347c461661e6cdb72f717e", - "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "task": "execute-acceptance", - "trial_index": 2, - "verdict": "injected", + "verdict": "verified", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "4408783aba57a0ec3124a3265f3a7eb34eeb429fcef2e60a955c91d84e2e91d2": { + "4272da024bd259baf9bf745ef4e33a71535f2af24bcad2dcb720a98b16ea1804": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-138dfa227234ea5f", "receipt_type": "cleanup", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "6tGxqeS8mYKz/z+CrKMYxH7v3xNyTpCdBf6Y3EqLepql9qiNxiiaocjccm1UXDSUM0QJrw1PTSnb9tcXtlGUCA==", - "source_artifact_sha256": "a44dac787050d0cb99551f8f0735973f618907d4b8f58c6f5760fc1634522c2f", - "verified_at": "2026-08-18T10:04:00Z", + "signature": "ZccBQGAwgbzOcebetOlXuM6hXVOCpzAuBz2H/eXdO9FzdesqK1IN6W1M1zKa1E8CSlR8+aWFdQ0Q/e+PdOCGCg==", + "source_artifact_sha256": "feb27a02d37abdd67aa0b50cdce26c636bfc6b3284475e77a21d027738a91b5a", + "verified_at": "2026-08-18T10:22:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "4c352a6999f77707e8837adebb4fc2b7451c2ef6de5145190b33a5c5645e47eb", + "attempt_id_sha256": "fc097c8b2e6ece94544a19b8d81f5c4a9367a89059e3dd4b2f746ab06a2fc930", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-01", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "a44dac787050d0cb99551f8f0735973f618907d4b8f58c6f5760fc1634522c2f", + "condition": "healthy-03", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "feb27a02d37abdd67aa0b50cdce26c636bfc6b3284475e77a21d027738a91b5a", "facts": {}, - "run_id_sha256": "4ee2bb61fb883cc8e77d636fb471aa3c0ce9ef0c0a8abd9682214bf0a8f16f26", + "run_id_sha256": "28768f565659133f5bf1170e638b81de4d7ca38dfecacd09ccf462a35344432b", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, + "trial_index": 1, "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "4649e4901902dd6aadb3108e0f89bd75854f5b64b0d59a28e567596a4ee75d58": { + "4278319bd324c7f5a84d181dcf8bda9862df008985b35ece71534aedad24f35d": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", - "receipt_type": "fault", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "jOuFrpBJNqqO9xoG1NMKELf9L5wymA8toKsai4zM6VyTCwSR0Hw9vyasVKyFT4J/9xZVZthxC+/ARQ4l1aL5CA==", - "source_artifact_sha256": "226019cc9a5778388b2bfe87bde12f7a08f8b33074eadc925d3e79197245a493", - "verified_at": "2026-08-18T10:54:00Z", + "signature": "9Lcze8RslFYyqdoar5M4uZ0xY3jBF1D8feBQvbCcOVNcT+BezKgAv4iJ9FPwStKgJhkYBw6q3fOfD+jq/wubDQ==", + "source_artifact_sha256": "6be0b951a73718afe96c480af0f29cc328de4d1d636fbaf54a6f89ba686a0158", + "verified_at": "2026-08-18T10:52:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "958342a9ddca98a83b82b662f52f404239d583afe7ed70634760e1b8dd592f3b", + "attempt_id_sha256": "fbfce2be9ce964be8b668aa518a310fe4a89e5c014f42bd0ea81401bd83bfd7a", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "stale-session", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "226019cc9a5778388b2bfe87bde12f7a08f8b33074eadc925d3e79197245a493", - "facts": {}, - "run_id_sha256": "6f2fb10bc2018c9f78e9702d5ccac0bedd78ee3b2e9d2a6ad779fba72d90ae50", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "6be0b951a73718afe96c480af0f29cc328de4d1d636fbaf54a6f89ba686a0158", + "facts": { + "derived_classifications": { + "collateral_effect_count": 0, + "duplicate_effect_count": 0, + "intended_effect_count": 0, + "wrong_record_count": 0 + }, + "dispatch_state": "not_dispatched", + "effect_inventory": [], + "expected_record_id_sha256": "11c08ea44660ba4cd68dde056a3a33382ef9b2fab17d1a2ac0899ba89e3a06bb", + "expected_transaction_ref_sha256": "85cb9b53b37f373d46c90484e326aa99c41b13772cf3868c1552d3a5b13aad79", + "post_state_evidence_sha256": "52241460ac478f2828fb3c39fb8c608ea57a42dc778807e1d54ee6c80d7aa415", + "pre_state_evidence_sha256": "fd54b5eabca5a36d2a785dfd38d6322321f46d60b3389cd6bcff4f45bd19545e", + "verifier_method": "read_only_system_of_record_query", + "verifier_tier": "independent_system_of_record" + }, + "run_id_sha256": "d9270fd4c85e4226a9347ecf703e876b9ffdc330f60c7fb8bed8f9321ea30225", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "injected", + "trial_index": 1, + "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "46db9b4b3f93076b0958db1375ebda5a9fec42081d32df4d1bec5e0b45bd39c0": { + "451799703f325f594a96b3388bd3c5c554d64c1aa25994d905195b7a0ea5790c": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-e37abcd79efd08db", "receipt_type": "replay", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "oxaxqhBx7WZIa6G+Uf1Bv9Yrpf/nQ915DNGUiHYVQHlkSCA069iYK4s4c0Et8K/ImoO24m4koqwtqz78bffiDA==", - "source_artifact_sha256": "0f409e89e3eb515df85e6adff2f2e9067dd70007afab83b7da6b7dce22e1824b", - "verified_at": "2026-08-18T10:23:00Z", + "signature": "QaRpYHiYkEM1biokyK5brscSRx1AMLlqVOtKQ7FHi8lFMJfBubEbiJ5Fi0RBoRnWXi+gCbPGh3QXsz5m4CrQDQ==", + "source_artifact_sha256": "92c76843346dc97ecdd23535ab0cebf2aecbaddd30aae938fed40434fb6b2da0", + "verified_at": "2026-08-18T10:32:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "2601335b1101424105277997a67850a8a60aa45f59637b7679c1f32af463c460", + "attempt_id_sha256": "3142933f4f168c98b8e89f2ae9d78fd3129e0a9975cbbaa60ddba853eee7d53c", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-03", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "0f409e89e3eb515df85e6adff2f2e9067dd70007afab83b7da6b7dce22e1824b", + "condition": "idempotency-replay", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "92c76843346dc97ecdd23535ab0cebf2aecbaddd30aae938fed40434fb6b2da0", "facts": {}, - "run_id_sha256": "237a0b7d1cafb64b1d113dca6699e6eefeaaf0b18679138545c3695495b901d5", + "run_id_sha256": "6cdff0cf50d0164fe1eee9c4b7db0b969c24f9b960f5653b516313a913c90a0f", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, + "trial_index": 1, "verdict": "verified", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "47a57ac3a76f6d6769d612a5d478882242a2354fce1255ed9ea6f3a1e4fdbb15": { + "4571f26328bd6bc5137100074f608fc8f33876a2ca368d42404848f3847b0770": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "xfOv3X/zCJBy9ufohNFWPtYWDPcZlRIYWyp5kZxJNilDMFZyPKmtNPibtTMyd67rjjSaM2H2/CJTgAulV7xxAQ==", - "source_artifact_sha256": "c2fe1abfc1e16a5382ce8eaf67f3774f713d586e6aefe6a00783455dceae530d", + "signature": "pxDzIrEgLzXxFMDfQnP8rjiahkQunzBvXoCDdC+JpsXzmllsRg0eRvpXNxRaz1AvepRsqyoqYLvqNJMLQMXkCg==", + "source_artifact_sha256": "e02b4733d09ac9c9e6e5d98ba7fc6645738e022e2f137f73feded4d27f3925e9", "verified_at": "2026-08-18T10:02:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", @@ -2418,24 +2408,24 @@ "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "healthy-01", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "c2fe1abfc1e16a5382ce8eaf67f3774f713d586e6aefe6a00783455dceae530d", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "e02b4733d09ac9c9e6e5d98ba7fc6645738e022e2f137f73feded4d27f3925e9", "facts": {}, "run_id_sha256": "0b5bda916a0808165159166955a9563cf9c2303949f762a18eb037f41b44a6dc", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, - "verdict": "verified", + "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "4830780f8c7ad36604ef1bd4935ae8ef598ac06c766368c7cadd8576a1d293e5": { + "4a888f9ee89279affe45292f04fa94f912699b1f6baa7d920ec69dd76d2d10b9": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "jt6OB9Y2C2KB+wEBBy5RSO0Rx/6MVGvIJmAM2fP3Z3gH0XjSLEN3WxzGdwvvEevdssbuHk3akrOAVdspF6aSDg==", - "source_artifact_sha256": "ce91f56ef05d03386741ded56d7c2728b371c0ffcd8dc025c0dcad239242f6d5", + "signature": "1XhvF5SO2Vw7CyOF3FKnefgI66zLRrpYhcaFA9zFHY5jSFg9if/eLA3AzRBLqAN7L0JzXJvSYYGrAh/XtbPYDw==", + "source_artifact_sha256": "975e43caa5b1e34f06e36ad0fd995c5ba6662a55f5cb8d8d28a9f6208420b800", "verified_at": "2026-08-18T10:53:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", @@ -2443,49 +2433,35 @@ "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "stale-session", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "ce91f56ef05d03386741ded56d7c2728b371c0ffcd8dc025c0dcad239242f6d5", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "975e43caa5b1e34f06e36ad0fd995c5ba6662a55f5cb8d8d28a9f6208420b800", "facts": {}, "run_id_sha256": "fd3a041b705d8c6277ce26134dc0018e866218cfa3fadd16ac29d1ad498965a3", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, - "verdict": "delivered", + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "4938c27207a78a9be3803dd7c6889dcba7f8be5af7ed4adc9cb6193dc1364b4f": { + "4b71aea00cb2a8373d5f2a1534c5c48ac189ca863ad55ad8c9720579afb6fe7e": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", - "receipt_type": "runner", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "7igZ9zpheClPWEucT+j5nNDpphMdhWDj8K2xvGHFbMAL+xMUKH7WisR1hQblcQFtrbbgehRmnhRic9swbmg7Bg==", - "source_artifact_sha256": "5e9c28fdf8c09dcfbbefa41ca8075e7daaa783d6ef24d5050cc9973c6aacb810", - "verified_at": "2026-08-18T11:24:00Z", + "signature": "21SHM0lkF1zsvn/FDDUaegQQxcHH3tKpgAICJ5dA0qFSRyWrUNTr+fQKBB7ie8gSnqvDP9DUt6naMtzR60yMDQ==", + "source_artifact_sha256": "32974d92bebc7e4e4d26c3f6df9b0cd6dfb4e7f0f23baa1df91fa850acf666da", + "verified_at": "2026-08-18T10:54:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "aa7d6be4f25a8992c0a22649ba7e703d6955abf5fece9f8322f560149cf09776", + "attempt_id_sha256": "958342a9ddca98a83b82b662f52f404239d583afe7ed70634760e1b8dd592f3b", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "weak-effect-only", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "5e9c28fdf8c09dcfbbefa41ca8075e7daaa783d6ef24d5050cc9973c6aacb810", - "facts": { - "model_call_counter": { - "attempted": 0, - "call_ids_sha256": [], - "completed": 0, - "cost_microusd": 0, - "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", - "input_tokens": 0, - "output_tokens": 0, - "provider_models": [], - "report_sha256": "5e9c28fdf8c09dcfbbefa41ca8075e7daaa783d6ef24d5050cc9973c6aacb810", - "source": "runner_signed_flow_report_and_enforced_egress_policy" - }, - "operator_intervention_ids_sha256": [] - }, - "run_id_sha256": "b974de9da8ef77c8dc9a7662114cc51023ab8c131c488681eeebb7d4c435c8d0", + "condition": "stale-session", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "32974d92bebc7e4e4d26c3f6df9b0cd6dfb4e7f0f23baa1df91fa850acf666da", + "facts": {}, + "run_id_sha256": "6f2fb10bc2018c9f78e9702d5ccac0bedd78ee3b2e9d2a6ad779fba72d90ae50", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, @@ -2493,122 +2469,62 @@ "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "4975d0d0574f5e4ed180eae087569cfb1b53445945a9e03f7bdc0b51aa40bfa4": { + "4b87f6f4552386044d98c2368ce0de712ddf4ca52825630502500be29a04081f": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d7e1e084be213b01", - "receipt_type": "observer", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "FhIwHVhDjDqbMWMMjBolYU3L5KC92thpL+EScRQrgyVnGwQ4xreceY1X5GEsBRfQ51BItpj9vyaRNQ4ski83Bg==", - "source_artifact_sha256": "2ae10ced05bdd00ae95b7a8d2893b178979ff8cf6d455c9e9fcf2596ecac18fb", - "verified_at": "2026-08-18T10:32:00Z", + "signature": "lVysNYbCItkSifqMvUPeB1j9+j/apHjWEegCx8jkweAqFVAWCZyHZRCsj+0K5p03aXeDy7SG6MX5sYhP5bfOBw==", + "source_artifact_sha256": "23708d813c5434c08faf44e36a798621030200b33f634d785750d86cf7fb96d7", + "verified_at": "2026-08-18T10:52:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "3142933f4f168c98b8e89f2ae9d78fd3129e0a9975cbbaa60ddba853eee7d53c", + "attempt_id_sha256": "fbfce2be9ce964be8b668aa518a310fe4a89e5c014f42bd0ea81401bd83bfd7a", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "idempotency-replay", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "2ae10ced05bdd00ae95b7a8d2893b178979ff8cf6d455c9e9fcf2596ecac18fb", - "facts": { - "derived_classifications": { - "collateral_effect_count": 0, - "duplicate_effect_count": 0, - "intended_effect_count": 1, - "wrong_record_count": 0 - }, - "dispatch_state": "dispatched", - "effect_inventory": [ - { - "effect_id_sha256": "85bd45c21ceba0278062e4a705854e8e10526bc02ae78161394f25b4364eabf6", - "record_id_sha256": "0b1c6a0c1bb7de295f5b36891fd2b6b1edd16a9b926b3a24548d2374711a2751", - "transaction_ref_sha256": "e984028cb73b01ea87ff6063feeac5ec2136c993f8db59af4cb7956b44fd9c03" - } - ], - "expected_record_id_sha256": "0b1c6a0c1bb7de295f5b36891fd2b6b1edd16a9b926b3a24548d2374711a2751", - "expected_transaction_ref_sha256": "e984028cb73b01ea87ff6063feeac5ec2136c993f8db59af4cb7956b44fd9c03", - "post_state_evidence_sha256": "9fa1859d90e896d31fd6e3180e29b09b5b23e48beb0a87e10059798232a14f8c", - "pre_state_evidence_sha256": "8499492a906730830b1977c341eb8d1f7a825f8710231c6f9e615b1d1497d288", - "verifier_method": "read_only_system_of_record_query", - "verifier_tier": "independent_system_of_record" - }, - "run_id_sha256": "6cdff0cf50d0164fe1eee9c4b7db0b969c24f9b960f5653b516313a913c90a0f", + "condition": "stale-session", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "23708d813c5434c08faf44e36a798621030200b33f634d785750d86cf7fb96d7", + "facts": {}, + "run_id_sha256": "d9270fd4c85e4226a9347ecf703e876b9ffdc330f60c7fb8bed8f9321ea30225", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, - "verdict": "satisfied", + "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "49de0ab8efa7c46b2f4594bf74c916ec99f1694e45b3ec734566913d14b4225f": { + "4d7d0b8647873a25e83f461377d89e4fe37b6f853636de8b383e90af2dd8c1e8": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "8wb7TRu0pLCTQYdMoYop94kyad5g8FTw+w0vFt9P1rviTWf0JXo79NneYpW99HPBXleX1DK0TqG0t2fAqaJHDg==", - "source_artifact_sha256": "82e77fe44a201615e8f4c27505e4418bc71c0e4706dbe79be35ff085e812e4ad", - "verified_at": "2026-08-18T10:02:00Z", + "signature": "Zb+aj+BGunVudiI1972nl6gVKEN6WoyhAHh4x1XGOftUwkSQxY+IDgbns89f/+6fKe0zywOnhjz1tIo1UUTqAQ==", + "source_artifact_sha256": "0e7b1e0c28c2cfe39870f987c674129552a27582914b580f2e13474b3636e942", + "verified_at": "2026-08-18T10:32:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "679af5a8dedceb8c696719e73f82a698c230cd8fc98bb61769f0883202c0b637", + "attempt_id_sha256": "3142933f4f168c98b8e89f2ae9d78fd3129e0a9975cbbaa60ddba853eee7d53c", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-01", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "82e77fe44a201615e8f4c27505e4418bc71c0e4706dbe79be35ff085e812e4ad", + "condition": "idempotency-replay", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "0e7b1e0c28c2cfe39870f987c674129552a27582914b580f2e13474b3636e942", "facts": {}, - "run_id_sha256": "0b5bda916a0808165159166955a9563cf9c2303949f762a18eb037f41b44a6dc", + "run_id_sha256": "6cdff0cf50d0164fe1eee9c4b7db0b969c24f9b960f5653b516313a913c90a0f", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, - "verdict": "delivered", - "workflow_version_id": "44444444-4444-4444-8444-444444444444" - } - }, - "49e6a4db6325d7245a2f8be4ae4d3defe236bf45fe8cf7775e5126575652a805": { - "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", - "receipt_type": "runner", - "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "FIEo66yW8J/k7LJ7PuVFCnjyuPW+Nsnw2Jjk8yFoQNtd5oivYv69mb7SYLL1tU5sXDF75O4HDSoaeqQXAw6DAw==", - "source_artifact_sha256": "ddf817056f83e416082775455ee6cb2ccc0139eeaeec131996cc584694bb9cf6", - "verified_at": "2026-08-18T11:04:00Z", - "verified_projection": { - "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "491a544656d05aea37920e5c7e2ad65a9452eac8d6e100268a599aeebd41187a", - "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "ambiguous-target", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "ddf817056f83e416082775455ee6cb2ccc0139eeaeec131996cc584694bb9cf6", - "facts": { - "model_call_counter": { - "attempted": 0, - "call_ids_sha256": [], - "completed": 0, - "cost_microusd": 0, - "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", - "input_tokens": 0, - "output_tokens": 0, - "provider_models": [], - "report_sha256": "ddf817056f83e416082775455ee6cb2ccc0139eeaeec131996cc584694bb9cf6", - "source": "runner_signed_flow_report_and_enforced_egress_policy" - }, - "operator_intervention_ids_sha256": [] - }, - "run_id_sha256": "aa62c7a17701a7ef01ea1d3519b4c1f90d357495b329fdda3054cc24c581a593", - "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "task": "execute-acceptance", - "trial_index": 3, - "verdict": "halted", + "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "4c3a2f062bd550c473b950f0dffd59d3526f54fadca154c653cc7f0011b9d31c": { + "4e237911933aebbe68ebbcecf56b199605ac887e6a533d2e5a77144a40cd29e3": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-e37abcd79efd08db", "receipt_type": "replay", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "sVihMEI/TmGprVout2Hm+DnYN2SZcSX+Cp0PkjMwl6dblUYtSBk3njtMDphlSX+PWk448E27WbUlJmn9CrOCBQ==", + "signature": "FE+I8nklqnRVF7+lkKv0M/Rnyo8PVku1roYR9Vm8P1J2F33gcUJdQhu+n4daXowGaU2USUS6QHOyGKcMXUMyAA==", "source_artifact_sha256": "072e0fd54863672011c83e29fe39c24ea7e477fb77ad912967512a7e5d7ffa65", "verified_at": "2026-08-18T10:24:00Z", "verified_projection": { @@ -2617,7 +2533,7 @@ "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "healthy-03", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", "evidence_sha256": "072e0fd54863672011c83e29fe39c24ea7e477fb77ad912967512a7e5d7ffa65", "facts": {}, "run_id_sha256": "784a0a94e581700a3d93581e7ce5bac0d3bc53c58f3e73198b896b5da9a819b0", @@ -2628,22 +2544,22 @@ "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "4ca3d5eb8e380f12fb327214dadcf889acb28d7970b29fca53bf9f8f85700ae1": { + "515a3fd0b57430577ff4d89d14b0c0057e68e3469d547a224f74dab304ea242c": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", "receipt_type": "runner", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "HgAX1ZVGoKF9W/LNksPO13gkMPa9jisi1Wo9GXw5WRLQoGHwxxr/Io2RObvdZlf5RxihnukZ4IVJWjgm1qbEDQ==", - "source_artifact_sha256": "4166eb8e3a385de458c987a5463a1a35943cb8e54fa4a174c56729232a96605a", - "verified_at": "2026-08-18T10:13:00Z", + "signature": "EAK9dCvGxZI87LCJe+k69Tp+0Qqclq/OfTc4f3smi8J10iwip8eytX9jIxSp5lLoK6zg2LPVdAlrVlzoPz1+AA==", + "source_artifact_sha256": "f2226cc85e803eb3cf39a88aa39b32d75a3910acc381cbd3197767c9c0b75b5b", + "verified_at": "2026-08-18T11:14:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "3d42601a69ef46cc44f57b51762affef4ccd829ffde30125619a6e582af00dab", + "attempt_id_sha256": "ad76dacfe19a4421ef1f128d4eef1099e846b385d29f17b8588ae5130b487118", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-02", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "4166eb8e3a385de458c987a5463a1a35943cb8e54fa4a174c56729232a96605a", + "condition": "verifier-unavailable", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "f2226cc85e803eb3cf39a88aa39b32d75a3910acc381cbd3197767c9c0b75b5b", "facts": { "model_call_counter": { "attempted": 0, @@ -2654,239 +2570,280 @@ "input_tokens": 0, "output_tokens": 0, "provider_models": [], - "report_sha256": "4166eb8e3a385de458c987a5463a1a35943cb8e54fa4a174c56729232a96605a", + "report_sha256": "f2226cc85e803eb3cf39a88aa39b32d75a3910acc381cbd3197767c9c0b75b5b", "source": "runner_signed_flow_report_and_enforced_egress_policy" }, "operator_intervention_ids_sha256": [] }, - "run_id_sha256": "091e13ed70dab439b31cb506cf3bba1ddf6476696531cf891c39a924a928b7a1", + "run_id_sha256": "87014cd8063f5a43ea22c995be03ec41ef5aa613145acacdef71b68c468fc8f1", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "verified", + "trial_index": 3, + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "4f32c6974bf19b3fcf9871beed963b99ec03ac9347a55059e9f5451333cb5b50": { + "51fb530a271d85665d41cc116eaab112f43985fa0ce8d2937d327e63900d6d07": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "dkr/ghG5sczKNzJLmd5DalgoQmVslTeE26kNtLzHz8M3uKVKTzEct4tljKVkwvyT/5rbrGHuLs4bZA+l4LPXBA==", - "source_artifact_sha256": "68f28b4ae7bd66c29ac1d2e3cf594da46ea4d7fa7bfc29557c835bb848cf81d8", - "verified_at": "2026-08-18T11:23:00Z", + "signature": "DRMH+RqoDxM5sR/U7HlR5aBYDzfwXvZKkX/B8i9uTaaqc+nW2yG9us9Y82qqS0nBtu6Cwh+1gupi6gt3kbdWAw==", + "source_artifact_sha256": "57e3d1b277db5cbe456c303c9cb64859db7dc268807b185a31e35936e13ee8c3", + "verified_at": "2026-08-18T11:22:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "eb52fb1b1bf2fac92d8f3a444bb5081161be8b3d0ef457c5065e7b79e96df770", + "attempt_id_sha256": "73a097b8b20bab7794369384f7ca1d7d711aad07967b7e1292373babbb7ff1b7", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "weak-effect-only", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "68f28b4ae7bd66c29ac1d2e3cf594da46ea4d7fa7bfc29557c835bb848cf81d8", - "facts": {}, - "run_id_sha256": "794033f9da2a42448254a478fb6de954898b1e544148708ad30264efdc255431", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "57e3d1b277db5cbe456c303c9cb64859db7dc268807b185a31e35936e13ee8c3", + "facts": { + "derived_classifications": { + "collateral_effect_count": 0, + "duplicate_effect_count": 0, + "intended_effect_count": 0, + "wrong_record_count": 0 + }, + "dispatch_state": "not_dispatched", + "effect_inventory": [], + "expected_record_id_sha256": "9834b8ac2ddaa9ad681db17b9bec4f192d28619c87021bce9515e9d2c5c0f4c8", + "expected_transaction_ref_sha256": "7feab8a28dcdcf6a94bb2e1551e37c1ec9443784e191b71faddd012c020fcb93", + "post_state_evidence_sha256": "6c1e8b0581e0efa08372ff5ea57591c559aaa279cf20353418d7e2f21bc53f59", + "pre_state_evidence_sha256": "02df7d1e41ca49f834c03a39fb4403890fb1aad742f41cd014a99926926dc8d5", + "verifier_method": "read_only_system_of_record_query", + "verifier_tier": "independent_system_of_record" + }, + "run_id_sha256": "b44783e70a980ec5b3cf3752bd5d1d01b2ff29f5a6892cba0c1c939d8aeb7c02", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "delivered", + "trial_index": 1, + "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "50c2a328d61a13cb7fd97b9eafe0e28fea69e930de081ac511e2023f3596a15c": { + "55fc4d13c0302e911e6f154818e6d5f2b5bfc4840e388ee8a622ab0e091c11cf": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "k8K7i8ckUErWWhSTnlvdOeJkDR+5AKQz1X24MbfTJM2YcXqJdhr71JSTdQCg2tM7A6Oe6MKNwEzfps8+hQ3fCQ==", - "source_artifact_sha256": "48d2fa219c08a4043c3d974e574816a8b3952b9f1b5d638dd8a8fa098edc61dc", - "verified_at": "2026-08-18T10:33:00Z", + "signature": "OylwuR3oUus8ngUbPCGBLPHmESNbS2Mmm1AhXkHRlcXaf/d4qldmfUPcjDjMsHXaDLJt0aq3ryB8ml2qVAqBCw==", + "source_artifact_sha256": "e7aa152d2f5d093083e644c448c30ba167727eb53ae1e0892f97cecc1e233fb5", + "verified_at": "2026-08-18T11:24:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "4667302b580ff7ceb223dbb15eb6d029969a8f6a54bcd33e8df5b6bff41f41ad", + "attempt_id_sha256": "aa7d6be4f25a8992c0a22649ba7e703d6955abf5fece9f8322f560149cf09776", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "idempotency-replay", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "48d2fa219c08a4043c3d974e574816a8b3952b9f1b5d638dd8a8fa098edc61dc", + "condition": "weak-effect-only", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "e7aa152d2f5d093083e644c448c30ba167727eb53ae1e0892f97cecc1e233fb5", "facts": {}, - "run_id_sha256": "33e0ad9bf64e477f24d46508fa432123e046dcd1c5853d5cc60b7cde1bce7537", + "run_id_sha256": "b974de9da8ef77c8dc9a7662114cc51023ab8c131c488681eeebb7d4c435c8d0", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "delivered", + "trial_index": 3, + "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "50ff634de0b6e29c4dfec89dae15e01e3872c32eff0ad8473e3eae442ea9f45a": { + "5622ec557cc98e8c2ca579e0777675c67934fb50b3559142125d7eec48c2d105": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", + "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", + "receipt_type": "fault", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "1uGrvhyOUZfUygvmJLehCAGah4BVFD7N7q69kWLVMzKU+BI0eMqTtex3kb00FntefzWuMJkfmFCte8naWAUTAA==", - "source_artifact_sha256": "11cdb7bd9282bd8b9c10b25bd5e552c14ca6658cb559b133ce7e6b8dfc17f0f3", - "verified_at": "2026-08-18T10:42:00Z", + "signature": "2VA4jZ/suIAyJPApwCUB2d6ElCFkn+5yiNxeI1MkdQcW++seE4N1/GbCy9a2JXvXEyuoT0o4jRFP2/am5H57AQ==", + "source_artifact_sha256": "0a6f7475010857b4c4c0c9f660926588236800ef17f86e670e163c98fa71c3a5", + "verified_at": "2026-08-18T10:44:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "e93521e706ad90d799dcd4e8cac15229c5da6aec1638540606f5fab4efce59fc", + "attempt_id_sha256": "7c910764b2dcc6f05261d609082f75474e4638c3f356006307212b8fed4a2eb7", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "wrong-reference", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "11cdb7bd9282bd8b9c10b25bd5e552c14ca6658cb559b133ce7e6b8dfc17f0f3", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "0a6f7475010857b4c4c0c9f660926588236800ef17f86e670e163c98fa71c3a5", "facts": {}, - "run_id_sha256": "ee82112f55e5e6c86cfd6e16df8c8b652549a8bd72de492f435d8255eb3dd252", + "run_id_sha256": "fe98ce7f0e66b885201f4667875fd38f5890ffddb575d68bd4cd5a66f8d53ca8", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, - "verdict": "absent", + "trial_index": 3, + "verdict": "injected", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "532808072697066585e9e78c84eb3df8a14d22f57a3499cd47a1a26c61062330": { + "5786a390d019271aab73fe18af1d56a98967bc512203af57de551696d5059a50": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-138dfa227234ea5f", - "receipt_type": "cleanup", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "TnlFbmWHqcatRTc9JA8Ff89GiP0O/cHFEJfLYOWWIXN8vbl2mCXswd0PDdjCydidIHAWJQPyZ1tsRcQOyRf3AA==", - "source_artifact_sha256": "d8c7b50d16df0a959a2fd2323040253e31e95b612b1ab829e460e68e6ad935b1", - "verified_at": "2026-08-18T10:52:00Z", + "signature": "zD4QBsaYH23D9vuUPtnzS+vIaDE/316uLuwjE6ZY1Ng92aVpEjUkNzMmH6bDyuHUZYuyMoUYrOX7wm4DzIdsAw==", + "source_artifact_sha256": "8f3a90b44ab62c40384d697eeb5664143c64378dc1162f48f40843beeb892c40", + "verified_at": "2026-08-18T10:53:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "fbfce2be9ce964be8b668aa518a310fe4a89e5c014f42bd0ea81401bd83bfd7a", + "attempt_id_sha256": "f5df4d6e64a2d38ffa8e320c87ad05d04025de267a8e152a755d3f1928ded120", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "stale-session", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "d8c7b50d16df0a959a2fd2323040253e31e95b612b1ab829e460e68e6ad935b1", - "facts": {}, - "run_id_sha256": "d9270fd4c85e4226a9347ecf703e876b9ffdc330f60c7fb8bed8f9321ea30225", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "8f3a90b44ab62c40384d697eeb5664143c64378dc1162f48f40843beeb892c40", + "facts": { + "derived_classifications": { + "collateral_effect_count": 0, + "duplicate_effect_count": 0, + "intended_effect_count": 0, + "wrong_record_count": 0 + }, + "dispatch_state": "not_dispatched", + "effect_inventory": [], + "expected_record_id_sha256": "1f281cf15b2a004cdd209558e754a9da1899d8ebc38689a353294b23448d9676", + "expected_transaction_ref_sha256": "454701823a6df98835a9b226538dc4772a1e3b6784a805907a45fd2590113fbe", + "post_state_evidence_sha256": "5af3f3e3a79cc3ac0cad3c3f31b71ebe92b8e3d4390d0ebda9951ba00e220d86", + "pre_state_evidence_sha256": "660b59ae4de4abb38c1d1bc900987fa8d4f15035c045cb40bf5384aaf94bad66", + "verifier_method": "read_only_system_of_record_query", + "verifier_tier": "independent_system_of_record" + }, + "run_id_sha256": "fd3a041b705d8c6277ce26134dc0018e866218cfa3fadd16ac29d1ad498965a3", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, - "verdict": "completed", + "trial_index": 2, + "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "54c1991cfc25ee0e9c19b42b0901851afed31454ab224132d6ba1f0438543683": { + "5b03fb13947284792725f63b6c77618288359007132179709aff2d05013fb5b4": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "N29jsZ9hX3mN4OWmVbFboeX8NkHD+rvZDKXhOhJQhBl2BSm/xTHOqqUgWl/MrzYQKvhN02q5K9LTG6IC4gioDA==", - "source_artifact_sha256": "2811b870f1234408f64ada1ddab6eb1a4160941d92a9f9df96df037d1da69536", - "verified_at": "2026-08-18T10:12:00Z", + "signature": "rw2QEBjAaRsYYJa1RODWllAl4R3FE8rYaQ40/7d2u9lKjtFOzxL6Huj0AQMcixiVsBdMvU1L7lklanVJ6z9qDQ==", + "source_artifact_sha256": "89e92e0a76d7ef86a369ad65837369620240dc66bc215bc9fa3fddc21d777f9e", + "verified_at": "2026-08-18T10:32:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "940d3ca125ff87ce7539740fbae29d2d64fec839328b0639127e1d197d2485d8", + "attempt_id_sha256": "3142933f4f168c98b8e89f2ae9d78fd3129e0a9975cbbaa60ddba853eee7d53c", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-02", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "2811b870f1234408f64ada1ddab6eb1a4160941d92a9f9df96df037d1da69536", + "condition": "idempotency-replay", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "89e92e0a76d7ef86a369ad65837369620240dc66bc215bc9fa3fddc21d777f9e", "facts": {}, - "run_id_sha256": "bbb9312ce4682b23580eced0f8d19438d8266b222555df85fb27eef22ad5afe2", + "run_id_sha256": "6cdff0cf50d0164fe1eee9c4b7db0b969c24f9b960f5653b516313a913c90a0f", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, - "verdict": "verified", + "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "5634cde23250446592813e4ebf81ff20cffd3b116818f8d8a4297d175e993be7": { + "5b8eecb4df0fdf0057010f3a8245c8a05b96ff9f6eaee02149f1e9654a87cb26": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", - "receipt_type": "runner", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "utfHRpHOIRKsCYVFTc9H2H8xVRcH8gbJTTDlpjgHIqpSt4rgy0MV3QjXYHcjsw8W5pgBFzwudSNvsM6Ngd9vBg==", - "source_artifact_sha256": "cfa32a5a84ca628c634a548be23b97ffb53dc187e1e8b479a30dba14275ec44a", - "verified_at": "2026-08-18T11:13:00Z", + "signature": "ZG/kKC5Ef20stp6XercJ3YvizM1EjMY/u37TiDE2cpa+PeGbrHsRDQO4B1WUk4yaWItu6zRe1Y9vlsio2PhICA==", + "source_artifact_sha256": "5774a782f9ec582ec3f9a710ccfee0a6b3fd6076d73029b33889cbb99d0526ed", + "verified_at": "2026-08-18T10:14:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "42259dbb767ced4c25ad8bd40edc209720a748897194c925ed9bd2e27b2258b2", + "attempt_id_sha256": "019dd96e9a771ccc01ebafab321d7d3a8314df8b2d6465bcfc5fa14cbdeabdf2", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-02", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "5774a782f9ec582ec3f9a710ccfee0a6b3fd6076d73029b33889cbb99d0526ed", + "facts": {}, + "run_id_sha256": "16cb8df40654c6a1b55ea0e50e772d8c6e6d4f0d8205bd1f8296be27d0af83eb", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 3, + "verdict": "delivered", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "5da9c9bbd77d8909da94a5a1c659e455b60e29c3922b1ce0a0a59d76a637fa02": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", + "receipt_type": "fault", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "VjFQo0tVbOi2ATZQmD8xaERnJGGPiYawZvFh68i2yZ+kxhV8Ggp5Y7uaVwg93YuPe32qQm7zJNJEhSS8RvX/Bg==", + "source_artifact_sha256": "49dbd40897c1bf5714a6e032fc07ef378207978f4db7ee347783daf9bfba90ca", + "verified_at": "2026-08-18T11:14:00Z", + "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "ad76dacfe19a4421ef1f128d4eef1099e846b385d29f17b8588ae5130b487118", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "verifier-unavailable", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "cfa32a5a84ca628c634a548be23b97ffb53dc187e1e8b479a30dba14275ec44a", - "facts": { - "model_call_counter": { - "attempted": 0, - "call_ids_sha256": [], - "completed": 0, - "cost_microusd": 0, - "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", - "input_tokens": 0, - "output_tokens": 0, - "provider_models": [], - "report_sha256": "cfa32a5a84ca628c634a548be23b97ffb53dc187e1e8b479a30dba14275ec44a", - "source": "runner_signed_flow_report_and_enforced_egress_policy" - }, - "operator_intervention_ids_sha256": [] - }, - "run_id_sha256": "4af84f2608a25a27e6252a5800263a238bb70fb3bec65148601ddcdddbf3e03c", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "49dbd40897c1bf5714a6e032fc07ef378207978f4db7ee347783daf9bfba90ca", + "facts": {}, + "run_id_sha256": "87014cd8063f5a43ea22c995be03ec41ef5aa613145acacdef71b68c468fc8f1", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "halted", + "trial_index": 3, + "verdict": "injected", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "5653aa19c3b4662ef8d1add74e5911af8f972791895812f4fec40722fd8af7e9": { + "5e2329eff39ff0461a3a4a814a167dacb574c45421ac5bd23b76a3b0045cfc4b": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-138dfa227234ea5f", - "receipt_type": "cleanup", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "NFmSUg0NetpHQH9dS3K6ma1BYTV4589cF3/29CdczLAsR4mjC1DpLhxK0rTDAYR13++BlC3wNQ/vds7VkOWfDw==", - "source_artifact_sha256": "7d89d8f99f5fd27361d5750bd99439b0669933179a8e2ce8e3c66d7f551cf8c3", - "verified_at": "2026-08-18T10:43:00Z", + "signature": "bkeRTEdGILi6AZ7ygDZd9Isb+eJdQV/aYbalEBUI/CxI2Ef/q6SHrGpnEpSEJ0raoIqGDHImx4sAxMHZz35nBA==", + "source_artifact_sha256": "19c8e4a8e4ef48302a4600b8bf8bd600dbffa7e3b33c7ac91fa693b98487bdf2", + "verified_at": "2026-08-18T11:04:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "6b0e5c10d55fc92c1ff8576392270a24fb65722414cf58ff9a51b8ce9ef88587", + "attempt_id_sha256": "491a544656d05aea37920e5c7e2ad65a9452eac8d6e100268a599aeebd41187a", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "wrong-reference", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "7d89d8f99f5fd27361d5750bd99439b0669933179a8e2ce8e3c66d7f551cf8c3", + "condition": "ambiguous-target", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "19c8e4a8e4ef48302a4600b8bf8bd600dbffa7e3b33c7ac91fa693b98487bdf2", "facts": {}, - "run_id_sha256": "577e37b10b1c87fd9c1b5d320888b736d272824657fd59a012e85a284ee88540", + "run_id_sha256": "aa62c7a17701a7ef01ea1d3519b4c1f90d357495b329fdda3054cc24c581a593", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "completed", + "trial_index": 3, + "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "57af80b4f9c67ba20ca7749c4d68e814cf91aba0141012d9f7385b7d9ec3f60f": { + "5f681c1375640e41f164a53a2464f560799ba45eab374a2400d9b42eecdbf320": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", "receipt_type": "fault", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "M4DeWIBYMUad26tVjrdjz9yVkraW21z+uCplyM9mN7gU9euh+ambYGSvQXMbu+PSARac9OkJl0gpMlJnRpDtBw==", - "source_artifact_sha256": "4337a75a39ceb7d333cbceb0fb54815f7dbe029048dbe20740c85d0b31f4d202", - "verified_at": "2026-08-18T10:52:00Z", + "signature": "JSkoxCQJJpaCqrQO2MghL04Lt/tFmZ5VM41pf5nZ3hmR2ig8C0R8grOYl1je022vlppqWlICxNev2zQg5qiFDg==", + "source_artifact_sha256": "ac34c209ded7d003e6d99a60a52adc51e65926a708df1a94834a196ba9fe9812", + "verified_at": "2026-08-18T11:04:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "fbfce2be9ce964be8b668aa518a310fe4a89e5c014f42bd0ea81401bd83bfd7a", + "attempt_id_sha256": "491a544656d05aea37920e5c7e2ad65a9452eac8d6e100268a599aeebd41187a", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "stale-session", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "4337a75a39ceb7d333cbceb0fb54815f7dbe029048dbe20740c85d0b31f4d202", + "condition": "ambiguous-target", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "ac34c209ded7d003e6d99a60a52adc51e65926a708df1a94834a196ba9fe9812", "facts": {}, - "run_id_sha256": "d9270fd4c85e4226a9347ecf703e876b9ffdc330f60c7fb8bed8f9321ea30225", + "run_id_sha256": "aa62c7a17701a7ef01ea1d3519b4c1f90d357495b329fdda3054cc24c581a593", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, + "trial_index": 3, "verdict": "injected", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "5c27733530c91746965049d5f68a6941c1b64018aa0272eb8eca9a1a086386fe": { + "60421bc90fb169912a5e28939426e583aa946aed608688d2bc8d6826f584697b": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", "receipt_type": "webhook", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "QQO1+hA3S9E/VHw41nouxsPY/InCwNMNmFzWHBuPo6nbMUDxkJs6ulZOijeqWurdLf9P0+qAiELiO+loXIVtBA==", + "signature": "dwz7M44Jks9iq49nKj05C8yr4DUYpx0uRPVuwz84veUbCK32HUQEORiu4C6YrHDJtY61cLg8ckYWuXwsZN9zBw==", "source_artifact_sha256": "72afc710ff840f8432ddcceda6a5dd0e1e24f1d5bf0b5ee610c56b51ff260c6d", "verified_at": "2026-08-18T11:12:00Z", "verified_projection": { @@ -2895,7 +2852,7 @@ "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "verifier-unavailable", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", "evidence_sha256": "72afc710ff840f8432ddcceda6a5dd0e1e24f1d5bf0b5ee610c56b51ff260c6d", "facts": {}, "run_id_sha256": "e8e89651045a5f5c011c9543ed968e0fe7697a061ed8ad5cedc27d194cb96acb", @@ -2906,63 +2863,91 @@ "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "5cfada7a9502dc0499d3b9d2ab92a6ad84e6b2a5b1298a05e006fdac34e9fbb5": { + "61d2951f335e53f8920a7f84739d8a458a61fb758ee671e8066dffc6377bff66": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-138dfa227234ea5f", - "receipt_type": "cleanup", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "m3DdYHjPp4RH5S3vba5hxxkzFyL42KNkxWM/2f9kMxWYHxL6rLI2Ju101/+p+oZYFchwVnVvqx5uKi4xvS0+Dw==", - "source_artifact_sha256": "9aff04082026c9a005b5b56eb7078d056d424b5024e1034aa161c875b0f71b80", - "verified_at": "2026-08-18T11:23:00Z", + "signature": "v3bhM7I3P+6Hr3GctiMRIftTlgZNzG4k9djoqhLyEcDIB/zPyDoRZXqmsUr5PrCHKAqd77O0f2LMK4M9LHkJBQ==", + "source_artifact_sha256": "c20ee28b4875041089aace249d6634176c0ed5050228c8c0fba2b37db74b7632", + "verified_at": "2026-08-18T10:43:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "eb52fb1b1bf2fac92d8f3a444bb5081161be8b3d0ef457c5065e7b79e96df770", + "attempt_id_sha256": "6b0e5c10d55fc92c1ff8576392270a24fb65722414cf58ff9a51b8ce9ef88587", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "weak-effect-only", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "9aff04082026c9a005b5b56eb7078d056d424b5024e1034aa161c875b0f71b80", - "facts": {}, - "run_id_sha256": "794033f9da2a42448254a478fb6de954898b1e544148708ad30264efdc255431", + "condition": "wrong-reference", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "c20ee28b4875041089aace249d6634176c0ed5050228c8c0fba2b37db74b7632", + "facts": { + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "c20ee28b4875041089aace249d6634176c0ed5050228c8c0fba2b37db74b7632", + "source": "runner_signed_flow_report_and_enforced_egress_policy" + }, + "operator_intervention_ids_sha256": [] + }, + "run_id_sha256": "577e37b10b1c87fd9c1b5d320888b736d272824657fd59a012e85a284ee88540", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, - "verdict": "completed", + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "61152c7946d6e0b701c6ff999dc1b1b63b0bdee8c4754077ce1909f5b6d279bd": { + "635dec4af95b2901a525ee8229fb3c403325e977f6ec35fea5460e7664b00a68": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-138dfa227234ea5f", - "receipt_type": "cleanup", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "1fzHxpsdM+XN9mq3E/fwCkGnPwYH2d57LlQg46Zl7IXIfagXuHyb5YU7DSSY4qKtOMI6Bzee+CkUC+jGb2HGDg==", - "source_artifact_sha256": "e7e294aaa63908c75e3513aee7e29b3bd24623d3fda8d6fe6fbb9dd04227630f", - "verified_at": "2026-08-18T10:23:00Z", + "signature": "beO079iIQnam7dZfIdKVtqZq8vcvxlgAfF1N4u64vJ6zGeQ5qhkOOjxUIULPXuJzXRsQR/QhUnUqwOzoouLdBw==", + "source_artifact_sha256": "ddf817056f83e416082775455ee6cb2ccc0139eeaeec131996cc584694bb9cf6", + "verified_at": "2026-08-18T11:04:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "2601335b1101424105277997a67850a8a60aa45f59637b7679c1f32af463c460", + "attempt_id_sha256": "491a544656d05aea37920e5c7e2ad65a9452eac8d6e100268a599aeebd41187a", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-03", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "e7e294aaa63908c75e3513aee7e29b3bd24623d3fda8d6fe6fbb9dd04227630f", - "facts": {}, - "run_id_sha256": "237a0b7d1cafb64b1d113dca6699e6eefeaaf0b18679138545c3695495b901d5", + "condition": "ambiguous-target", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "ddf817056f83e416082775455ee6cb2ccc0139eeaeec131996cc584694bb9cf6", + "facts": { + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "ddf817056f83e416082775455ee6cb2ccc0139eeaeec131996cc584694bb9cf6", + "source": "runner_signed_flow_report_and_enforced_egress_policy" + }, + "operator_intervention_ids_sha256": [] + }, + "run_id_sha256": "aa62c7a17701a7ef01ea1d3519b4c1f90d357495b329fdda3054cc24c581a593", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "completed", + "trial_index": 3, + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "61de0f8814b796a5fc827d229ec0a83d37e81a097a8e8a0ab276d0eb1a274ae5": { + "646931da47f53dca5a34ab118624a8e7fb42e895b13070a59d42b59870574155": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", - "receipt_type": "fault", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "IdOCDuUKXQPfG7xbL6PSwIUXJ35WEV70TMShZgyBmGtFTKAKi2ddpWZqKCkNg9l7qtx8oc4n2mK9DqGTGcuhDg==", - "source_artifact_sha256": "0eafb7867b5bb7cf68f39f40315893e1d694dd3566b71331a554025c69b9504f", + "signature": "Qb/X5n+zMmr5ymysZi55MM+ieUEiwnFUCOJix07x+FcecbUbQe1g0c7ErV0XP96QqbN+P77A2zl3/6Dnhmo4Bw==", + "source_artifact_sha256": "7742811fd54dc2fb2b1336f83c65918fcb116f4cf437d0246c2095228d61249a", "verified_at": "2026-08-18T10:42:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", @@ -2970,185 +2955,253 @@ "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "wrong-reference", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "0eafb7867b5bb7cf68f39f40315893e1d694dd3566b71331a554025c69b9504f", - "facts": {}, + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "7742811fd54dc2fb2b1336f83c65918fcb116f4cf437d0246c2095228d61249a", + "facts": { + "derived_classifications": { + "collateral_effect_count": 0, + "duplicate_effect_count": 0, + "intended_effect_count": 0, + "wrong_record_count": 0 + }, + "dispatch_state": "not_dispatched", + "effect_inventory": [], + "expected_record_id_sha256": "2d1f4e51a934947a53e829f1608e93181d2cd4c7b9c24394cfd615713fc3c6be", + "expected_transaction_ref_sha256": "098205ce5255fe5150c178cd23e88274085b7dcd77c3eefba408633c996c4897", + "post_state_evidence_sha256": "ab3889d4bf86da6e33192c3de9bda5de4ff596bb0c04a4e581e834e95ec60bda", + "pre_state_evidence_sha256": "8b14b2452165cda2d8b0053c956b6bfa60abf5a6935b7e98f4b549fad3ca055e", + "verifier_method": "read_only_system_of_record_query", + "verifier_tier": "independent_system_of_record" + }, "run_id_sha256": "ee82112f55e5e6c86cfd6e16df8c8b652549a8bd72de492f435d8255eb3dd252", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, - "verdict": "injected", + "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "620ac6e3d7907f00bc17a13c98a6f49d1b6e5f4be2f45e348f07b8cb680f1f81": { + "65e06f16ef02103f69137135bcee9383043a2131983fefa999ce909cd0098be4": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "B7BNXAf5AnNinlwLkeND38ks1cilN5saiM3Z+8Vba0Bgd850Rb2PtmKTmtSZG6nmNBgvSwgqIVRfI92BYBhDBw==", - "source_artifact_sha256": "9ee6e57b75e164f5f91625d37f3d8286db558d96de0fe27acfcfc45c1288fda5", - "verified_at": "2026-08-18T11:03:00Z", + "signature": "GLTNupTlhMfgdKfl1dGbCRCpWRJ4J+OZZ8bRMzCWp4MmcnCjgCZjVYq6ck3/S9Efrtc15zyQsdoRprd/9xuBAg==", + "source_artifact_sha256": "5715c0e7be0a23b342d074947567c9aab924b43b2318265f28013a0d5715506f", + "verified_at": "2026-08-18T10:34:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "1ec11a9862ede3ac701af71835ac28c551d604a026b5bab7d776dbcdf288394e", + "attempt_id_sha256": "3aee8ad755c7f4bec71cc194bcfaa805e0ea29cf8b830ed0782f8263dd9620ca", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "ambiguous-target", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "9ee6e57b75e164f5f91625d37f3d8286db558d96de0fe27acfcfc45c1288fda5", + "condition": "idempotency-replay", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "5715c0e7be0a23b342d074947567c9aab924b43b2318265f28013a0d5715506f", "facts": {}, - "run_id_sha256": "43f0a1c00950c390b0676fab55a2aa98c354d028f2347c461661e6cdb72f717e", + "run_id_sha256": "3df83453126754a62d00ed10837720542d0469799bb8a88cb5257ac5f477a919", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "absent", + "trial_index": 3, + "verdict": "verified", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "623ae0f6cc3220ffa04c016943dc42361acb180e7f5649b4b410e3661063a450": { + "68743fb138f5b0323c8780ae12c25625f8bd94215e079453148bb3ccc1e321bb": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "+bU3ND+Mc3wR4g/HLadcuzvY5605oX79uJzz3tBE3bWybVLojL7HXZ/haeVyPvTnAeMVCS/5EI/89Zuslk0HDg==", - "source_artifact_sha256": "0e7b1e0c28c2cfe39870f987c674129552a27582914b580f2e13474b3636e942", - "verified_at": "2026-08-18T10:32:00Z", + "signature": "nkpW163xzuB6/JSTJsW9mZJxVr3XT2DN83whOOSNbuYKzKg8qYb347Q8O2q5T40uR+nBdc0DX80RMNtReDoJBQ==", + "source_artifact_sha256": "9e7ce6c0c14f2e05ca217cb2830c9fbdd1205753014ece86f7e77671774081da", + "verified_at": "2026-08-18T11:23:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "3142933f4f168c98b8e89f2ae9d78fd3129e0a9975cbbaa60ddba853eee7d53c", + "attempt_id_sha256": "eb52fb1b1bf2fac92d8f3a444bb5081161be8b3d0ef457c5065e7b79e96df770", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "idempotency-replay", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "0e7b1e0c28c2cfe39870f987c674129552a27582914b580f2e13474b3636e942", - "facts": {}, - "run_id_sha256": "6cdff0cf50d0164fe1eee9c4b7db0b969c24f9b960f5653b516313a913c90a0f", + "condition": "weak-effect-only", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "9e7ce6c0c14f2e05ca217cb2830c9fbdd1205753014ece86f7e77671774081da", + "facts": { + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "9e7ce6c0c14f2e05ca217cb2830c9fbdd1205753014ece86f7e77671774081da", + "source": "runner_signed_flow_report_and_enforced_egress_policy" + }, + "operator_intervention_ids_sha256": [] + }, + "run_id_sha256": "794033f9da2a42448254a478fb6de954898b1e544148708ad30264efdc255431", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, - "verdict": "absent", + "trial_index": 2, + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "624fbbdd7880133c85ef5e91662bd815d4f451b168876822f76ac149caba0b11": { + "690e9a06f4247ffb8bb5dc38a360e35ed40c03c817ea2242c42b944a706a0511": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "Vy5RiysTcZFYrD8cw94AB+mEumRD+wQ7XosmMSCI3tfT8S+WCbkT+CLQ+RQY+K+pmj3/394T+1jbIMH73EWgAg==", - "source_artifact_sha256": "2c464c80d9d0976e30c3c1b674426f3db967a0264e7bb8ee48984e6b235a5a80", - "verified_at": "2026-08-18T10:44:00Z", + "signature": "LlP/VjWZ4gYh3+XtBl4vFEeZNxiC5ow3BL1eXdybYLphx+PYiE7tiCq5apPBXP16SBNhymPxvHT0eFWmh7vGBg==", + "source_artifact_sha256": "dcdc96c4f09e390d61f558318a74baef2f65d601e71808bdbf922fcc7f4d5bbf", + "verified_at": "2026-08-18T10:03:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "7c910764b2dcc6f05261d609082f75474e4638c3f356006307212b8fed4a2eb7", + "attempt_id_sha256": "fdad940f245d690750ad647fac25c7e76aac2f474db49732fec8129051750186", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "wrong-reference", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "2c464c80d9d0976e30c3c1b674426f3db967a0264e7bb8ee48984e6b235a5a80", + "condition": "healthy-01", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "dcdc96c4f09e390d61f558318a74baef2f65d601e71808bdbf922fcc7f4d5bbf", "facts": {}, - "run_id_sha256": "fe98ce7f0e66b885201f4667875fd38f5890ffddb575d68bd4cd5a66f8d53ca8", + "run_id_sha256": "3739043a92a8781376cfbd022460c03aba40f92a800b3885ebc046321437bc40", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "delivered", + "trial_index": 2, + "verdict": "verified", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "6e98856f3363123ebb77e70e55b34aa80b64121bdf434d4784907d8565c88ab3": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "8OfkTMRyBhIdf8azq5H7+H2lLJpbrITyYhYhnJ4ySMuvCqmi0gf2pBVmpMigyKxWgNKltsSXGtxECk0qFpI3DQ==", + "source_artifact_sha256": "11f183b9a6fd7d20a3cfc66e95960832da64804b9d3f6980ee365679b3a1793f", + "verified_at": "2026-08-18T11:13:00Z", + "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "42259dbb767ced4c25ad8bd40edc209720a748897194c925ed9bd2e27b2258b2", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "verifier-unavailable", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "11f183b9a6fd7d20a3cfc66e95960832da64804b9d3f6980ee365679b3a1793f", + "facts": {}, + "run_id_sha256": "4af84f2608a25a27e6252a5800263a238bb70fb3bec65148601ddcdddbf3e03c", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "64044bd99feae9406b2089417a4e5b33dca8a65bc8c4c0227b47594912bf71c1": { + "705af4a02c6cb6c96be1b72ec3decc34e2e2f13f9a35a2e7e50d6e7f774a369a": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", "receipt_type": "webhook", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "eQhYzzODVj5EOITyB1i7RnkM9ku3kXliT5Dy9HaXc8QQYLIm0d/BHQBD5g2V/G2MKjiBstWMn/0Nz8445TnaAQ==", - "source_artifact_sha256": "c68ae5d22981662c17338c01af40177a0e375c993c4e4dcefc9aaf4df2d5366d", - "verified_at": "2026-08-18T10:23:00Z", + "signature": "Gl7gSSiQ9YmS2RKoMMNi90HZkZ6/Wr2hgg+tGhmqA9J1UUkLgZa2IAV3LuPIeUWfwI2R6wEcO50UsY3zadIqCQ==", + "source_artifact_sha256": "dc043aee537d3d9f2971b9f6f507101da11be20d6c62347dddc91b4c9eeb8fdc", + "verified_at": "2026-08-18T11:24:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "2601335b1101424105277997a67850a8a60aa45f59637b7679c1f32af463c460", + "attempt_id_sha256": "aa7d6be4f25a8992c0a22649ba7e703d6955abf5fece9f8322f560149cf09776", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-03", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "c68ae5d22981662c17338c01af40177a0e375c993c4e4dcefc9aaf4df2d5366d", + "condition": "weak-effect-only", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "dc043aee537d3d9f2971b9f6f507101da11be20d6c62347dddc91b4c9eeb8fdc", "facts": {}, - "run_id_sha256": "237a0b7d1cafb64b1d113dca6699e6eefeaaf0b18679138545c3695495b901d5", + "run_id_sha256": "b974de9da8ef77c8dc9a7662114cc51023ab8c131c488681eeebb7d4c435c8d0", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, + "trial_index": 3, "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "64adf7272b03ff909a4d9420d130a4755b4925ea6f6e76341b621a79e975a5d7": { + "729648debeebf209f4ab45315cebd2de9bd4fc3ba7e2497ab41441954b3044dd": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "yT/7ky+j24+nw9fIpaJhD8tgTv0OzAiVHGRC2fTUG4IFe92P5HccmQZUcVSyBq6GYHupOf25f/GrRnUOaH0xBg==", - "source_artifact_sha256": "b9930bf1c041fb17cb156788d0424c034c6be2711ca5911469fb8791a6c925f4", - "verified_at": "2026-08-18T10:34:00Z", + "signature": "vM9DmaPLT9iwsx39q16XXYw1bE4PuFTwFBByJlyrDl1lIqAhqE7hhyEx9KGJRI0lk0es26UkwYiOhel4o8XlCw==", + "source_artifact_sha256": "516ecd879cd6bf3ddce68daf59c204f277f8dc9c69b44e4aab5485a9563bb56b", + "verified_at": "2026-08-18T10:04:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "3aee8ad755c7f4bec71cc194bcfaa805e0ea29cf8b830ed0782f8263dd9620ca", + "attempt_id_sha256": "4c352a6999f77707e8837adebb4fc2b7451c2ef6de5145190b33a5c5645e47eb", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "idempotency-replay", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "b9930bf1c041fb17cb156788d0424c034c6be2711ca5911469fb8791a6c925f4", - "facts": {}, - "run_id_sha256": "3df83453126754a62d00ed10837720542d0469799bb8a88cb5257ac5f477a919", + "condition": "healthy-01", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "516ecd879cd6bf3ddce68daf59c204f277f8dc9c69b44e4aab5485a9563bb56b", + "facts": { + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "516ecd879cd6bf3ddce68daf59c204f277f8dc9c69b44e4aab5485a9563bb56b", + "source": "runner_signed_flow_report_and_enforced_egress_policy" + }, + "operator_intervention_ids_sha256": [] + }, + "run_id_sha256": "4ee2bb61fb883cc8e77d636fb471aa3c0ce9ef0c0a8abd9682214bf0a8f16f26", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, - "verdict": "absent", + "verdict": "verified", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "65fba274ba6ef5364ee1212f448cacfa222246d4c278b29535b3569b9bfd699b": { + "74228591b612613ec96863c47e901cc6cd28a58b97a1499c42c95d38ebb1aa17": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-d92d542a589844dd", "receipt_type": "cleanup_absence", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "8T5U0FgVeZTtZqvZdi7iRA36FC/hLFPbtczSmdSRTWA3LTjSwoeWFbXxavbxC3VGU9XYHFOP/6yPv8QeufrHAw==", - "source_artifact_sha256": "c129344c7dd911068c387c21d9a1042713a90190dcd848662cf894d8283c4db2", - "verified_at": "2026-08-18T10:54:00Z", + "signature": "MQofPwBZZ+Cu1yWNs00xxq5Xdzifr0GU3Xwos4Z01WdLstbDuy2vOiLlDq5xelmwvDh8Ft3bBVr5ImeQovpjDA==", + "source_artifact_sha256": "0e28a6c49ce0c22f0e6a0220a2c3340d4e956f0f9a29511f0c44e7492d004a89", + "verified_at": "2026-08-18T11:13:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "958342a9ddca98a83b82b662f52f404239d583afe7ed70634760e1b8dd592f3b", + "attempt_id_sha256": "42259dbb767ced4c25ad8bd40edc209720a748897194c925ed9bd2e27b2258b2", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "stale-session", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "c129344c7dd911068c387c21d9a1042713a90190dcd848662cf894d8283c4db2", + "condition": "verifier-unavailable", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "0e28a6c49ce0c22f0e6a0220a2c3340d4e956f0f9a29511f0c44e7492d004a89", "facts": {}, - "run_id_sha256": "6f2fb10bc2018c9f78e9702d5ccac0bedd78ee3b2e9d2a6ad779fba72d90ae50", + "run_id_sha256": "4af84f2608a25a27e6252a5800263a238bb70fb3bec65148601ddcdddbf3e03c", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, + "trial_index": 2, "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "67aef634540cce7bb70a512081e96ebc7edd41e8bb8835891ce1378efd425557": { + "754e94df2f1696ba724d94b2a9251bd21cbdd4a00fd7a7438a2ec3ca84a44b6c": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-138dfa227234ea5f", "receipt_type": "cleanup", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "VZqeX1oqQnQLVuUUmXRa8IamudaFHwFsy1pR7G2pSheJmSYho28B5tRuTdNiwvBvwTisKDKzRBmqYHuQP62QBQ==", - "source_artifact_sha256": "b2d52421d96d2fc81f80e91f43d0228f793bae8fefedbea6d79a281c903b0000", - "verified_at": "2026-08-18T10:33:00Z", + "signature": "Ti6+U6ZjxMGOzJqJZgouS8zWS1oYufvWlcxikTlLhiPwdClguL3J2h44bgoBbWbwZypSlDvCjtx/h/KiBUywBw==", + "source_artifact_sha256": "e7e294aaa63908c75e3513aee7e29b3bd24623d3fda8d6fe6fbb9dd04227630f", + "verified_at": "2026-08-18T10:23:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "4667302b580ff7ceb223dbb15eb6d029969a8f6a54bcd33e8df5b6bff41f41ad", + "attempt_id_sha256": "2601335b1101424105277997a67850a8a60aa45f59637b7679c1f32af463c460", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "idempotency-replay", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "b2d52421d96d2fc81f80e91f43d0228f793bae8fefedbea6d79a281c903b0000", + "condition": "healthy-03", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "e7e294aaa63908c75e3513aee7e29b3bd24623d3fda8d6fe6fbb9dd04227630f", "facts": {}, - "run_id_sha256": "33e0ad9bf64e477f24d46508fa432123e046dcd1c5853d5cc60b7cde1bce7537", + "run_id_sha256": "237a0b7d1cafb64b1d113dca6699e6eefeaaf0b18679138545c3695495b901d5", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, @@ -3156,77 +3209,76 @@ "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "6944fec3e81116c5e5fa95147eeb513a8d68d388d64b0269fa617cde342b9f4f": { + "7602e3cdeee8a9d03aaa5ca0cf40be1f760d55237f8e286e419e168dc1e09c8a": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", - "receipt_type": "fault", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "Km9/LP+fYy9HU/BZG/nToFMfBFVMkOEJ57jwKCumlsUoYTsZhz8rhQCUywzUT5K5y8dqdUHQSRu+mSix2ixEBA==", - "source_artifact_sha256": "002efaa296dd38b0596e300894d23a4d0a9ceda1480bd302602a34e6d5d6b884", - "verified_at": "2026-08-18T10:53:00Z", + "signature": "wi7rgQz/GnJIqO85DtCEVaTOjUnVQDm2GIelnTpiZFqBI9UdCAillYTAZFXhUIXj8DHFVtD+jyQZpRk90o+tBA==", + "source_artifact_sha256": "a44dac787050d0cb99551f8f0735973f618907d4b8f58c6f5760fc1634522c2f", + "verified_at": "2026-08-18T10:04:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "f5df4d6e64a2d38ffa8e320c87ad05d04025de267a8e152a755d3f1928ded120", + "attempt_id_sha256": "4c352a6999f77707e8837adebb4fc2b7451c2ef6de5145190b33a5c5645e47eb", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "stale-session", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "002efaa296dd38b0596e300894d23a4d0a9ceda1480bd302602a34e6d5d6b884", + "condition": "healthy-01", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "a44dac787050d0cb99551f8f0735973f618907d4b8f58c6f5760fc1634522c2f", "facts": {}, - "run_id_sha256": "fd3a041b705d8c6277ce26134dc0018e866218cfa3fadd16ac29d1ad498965a3", + "run_id_sha256": "4ee2bb61fb883cc8e77d636fb471aa3c0ce9ef0c0a8abd9682214bf0a8f16f26", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "injected", + "trial_index": 3, + "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "695743910a9a3fc4f38f7cef21f960b3ad157b1c971cb6d5858c866f10eecb7f": { + "767088dbd029bd114a97ac8b4aead8dd3684260f29a510f17247e869a1638c79": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d7e1e084be213b01", - "receipt_type": "observer", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "/m5MCULfiyrWEh4xtoqCAZDxtDVov6VKdTef5B0sSlG9wp0XdyBPgGKEETIUQn/b9FfxN6VbbBoFYZ3DoekKAw==", - "source_artifact_sha256": "6820b7608a765ba712f9643379187af143db8c68f93b58d7a8825daa976ffc69", - "verified_at": "2026-08-18T11:02:00Z", + "signature": "CpjWaNomf7/Fzvhy8OT73CEwhRao5R7CD6e4Q3NfGnqwJGAEm/CEegYzUaqWSZNZe4VX1KlPB9e81yGoYLOlDA==", + "source_artifact_sha256": "41b0b0f3cb3d31cd294283b6d49a4982e36b7f34033f72e83a81354f0aa54a47", + "verified_at": "2026-08-18T11:12:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "60ee9db05b1126cfaa3b31c13bc3fab4755ac09c44e846b4d07ee51865dfa7b1", + "attempt_id_sha256": "f5e96a2e9a580376b18beabf57798b8761e772a0c4d112877045780bb12b3720", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "ambiguous-target", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "6820b7608a765ba712f9643379187af143db8c68f93b58d7a8825daa976ffc69", + "condition": "verifier-unavailable", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "41b0b0f3cb3d31cd294283b6d49a4982e36b7f34033f72e83a81354f0aa54a47", "facts": { - "derived_classifications": { - "collateral_effect_count": 0, - "duplicate_effect_count": 0, - "intended_effect_count": 0, - "wrong_record_count": 0 + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "41b0b0f3cb3d31cd294283b6d49a4982e36b7f34033f72e83a81354f0aa54a47", + "source": "runner_signed_flow_report_and_enforced_egress_policy" }, - "dispatch_state": "not_dispatched", - "effect_inventory": [], - "expected_record_id_sha256": "7d599c341cd3b8ec3ce6c069e9a62b9e3aa59670bcba88b72b660f9dbbfa62f4", - "expected_transaction_ref_sha256": "0d92f2608c1d242b3bc3560b9c2cfcf3960432c5c36cb6a69608100e5d1b5ecd", - "post_state_evidence_sha256": "d71194830ea6369e85b522ee44e4f3d44f4fe9a4936a7643e75a8816ea89ee4d", - "pre_state_evidence_sha256": "8b4ae3dd7daeabd4c3609a04d2e8d42349500558fbc4fb7be692d2268a6229f1", - "verifier_method": "read_only_system_of_record_query", - "verifier_tier": "independent_system_of_record" + "operator_intervention_ids_sha256": [] }, - "run_id_sha256": "628f991a182613b8700294d7483b5a4c06872cb9d5ca6047ea552b8ab6585357", + "run_id_sha256": "e8e89651045a5f5c011c9543ed968e0fe7697a061ed8ad5cedc27d194cb96acb", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, - "verdict": "satisfied", + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "6af0a975d21278b3a18e55ee5036101ea423eb08313a1923528755ab608c889d": { + "7676355320476b68f3da156c4eb5cd44d8ec709d9cd850dfa56d43a2af507ed7": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", "receipt_type": "webhook", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "jX3Jt06o66b0HEvwCa2fyPyoELeOEff9e1hWVrrbG7L6mmGhEiBpt1jHrr1SOhRQiUTo888F2L+kUGma3SgfDA==", + "signature": "4gAU3ISBK3V3VSu99dzaC5ghrKoWzrlOS61YHPzcHCPyAK2N9zCFVDcyi1a058rKAxL1r8ZdWEhgYWf9W23yCQ==", "source_artifact_sha256": "b181977448bfbd12d2ed392d09d1d8be4a7489c9f5214c80bf97e84b3f745b64", "verified_at": "2026-08-18T10:52:00Z", "verified_projection": { @@ -3235,7 +3287,7 @@ "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "stale-session", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", "evidence_sha256": "b181977448bfbd12d2ed392d09d1d8be4a7489c9f5214c80bf97e84b3f745b64", "facts": {}, "run_id_sha256": "d9270fd4c85e4226a9347ecf703e876b9ffdc330f60c7fb8bed8f9321ea30225", @@ -3246,47 +3298,72 @@ "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "6ce64d58e69df317d74e94e480a3952ba89133053a77da3f7fcbb51e22da53ce": { + "778948228fce99d1ec2f8fc2f17c43e39ad4ec5e59bcc78ca4204f989622c938": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "ue83YucAh+RDLqjFFLLSWOiFAT7oNrb9Z1LPx32crtMEGriJ1jVdRnZHQjj3t48saManeW2D+llcTYRldAD5Dw==", - "source_artifact_sha256": "dc043aee537d3d9f2971b9f6f507101da11be20d6c62347dddc91b4c9eeb8fdc", - "verified_at": "2026-08-18T11:24:00Z", + "signature": "gSqM/M11tonoICt0oQzZUWZaeKZi1YwTrJ4I+/mO2L1q9ulFC4HvicUbxi7BGSHG/u5XJMAHsw4ZbKt9Tw7YCw==", + "source_artifact_sha256": "c51fe4dc79cc2e8b749809c818af5f63c67cbe6e82656cb990d1bc7b13a0b6eb", + "verified_at": "2026-08-18T10:34:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "aa7d6be4f25a8992c0a22649ba7e703d6955abf5fece9f8322f560149cf09776", + "attempt_id_sha256": "3aee8ad755c7f4bec71cc194bcfaa805e0ea29cf8b830ed0782f8263dd9620ca", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "weak-effect-only", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "dc043aee537d3d9f2971b9f6f507101da11be20d6c62347dddc91b4c9eeb8fdc", + "condition": "idempotency-replay", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "c51fe4dc79cc2e8b749809c818af5f63c67cbe6e82656cb990d1bc7b13a0b6eb", "facts": {}, - "run_id_sha256": "b974de9da8ef77c8dc9a7662114cc51023ab8c131c488681eeebb7d4c435c8d0", + "run_id_sha256": "3df83453126754a62d00ed10837720542d0469799bb8a88cb5257ac5f477a919", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, - "verdict": "delivered", + "verdict": "completed", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "77bfbb23e1d36f068e036695786c1e798bc5f5914a3419d3635c2098c0f68402": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "fz8SigEroojdRzEup5cAwUe4CLB+v6R2u8/OApkOaKaHIGEGZm95ZY93OE35k/hUdgVlwB+JYcvVAPxWGOoeBg==", + "source_artifact_sha256": "1eca1abe283fecbe71ddaa403079343a5a6893d159482e26421de9b3004b7e29", + "verified_at": "2026-08-18T11:22:00Z", + "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "73a097b8b20bab7794369384f7ca1d7d711aad07967b7e1292373babbb7ff1b7", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "weak-effect-only", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "1eca1abe283fecbe71ddaa403079343a5a6893d159482e26421de9b3004b7e29", + "facts": {}, + "run_id_sha256": "b44783e70a980ec5b3cf3752bd5d1d01b2ff29f5a6892cba0c1c939d8aeb7c02", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "741bb99666db76220c53c49c9729b0f8b75036e458f2d75542760ad6581184fc": { + "7907acbc65d0fcf1f5e8f336840294521ef04443d50decf218803f0c83c5678c": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-d7e1e084be213b01", "receipt_type": "observer", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "mc9zUvRFUXlJvcg7/E8IgqzveIeYIVRMd6e6/7LXo0+EdcgDFZ2wj/jFdM+bMT0l0HIkOphuuwIfy08kdOdVCw==", - "source_artifact_sha256": "8f3a90b44ab62c40384d697eeb5664143c64378dc1162f48f40843beeb892c40", - "verified_at": "2026-08-18T10:53:00Z", + "signature": "SA871B6ZEXMNEy6JwJlFrk1hLPbgLO0sdaH1ekYzF/t3PuoHWGWH8TUn4C6YPNjjOA8u596GqXMce+clReMeDw==", + "source_artifact_sha256": "6820b7608a765ba712f9643379187af143db8c68f93b58d7a8825daa976ffc69", + "verified_at": "2026-08-18T11:02:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "f5df4d6e64a2d38ffa8e320c87ad05d04025de267a8e152a755d3f1928ded120", + "attempt_id_sha256": "60ee9db05b1126cfaa3b31c13bc3fab4755ac09c44e846b4d07ee51865dfa7b1", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "stale-session", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "8f3a90b44ab62c40384d697eeb5664143c64378dc1162f48f40843beeb892c40", + "condition": "ambiguous-target", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "6820b7608a765ba712f9643379187af143db8c68f93b58d7a8825daa976ffc69", "facts": { "derived_classifications": { "collateral_effect_count": 0, @@ -3296,64 +3373,64 @@ }, "dispatch_state": "not_dispatched", "effect_inventory": [], - "expected_record_id_sha256": "1f281cf15b2a004cdd209558e754a9da1899d8ebc38689a353294b23448d9676", - "expected_transaction_ref_sha256": "454701823a6df98835a9b226538dc4772a1e3b6784a805907a45fd2590113fbe", - "post_state_evidence_sha256": "5af3f3e3a79cc3ac0cad3c3f31b71ebe92b8e3d4390d0ebda9951ba00e220d86", - "pre_state_evidence_sha256": "660b59ae4de4abb38c1d1bc900987fa8d4f15035c045cb40bf5384aaf94bad66", + "expected_record_id_sha256": "7d599c341cd3b8ec3ce6c069e9a62b9e3aa59670bcba88b72b660f9dbbfa62f4", + "expected_transaction_ref_sha256": "0d92f2608c1d242b3bc3560b9c2cfcf3960432c5c36cb6a69608100e5d1b5ecd", + "post_state_evidence_sha256": "d71194830ea6369e85b522ee44e4f3d44f4fe9a4936a7643e75a8816ea89ee4d", + "pre_state_evidence_sha256": "8b4ae3dd7daeabd4c3609a04d2e8d42349500558fbc4fb7be692d2268a6229f1", "verifier_method": "read_only_system_of_record_query", "verifier_tier": "independent_system_of_record" }, - "run_id_sha256": "fd3a041b705d8c6277ce26134dc0018e866218cfa3fadd16ac29d1ad498965a3", + "run_id_sha256": "628f991a182613b8700294d7483b5a4c06872cb9d5ca6047ea552b8ab6585357", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, + "trial_index": 1, "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "74bf2158a084de1057a2f9332e58a275be7e26aac5b1ff5ccdb29efb49923593": { + "7a6bbef1d68871f1e8195e05991b676613334e8a201812dd911532a7e4f6c209": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-138dfa227234ea5f", - "receipt_type": "cleanup", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "97/8BzGFuGdlxnvXyNoVYZ0jdSruTSBwHhzjast9BV2cNfSArL9rgQk01anb+AXiSR+glzkfc8oVhMQEOj8jCg==", - "source_artifact_sha256": "89e92e0a76d7ef86a369ad65837369620240dc66bc215bc9fa3fddc21d777f9e", - "verified_at": "2026-08-18T10:32:00Z", + "signature": "XRYyTyM1ML46OQdtK/G8uLVIQgPjo5vGLHVp7XLEbkw7jZJZvEkQodvIRkpEkGbIqjbW68M8f7AQYpjWMGXMDg==", + "source_artifact_sha256": "051bac821eaa3486034f245101d6c1f831d659444be87a3b5d774a9abaea05ff", + "verified_at": "2026-08-18T11:02:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "3142933f4f168c98b8e89f2ae9d78fd3129e0a9975cbbaa60ddba853eee7d53c", + "attempt_id_sha256": "60ee9db05b1126cfaa3b31c13bc3fab4755ac09c44e846b4d07ee51865dfa7b1", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "idempotency-replay", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "89e92e0a76d7ef86a369ad65837369620240dc66bc215bc9fa3fddc21d777f9e", + "condition": "ambiguous-target", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "051bac821eaa3486034f245101d6c1f831d659444be87a3b5d774a9abaea05ff", "facts": {}, - "run_id_sha256": "6cdff0cf50d0164fe1eee9c4b7db0b969c24f9b960f5653b516313a913c90a0f", + "run_id_sha256": "628f991a182613b8700294d7483b5a4c06872cb9d5ca6047ea552b8ab6585357", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, - "verdict": "completed", + "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "74c0ad2e902682f3f0c36c859ab514c9d2ca0c5e62a6efd3054713b92dc094e6": { + "7aa8397c5de967f8e81eabecfe52c021b1e07871d713156463a1b3b1db1855de": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-138dfa227234ea5f", "receipt_type": "cleanup", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "bUamh8YT7cXAPWKlsA7GwbZV59ZajMLYR4rIaB0S382SnhEXDCKE4edP7hZsWgSy78kqhhxTt3189hIuT6A1DA==", - "source_artifact_sha256": "4b49c957d7eeb5d558fc4b83415475999503aa48aa8d8be5ec00a745b6c78701", - "verified_at": "2026-08-18T10:13:00Z", + "signature": "4S6LcIdTIoi7U0WbYZtqywO8/s+3XDQzPa6V/cJH67MFcf8fiwa4b4+8EZE1hjTUnMgPxogrRuDozYBKumXcBg==", + "source_artifact_sha256": "d4f5375e18344432614ad6d37de4727b4ccbfb1465851f36df15fcd2cf052c4e", + "verified_at": "2026-08-18T10:03:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "3d42601a69ef46cc44f57b51762affef4ccd829ffde30125619a6e582af00dab", + "attempt_id_sha256": "fdad940f245d690750ad647fac25c7e76aac2f474db49732fec8129051750186", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-02", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "4b49c957d7eeb5d558fc4b83415475999503aa48aa8d8be5ec00a745b6c78701", + "condition": "healthy-01", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "d4f5375e18344432614ad6d37de4727b4ccbfb1465851f36df15fcd2cf052c4e", "facts": {}, - "run_id_sha256": "091e13ed70dab439b31cb506cf3bba1ddf6476696531cf891c39a924a928b7a1", + "run_id_sha256": "3739043a92a8781376cfbd022460c03aba40f92a800b3885ebc046321437bc40", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, @@ -3361,212 +3438,206 @@ "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "7680aca959060d5c6c03586cd4555132a94bbec661dd09cb82aa51f0fdea9746": { + "807bf8e238a171e94d0a61e5d2f7ecacef62042842047274b982d67de9956727": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "GyqjM3ToZrQdV+I6PFKCyYbXjiQhVz5PEzu57TI68NbgMNiUa/Hpg9rp23zp6AvP1Cg4/J57Lngpn2Ny6oQCAg==", - "source_artifact_sha256": "92c76843346dc97ecdd23535ab0cebf2aecbaddd30aae938fed40434fb6b2da0", - "verified_at": "2026-08-18T10:32:00Z", + "signature": "K2sUHr2OC6UAlfPQ0qFFaNhHknwl2AdUP1ILuhXgo5NTkzMd65OrDvozwjdOV+Qg0E6TahjZdyAM1x2Y2BevBw==", + "source_artifact_sha256": "fc34b2087c0ac5df3a7283f31412b0a354de6d6f9a21946e56ad9f8cd42edfd6", + "verified_at": "2026-08-18T10:03:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "3142933f4f168c98b8e89f2ae9d78fd3129e0a9975cbbaa60ddba853eee7d53c", + "attempt_id_sha256": "fdad940f245d690750ad647fac25c7e76aac2f474db49732fec8129051750186", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "idempotency-replay", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "92c76843346dc97ecdd23535ab0cebf2aecbaddd30aae938fed40434fb6b2da0", + "condition": "healthy-01", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "fc34b2087c0ac5df3a7283f31412b0a354de6d6f9a21946e56ad9f8cd42edfd6", "facts": {}, - "run_id_sha256": "6cdff0cf50d0164fe1eee9c4b7db0b969c24f9b960f5653b516313a913c90a0f", + "run_id_sha256": "3739043a92a8781376cfbd022460c03aba40f92a800b3885ebc046321437bc40", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, - "verdict": "verified", + "trial_index": 2, + "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "76e7394342df02acda6f125c6069601220ea6de460350b3746e09b4b55cfa461": { + "83a6ec6781549ddd4a7798e1c2434de963dc5e7c9589022d8f811c96c56b98ba": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-138dfa227234ea5f", - "receipt_type": "cleanup", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "L7SfdkFP5nL3A2lafVF7uoe5gT02finHwrjguBwA/PCG+w+M/BInqhYR41gGlKq6T5k7ju3GzXQDl4HntcEVAg==", - "source_artifact_sha256": "d4f5375e18344432614ad6d37de4727b4ccbfb1465851f36df15fcd2cf052c4e", - "verified_at": "2026-08-18T10:03:00Z", + "signature": "6S6pOhB+XPNRBJMtqNXa21BIUKjW+MC0VsLl1iMDVtQifTmJT8el1CTT2xkYy+i/bKVFMJFseXgfXxFsoB4XDg==", + "source_artifact_sha256": "25166ea6bdc49a633c232781e8ef3511a9a11ef23e033b141c9a8ec8cb3f6834", + "verified_at": "2026-08-18T10:54:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "fdad940f245d690750ad647fac25c7e76aac2f474db49732fec8129051750186", + "attempt_id_sha256": "958342a9ddca98a83b82b662f52f404239d583afe7ed70634760e1b8dd592f3b", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-01", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "d4f5375e18344432614ad6d37de4727b4ccbfb1465851f36df15fcd2cf052c4e", - "facts": {}, - "run_id_sha256": "3739043a92a8781376cfbd022460c03aba40f92a800b3885ebc046321437bc40", + "condition": "stale-session", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "25166ea6bdc49a633c232781e8ef3511a9a11ef23e033b141c9a8ec8cb3f6834", + "facts": { + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "25166ea6bdc49a633c232781e8ef3511a9a11ef23e033b141c9a8ec8cb3f6834", + "source": "runner_signed_flow_report_and_enforced_egress_policy" + }, + "operator_intervention_ids_sha256": [] + }, + "run_id_sha256": "6f2fb10bc2018c9f78e9702d5ccac0bedd78ee3b2e9d2a6ad779fba72d90ae50", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "completed", + "trial_index": 3, + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "76f7d5b5fc039b3ce624e887fb4e076bfc10f32577f8a3c72566678942ff8bea": { + "84b89d7009d9583a5dcb13564ec0ec9264603f2ea4bc102c3d5c1b426ce7696c": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d7e1e084be213b01", - "receipt_type": "observer", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "BAVUqLTyK/B6rPr0oogBhlPsAS2Gz0DdeGuPwI17PTEpH0NDQkZPRTfcOaLm9QuEvcYvy9ORfs0nT0yYuJC1Ag==", - "source_artifact_sha256": "f4e30b79fe5403ce13c6b1b63149637b35847c5bb37a7e923317e0cb11fdce22", - "verified_at": "2026-08-18T10:33:00Z", + "signature": "PqAA8v+AO+eP8LMviRbDQbptF9IoMOldP7ABzDmVS6b9wxbBYuY8064T+IqJaeL2I8oaH4LgmZot1Altr3wIAw==", + "source_artifact_sha256": "ce0aa45ff0449ef101823a15d86eaad2e81cfaedb64c35017e27146adae0a845", + "verified_at": "2026-08-18T10:43:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "4667302b580ff7ceb223dbb15eb6d029969a8f6a54bcd33e8df5b6bff41f41ad", + "attempt_id_sha256": "6b0e5c10d55fc92c1ff8576392270a24fb65722414cf58ff9a51b8ce9ef88587", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "idempotency-replay", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "f4e30b79fe5403ce13c6b1b63149637b35847c5bb37a7e923317e0cb11fdce22", - "facts": { - "derived_classifications": { - "collateral_effect_count": 0, - "duplicate_effect_count": 0, - "intended_effect_count": 1, - "wrong_record_count": 0 - }, - "dispatch_state": "dispatched", - "effect_inventory": [ - { - "effect_id_sha256": "3de74331383c83b299c3122cdd26ec8f11285c4bf933b8a7fb07fbacab6fa222", - "record_id_sha256": "f937550eaf086105b0c0b3bd09d88c72b16eadd01378e96a650960491e50bbb1", - "transaction_ref_sha256": "dc78636b2afb08f287cc1754e616ac46e228aa478a330e9c914e90c55bfa795c" - } - ], - "expected_record_id_sha256": "f937550eaf086105b0c0b3bd09d88c72b16eadd01378e96a650960491e50bbb1", - "expected_transaction_ref_sha256": "dc78636b2afb08f287cc1754e616ac46e228aa478a330e9c914e90c55bfa795c", - "post_state_evidence_sha256": "d0d8ebe302f92064c831e89e995d7b53b02e7814a5b9314715f4144e06536451", - "pre_state_evidence_sha256": "8ddef5d347d9382ea81a6b68f1475284a4383cc8341fd3104a762695ffc2f97b", - "verifier_method": "read_only_system_of_record_query", - "verifier_tier": "independent_system_of_record" - }, - "run_id_sha256": "33e0ad9bf64e477f24d46508fa432123e046dcd1c5853d5cc60b7cde1bce7537", + "condition": "wrong-reference", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "ce0aa45ff0449ef101823a15d86eaad2e81cfaedb64c35017e27146adae0a845", + "facts": {}, + "run_id_sha256": "577e37b10b1c87fd9c1b5d320888b736d272824657fd59a012e85a284ee88540", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, - "verdict": "satisfied", + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "7822fdf37dfcdd3dac8232707e1237c777e0fe82d4d6ef3424dff0c260b6ab18": { + "8596b07cf41f10f0fbe9aa0ca392ee4145c40ebd7f72bf8a0ef96d533c597128": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d7e1e084be213b01", - "receipt_type": "observer", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "WNCfzfILsVQN0U6Shbrk02zwnzX40gEZfFhlX2CWVyTEj4p8bg6kih46EhdGsxBzlsDaj2KGtFoBA84MiG9bCQ==", - "source_artifact_sha256": "e0ce2fefc18a96fdbe4db27543f31525ec9852a94a94d757559ccdd960f8faf9", - "verified_at": "2026-08-18T10:13:00Z", + "signature": "+PSbM/Ib2oyLR44W+rS3EJrwbZ2D5RlOYCZeRgDTzuiffiy9A73sGh2ffwvmeaagzr9RATYItUtHXjX84RVjBw==", + "source_artifact_sha256": "17bb1d69cfdd94f6150054ac594fc42cd59a8d09b780ee0103962cd549f157ef", + "verified_at": "2026-08-18T10:53:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "3d42601a69ef46cc44f57b51762affef4ccd829ffde30125619a6e582af00dab", + "attempt_id_sha256": "f5df4d6e64a2d38ffa8e320c87ad05d04025de267a8e152a755d3f1928ded120", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-02", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "e0ce2fefc18a96fdbe4db27543f31525ec9852a94a94d757559ccdd960f8faf9", + "condition": "stale-session", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "17bb1d69cfdd94f6150054ac594fc42cd59a8d09b780ee0103962cd549f157ef", "facts": { - "derived_classifications": { - "collateral_effect_count": 0, - "duplicate_effect_count": 0, - "intended_effect_count": 1, - "wrong_record_count": 0 + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "17bb1d69cfdd94f6150054ac594fc42cd59a8d09b780ee0103962cd549f157ef", + "source": "runner_signed_flow_report_and_enforced_egress_policy" }, - "dispatch_state": "dispatched", - "effect_inventory": [ - { - "effect_id_sha256": "8b445acee6aae04feb051f8c04d3c5983b50b60075a530553e9ef68a94339497", - "record_id_sha256": "d11cba9b016242b077f75fca7a6ba081ffcd42685c539aae24aa6a6a345873ae", - "transaction_ref_sha256": "9e9fc97defc5a1352a121bbb49532d28352f7488b87f5ffe23650890cc1828b3" - } - ], - "expected_record_id_sha256": "d11cba9b016242b077f75fca7a6ba081ffcd42685c539aae24aa6a6a345873ae", - "expected_transaction_ref_sha256": "9e9fc97defc5a1352a121bbb49532d28352f7488b87f5ffe23650890cc1828b3", - "post_state_evidence_sha256": "688116b3cbe3b2c66b24588c90a8240bcabbaf0aac8f1aadd8a8294e31114f32", - "pre_state_evidence_sha256": "b604ab87a04cc6869af9c1991b242920aa576870d7f254ec9169294c5ff9f13b", - "verifier_method": "read_only_system_of_record_query", - "verifier_tier": "independent_system_of_record" + "operator_intervention_ids_sha256": [] }, - "run_id_sha256": "091e13ed70dab439b31cb506cf3bba1ddf6476696531cf891c39a924a928b7a1", + "run_id_sha256": "fd3a041b705d8c6277ce26134dc0018e866218cfa3fadd16ac29d1ad498965a3", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, - "verdict": "satisfied", + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "78b6fbcd45afdcab40cc88b65a9c53caea37e18ea8df239812cfb2922fd26df4": { + "8924de4c24e49cc1160cf6e7df60b0ae93ab34d13b4b03073b9981156696dcd2": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "hH8bNIAWeZZOYxITXxHgfhdhajUoqDztL+BwJXVPalnv3eXR1RRRMd88H0tVHsCNAaSnaOkaY+lwGBmza1dkDg==", - "source_artifact_sha256": "fc34b2087c0ac5df3a7283f31412b0a354de6d6f9a21946e56ad9f8cd42edfd6", - "verified_at": "2026-08-18T10:03:00Z", + "signature": "oVHgPu36tNK1keCv2YkTZaKjNnXPlF+8B20f3+SFezjP0sRuMssyinXm3HhGehFKFeSWMZEI78MMZ7jB2tTNBQ==", + "source_artifact_sha256": "40933d309a18fba8094517dfd195dd4feea0486e031db26f66ff09699477bda9", + "verified_at": "2026-08-18T10:12:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "fdad940f245d690750ad647fac25c7e76aac2f474db49732fec8129051750186", + "attempt_id_sha256": "940d3ca125ff87ce7539740fbae29d2d64fec839328b0639127e1d197d2485d8", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-01", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "fc34b2087c0ac5df3a7283f31412b0a354de6d6f9a21946e56ad9f8cd42edfd6", - "facts": {}, - "run_id_sha256": "3739043a92a8781376cfbd022460c03aba40f92a800b3885ebc046321437bc40", + "condition": "healthy-02", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "40933d309a18fba8094517dfd195dd4feea0486e031db26f66ff09699477bda9", + "facts": { + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "40933d309a18fba8094517dfd195dd4feea0486e031db26f66ff09699477bda9", + "source": "runner_signed_flow_report_and_enforced_egress_policy" + }, + "operator_intervention_ids_sha256": [] + }, + "run_id_sha256": "bbb9312ce4682b23580eced0f8d19438d8266b222555df85fb27eef22ad5afe2", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "absent", + "trial_index": 1, + "verdict": "verified", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "7955935e031e774f701302635fe41d80f3cb44696a61234b7849200d253a24e3": { + "892e05f5233be53abbedfeb5c739f527a72cd00aa5588b7cd85b38d79e3be395": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-d7e1e084be213b01", "receipt_type": "observer", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "0EkXqS+k8l6ufSZ3LO3u2cc13k4+LmkOmL70V5VdnES5v3i7goAT7IglUqvqX0BAlWt7SRC9/FjMTyAO0Fo6CA==", - "source_artifact_sha256": "237359293198c0bcf55e931c23b25d4af0950bb1488672f69a6d6260eb2aee06", - "verified_at": "2026-08-18T10:02:00Z", + "signature": "hMuGl0gfuwsLAgVK0PG1eLb30JBGe2z+ex09dSX5fHFwlBEXJJ+Y/mju6OHavYal4VkQ8ly4RG+qODTbvoYzBA==", + "source_artifact_sha256": "a71340e07f39ce3002adc89f5435ab9eade0ea3cf1426a1e7905df87ae659b41", + "verified_at": "2026-08-18T11:12:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "679af5a8dedceb8c696719e73f82a698c230cd8fc98bb61769f0883202c0b637", + "attempt_id_sha256": "f5e96a2e9a580376b18beabf57798b8761e772a0c4d112877045780bb12b3720", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-01", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "237359293198c0bcf55e931c23b25d4af0950bb1488672f69a6d6260eb2aee06", + "condition": "verifier-unavailable", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "a71340e07f39ce3002adc89f5435ab9eade0ea3cf1426a1e7905df87ae659b41", "facts": { "derived_classifications": { "collateral_effect_count": 0, "duplicate_effect_count": 0, - "intended_effect_count": 1, + "intended_effect_count": 0, "wrong_record_count": 0 }, - "dispatch_state": "dispatched", - "effect_inventory": [ - { - "effect_id_sha256": "07635412bdd073f2f53c0be32e8df7b16940124d3693645e5af379b76ecebbc1", - "record_id_sha256": "22bafa5f842de0c2269205fd3478833f83c5c6f54d0066a5af6b89940f1564e9", - "transaction_ref_sha256": "7ac0c694e5cb88e5efd44ea972cad8449b7292b86e10a54bba4982f8e26078a4" - } - ], - "expected_record_id_sha256": "22bafa5f842de0c2269205fd3478833f83c5c6f54d0066a5af6b89940f1564e9", - "expected_transaction_ref_sha256": "7ac0c694e5cb88e5efd44ea972cad8449b7292b86e10a54bba4982f8e26078a4", - "post_state_evidence_sha256": "5a7aef9cfd51033988dd21227fdbc210ca4c54128fa825521f5d56ad71f4ae44", - "pre_state_evidence_sha256": "03f1c91bf767df95663ac91cb91323fe712c1f5284c789c96ad65f5f94d1c090", + "dispatch_state": "not_dispatched", + "effect_inventory": [], + "expected_record_id_sha256": "37b0146870f3d4a319e6446186a285fb632a6f9637d720bcb3139d9fcccd8775", + "expected_transaction_ref_sha256": "04b62fe444529c82e87c0c6d030a1e5674582f4a9fae517882d53328ce0bb12b", + "post_state_evidence_sha256": "7698e71e3b5a9851a6b4d850d356966517b9680e9d65ef611cf9fcfdc97b1c3e", + "pre_state_evidence_sha256": "82d7a352f0e35fce89e927fb469da061cffdde4bcb91098e725ac7a75e9fd266", "verifier_method": "read_only_system_of_record_query", "verifier_tier": "independent_system_of_record" }, - "run_id_sha256": "0b5bda916a0808165159166955a9563cf9c2303949f762a18eb037f41b44a6dc", + "run_id_sha256": "e8e89651045a5f5c011c9543ed968e0fe7697a061ed8ad5cedc27d194cb96acb", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, @@ -3574,83 +3645,52 @@ "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "7b0b7f71536e3d63e9f66ed1e0e47efcb78cd4930e486371ce40dd82d114d035": { - "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-138dfa227234ea5f", - "receipt_type": "cleanup", - "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "KGQFNk/YqfiRFiyNIXKD7YR+xk/7reXclP5r8SzizCAlmssPB5y2JLrqoHVpuFne//WnB1/am3X5ZY37Rzi5BA==", - "source_artifact_sha256": "9003f18eed9ca02f5288ee8e9b498e2a7792375249a68b2444ff5d147b9c24d2", - "verified_at": "2026-08-18T10:12:00Z", - "verified_projection": { - "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "940d3ca125ff87ce7539740fbae29d2d64fec839328b0639127e1d197d2485d8", - "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-02", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "9003f18eed9ca02f5288ee8e9b498e2a7792375249a68b2444ff5d147b9c24d2", - "facts": {}, - "run_id_sha256": "bbb9312ce4682b23580eced0f8d19438d8266b222555df85fb27eef22ad5afe2", - "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "task": "execute-acceptance", - "trial_index": 1, - "verdict": "completed", - "workflow_version_id": "44444444-4444-4444-8444-444444444444" - } - }, - "7bd04520d9af9cf9f2f39acffd0fda362dd5e762823fcc38102fb847a1b803e8": { + "8a166a11aa8642427f58ae8e9690bca1f58db1631d0b837ed72e79cb823267ef": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-d7e1e084be213b01", "receipt_type": "observer", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "UJtNwuagERerC/EaIJuY01IAn+JDchBLVbbyFMBkUjELua8sVWc+cBtha2glXTW95naJP4on3XmW3YwLWevxBg==", - "source_artifact_sha256": "a8a94089ae42720eff6c8154fd7ed91674171e6a51ac522db76f1d69704673d6", - "verified_at": "2026-08-18T10:23:00Z", + "signature": "DHMtZMNxJ7zgYhhZdPdYfded7yMN+u5Lrem4XY0DouyPx+HFef3bMo6utiUgHYrSfzupKUEStzaPyem+/gjmCA==", + "source_artifact_sha256": "24e69a5639acfa91d8833695390d6df6885bdfd9c998f69d8042b203ac41fade", + "verified_at": "2026-08-18T11:14:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "2601335b1101424105277997a67850a8a60aa45f59637b7679c1f32af463c460", + "attempt_id_sha256": "ad76dacfe19a4421ef1f128d4eef1099e846b385d29f17b8588ae5130b487118", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-03", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "a8a94089ae42720eff6c8154fd7ed91674171e6a51ac522db76f1d69704673d6", + "condition": "verifier-unavailable", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "24e69a5639acfa91d8833695390d6df6885bdfd9c998f69d8042b203ac41fade", "facts": { "derived_classifications": { "collateral_effect_count": 0, "duplicate_effect_count": 0, - "intended_effect_count": 1, + "intended_effect_count": 0, "wrong_record_count": 0 }, - "dispatch_state": "dispatched", - "effect_inventory": [ - { - "effect_id_sha256": "4cb3b1b2bddf9bab2ecc70f350793a5c08d1ef6995f03d83613414232aa67915", - "record_id_sha256": "376b86277507af8309dd9c7ee34843c68aa8000b6cb6246f3df9311e1a157a57", - "transaction_ref_sha256": "a8dcbf41043fdea74256844cddce6df4cb244c53ad6021edac20c136e24f7ffe" - } - ], - "expected_record_id_sha256": "376b86277507af8309dd9c7ee34843c68aa8000b6cb6246f3df9311e1a157a57", - "expected_transaction_ref_sha256": "a8dcbf41043fdea74256844cddce6df4cb244c53ad6021edac20c136e24f7ffe", - "post_state_evidence_sha256": "d186e527afc60846f97057220efa366ccf99dc2bf1c32e246bc947602bce5487", - "pre_state_evidence_sha256": "a7b5943eb7e95bc4d94fc9bdf6bb5650e69e23b75c5d1a0a1abc572fdc20060c", + "dispatch_state": "not_dispatched", + "effect_inventory": [], + "expected_record_id_sha256": "15667bd46a6b2a68c33d091a7cdb820efc8c7bc525b84a19df86f11a4b15c348", + "expected_transaction_ref_sha256": "8c2fa32d2ef5dc92756e014ebd4047b72f071156d39dd5040118ee69acf9a0fa", + "post_state_evidence_sha256": "1568879b7f568dd40270fdacb3a76a253577307b7f8c522c02e19b4d1656a6b1", + "pre_state_evidence_sha256": "e7aa4d479e6a7046141e1a00904cac2d9c2ba674e0754c47be79418161b8f1bf", "verifier_method": "read_only_system_of_record_query", "verifier_tier": "independent_system_of_record" }, - "run_id_sha256": "237a0b7d1cafb64b1d113dca6699e6eefeaaf0b18679138545c3695495b901d5", + "run_id_sha256": "87014cd8063f5a43ea22c995be03ec41ef5aa613145acacdef71b68c468fc8f1", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, + "trial_index": 3, "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "7d63a530b52e8faf6e3476894739e626da62bc5df1ccbe74ee9645b7fc8ef05a": { + "8a53a6788a7e538654cc1512c401949e5fbfd9a44cc4b7e86ac235ab702d35f9": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", "receipt_type": "webhook", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "+GlFwk7708zu3wylnNfsZTtQbzA1lWwbuJtx7ske1ujmOoO+DprqArGh3ZB6A88s4OMsmxRjHyk2V293RPwkAQ==", + "signature": "3nSbdT/O0Nhl3FPPTsWfZEsU+xxhcnxXD5tUQZqJT8PT+EIZkER/d0lJZTIi7fx3Be+X6wLR/q43EJ9xOM8bDg==", "source_artifact_sha256": "b6355ed63a5d7f1df450f75bb77fdcf81321616662fe3728a6da23d2a8957ce5", "verified_at": "2026-08-18T10:34:00Z", "verified_projection": { @@ -3659,7 +3699,7 @@ "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "idempotency-replay", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", "evidence_sha256": "b6355ed63a5d7f1df450f75bb77fdcf81321616662fe3728a6da23d2a8957ce5", "facts": {}, "run_id_sha256": "3df83453126754a62d00ed10837720542d0469799bb8a88cb5257ac5f477a919", @@ -3670,87 +3710,47 @@ "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "7ed9cc546bbca6006bf1cde43b11ded649bc2f080ffbf74b3e820d8775e05170": { + "8abeb7be0161592573418934ec1635b2461315692b4b18164ff0b0cc9eccf479": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d7e1e084be213b01", - "receipt_type": "observer", - "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "qhtsaGBUWRD+mPkXZrb68dk//dJOZPFvCRjWlXz+o6t2yFZ5yfu6ieCqpHUNioI05K+xrR03heLup2a6NJhKBQ==", - "source_artifact_sha256": "7742811fd54dc2fb2b1336f83c65918fcb116f4cf437d0246c2095228d61249a", - "verified_at": "2026-08-18T10:42:00Z", - "verified_projection": { - "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "e93521e706ad90d799dcd4e8cac15229c5da6aec1638540606f5fab4efce59fc", - "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "wrong-reference", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "7742811fd54dc2fb2b1336f83c65918fcb116f4cf437d0246c2095228d61249a", - "facts": { - "derived_classifications": { - "collateral_effect_count": 0, - "duplicate_effect_count": 0, - "intended_effect_count": 0, - "wrong_record_count": 0 - }, - "dispatch_state": "not_dispatched", - "effect_inventory": [], - "expected_record_id_sha256": "2d1f4e51a934947a53e829f1608e93181d2cd4c7b9c24394cfd615713fc3c6be", - "expected_transaction_ref_sha256": "098205ce5255fe5150c178cd23e88274085b7dcd77c3eefba408633c996c4897", - "post_state_evidence_sha256": "ab3889d4bf86da6e33192c3de9bda5de4ff596bb0c04a4e581e834e95ec60bda", - "pre_state_evidence_sha256": "8b14b2452165cda2d8b0053c956b6bfa60abf5a6935b7e98f4b549fad3ca055e", - "verifier_method": "read_only_system_of_record_query", - "verifier_tier": "independent_system_of_record" - }, - "run_id_sha256": "ee82112f55e5e6c86cfd6e16df8c8b652549a8bd72de492f435d8255eb3dd252", - "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "task": "execute-acceptance", - "trial_index": 1, - "verdict": "satisfied", - "workflow_version_id": "44444444-4444-4444-8444-444444444444" - } - }, - "7fb90d2da8912d351338ac30b3136cfae35c3cfcb21a1be3cefe268eb732696c": { - "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "0Q0nLVYKU9+1BbZRVNlX3VV9quImn7rhfc0+rj44JYMjFHq++/xMnzHty9D4dnWOh1RPkDD+mMR5FcMSVbBvBQ==", - "source_artifact_sha256": "12e1cf402efb1b543738dbf0096014533d4c1324c94e1af43a90e76c161e34d4", - "verified_at": "2026-08-18T10:04:00Z", + "signature": "GcDn4Tx11AZI67aJyhcmP6VoimL4ZJE6Ra1rgrOpyulFYB6WbR80L9jo5W60g7lquDyFnhjPPX3ej3FY7kFnAA==", + "source_artifact_sha256": "05601e1e28046d813b5d1fc7fc6f90292c7397fe2bfacb1b27e302242c388659", + "verified_at": "2026-08-18T11:14:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "4c352a6999f77707e8837adebb4fc2b7451c2ef6de5145190b33a5c5645e47eb", + "attempt_id_sha256": "ad76dacfe19a4421ef1f128d4eef1099e846b385d29f17b8588ae5130b487118", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-01", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "12e1cf402efb1b543738dbf0096014533d4c1324c94e1af43a90e76c161e34d4", + "condition": "verifier-unavailable", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "05601e1e28046d813b5d1fc7fc6f90292c7397fe2bfacb1b27e302242c388659", "facts": {}, - "run_id_sha256": "4ee2bb61fb883cc8e77d636fb471aa3c0ce9ef0c0a8abd9682214bf0a8f16f26", + "run_id_sha256": "87014cd8063f5a43ea22c995be03ec41ef5aa613145acacdef71b68c468fc8f1", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, - "verdict": "delivered", + "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "83a40647d6d151da844fcff4f96c40516ee57ceae72f370078106244e2efb750": { + "8c30814ef7ae80cf5d940cc3a2850d248027e7db11ed074e7a893cc95a8984c3": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", "receipt_type": "runner", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "0MiRpRLNXpVDdCYYbFsJ8jep/E8nBPkB5VVJvmvl2HA8YfqGSGPLgBlpcla4TwAPn/eZvAzbIV1ojbqzn55lAg==", - "source_artifact_sha256": "25166ea6bdc49a633c232781e8ef3511a9a11ef23e033b141c9a8ec8cb3f6834", - "verified_at": "2026-08-18T10:54:00Z", + "signature": "BPRaA1pB7JlHP5DZY5cHw5mJJYg+POltL7L748x4fFrGzcD5DqvvLytRZ6/fqvfj1jTa/nkBs3Zb9n5JE2jlDQ==", + "source_artifact_sha256": "6fe2828f0849b15893e440cf5a75e8cb3040f255c8d6d99adec885362da6f9c5", + "verified_at": "2026-08-18T11:22:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "958342a9ddca98a83b82b662f52f404239d583afe7ed70634760e1b8dd592f3b", + "attempt_id_sha256": "73a097b8b20bab7794369384f7ca1d7d711aad07967b7e1292373babbb7ff1b7", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "stale-session", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "25166ea6bdc49a633c232781e8ef3511a9a11ef23e033b141c9a8ec8cb3f6834", + "condition": "weak-effect-only", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "6fe2828f0849b15893e440cf5a75e8cb3040f255c8d6d99adec885362da6f9c5", "facts": { "model_call_counter": { "attempted": 0, @@ -3761,110 +3761,174 @@ "input_tokens": 0, "output_tokens": 0, "provider_models": [], - "report_sha256": "25166ea6bdc49a633c232781e8ef3511a9a11ef23e033b141c9a8ec8cb3f6834", + "report_sha256": "6fe2828f0849b15893e440cf5a75e8cb3040f255c8d6d99adec885362da6f9c5", "source": "runner_signed_flow_report_and_enforced_egress_policy" }, "operator_intervention_ids_sha256": [] }, - "run_id_sha256": "6f2fb10bc2018c9f78e9702d5ccac0bedd78ee3b2e9d2a6ad779fba72d90ae50", + "run_id_sha256": "b44783e70a980ec5b3cf3752bd5d1d01b2ff29f5a6892cba0c1c939d8aeb7c02", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, + "trial_index": 1, "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "84070f921aa2358567527d3ec76d99bad2dd8b589b8c908bde0f717f266ad696": { + "8d6cd13595cc62db5abf7d5b868ef4662660977e235bb3c49ea6cc607eb6137f": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", + "receipt_type": "fault", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "FzPTo2wSexHv1cUQt8TlNW4cTT7h6tdp3pNoLWak3C5Pe3jaQTM/ZJXHwq9WVtWGQZuB8tduQ+fPSKqFfp/fCw==", + "source_artifact_sha256": "d80e5faa489be940291e74948facb9a38c3f6ce34fbe6fb5c586b966e5c82228", + "verified_at": "2026-08-18T11:12:00Z", + "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "f5e96a2e9a580376b18beabf57798b8761e772a0c4d112877045780bb12b3720", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "verifier-unavailable", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "d80e5faa489be940291e74948facb9a38c3f6ce34fbe6fb5c586b966e5c82228", + "facts": {}, + "run_id_sha256": "e8e89651045a5f5c011c9543ed968e0fe7697a061ed8ad5cedc27d194cb96acb", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "injected", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "8dbfb683596b52b2263a3cc9a97148b7d4787eb0e7780d71e3349c4d2cac8dd4": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", "receipt_type": "webhook", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "cSyqgHGEZBvBF+LhpkWsJ4cdfTWtXEYRYiGbAhPj/W/EwIRTtec06NH+ONwL6Ugakk/CIpUnNyMo2AtcbT1yDA==", - "source_artifact_sha256": "841ebd8beb38baf63b1ce9c65d1f22d80a15e36e268eab7f019f063c7242ce9e", - "verified_at": "2026-08-18T10:12:00Z", + "signature": "pZeQLyMghBBdyHMJS2HAbCRzR8mCIL4ulRO8zWVH7XweLTGW80VuWapzHpliB4suakCcmMq9CT9KCFMc58O8BQ==", + "source_artifact_sha256": "e8401afc508900868571caae7995d9771884b1f6faac3543a13bc77ce498c1fd", + "verified_at": "2026-08-18T10:03:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "940d3ca125ff87ce7539740fbae29d2d64fec839328b0639127e1d197d2485d8", + "attempt_id_sha256": "fdad940f245d690750ad647fac25c7e76aac2f474db49732fec8129051750186", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-02", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "841ebd8beb38baf63b1ce9c65d1f22d80a15e36e268eab7f019f063c7242ce9e", + "condition": "healthy-01", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "e8401afc508900868571caae7995d9771884b1f6faac3543a13bc77ce498c1fd", "facts": {}, - "run_id_sha256": "bbb9312ce4682b23580eced0f8d19438d8266b222555df85fb27eef22ad5afe2", + "run_id_sha256": "3739043a92a8781376cfbd022460c03aba40f92a800b3885ebc046321437bc40", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, + "trial_index": 2, "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "84e5195b0a66b7c41b3bd1424059ba26346faa8012fc4ab9d569e108e3553615": { + "8f202eff0bbb187e9a61ca28eba51b60540b7de0e437ff036eea34c416bc8418": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "CIth4iY2GxRop9zRmBY2Atv+1ZGlP5/uW/VspodSv/65rbJOZ5Icy6qedHQlAA0RmoVWYRDfgjKgCWAKg8noBw==", - "source_artifact_sha256": "f8152ccb0471b92317861ddb7fabeae5fcf740530b8b050510e29e1da130d3e3", - "verified_at": "2026-08-18T10:22:00Z", + "signature": "xTnz3J7Lp9HiKAZ5Qh4HvBU4C1cwD/EN2gUhmfEM8gZ4pl7I/r91BtMRlae741XNjJBCoE+VwUGzGW3tvN1/Cw==", + "source_artifact_sha256": "7d36fcea2384b6bb28044bc68847492fefb2783909042a96f6416cc457c258c6", + "verified_at": "2026-08-18T11:02:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "fc097c8b2e6ece94544a19b8d81f5c4a9367a89059e3dd4b2f746ab06a2fc930", + "attempt_id_sha256": "60ee9db05b1126cfaa3b31c13bc3fab4755ac09c44e846b4d07ee51865dfa7b1", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-03", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "f8152ccb0471b92317861ddb7fabeae5fcf740530b8b050510e29e1da130d3e3", + "condition": "ambiguous-target", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "7d36fcea2384b6bb28044bc68847492fefb2783909042a96f6416cc457c258c6", "facts": {}, - "run_id_sha256": "28768f565659133f5bf1170e638b81de4d7ca38dfecacd09ccf462a35344432b", + "run_id_sha256": "628f991a182613b8700294d7483b5a4c06872cb9d5ca6047ea552b8ab6585357", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "delivered", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "8f4f18d06faedba5e1d8644e0014528818b79fff8c944bc88b0b452784ee2ce1": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "l+xG7XBp5DdGu81BCIaSnZH3vpDK0oU5CiZ3JX6R9l6Cdxc5TXyrYto6fzwbg0NDapgswpZVSlwCSVKCel2+AA==", + "source_artifact_sha256": "e1dd07c3df4aed8ff42376ff74a3f68c13ebb7fb509304a544b0e8bde5b1f4ed", + "verified_at": "2026-08-18T10:02:00Z", + "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "679af5a8dedceb8c696719e73f82a698c230cd8fc98bb61769f0883202c0b637", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-01", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "e1dd07c3df4aed8ff42376ff74a3f68c13ebb7fb509304a544b0e8bde5b1f4ed", + "facts": { + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "e1dd07c3df4aed8ff42376ff74a3f68c13ebb7fb509304a544b0e8bde5b1f4ed", + "source": "runner_signed_flow_report_and_enforced_egress_policy" + }, + "operator_intervention_ids_sha256": [] + }, + "run_id_sha256": "0b5bda916a0808165159166955a9563cf9c2303949f762a18eb037f41b44a6dc", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, - "verdict": "absent", + "verdict": "verified", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "85e7b8b6b58819ab3b4574721e4263084e66b3a3aa505c1a0d5fe04e5df8cda8": { + "9153aff7978db8adadbd8fd7ffd462d72c487ab458e8ccfd385712722acc256f": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "Jqtj6q3UaBtetU/qaQ3cGM+wByza3Fp+ouKQZDYCyAr5hDrBRRcvoQO55Lxt2k10JVubrc7YkP0tjNj56tFQDg==", - "source_artifact_sha256": "67d2fc6cdd3fbe39ae3cd6003edb1e7069940afea7f0c3b00794713d26646677", - "verified_at": "2026-08-18T10:13:00Z", + "signature": "3fg6pTkn5K0+9xZG2AgP/yki9jKjetcOhNk/lqulcedIX8Wr34p8l1bFOWOfg8nM4yz05mjqyVYGpC2EiZ/ZBQ==", + "source_artifact_sha256": "c2fe1abfc1e16a5382ce8eaf67f3774f713d586e6aefe6a00783455dceae530d", + "verified_at": "2026-08-18T10:02:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "3d42601a69ef46cc44f57b51762affef4ccd829ffde30125619a6e582af00dab", + "attempt_id_sha256": "679af5a8dedceb8c696719e73f82a698c230cd8fc98bb61769f0883202c0b637", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-02", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "67d2fc6cdd3fbe39ae3cd6003edb1e7069940afea7f0c3b00794713d26646677", + "condition": "healthy-01", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "c2fe1abfc1e16a5382ce8eaf67f3774f713d586e6aefe6a00783455dceae530d", "facts": {}, - "run_id_sha256": "091e13ed70dab439b31cb506cf3bba1ddf6476696531cf891c39a924a928b7a1", + "run_id_sha256": "0b5bda916a0808165159166955a9563cf9c2303949f762a18eb037f41b44a6dc", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "delivered", + "trial_index": 1, + "verdict": "verified", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "86565ed67acb88cd35e0a34cf2639b54eedf257f0391a7fcaa9ecc29b98fd533": { + "91f0b4623e063b41aebdd6454810950e8ae05b8f33422268de99a3aa158705b7": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-d7e1e084be213b01", "receipt_type": "observer", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "m8dGgS6Rg617uu+O2FK4f2UOOboIiGEQq1WWKdN3KyXTPGYnurXMGu78ZCxO6xZ42vVg04ZptYgVYYYbG902CQ==", - "source_artifact_sha256": "e92cda8b4f49cc4af5827dbf65d991b60d7bdb9a894000c57505f7fe072616ce", - "verified_at": "2026-08-18T10:14:00Z", + "signature": "psZtxwbU0MgsP/g45tLfbJFHT53Bz+yYYANykOR1lyDJn0AOXvOWkjt/X/R+/r/Yxq8NWsCk/MCmLQ6YVdcIDg==", + "source_artifact_sha256": "f4e30b79fe5403ce13c6b1b63149637b35847c5bb37a7e923317e0cb11fdce22", + "verified_at": "2026-08-18T10:33:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "019dd96e9a771ccc01ebafab321d7d3a8314df8b2d6465bcfc5fa14cbdeabdf2", + "attempt_id_sha256": "4667302b580ff7ceb223dbb15eb6d029969a8f6a54bcd33e8df5b6bff41f41ad", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-02", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "e92cda8b4f49cc4af5827dbf65d991b60d7bdb9a894000c57505f7fe072616ce", + "condition": "idempotency-replay", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "f4e30b79fe5403ce13c6b1b63149637b35847c5bb37a7e923317e0cb11fdce22", "facts": { "derived_classifications": { "collateral_effect_count": 0, @@ -3875,81 +3939,92 @@ "dispatch_state": "dispatched", "effect_inventory": [ { - "effect_id_sha256": "d5f1622c2956d2563fb993ded150f7a36e0a79b51f070beec032b8bb5acab8a2", - "record_id_sha256": "168a687e3fd8fbed76d59d0f70899eab30f82058098fc47ba24a1d253c425d62", - "transaction_ref_sha256": "bf754d98ea2b40b05ef93a4212b0285b205b20e9d30b402bc9fdeae969a8503a" + "effect_id_sha256": "3de74331383c83b299c3122cdd26ec8f11285c4bf933b8a7fb07fbacab6fa222", + "record_id_sha256": "f937550eaf086105b0c0b3bd09d88c72b16eadd01378e96a650960491e50bbb1", + "transaction_ref_sha256": "dc78636b2afb08f287cc1754e616ac46e228aa478a330e9c914e90c55bfa795c" } ], - "expected_record_id_sha256": "168a687e3fd8fbed76d59d0f70899eab30f82058098fc47ba24a1d253c425d62", - "expected_transaction_ref_sha256": "bf754d98ea2b40b05ef93a4212b0285b205b20e9d30b402bc9fdeae969a8503a", - "post_state_evidence_sha256": "bf2a04f127fef945d393aee65f6c924165667c723fcfd86b2073084b3b1fcd2b", - "pre_state_evidence_sha256": "8c1ec681950f04f1b3509f2a0add5b414c992fc27f3f9604378a7512ecdb510f", + "expected_record_id_sha256": "f937550eaf086105b0c0b3bd09d88c72b16eadd01378e96a650960491e50bbb1", + "expected_transaction_ref_sha256": "dc78636b2afb08f287cc1754e616ac46e228aa478a330e9c914e90c55bfa795c", + "post_state_evidence_sha256": "d0d8ebe302f92064c831e89e995d7b53b02e7814a5b9314715f4144e06536451", + "pre_state_evidence_sha256": "8ddef5d347d9382ea81a6b68f1475284a4383cc8341fd3104a762695ffc2f97b", "verifier_method": "read_only_system_of_record_query", "verifier_tier": "independent_system_of_record" }, - "run_id_sha256": "16cb8df40654c6a1b55ea0e50e772d8c6e6d4f0d8205bd1f8296be27d0af83eb", + "run_id_sha256": "33e0ad9bf64e477f24d46508fa432123e046dcd1c5853d5cc60b7cde1bce7537", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, + "trial_index": 2, "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "873af0327d6a3360731e326c236f2b05e1220aa18a00a83d0c42b6d5012f0c08": { + "92d93cf5b7ac9046291713d0ec627b75a2f48c7863677f2255f2b890e2c68c8b": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", - "receipt_type": "runner", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "02hXX7MYoTXKHF6UfLrnw6/xSk+aQDIr+U6EtC5WOPVLTFF3I/Qgml4YIBRLzgcqx0PSH286g+BtP1an+evHBQ==", - "source_artifact_sha256": "a19b4b67cbeff4e08ebe9a0818d950e8d1ebeec5dec837efe97635b5fb541ea0", - "verified_at": "2026-08-18T10:52:00Z", + "signature": "TZTW/03/+qM+KDnu8oQDK8GRNaekZztDcu3poIXdOCWHbjeGob0IF+EGVCX3EHTUbfvtqG2rIWTEsqPz8fTOAw==", + "source_artifact_sha256": "f48a35f45e70951886d40904c131ba517e46acb12368169e31b1c47de7ee6a8c", + "verified_at": "2026-08-18T10:12:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "fbfce2be9ce964be8b668aa518a310fe4a89e5c014f42bd0ea81401bd83bfd7a", + "attempt_id_sha256": "940d3ca125ff87ce7539740fbae29d2d64fec839328b0639127e1d197d2485d8", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "stale-session", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "a19b4b67cbeff4e08ebe9a0818d950e8d1ebeec5dec837efe97635b5fb541ea0", - "facts": { - "model_call_counter": { - "attempted": 0, - "call_ids_sha256": [], - "completed": 0, - "cost_microusd": 0, - "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", - "input_tokens": 0, - "output_tokens": 0, - "provider_models": [], - "report_sha256": "a19b4b67cbeff4e08ebe9a0818d950e8d1ebeec5dec837efe97635b5fb541ea0", - "source": "runner_signed_flow_report_and_enforced_egress_policy" - }, - "operator_intervention_ids_sha256": [] - }, - "run_id_sha256": "d9270fd4c85e4226a9347ecf703e876b9ffdc330f60c7fb8bed8f9321ea30225", + "condition": "healthy-02", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "f48a35f45e70951886d40904c131ba517e46acb12368169e31b1c47de7ee6a8c", + "facts": {}, + "run_id_sha256": "bbb9312ce4682b23580eced0f8d19438d8266b222555df85fb27eef22ad5afe2", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, - "verdict": "halted", + "verdict": "absent", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "93baab109d6523059e7d4a73e9d1fc956a9044e9db22d1cad206bedfd3103cae": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "Cw6t5+0hnUUma2YKq4hxNG4c0a5qX9UHSRefERiYhhCc5DnWS/MtqkhxEJ7hXq7lbhXmt5x2j4LuOE03PugjAw==", + "source_artifact_sha256": "c68ae5d22981662c17338c01af40177a0e375c993c4e4dcefc9aaf4df2d5366d", + "verified_at": "2026-08-18T10:23:00Z", + "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "2601335b1101424105277997a67850a8a60aa45f59637b7679c1f32af463c460", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-03", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "c68ae5d22981662c17338c01af40177a0e375c993c4e4dcefc9aaf4df2d5366d", + "facts": {}, + "run_id_sha256": "237a0b7d1cafb64b1d113dca6699e6eefeaaf0b18679138545c3695495b901d5", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "8a046aaef8eff4fe4e86a69ef8ef2c0b035131876b0628a7fd6258cc34f1976b": { + "93f8813fd20e587ec1a7c00d318bb5e4267292d2d46f25dda70486cc3204e082": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", "receipt_type": "runner", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "7vw7ezzX6lGrP6XwV1ZXe8OOZSzARBB4fopfIySIyBuihKPN9qCpHND0ybUn3UA+Gg/E+pX72bMgFCfDk0BIBg==", - "source_artifact_sha256": "6fe2828f0849b15893e440cf5a75e8cb3040f255c8d6d99adec885362da6f9c5", - "verified_at": "2026-08-18T11:22:00Z", + "signature": "WWx6BMWzZhU250wY4f5dQgdUfWoX/lnlTasnKEdtVAHsq6YbKZwoeIxuEus+aHyuA7jAI3iaRvcqCFkAF4VyCg==", + "source_artifact_sha256": "d216e429bd0611ac65b285ab73297d037fa3aeb3adb76d299da0c91d2559f159", + "verified_at": "2026-08-18T10:42:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "73a097b8b20bab7794369384f7ca1d7d711aad07967b7e1292373babbb7ff1b7", + "attempt_id_sha256": "e93521e706ad90d799dcd4e8cac15229c5da6aec1638540606f5fab4efce59fc", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "weak-effect-only", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "6fe2828f0849b15893e440cf5a75e8cb3040f255c8d6d99adec885362da6f9c5", + "condition": "wrong-reference", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "d216e429bd0611ac65b285ab73297d037fa3aeb3adb76d299da0c91d2559f159", "facts": { "model_call_counter": { "attempted": 0, @@ -3960,12 +4035,12 @@ "input_tokens": 0, "output_tokens": 0, "provider_models": [], - "report_sha256": "6fe2828f0849b15893e440cf5a75e8cb3040f255c8d6d99adec885362da6f9c5", + "report_sha256": "d216e429bd0611ac65b285ab73297d037fa3aeb3adb76d299da0c91d2559f159", "source": "runner_signed_flow_report_and_enforced_egress_policy" }, "operator_intervention_ids_sha256": [] }, - "run_id_sha256": "b44783e70a980ec5b3cf3752bd5d1d01b2ff29f5a6892cba0c1c939d8aeb7c02", + "run_id_sha256": "ee82112f55e5e6c86cfd6e16df8c8b652549a8bd72de492f435d8255eb3dd252", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, @@ -3973,38 +4048,38 @@ "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "8aec61997da4bb5f9445dd4625b2d07f5a94688dd77d182d32b47cc064f12902": { + "942df1c36be1e8d4d82b0b70b1c719a1e01853dc3a8bd76e703d0ddd57b88ca3": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "EgxW23N8XFlNNn1mYd+idnIeYbcbScVNTGa1JrlgEkSQFXnVNBEhy9gkOxss1ZQCazkYtVU8XV2yOJASyJinCg==", - "source_artifact_sha256": "7cfb7c321bd76fc1bf31a8453b02adde00c9bde35f22ce38726f169660f2b323", - "verified_at": "2026-08-18T10:23:00Z", + "signature": "KjLgcWes2nP8tOPU6sIzeSdPrhYzjxnKGRegjnvF5JmQaCDTDcx44lxg0BuwTIsN848M1Ne9oJbyOa05fHmfBg==", + "source_artifact_sha256": "82e77fe44a201615e8f4c27505e4418bc71c0e4706dbe79be35ff085e812e4ad", + "verified_at": "2026-08-18T10:02:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "2601335b1101424105277997a67850a8a60aa45f59637b7679c1f32af463c460", + "attempt_id_sha256": "679af5a8dedceb8c696719e73f82a698c230cd8fc98bb61769f0883202c0b637", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-03", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "7cfb7c321bd76fc1bf31a8453b02adde00c9bde35f22ce38726f169660f2b323", + "condition": "healthy-01", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "82e77fe44a201615e8f4c27505e4418bc71c0e4706dbe79be35ff085e812e4ad", "facts": {}, - "run_id_sha256": "237a0b7d1cafb64b1d113dca6699e6eefeaaf0b18679138545c3695495b901d5", + "run_id_sha256": "0b5bda916a0808165159166955a9563cf9c2303949f762a18eb037f41b44a6dc", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "absent", + "trial_index": 1, + "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "914f5d551d662ec06a7dd8f330bd5256cf317ed0d280fe1da10fdb296c9e9b5f": { + "966cc812c23ff6b11a0a6222f12c32a89fe0a2874a50afd756d52ace26fdbc9a": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "1u8xRYwU8p0xHXvQr1JVe95+Z8AacMPaY5tgnd1nDsytNlec0KlIQuF8sAmTCYyNHPVhhHlw6/wBRkBQh8c/Dw==", - "source_artifact_sha256": "6381975addf1b4ec60255f58a8d2ec052c169a3228310d84dc3954d444e76d0f", + "signature": "dQ1wTnGqN7wZULxA6I1JxmYosoYUi2eM77ZGHZMTQFIZiIz5iZ+crgQ4WAPaBdbcv+jbHL3GWDqlOQMh0i7HCw==", + "source_artifact_sha256": "2ae10ced05bdd00ae95b7a8d2893b178979ff8cf6d455c9e9fcf2596ecac18fb", "verified_at": "2026-08-18T10:32:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", @@ -4012,122 +4087,104 @@ "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "idempotency-replay", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "6381975addf1b4ec60255f58a8d2ec052c169a3228310d84dc3954d444e76d0f", - "facts": {}, + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "2ae10ced05bdd00ae95b7a8d2893b178979ff8cf6d455c9e9fcf2596ecac18fb", + "facts": { + "derived_classifications": { + "collateral_effect_count": 0, + "duplicate_effect_count": 0, + "intended_effect_count": 1, + "wrong_record_count": 0 + }, + "dispatch_state": "dispatched", + "effect_inventory": [ + { + "effect_id_sha256": "85bd45c21ceba0278062e4a705854e8e10526bc02ae78161394f25b4364eabf6", + "record_id_sha256": "0b1c6a0c1bb7de295f5b36891fd2b6b1edd16a9b926b3a24548d2374711a2751", + "transaction_ref_sha256": "e984028cb73b01ea87ff6063feeac5ec2136c993f8db59af4cb7956b44fd9c03" + } + ], + "expected_record_id_sha256": "0b1c6a0c1bb7de295f5b36891fd2b6b1edd16a9b926b3a24548d2374711a2751", + "expected_transaction_ref_sha256": "e984028cb73b01ea87ff6063feeac5ec2136c993f8db59af4cb7956b44fd9c03", + "post_state_evidence_sha256": "9fa1859d90e896d31fd6e3180e29b09b5b23e48beb0a87e10059798232a14f8c", + "pre_state_evidence_sha256": "8499492a906730830b1977c341eb8d1f7a825f8710231c6f9e615b1d1497d288", + "verifier_method": "read_only_system_of_record_query", + "verifier_tier": "independent_system_of_record" + }, "run_id_sha256": "6cdff0cf50d0164fe1eee9c4b7db0b969c24f9b960f5653b516313a913c90a0f", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, - "verdict": "delivered", + "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "932ee45a17ff8efd7ce9813d4b02db10de4b9020f03797a2ee56d95c5d517366": { + "97063a395176b12f541ebd423aa15347f5dfe018b77bfa1ee882140113d2a59e": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-e37abcd79efd08db", "receipt_type": "replay", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "tkuPgg8/Bbc1iQ/3JyNvo5w0SIK96+GPo87M7/I1+kqIVmuN1LWCcIOg6NwbPuEkyI0pymRo1FHIsNHe2xVSCw==", - "source_artifact_sha256": "1f77854e1846d96a3d4c187c4946e746d7139d3a025dbd5ede6e8a6ee6be2c40", - "verified_at": "2026-08-18T10:22:00Z", + "signature": "yjPkQ25GO9UPoblaVIdOmznMeLmBZ90lqBvKN9aexmuHWxe7N0tsZ2p0QVNLJAspSkkR6besb90d/XOja+BJAA==", + "source_artifact_sha256": "26eef6795405076a78c4a1d95d85251e7454d3059e296b07b2cf612e7b6231a2", + "verified_at": "2026-08-18T11:12:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "fc097c8b2e6ece94544a19b8d81f5c4a9367a89059e3dd4b2f746ab06a2fc930", + "attempt_id_sha256": "f5e96a2e9a580376b18beabf57798b8761e772a0c4d112877045780bb12b3720", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-03", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "1f77854e1846d96a3d4c187c4946e746d7139d3a025dbd5ede6e8a6ee6be2c40", + "condition": "verifier-unavailable", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "26eef6795405076a78c4a1d95d85251e7454d3059e296b07b2cf612e7b6231a2", "facts": {}, - "run_id_sha256": "28768f565659133f5bf1170e638b81de4d7ca38dfecacd09ccf462a35344432b", + "run_id_sha256": "e8e89651045a5f5c011c9543ed968e0fe7697a061ed8ad5cedc27d194cb96acb", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, - "verdict": "verified", - "workflow_version_id": "44444444-4444-4444-8444-444444444444" - } - }, - "93325b31e545651925604b95ea62b9327da8cb98905734f4925ca5d77aa5d1ed": { - "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", - "receipt_type": "runner", - "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "pk3fWzT8VLQJg/HkT+0sS7BfPSkR2fz7LSZi5QlPFpgaDh9D7Inel9EYambeiNkXZ93jYFR0zy0u7VbDmAuQAA==", - "source_artifact_sha256": "516ecd879cd6bf3ddce68daf59c204f277f8dc9c69b44e4aab5485a9563bb56b", - "verified_at": "2026-08-18T10:04:00Z", - "verified_projection": { - "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "4c352a6999f77707e8837adebb4fc2b7451c2ef6de5145190b33a5c5645e47eb", - "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-01", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "516ecd879cd6bf3ddce68daf59c204f277f8dc9c69b44e4aab5485a9563bb56b", - "facts": { - "model_call_counter": { - "attempted": 0, - "call_ids_sha256": [], - "completed": 0, - "cost_microusd": 0, - "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", - "input_tokens": 0, - "output_tokens": 0, - "provider_models": [], - "report_sha256": "516ecd879cd6bf3ddce68daf59c204f277f8dc9c69b44e4aab5485a9563bb56b", - "source": "runner_signed_flow_report_and_enforced_egress_policy" - }, - "operator_intervention_ids_sha256": [] - }, - "run_id_sha256": "4ee2bb61fb883cc8e77d636fb471aa3c0ce9ef0c0a8abd9682214bf0a8f16f26", - "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "task": "execute-acceptance", - "trial_index": 3, - "verdict": "verified", + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "93a820891c954075ce0f99539579a121345fc59129f8465a37c3937e401c5c7f": { + "970b7b84c37367a963760c209eada9f627004aef2e4c725901e48a995af58dd6": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-e37abcd79efd08db", "receipt_type": "replay", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "bR+QhRcOk4EBDKLjJz/pnIhaq4S/FgEIttGvPKgcbMx3qmKasgm7rFkPiHNN9e+x1mlEA/Qk2YJvs/hMwdxLAQ==", - "source_artifact_sha256": "63a797c26af0607f83fd33dbce35617c4061915381435f3fbbd782b3554c15dc", - "verified_at": "2026-08-18T10:13:00Z", + "signature": "dJmkchECGa83OnY7x4sfo8EyXCVPgacy/5DcrQhSJkebXSwfumrM8TuMP6MlhSSbc9GNTtNGxcSxYmVkgKfXCQ==", + "source_artifact_sha256": "2811b870f1234408f64ada1ddab6eb1a4160941d92a9f9df96df037d1da69536", + "verified_at": "2026-08-18T10:12:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "3d42601a69ef46cc44f57b51762affef4ccd829ffde30125619a6e582af00dab", + "attempt_id_sha256": "940d3ca125ff87ce7539740fbae29d2d64fec839328b0639127e1d197d2485d8", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "healthy-02", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "63a797c26af0607f83fd33dbce35617c4061915381435f3fbbd782b3554c15dc", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "2811b870f1234408f64ada1ddab6eb1a4160941d92a9f9df96df037d1da69536", "facts": {}, - "run_id_sha256": "091e13ed70dab439b31cb506cf3bba1ddf6476696531cf891c39a924a928b7a1", + "run_id_sha256": "bbb9312ce4682b23580eced0f8d19438d8266b222555df85fb27eef22ad5afe2", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, + "trial_index": 1, "verdict": "verified", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "94480255df8b3ebf0a824b340d666a28d5fff75dc3d668d6ed30b4c69d06590b": { + "9750eaae943a1633bae0501398d43b221c7ec4a552ef4ad604615427f14e4550": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", "receipt_type": "runner", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "6guxXkBYJx7whL3RpfwFeEQqUVXvR9jJfM/B/sBi/EYvaAAN9UVOlsqBHNV9jNVE950V69Feddml7dSEm1KrBQ==", - "source_artifact_sha256": "693c5de78792744df15509b8187bfaf3ec71a4d879011e9773e98d139b5d7856", - "verified_at": "2026-08-18T10:03:00Z", + "signature": "dXWnMVV4xezc+y9BzXe34yfDF0YHHRSjZ6DEkxyOM+myz7N4Crr2+eUHd0fhagtfL4FC3/spZvYJbZdvOu3sCA==", + "source_artifact_sha256": "5e9c28fdf8c09dcfbbefa41ca8075e7daaa783d6ef24d5050cc9973c6aacb810", + "verified_at": "2026-08-18T11:24:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "fdad940f245d690750ad647fac25c7e76aac2f474db49732fec8129051750186", + "attempt_id_sha256": "aa7d6be4f25a8992c0a22649ba7e703d6955abf5fece9f8322f560149cf09776", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-01", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "693c5de78792744df15509b8187bfaf3ec71a4d879011e9773e98d139b5d7856", + "condition": "weak-effect-only", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "5e9c28fdf8c09dcfbbefa41ca8075e7daaa783d6ef24d5050cc9973c6aacb810", "facts": { "model_call_counter": { "attempted": 0, @@ -4138,51 +4195,51 @@ "input_tokens": 0, "output_tokens": 0, "provider_models": [], - "report_sha256": "693c5de78792744df15509b8187bfaf3ec71a4d879011e9773e98d139b5d7856", + "report_sha256": "5e9c28fdf8c09dcfbbefa41ca8075e7daaa783d6ef24d5050cc9973c6aacb810", "source": "runner_signed_flow_report_and_enforced_egress_policy" }, "operator_intervention_ids_sha256": [] }, - "run_id_sha256": "3739043a92a8781376cfbd022460c03aba40f92a800b3885ebc046321437bc40", + "run_id_sha256": "b974de9da8ef77c8dc9a7662114cc51023ab8c131c488681eeebb7d4c435c8d0", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "verified", + "trial_index": 3, + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "95d12087d75ba87fd4915c47e5b83e12371fac79a045b1fd1ac7f778089a16ff": { + "97b41e4ab722b2046be90098c4daa16abe2a157b05235cc7d8dd4caebd66cbf4": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "mMwosfl1xK5ystPKMT167odFKgy0+P80y3BXd7xiY0UPfssVl3MAhntDfluQ22yNB6WUri5MFGdPnm6r06BYDA==", - "source_artifact_sha256": "5a3777b92fabc030635bb4f578eda746f0b307d541bf84a0099314eed54c8d00", - "verified_at": "2026-08-18T10:14:00Z", + "signature": "tStnZkaeSrkWzE5IJZtO/cmonu1B7UnBBawCwv3jqM6XzMgb+95A2VZAmG43AKKQcN5zRysj0EvNS8IsNxiTCQ==", + "source_artifact_sha256": "a28ad5edfe12f8c387974db36928b3aa5aa2bded20b70ce40baeea09eb16b8e1", + "verified_at": "2026-08-18T11:14:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "019dd96e9a771ccc01ebafab321d7d3a8314df8b2d6465bcfc5fa14cbdeabdf2", + "attempt_id_sha256": "ad76dacfe19a4421ef1f128d4eef1099e846b385d29f17b8588ae5130b487118", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-02", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "5a3777b92fabc030635bb4f578eda746f0b307d541bf84a0099314eed54c8d00", + "condition": "verifier-unavailable", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "a28ad5edfe12f8c387974db36928b3aa5aa2bded20b70ce40baeea09eb16b8e1", "facts": {}, - "run_id_sha256": "16cb8df40654c6a1b55ea0e50e772d8c6e6d4f0d8205bd1f8296be27d0af83eb", + "run_id_sha256": "87014cd8063f5a43ea22c995be03ec41ef5aa613145acacdef71b68c468fc8f1", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, - "verdict": "absent", + "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "960800964e484e67a3e76cdcc336b8b620f46d64b6fce87bdd6475c66097416c": { + "99742de45b63e3669313b1cd5df2f410fe373937cdb51d87c05ec816ef88ed00": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d7e1e084be213b01", - "receipt_type": "observer", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "EusYsr8DJKBRwi2FbjlRtR6EjSTcmb6hHB6FudNycpKGCNwTMHdhROQJi8Ri9Y4Yjsm4WummM192uTT2DLk6DA==", - "source_artifact_sha256": "58703c8fb721c8bd010e150d01acbc91a664c3273b9d1b85d945398148b6ff87", + "signature": "J5LlEcpdmj03vumD21tYQ0aEZL/lZtco8+4/dos42MZx5SdCoees9Ud0Fktrm0gRM8ITA/9AKlE6ov5A1k6VDw==", + "source_artifact_sha256": "5b97c09965f50b433ebd2e38459a56f0ae35537b2267b3e89faf7125ea0c2e25", "verified_at": "2026-08-18T11:23:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", @@ -4190,50 +4247,35 @@ "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "weak-effect-only", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "58703c8fb721c8bd010e150d01acbc91a664c3273b9d1b85d945398148b6ff87", - "facts": { - "derived_classifications": { - "collateral_effect_count": 0, - "duplicate_effect_count": 0, - "intended_effect_count": 0, - "wrong_record_count": 0 - }, - "dispatch_state": "not_dispatched", - "effect_inventory": [], - "expected_record_id_sha256": "21c651c545d2279507f7ddd513acee7961b4cb9e59e9738831b5b2a8bc1fae80", - "expected_transaction_ref_sha256": "822f722f5eb229e4240375407ed8896979fc5fea472542519de2a1525e020012", - "post_state_evidence_sha256": "26299f46a60d4c30304e365977a48f64fa8c8f64d408f804601a3153d2b058f4", - "pre_state_evidence_sha256": "9e0c1139ef3ee5b7e2f4e9d209ba561c244af89fc8211606a0698486ad47e930", - "verifier_method": "read_only_system_of_record_query", - "verifier_tier": "independent_system_of_record" - }, + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "5b97c09965f50b433ebd2e38459a56f0ae35537b2267b3e89faf7125ea0c2e25", + "facts": {}, "run_id_sha256": "794033f9da2a42448254a478fb6de954898b1e544148708ad30264efdc255431", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, - "verdict": "satisfied", + "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "96ebae402e023ee731b31211979466c1ba782490d54bbf69f6e9741f6f3177a2": { + "998a4c1dd4573e7e7376bfb34aba3b66ad245d8fcbe756e1a860d506dddbde97": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-138dfa227234ea5f", "receipt_type": "cleanup", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "G6lBKOHThIVwysrHQjmuxoeBb6Oq3pUuePhadofUFFMJgc/X+ceHQBPzPou0UqsGmd5EO5Ppsb96/vSL77wZDA==", - "source_artifact_sha256": "feb27a02d37abdd67aa0b50cdce26c636bfc6b3284475e77a21d027738a91b5a", - "verified_at": "2026-08-18T10:22:00Z", + "signature": "cj1B/QZODnoLh5w/9ZctCX/Hrcw9paz/kzN7gEcpJ9EdwV7ZSVfdZEPOHwlAGeuVEh9H5Z4TzYqeUF78wNSUCA==", + "source_artifact_sha256": "82558495613e411f7ace5490f50e22b445058f1f1d0661f39959e3fa8d25a742", + "verified_at": "2026-08-18T11:22:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "fc097c8b2e6ece94544a19b8d81f5c4a9367a89059e3dd4b2f746ab06a2fc930", + "attempt_id_sha256": "73a097b8b20bab7794369384f7ca1d7d711aad07967b7e1292373babbb7ff1b7", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-03", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "feb27a02d37abdd67aa0b50cdce26c636bfc6b3284475e77a21d027738a91b5a", + "condition": "weak-effect-only", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "82558495613e411f7ace5490f50e22b445058f1f1d0661f39959e3fa8d25a742", "facts": {}, - "run_id_sha256": "28768f565659133f5bf1170e638b81de4d7ca38dfecacd09ccf462a35344432b", + "run_id_sha256": "b44783e70a980ec5b3cf3752bd5d1d01b2ff29f5a6892cba0c1c939d8aeb7c02", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, @@ -4241,88 +4283,74 @@ "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "97a4c47d8a841b03b91b1cbcf6df1d4c9c5cf9f11d5073d7c3586e835d872801": { + "9a75b4d66f9d29893a765a475b5379c6a8f7fe61aad00dd7e2155dec590910cb": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", - "receipt_type": "runner", + "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", + "receipt_type": "fault", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "JJ1D4qevhD+boJZ6OwlvccOdFGL0j1Dt0TFhsPbU+hEyNhvVUIsn9K+lQLbW4iPlYJrOBpE4HzfYXdEkKXJBDg==", - "source_artifact_sha256": "f847f556481bc9323fcdfb083e5068e729d1de913f60d34a1f7f7352a95af4a0", - "verified_at": "2026-08-18T10:14:00Z", + "signature": "luCuoymhHR96i37DTvUyI2dJlKFwiz8EflGgNvuc5AgfjFa2uIuHTZHe3MPV+Bs+aS1qrJ3zm1mp8LwksiXPCg==", + "source_artifact_sha256": "18258b93a65383507d1a93b2de83059c8074fd781add23d4f4d40911bf56b059", + "verified_at": "2026-08-18T11:13:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "019dd96e9a771ccc01ebafab321d7d3a8314df8b2d6465bcfc5fa14cbdeabdf2", + "attempt_id_sha256": "42259dbb767ced4c25ad8bd40edc209720a748897194c925ed9bd2e27b2258b2", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-02", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "f847f556481bc9323fcdfb083e5068e729d1de913f60d34a1f7f7352a95af4a0", - "facts": { - "model_call_counter": { - "attempted": 0, - "call_ids_sha256": [], - "completed": 0, - "cost_microusd": 0, - "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", - "input_tokens": 0, - "output_tokens": 0, - "provider_models": [], - "report_sha256": "f847f556481bc9323fcdfb083e5068e729d1de913f60d34a1f7f7352a95af4a0", - "source": "runner_signed_flow_report_and_enforced_egress_policy" - }, - "operator_intervention_ids_sha256": [] - }, - "run_id_sha256": "16cb8df40654c6a1b55ea0e50e772d8c6e6d4f0d8205bd1f8296be27d0af83eb", + "condition": "verifier-unavailable", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "18258b93a65383507d1a93b2de83059c8074fd781add23d4f4d40911bf56b059", + "facts": {}, + "run_id_sha256": "4af84f2608a25a27e6252a5800263a238bb70fb3bec65148601ddcdddbf3e03c", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "verified", + "trial_index": 2, + "verdict": "injected", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "97d0bac2c04b176b3a168f9692a80308b7a473fe021aa8e3936ba660c7425eab": { + "9ac20993310eb294d1c4cb9e279d8c5aaf11ee59cd3e506d5ccbf5943ed67e16": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "UuzHkZ+xRvo9LFGiAXBvB4LARuI3i1bvS9o9bRxHQ4FkTm4DSjdUgURf6itEvhLIdMLCH+6eHaR/4Hlw57gpBQ==", - "source_artifact_sha256": "6eac8e2767237847378635c85aa204fee9f7317f048965d102409679612f37c4", - "verified_at": "2026-08-18T11:23:00Z", + "signature": "2KlUijJSRczF7dkaPTzM+oagiFF3aPvPweLxfqfzbYX95zGAUy8NCr9WPSgpDRXvgjZ2a+RfeqfDjVBKQNIiCw==", + "source_artifact_sha256": "3edf91becb8c50a0a4c4769e60bfd13bf8bfc1727bb05e1737099caba33e651e", + "verified_at": "2026-08-18T11:02:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "eb52fb1b1bf2fac92d8f3a444bb5081161be8b3d0ef457c5065e7b79e96df770", + "attempt_id_sha256": "60ee9db05b1126cfaa3b31c13bc3fab4755ac09c44e846b4d07ee51865dfa7b1", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "weak-effect-only", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "6eac8e2767237847378635c85aa204fee9f7317f048965d102409679612f37c4", + "condition": "ambiguous-target", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "3edf91becb8c50a0a4c4769e60bfd13bf8bfc1727bb05e1737099caba33e651e", "facts": {}, - "run_id_sha256": "794033f9da2a42448254a478fb6de954898b1e544148708ad30264efdc255431", + "run_id_sha256": "628f991a182613b8700294d7483b5a4c06872cb9d5ca6047ea552b8ab6585357", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "halted", + "trial_index": 1, + "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "9842d656d4d92597e76248af6b34e1577d204588dd9b446cc98424630c4ba79f": { + "9ba1afa04fd9f4984ec6caa3bb6dfc33139043b0e59e04f1213946d5b6897401": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", "receipt_type": "fault", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "wsbwuw/Ie7cVjsoqUq6DDl+LotOlzY6MoM5qrOwqObYgbkupWwrn7Pu8rXrugua6bO/NP9Naflu3ax9udTiuDA==", - "source_artifact_sha256": "7d54c11699d0fc258007146c754f3dd04a68594dea5bf0402d10aa55a04b514d", - "verified_at": "2026-08-18T11:02:00Z", + "signature": "ghH7ci1o0fKmFerGtZqoV1MwXdTYmyDas/A6Vga6lBPQFNmGk6jYt0nBosllnqVwEca5bMhPjxVGC38trhe/AQ==", + "source_artifact_sha256": "0eafb7867b5bb7cf68f39f40315893e1d694dd3566b71331a554025c69b9504f", + "verified_at": "2026-08-18T10:42:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "60ee9db05b1126cfaa3b31c13bc3fab4755ac09c44e846b4d07ee51865dfa7b1", + "attempt_id_sha256": "e93521e706ad90d799dcd4e8cac15229c5da6aec1638540606f5fab4efce59fc", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "ambiguous-target", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "7d54c11699d0fc258007146c754f3dd04a68594dea5bf0402d10aa55a04b514d", + "condition": "wrong-reference", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "0eafb7867b5bb7cf68f39f40315893e1d694dd3566b71331a554025c69b9504f", "facts": {}, - "run_id_sha256": "628f991a182613b8700294d7483b5a4c06872cb9d5ca6047ea552b8ab6585357", + "run_id_sha256": "ee82112f55e5e6c86cfd6e16df8c8b652549a8bd72de492f435d8255eb3dd252", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, @@ -4330,467 +4358,550 @@ "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "9a7ff6004d469b48ff0888078d491586e9590f75f13abd4764fd6295eb6aabb7": { + "9ce0903a48e097fdfbefd60e74faf245a965a2522af782e3bf1281bca4ce21c3": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-138dfa227234ea5f", - "receipt_type": "cleanup", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "n4X/HhHTESCcumMo+/kswvM2xWqWBKWehNKpd1SVL50wjcfJYhwWeFJUePLtVO+iVnQy9rGgoB0xfZqpIZo6Bg==", - "source_artifact_sha256": "6f4098a4cb069c24d492715c73eabdf78d759e24953b88a134df911d06fd36f5", - "verified_at": "2026-08-18T10:54:00Z", + "signature": "nMMpI2RDPpnia3aOUxX/3aQa1ghvyn6jqfcqVv+xCoq9sNkNBJGdOYiM4RUiUJYOGTyRBUUUrcdNa+StDgqKBA==", + "source_artifact_sha256": "7783dfcd8f2e57ff07c7bd69c17fa37665760981171e801c30d76e22a8d5802a", + "verified_at": "2026-08-18T11:13:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "958342a9ddca98a83b82b662f52f404239d583afe7ed70634760e1b8dd592f3b", + "attempt_id_sha256": "42259dbb767ced4c25ad8bd40edc209720a748897194c925ed9bd2e27b2258b2", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "stale-session", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "6f4098a4cb069c24d492715c73eabdf78d759e24953b88a134df911d06fd36f5", - "facts": {}, - "run_id_sha256": "6f2fb10bc2018c9f78e9702d5ccac0bedd78ee3b2e9d2a6ad779fba72d90ae50", + "condition": "verifier-unavailable", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "7783dfcd8f2e57ff07c7bd69c17fa37665760981171e801c30d76e22a8d5802a", + "facts": { + "derived_classifications": { + "collateral_effect_count": 0, + "duplicate_effect_count": 0, + "intended_effect_count": 0, + "wrong_record_count": 0 + }, + "dispatch_state": "not_dispatched", + "effect_inventory": [], + "expected_record_id_sha256": "876c2932bfee2296fa4602d5f63194e6a399e970ba2009ab631e69cfb123d88e", + "expected_transaction_ref_sha256": "f91fb48f273432eb9696a65fec9e78725e79d54198a301868ccac2fb331ff740", + "post_state_evidence_sha256": "a5789c10e5a561103b525e51001bdcdd8023c7154d3ae6ef8a72a3f861ba5243", + "pre_state_evidence_sha256": "ae6f097e196a0806234cb6ca907ba6618d65ceb3c1e701576ccede89f0bd22d9", + "verifier_method": "read_only_system_of_record_query", + "verifier_tier": "independent_system_of_record" + }, + "run_id_sha256": "4af84f2608a25a27e6252a5800263a238bb70fb3bec65148601ddcdddbf3e03c", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "completed", + "trial_index": 2, + "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "9ad9415421ff129296360281cd537671da5f6894ab31b17254eb0d15aa976584": { + "9d87353a1de7c009237dbe68a433c36c485ec2ba6741e274c0b7afa5fdf57056": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "S4jo6gZ95myTyqyH6a0kc3T7Bk6Y1AP0t8qUuIMQaU+uMN9qZhL/FGVEGC+RM+ePVwNJBthKWuTED+z1d3HuBg==", - "source_artifact_sha256": "19c8e4a8e4ef48302a4600b8bf8bd600dbffa7e3b33c7ac91fa693b98487bdf2", - "verified_at": "2026-08-18T11:04:00Z", + "signature": "Ol23QLXs+ol9vJNpegSnPzEzXznEcyotEFb6rpCOkMCQZtTqqXgpubrOBhE0Wdx8sqGFpSs1VHW+eSBdxmZ5CA==", + "source_artifact_sha256": "7cfb7c321bd76fc1bf31a8453b02adde00c9bde35f22ce38726f169660f2b323", + "verified_at": "2026-08-18T10:23:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "491a544656d05aea37920e5c7e2ad65a9452eac8d6e100268a599aeebd41187a", + "attempt_id_sha256": "2601335b1101424105277997a67850a8a60aa45f59637b7679c1f32af463c460", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "ambiguous-target", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "19c8e4a8e4ef48302a4600b8bf8bd600dbffa7e3b33c7ac91fa693b98487bdf2", + "condition": "healthy-03", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "7cfb7c321bd76fc1bf31a8453b02adde00c9bde35f22ce38726f169660f2b323", "facts": {}, - "run_id_sha256": "aa62c7a17701a7ef01ea1d3519b4c1f90d357495b329fdda3054cc24c581a593", + "run_id_sha256": "237a0b7d1cafb64b1d113dca6699e6eefeaaf0b18679138545c3695495b901d5", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "delivered", + "trial_index": 2, + "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "9b67f51c4c82736ce53e697d96f9d24851bd56aaf11882d44ded060ea9417a8c": { + "a1ca7dc9135e1a2ebff6416e6b80fa32b44f88a9fc5e30c9a2acb86997245739": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "DEdefsUk7IYe+OzAHlV2gbR6I54BT1ogex/at7YILyi5XZXdGIX1N3kpTlDk1g4PRqhb4YQrBxDSfacG5r+NCA==", - "source_artifact_sha256": "450c89cbaa5a936d700d26b432db8bd4bbdbc51112a84e99abd73954c0897001", - "verified_at": "2026-08-18T11:04:00Z", + "signature": "a0pqf0JWRCLAxQthlP0723LIghI4G6TBbGHsEJCTgECT/0khTjxIrziPZZV7oHxXfwxhHb3XXd6uZ168+Za4DA==", + "source_artifact_sha256": "ae52f89326f6a1eaced707ed240c61ddf62d1abbd3ac6891f3dc097aef1451cb", + "verified_at": "2026-08-18T11:12:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "491a544656d05aea37920e5c7e2ad65a9452eac8d6e100268a599aeebd41187a", + "attempt_id_sha256": "f5e96a2e9a580376b18beabf57798b8761e772a0c4d112877045780bb12b3720", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "ambiguous-target", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "450c89cbaa5a936d700d26b432db8bd4bbdbc51112a84e99abd73954c0897001", + "condition": "verifier-unavailable", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "ae52f89326f6a1eaced707ed240c61ddf62d1abbd3ac6891f3dc097aef1451cb", "facts": {}, - "run_id_sha256": "aa62c7a17701a7ef01ea1d3519b4c1f90d357495b329fdda3054cc24c581a593", + "run_id_sha256": "e8e89651045a5f5c011c9543ed968e0fe7697a061ed8ad5cedc27d194cb96acb", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "absent", + "trial_index": 1, + "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "9c2d9af1bfda87a93cd19e5f83962d6c0332255f487fd35b5a494468cee86b32": { + "a36da032e4dd06563a3377f89fe60b791b21e70cdb776c73df15e6935c7c7399": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "Dexe7h0OoZwV3KB27Bmp3TpO+7pgDGtm/+YNfwFeXEgfeGaujW6H/t82+Uqfn4Kk+ACGtKcRi34oxxqgEgByDA==", + "source_artifact_sha256": "693c5de78792744df15509b8187bfaf3ec71a4d879011e9773e98d139b5d7856", + "verified_at": "2026-08-18T10:03:00Z", + "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "fdad940f245d690750ad647fac25c7e76aac2f474db49732fec8129051750186", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-01", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "693c5de78792744df15509b8187bfaf3ec71a4d879011e9773e98d139b5d7856", + "facts": { + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "693c5de78792744df15509b8187bfaf3ec71a4d879011e9773e98d139b5d7856", + "source": "runner_signed_flow_report_and_enforced_egress_policy" + }, + "operator_intervention_ids_sha256": [] + }, + "run_id_sha256": "3739043a92a8781376cfbd022460c03aba40f92a800b3885ebc046321437bc40", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "verified", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "a58bfd664642a35143e96f9bc279f6cfafd4888aa3bf2538f07d7cb82495c2f5": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "fB87wo9UI/17XHNqfEKlSCeYK8H4zrlf7WXk3Xp9/x41jjU7VlSm6ZW8ixmd6llp+qVzQQcoKVhtq2xxmYzzBQ==", - "source_artifact_sha256": "1eca1abe283fecbe71ddaa403079343a5a6893d159482e26421de9b3004b7e29", - "verified_at": "2026-08-18T11:22:00Z", + "signature": "e+jZfhngZ/ReWb6e5eHUIvk8Be/jcT1dOsrioU6mvD8Ta3GWdENX5OxNNs68RAK2kYKf9RGCtqWn+w5BTqVvAw==", + "source_artifact_sha256": "11df3fb01cf5dba128c9a69827676bb2d78cf90dedf8bd2071bcea42c25916e5", + "verified_at": "2026-08-18T10:33:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "73a097b8b20bab7794369384f7ca1d7d711aad07967b7e1292373babbb7ff1b7", + "attempt_id_sha256": "4667302b580ff7ceb223dbb15eb6d029969a8f6a54bcd33e8df5b6bff41f41ad", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "weak-effect-only", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "1eca1abe283fecbe71ddaa403079343a5a6893d159482e26421de9b3004b7e29", - "facts": {}, - "run_id_sha256": "b44783e70a980ec5b3cf3752bd5d1d01b2ff29f5a6892cba0c1c939d8aeb7c02", + "condition": "idempotency-replay", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "11df3fb01cf5dba128c9a69827676bb2d78cf90dedf8bd2071bcea42c25916e5", + "facts": { + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "11df3fb01cf5dba128c9a69827676bb2d78cf90dedf8bd2071bcea42c25916e5", + "source": "runner_signed_flow_report_and_enforced_egress_policy" + }, + "operator_intervention_ids_sha256": [] + }, + "run_id_sha256": "33e0ad9bf64e477f24d46508fa432123e046dcd1c5853d5cc60b7cde1bce7537", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, - "verdict": "halted", + "trial_index": 2, + "verdict": "verified", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "9db2b18e2dc3cf9b5d36401b3b39deff53f42376f1ef0e4db7e5bf74f8a2d41c": { + "aa03bb52368f1cfa082d5cf602622bb97606d6132a20cd3bd61b9c291b35aa2c": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "gdZpLo07H3UPnCZ2ml+YovGEvpTgnY5UEd7BGV8w7Xgoi9/ww6hcBjMQOH390mTHrOhlE4viQaqUerLFcMcrAQ==", - "source_artifact_sha256": "975e43caa5b1e34f06e36ad0fd995c5ba6662a55f5cb8d8d28a9f6208420b800", - "verified_at": "2026-08-18T10:53:00Z", + "signature": "RlfacXA6CDr16qxnyNOq6eBH/tHY2V+RR0ZrGkSHMiJiPKuVH5U7XuiXe9GaxAJxNEPn6qaxrmHqZ9DQz1CIBg==", + "source_artifact_sha256": "c129344c7dd911068c387c21d9a1042713a90190dcd848662cf894d8283c4db2", + "verified_at": "2026-08-18T10:54:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "f5df4d6e64a2d38ffa8e320c87ad05d04025de267a8e152a755d3f1928ded120", + "attempt_id_sha256": "958342a9ddca98a83b82b662f52f404239d583afe7ed70634760e1b8dd592f3b", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "stale-session", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "975e43caa5b1e34f06e36ad0fd995c5ba6662a55f5cb8d8d28a9f6208420b800", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "c129344c7dd911068c387c21d9a1042713a90190dcd848662cf894d8283c4db2", "facts": {}, - "run_id_sha256": "fd3a041b705d8c6277ce26134dc0018e866218cfa3fadd16ac29d1ad498965a3", + "run_id_sha256": "6f2fb10bc2018c9f78e9702d5ccac0bedd78ee3b2e9d2a6ad779fba72d90ae50", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "halted", + "trial_index": 3, + "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "9ecd01ee39fd20d52a6ac0015f2d41508e79bdae57d936cbadc31dddf3f9a1a6": { + "abf35f66135e4a90f2ed209bfdea0e216caea560808882a9aefeefb726b18cd1": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", - "receipt_type": "fault", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "YcA8RX/nVVCzbegHGJ6FG4ERtYa5BOfzGT0q+NhrUE7rpzhfbR79lBbk/j1LtfIFzb1MKE7Qe81p+/rnl29QDg==", - "source_artifact_sha256": "49dbd40897c1bf5714a6e032fc07ef378207978f4db7ee347783daf9bfba90ca", - "verified_at": "2026-08-18T11:14:00Z", + "signature": "tBV0sfuykp4A3Px1sMFd/tDYDVxpKBR6xyWzuxWFXOgF1ZYXOdcq+mVw+yGFvehfbKYuGX127xlESDkbYjuaBA==", + "source_artifact_sha256": "43d2d3f884205de0a56e566e84429edcbc2e0a31f4904212f36f787c3ea8df6a", + "verified_at": "2026-08-18T10:23:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "ad76dacfe19a4421ef1f128d4eef1099e846b385d29f17b8588ae5130b487118", + "attempt_id_sha256": "2601335b1101424105277997a67850a8a60aa45f59637b7679c1f32af463c460", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "verifier-unavailable", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "49dbd40897c1bf5714a6e032fc07ef378207978f4db7ee347783daf9bfba90ca", - "facts": {}, - "run_id_sha256": "87014cd8063f5a43ea22c995be03ec41ef5aa613145acacdef71b68c468fc8f1", + "condition": "healthy-03", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "43d2d3f884205de0a56e566e84429edcbc2e0a31f4904212f36f787c3ea8df6a", + "facts": { + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "43d2d3f884205de0a56e566e84429edcbc2e0a31f4904212f36f787c3ea8df6a", + "source": "runner_signed_flow_report_and_enforced_egress_policy" + }, + "operator_intervention_ids_sha256": [] + }, + "run_id_sha256": "237a0b7d1cafb64b1d113dca6699e6eefeaaf0b18679138545c3695495b901d5", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "injected", + "trial_index": 2, + "verdict": "verified", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "a084fd73559d8b3db4eb489627c23d3fbddcb149c5f22bdc0f21b3057fe78fc5": { + "ad0d51bc368a7760c871b7d88eaa18c6c0d4c4f42e20abc46d4914935d69728d": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d7e1e084be213b01", - "receipt_type": "observer", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "O8+zPNpLrrNfk/Dghwr6uJecLDizKqszIE3i4fX1KEmr8daEZWZ2VPdn5U30n2Ly427p95z31xoxGf4OXEiRBg==", - "source_artifact_sha256": "a71340e07f39ce3002adc89f5435ab9eade0ea3cf1426a1e7905df87ae659b41", - "verified_at": "2026-08-18T11:12:00Z", + "signature": "gBTYjsSosVGRcy9h7tNccHXjxkuvjFtYNUPLl0aMlvD/9QeoRrVXQI8cMH9G48XSx+0Mk4I9SDiEMU/k18PvDw==", + "source_artifact_sha256": "1f77854e1846d96a3d4c187c4946e746d7139d3a025dbd5ede6e8a6ee6be2c40", + "verified_at": "2026-08-18T10:22:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "f5e96a2e9a580376b18beabf57798b8761e772a0c4d112877045780bb12b3720", + "attempt_id_sha256": "fc097c8b2e6ece94544a19b8d81f5c4a9367a89059e3dd4b2f746ab06a2fc930", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "verifier-unavailable", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "a71340e07f39ce3002adc89f5435ab9eade0ea3cf1426a1e7905df87ae659b41", - "facts": { - "derived_classifications": { - "collateral_effect_count": 0, - "duplicate_effect_count": 0, - "intended_effect_count": 0, - "wrong_record_count": 0 - }, - "dispatch_state": "not_dispatched", - "effect_inventory": [], - "expected_record_id_sha256": "37b0146870f3d4a319e6446186a285fb632a6f9637d720bcb3139d9fcccd8775", - "expected_transaction_ref_sha256": "04b62fe444529c82e87c0c6d030a1e5674582f4a9fae517882d53328ce0bb12b", - "post_state_evidence_sha256": "7698e71e3b5a9851a6b4d850d356966517b9680e9d65ef611cf9fcfdc97b1c3e", - "pre_state_evidence_sha256": "82d7a352f0e35fce89e927fb469da061cffdde4bcb91098e725ac7a75e9fd266", - "verifier_method": "read_only_system_of_record_query", - "verifier_tier": "independent_system_of_record" - }, - "run_id_sha256": "e8e89651045a5f5c011c9543ed968e0fe7697a061ed8ad5cedc27d194cb96acb", + "condition": "healthy-03", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "1f77854e1846d96a3d4c187c4946e746d7139d3a025dbd5ede6e8a6ee6be2c40", + "facts": {}, + "run_id_sha256": "28768f565659133f5bf1170e638b81de4d7ca38dfecacd09ccf462a35344432b", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, - "verdict": "satisfied", + "verdict": "verified", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "a1e2cf48ee6a452726941504cdfcb692d395b1d31133f828215e77c2ac8228b5": { + "ad2b550928fbb0369b1d1da2f2d50964d55c396ef7766f46f6578e52326c8af4": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "QJFy8sbOeKKjy5JQ2f5Afh46XYojolwTL/JwjENRUpcKvBO/bf2Yiaue91tQGY4CmhbYSb+CoyNx0bfKQ1YoBg==", - "source_artifact_sha256": "0e28a6c49ce0c22f0e6a0220a2c3340d4e956f0f9a29511f0c44e7492d004a89", - "verified_at": "2026-08-18T11:13:00Z", + "signature": "dSxcIOF4ncd+lI91/Kmx4rlWuIFPD7VortgOrNH4ubLDmIii0nylNg8IthD978DdhJgRy8JdoYk+NfXdgcNvDQ==", + "source_artifact_sha256": "6381975addf1b4ec60255f58a8d2ec052c169a3228310d84dc3954d444e76d0f", + "verified_at": "2026-08-18T10:32:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "42259dbb767ced4c25ad8bd40edc209720a748897194c925ed9bd2e27b2258b2", + "attempt_id_sha256": "3142933f4f168c98b8e89f2ae9d78fd3129e0a9975cbbaa60ddba853eee7d53c", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "verifier-unavailable", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "0e28a6c49ce0c22f0e6a0220a2c3340d4e956f0f9a29511f0c44e7492d004a89", + "condition": "idempotency-replay", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "6381975addf1b4ec60255f58a8d2ec052c169a3228310d84dc3954d444e76d0f", "facts": {}, - "run_id_sha256": "4af84f2608a25a27e6252a5800263a238bb70fb3bec65148601ddcdddbf3e03c", + "run_id_sha256": "6cdff0cf50d0164fe1eee9c4b7db0b969c24f9b960f5653b516313a913c90a0f", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "absent", + "trial_index": 1, + "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "a4f8f64f3037b61213ea0e1e562cce78f79c336de874f207224906d671a84531": { + "ad51ef4fd9a3c9bc18b6ff60954b969f569425362fae180e6a79f41ef2ca8f52": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "Urn1GeBqY/R2cqz2OH+iBqNsnheddn0hc41Fz+0bnM4XIsaul5d5nwPCas2LYQozQ3quNYu0dY/UFdM5LYQxAQ==", - "source_artifact_sha256": "0aefdcb48f524cd1122dc1bfffdbcea74cc3d239411590ae1b6c6b5d0ca845b4", - "verified_at": "2026-08-18T10:43:00Z", + "signature": "+VGxCkttTx1TSqGjrlO9//zCIyJo2zqTjctRsyNe3kubwCPY6wOxctjCCiC2Qq534r9EWL2PfMRokyA1JGx/AQ==", + "source_artifact_sha256": "d8c7b50d16df0a959a2fd2323040253e31e95b612b1ab829e460e68e6ad935b1", + "verified_at": "2026-08-18T10:52:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "6b0e5c10d55fc92c1ff8576392270a24fb65722414cf58ff9a51b8ce9ef88587", + "attempt_id_sha256": "fbfce2be9ce964be8b668aa518a310fe4a89e5c014f42bd0ea81401bd83bfd7a", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "wrong-reference", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "0aefdcb48f524cd1122dc1bfffdbcea74cc3d239411590ae1b6c6b5d0ca845b4", + "condition": "stale-session", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "d8c7b50d16df0a959a2fd2323040253e31e95b612b1ab829e460e68e6ad935b1", "facts": {}, - "run_id_sha256": "577e37b10b1c87fd9c1b5d320888b736d272824657fd59a012e85a284ee88540", + "run_id_sha256": "d9270fd4c85e4226a9347ecf703e876b9ffdc330f60c7fb8bed8f9321ea30225", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "absent", + "trial_index": 1, + "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "a568e4172ae077650c03fe76891b0f0592699afd2e87c9e60ff669d78c484cd4": { + "ad5d7b5de720923a39775e10003814af4faa1d83050c2111e02108e2d7197eb9": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", "receipt_type": "webhook", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "pO3K/ic4z9liXLhz4dxTrtgDuAVxiMSzBOaT2SGkrKhoFHK5hzsynOXBX/1ZXSG0kEQJsH6MRZZ40tlYuimhDg==", - "source_artifact_sha256": "19bdab0320cb59b56b35ff49a7413fec8a975d93a0f54d88dbb5ccb742efafcf", - "verified_at": "2026-08-18T10:22:00Z", + "signature": "KRXypq7YgWWGCVPVOelc96v3Ur1EM9DlLiE4t60CamksPlCT4k2Ebp7Ijfv28iz9Ec+Vpq+HU6Ul9W0kDkvNCg==", + "source_artifact_sha256": "2c464c80d9d0976e30c3c1b674426f3db967a0264e7bb8ee48984e6b235a5a80", + "verified_at": "2026-08-18T10:44:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "fc097c8b2e6ece94544a19b8d81f5c4a9367a89059e3dd4b2f746ab06a2fc930", + "attempt_id_sha256": "7c910764b2dcc6f05261d609082f75474e4638c3f356006307212b8fed4a2eb7", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-03", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "19bdab0320cb59b56b35ff49a7413fec8a975d93a0f54d88dbb5ccb742efafcf", + "condition": "wrong-reference", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "2c464c80d9d0976e30c3c1b674426f3db967a0264e7bb8ee48984e6b235a5a80", "facts": {}, - "run_id_sha256": "28768f565659133f5bf1170e638b81de4d7ca38dfecacd09ccf462a35344432b", + "run_id_sha256": "fe98ce7f0e66b885201f4667875fd38f5890ffddb575d68bd4cd5a66f8d53ca8", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, + "trial_index": 3, "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "a940f273dc2d98ad1504d3a5308e8a53af1d16f8801c2a15efaacbe548ec3efd": { + "afded6110d5028aa1b83ed86fd9ecdb3c150b78499a205edb43a22fec07cc910": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-138dfa227234ea5f", - "receipt_type": "cleanup", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "41IhWU6s0CCItj9L04QvrDWu9rsUnsMAU2Xzt7PW5E3P23B3+aeLVTf7egjxB5kIkTuKdHmwosxPbFUiIl4+DQ==", - "source_artifact_sha256": "d132a667b9a158fba09b3f6dca9d0d1ef2f87570aba4df8bc3f9fa30778693c1", - "verified_at": "2026-08-18T10:53:00Z", + "signature": "7lbdT2NafUAaKI8NFyU34ifDdo07CittFwsdfmYKWAub/9RO9yHQxBqV1ESWl9Jkn3mhD/oy2IiPR7C2j8hlAg==", + "source_artifact_sha256": "94f304fac630bb580a17d9bcc9e35a0c85e9d873543699c6e9b5668ec6c6ea4b", + "verified_at": "2026-08-18T11:03:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "f5df4d6e64a2d38ffa8e320c87ad05d04025de267a8e152a755d3f1928ded120", + "attempt_id_sha256": "1ec11a9862ede3ac701af71835ac28c551d604a026b5bab7d776dbcdf288394e", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "stale-session", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "d132a667b9a158fba09b3f6dca9d0d1ef2f87570aba4df8bc3f9fa30778693c1", + "condition": "ambiguous-target", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "94f304fac630bb580a17d9bcc9e35a0c85e9d873543699c6e9b5668ec6c6ea4b", "facts": {}, - "run_id_sha256": "fd3a041b705d8c6277ce26134dc0018e866218cfa3fadd16ac29d1ad498965a3", + "run_id_sha256": "43f0a1c00950c390b0676fab55a2aa98c354d028f2347c461661e6cdb72f717e", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, - "verdict": "completed", + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "aa9087e68e6a8479b57a4463ffc5c56b32f86c74f9b79f6a507b816a68ed843e": { + "b0958e2c3585413ee6257ad04f32a2ddb9303bb999131741c6aed903c7c3e3ee": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", - "receipt_type": "fault", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "fKhaaK6wutYSCQwYUOHmIisqpcLvvZk47NMy6RMVMOt61pfEj2djgqQHNG0vgsj8q4UcmBKqfM8Bsgkd8QumCg==", - "source_artifact_sha256": "18258b93a65383507d1a93b2de83059c8074fd781add23d4f4d40911bf56b059", - "verified_at": "2026-08-18T11:13:00Z", + "signature": "aDE48wRLjdRRd8x6hl6n5EidUsb13NcG2KxDJteJDh+Q7SG8tcfDZgHu3CQxcUJe9deRJ7emClh5fFz6YPczDw==", + "source_artifact_sha256": "e5dea576ba929b469a889784b3eb264880f21206f61c472ea33b1b5b59d161cf", + "verified_at": "2026-08-18T11:14:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "42259dbb767ced4c25ad8bd40edc209720a748897194c925ed9bd2e27b2258b2", + "attempt_id_sha256": "ad76dacfe19a4421ef1f128d4eef1099e846b385d29f17b8588ae5130b487118", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "verifier-unavailable", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "18258b93a65383507d1a93b2de83059c8074fd781add23d4f4d40911bf56b059", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "e5dea576ba929b469a889784b3eb264880f21206f61c472ea33b1b5b59d161cf", "facts": {}, - "run_id_sha256": "4af84f2608a25a27e6252a5800263a238bb70fb3bec65148601ddcdddbf3e03c", + "run_id_sha256": "87014cd8063f5a43ea22c995be03ec41ef5aa613145acacdef71b68c468fc8f1", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "injected", + "trial_index": 3, + "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "ad0a42eb042759c673eb9a940f4924f8b054fbf2ecc5b9d6bdf9e16bb1996caf": { + "b1ca427c5147430f04e14f2f6ce94a864ef58c1216b5614b8b8f6738e6fd1140": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-138dfa227234ea5f", - "receipt_type": "cleanup", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "TPCauGpn9mTV7gvO07gVE5NvQPtaczWVj/uABTZajANJsNH5DDZ/tAjZitjmOKX+tUMCto5h5RJTXhB1C9nTCg==", - "source_artifact_sha256": "c51fe4dc79cc2e8b749809c818af5f63c67cbe6e82656cb990d1bc7b13a0b6eb", - "verified_at": "2026-08-18T10:34:00Z", + "signature": "eldo/lUapy+uImhWrc7HY6n4cS/LF33azR6m/YuNLFM9lDc92JvkgpItclnzEO7AwVfyzdSntphJfEFT+zRnCw==", + "source_artifact_sha256": "343f637659566d84e7014bb1c057b6f9363086e8d04e122e7df754c45b3367d3", + "verified_at": "2026-08-18T10:33:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "3aee8ad755c7f4bec71cc194bcfaa805e0ea29cf8b830ed0782f8263dd9620ca", + "attempt_id_sha256": "4667302b580ff7ceb223dbb15eb6d029969a8f6a54bcd33e8df5b6bff41f41ad", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "idempotency-replay", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "c51fe4dc79cc2e8b749809c818af5f63c67cbe6e82656cb990d1bc7b13a0b6eb", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "343f637659566d84e7014bb1c057b6f9363086e8d04e122e7df754c45b3367d3", "facts": {}, - "run_id_sha256": "3df83453126754a62d00ed10837720542d0469799bb8a88cb5257ac5f477a919", + "run_id_sha256": "33e0ad9bf64e477f24d46508fa432123e046dcd1c5853d5cc60b7cde1bce7537", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "completed", + "trial_index": 2, + "verdict": "verified", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "ae850dfd7e4e0688962457aa9c6277ca031ff48e9046ecd1339ba5ac3a8bc8fb": { + "b2ecb4573f5039a6a1cc1dfab8558a0f999e1382ff0c7ff5a258c9153fbd7914": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-d7e1e084be213b01", "receipt_type": "observer", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "lilfIKgICvQ33dLgx6dNmv0LKg9oBt9sRNz9CVKh92tQhVXP+U82jhlGhJsU8Ri/M+DYFu4skh+gysO9EiWaDg==", - "source_artifact_sha256": "7783dfcd8f2e57ff07c7bd69c17fa37665760981171e801c30d76e22a8d5802a", - "verified_at": "2026-08-18T11:13:00Z", + "signature": "lVzDHu341hBi4HPNKdDyQyxWeqfGupIGYxgFOikJyVu2dfdP+QrUC2xQV3kWVPYdOPedQqhe5ND7LUBTLgAADw==", + "source_artifact_sha256": "3d1fc9371e1623ec11f20518ce702cb97dd2336df830ce8143c419fac0bae157", + "verified_at": "2026-08-18T10:22:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "42259dbb767ced4c25ad8bd40edc209720a748897194c925ed9bd2e27b2258b2", + "attempt_id_sha256": "fc097c8b2e6ece94544a19b8d81f5c4a9367a89059e3dd4b2f746ab06a2fc930", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "verifier-unavailable", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "7783dfcd8f2e57ff07c7bd69c17fa37665760981171e801c30d76e22a8d5802a", + "condition": "healthy-03", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "3d1fc9371e1623ec11f20518ce702cb97dd2336df830ce8143c419fac0bae157", "facts": { "derived_classifications": { "collateral_effect_count": 0, "duplicate_effect_count": 0, - "intended_effect_count": 0, + "intended_effect_count": 1, "wrong_record_count": 0 }, - "dispatch_state": "not_dispatched", - "effect_inventory": [], - "expected_record_id_sha256": "876c2932bfee2296fa4602d5f63194e6a399e970ba2009ab631e69cfb123d88e", - "expected_transaction_ref_sha256": "f91fb48f273432eb9696a65fec9e78725e79d54198a301868ccac2fb331ff740", - "post_state_evidence_sha256": "a5789c10e5a561103b525e51001bdcdd8023c7154d3ae6ef8a72a3f861ba5243", - "pre_state_evidence_sha256": "ae6f097e196a0806234cb6ca907ba6618d65ceb3c1e701576ccede89f0bd22d9", + "dispatch_state": "dispatched", + "effect_inventory": [ + { + "effect_id_sha256": "a91846a30c53a237665dd255d69c1469ec67a380cd6a5c452ff954d3b5c67c14", + "record_id_sha256": "697f29481764fb661a736c86f19f80bc542433d3738c384c457338f57ebf9b8f", + "transaction_ref_sha256": "0283a6ca27c79953fbafd963e0489de38177725eb7559f51f84625a79db97f49" + } + ], + "expected_record_id_sha256": "697f29481764fb661a736c86f19f80bc542433d3738c384c457338f57ebf9b8f", + "expected_transaction_ref_sha256": "0283a6ca27c79953fbafd963e0489de38177725eb7559f51f84625a79db97f49", + "post_state_evidence_sha256": "32235684a3f75866ab34c6cc9044779f7db5299bae160d15b31132149e3ea80c", + "pre_state_evidence_sha256": "67360382287d023330ff329bc48478121c00fd065cd946af67a84edd62aae6b7", "verifier_method": "read_only_system_of_record_query", "verifier_tier": "independent_system_of_record" }, - "run_id_sha256": "4af84f2608a25a27e6252a5800263a238bb70fb3bec65148601ddcdddbf3e03c", + "run_id_sha256": "28768f565659133f5bf1170e638b81de4d7ca38dfecacd09ccf462a35344432b", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, + "trial_index": 1, "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "b33cd0b3700716aed5d44075b7e26be191c809331d4cd3e25212c307e43655e5": { + "b311d4ac01445d6fb90500804fbd1f833b407fe03fecf1d61c216125bef95540": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "5G9mt0a3etH1opsXkY9dz6aNtu2yEH6z4z/m2Ix+VIIezM8tpHXhPMXOLgYAdQLBivH72KmH5FEquFsx1YOQBw==", - "source_artifact_sha256": "e7aa152d2f5d093083e644c448c30ba167727eb53ae1e0892f97cecc1e233fb5", - "verified_at": "2026-08-18T11:24:00Z", + "signature": "RkU/C2KO/6C5N2tSGeTmBAHB46LO89XnJJIKGdrTow/8YG0lYoeW+wJn4cd9Xa8ld0BBqXm6hDDggxBUXqU/Dg==", + "source_artifact_sha256": "6eac8e2767237847378635c85aa204fee9f7317f048965d102409679612f37c4", + "verified_at": "2026-08-18T11:23:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "aa7d6be4f25a8992c0a22649ba7e703d6955abf5fece9f8322f560149cf09776", + "attempt_id_sha256": "eb52fb1b1bf2fac92d8f3a444bb5081161be8b3d0ef457c5065e7b79e96df770", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "weak-effect-only", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "e7aa152d2f5d093083e644c448c30ba167727eb53ae1e0892f97cecc1e233fb5", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "6eac8e2767237847378635c85aa204fee9f7317f048965d102409679612f37c4", "facts": {}, - "run_id_sha256": "b974de9da8ef77c8dc9a7662114cc51023ab8c131c488681eeebb7d4c435c8d0", + "run_id_sha256": "794033f9da2a42448254a478fb6de954898b1e544148708ad30264efdc255431", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "absent", + "trial_index": 2, + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "b6148432883a666f0099767e8e3a51c46b65e8f765b75afc9106ceccec1c2e5a": { + "b3d5d2cd580d1b11ec8ed73f8e9a1eeb228c8ceccf80344956742cb0291c124d": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d7e1e084be213b01", - "receipt_type": "observer", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "FJ9qoL4IuKWUSnT51BZjpdeIRJsf9U9aTBdaSi1zG+H9NUdDZ2TEih8exl2fynK+Vs/I77piVWCx0miSys7GAA==", - "source_artifact_sha256": "79805e89b0f4e3d696c11dc8e97714ea0bcdca545f81356e0ed760612fe2925e", - "verified_at": "2026-08-18T10:44:00Z", + "signature": "TYBHgY00M99r18Lfr1XMy9cwq2cle8iZzmPhoCcgzAAf1zjcGfushuA645n0n2qN1dEd/0GlMrzxyh/O4S4xBQ==", + "source_artifact_sha256": "0f409e89e3eb515df85e6adff2f2e9067dd70007afab83b7da6b7dce22e1824b", + "verified_at": "2026-08-18T10:23:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "7c910764b2dcc6f05261d609082f75474e4638c3f356006307212b8fed4a2eb7", + "attempt_id_sha256": "2601335b1101424105277997a67850a8a60aa45f59637b7679c1f32af463c460", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "wrong-reference", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "79805e89b0f4e3d696c11dc8e97714ea0bcdca545f81356e0ed760612fe2925e", - "facts": { - "derived_classifications": { - "collateral_effect_count": 0, - "duplicate_effect_count": 0, - "intended_effect_count": 0, - "wrong_record_count": 0 - }, - "dispatch_state": "not_dispatched", - "effect_inventory": [], - "expected_record_id_sha256": "0dc6218bdc8bf4591648aa33d57dff0688022d50b9056737ceed0685bbbf7e90", - "expected_transaction_ref_sha256": "d148dd9153e31c2d04b5dcdde5965456e7e3e1f0109b358519450847da148f59", - "post_state_evidence_sha256": "f5464e6e0f54cdf1afc377b423019b32f05125c5f5f85920a729408ecb6eb187", - "pre_state_evidence_sha256": "32bfcef60ea6496a047480ecb2cafe23403fde0a50d0f928378d3165f6243ff4", - "verifier_method": "read_only_system_of_record_query", - "verifier_tier": "independent_system_of_record" - }, - "run_id_sha256": "fe98ce7f0e66b885201f4667875fd38f5890ffddb575d68bd4cd5a66f8d53ca8", + "condition": "healthy-03", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "0f409e89e3eb515df85e6adff2f2e9067dd70007afab83b7da6b7dce22e1824b", + "facts": {}, + "run_id_sha256": "237a0b7d1cafb64b1d113dca6699e6eefeaaf0b18679138545c3695495b901d5", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "verified", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "b4ca3d26a2ebbe59ba3f50a127d16ba717aad436cd6577fcb08a15900f6c01c8": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "/fs6LpF86+N9vOwsygnZGBfA56vWGzAPM0StSnj6eqtagk7BS8Gael30MqHR7MaAZO66yK9Tru0Y2og41TsjCQ==", + "source_artifact_sha256": "1594ca15edbb7755f6b59f1e58383c96dab980507ce5edff073a7a295f07069b", + "verified_at": "2026-08-18T10:14:00Z", + "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "019dd96e9a771ccc01ebafab321d7d3a8314df8b2d6465bcfc5fa14cbdeabdf2", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-02", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "1594ca15edbb7755f6b59f1e58383c96dab980507ce5edff073a7a295f07069b", + "facts": {}, + "run_id_sha256": "16cb8df40654c6a1b55ea0e50e772d8c6e6d4f0d8205bd1f8296be27d0af83eb", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, - "verdict": "satisfied", + "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "b661cb27d6061e177a2d7305a99de342ccf5336168bafbe9d0356c0ad65c92b8": { + "b5dd17365119ad6646ff53896c26124d41a307dba088e230d63fd6858fd4d7b0": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", "receipt_type": "runner", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "+zJEOrA//KYPzqgVZhL5t9uVk8PlhN8R/4YeUaMKF2SiyLShy58cNUOf+jwV8OmdtFxi5Hk/cCXDIBLwIi2rAw==", - "source_artifact_sha256": "3f1ce2b52c8b8ed56bc485f70b885b295f43f601b14c7834ee455b982154a6e5", - "verified_at": "2026-08-18T11:02:00Z", + "signature": "tS/rvFq+Mvw04+Mk18BRljAV3U/1jiJDdE4juJvSeHwe+J0XxTnVnk5sbGgy+snZDsJP/zfZ/zidTXeezmv3BA==", + "source_artifact_sha256": "2939663aad44035d0e4b7f6c59580cd6d7589dc8db1f48abe2e60db3cef03a78", + "verified_at": "2026-08-18T10:32:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "60ee9db05b1126cfaa3b31c13bc3fab4755ac09c44e846b4d07ee51865dfa7b1", + "attempt_id_sha256": "3142933f4f168c98b8e89f2ae9d78fd3129e0a9975cbbaa60ddba853eee7d53c", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "ambiguous-target", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "3f1ce2b52c8b8ed56bc485f70b885b295f43f601b14c7834ee455b982154a6e5", + "condition": "idempotency-replay", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "2939663aad44035d0e4b7f6c59580cd6d7589dc8db1f48abe2e60db3cef03a78", "facts": { "model_call_counter": { "attempted": 0, @@ -4801,11 +4912,61 @@ "input_tokens": 0, "output_tokens": 0, "provider_models": [], - "report_sha256": "3f1ce2b52c8b8ed56bc485f70b885b295f43f601b14c7834ee455b982154a6e5", + "report_sha256": "2939663aad44035d0e4b7f6c59580cd6d7589dc8db1f48abe2e60db3cef03a78", "source": "runner_signed_flow_report_and_enforced_egress_policy" }, "operator_intervention_ids_sha256": [] }, + "run_id_sha256": "6cdff0cf50d0164fe1eee9c4b7db0b969c24f9b960f5653b516313a913c90a0f", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "verified", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "b6d3dcfcf35b033f7905b3655232cc403aefc0c7ae0265d08e9c684a20be3042": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "asHNS3+rWGWTIutf1y1eFU5iRZhBTqQu8YzSNq3KopzjpM8Vz7bvo/sfqtDb10HGhnMx+mylBNhKqSsM7aHBBQ==", + "source_artifact_sha256": "19bdab0320cb59b56b35ff49a7413fec8a975d93a0f54d88dbb5ccb742efafcf", + "verified_at": "2026-08-18T10:22:00Z", + "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "fc097c8b2e6ece94544a19b8d81f5c4a9367a89059e3dd4b2f746ab06a2fc930", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "healthy-03", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "19bdab0320cb59b56b35ff49a7413fec8a975d93a0f54d88dbb5ccb742efafcf", + "facts": {}, + "run_id_sha256": "28768f565659133f5bf1170e638b81de4d7ca38dfecacd09ccf462a35344432b", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "delivered", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "b7f1ff5698484b8a9212e8b144b29a955afef9165666f9ae0ac3ec662400d967": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "q7iuyZj0eGvi9mhHcKdcYFh7HVksCPHBQvOCWyuAKwXIJNTILI02T1foapp7luHJQVdvuye2Hfrx7XRrhsDzDw==", + "source_artifact_sha256": "ddb254eb6e2490fcb9e2b2952775ac00220ba9a95a70f4f784bec71ab5df37b7", + "verified_at": "2026-08-18T11:02:00Z", + "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "60ee9db05b1126cfaa3b31c13bc3fab4755ac09c44e846b4d07ee51865dfa7b1", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "ambiguous-target", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "ddb254eb6e2490fcb9e2b2952775ac00220ba9a95a70f4f784bec71ab5df37b7", + "facts": {}, "run_id_sha256": "628f991a182613b8700294d7483b5a4c06872cb9d5ca6047ea552b8ab6585357", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", @@ -4814,13 +4975,13 @@ "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "b6865344d649c442168a1a23f725bde6cecc3c2a2ac876c58aae1f28ed3fa044": { + "b86debd9b84efec758faa9783e4217377e236001ddf878af9777e6f21edf56aa": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-138dfa227234ea5f", - "receipt_type": "cleanup", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "NthuQ04+OrO6tA+ishaITksSmAhI9UppY/qHD8dOyg9Dj8h0f6/NntZ1wfEM+natGXLB9D9pV5EunAmov/tRDg==", - "source_artifact_sha256": "0c3d68b46266286eb32f09365d96174863b4fe9cac3fb3f91625fcbb4f521e71", + "signature": "YN6WPolDEXgNNog/U87aHj4PoeNmqhM+WU+oUAT6ccXPdww+pvYCOQeMD+5ovIPab4rjSOsopxKuhqMYvSjXBw==", + "source_artifact_sha256": "450c89cbaa5a936d700d26b432db8bd4bbdbc51112a84e99abd73954c0897001", "verified_at": "2026-08-18T11:04:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", @@ -4828,122 +4989,148 @@ "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "ambiguous-target", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "0c3d68b46266286eb32f09365d96174863b4fe9cac3fb3f91625fcbb4f521e71", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "450c89cbaa5a936d700d26b432db8bd4bbdbc51112a84e99abd73954c0897001", "facts": {}, "run_id_sha256": "aa62c7a17701a7ef01ea1d3519b4c1f90d357495b329fdda3054cc24c581a593", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, - "verdict": "completed", + "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "b69c63d7548ba4bcd6870077e4a5baedd402af5d7528845cfb9187913a26e46c": { + "ba2563fdd6d4d4f127a50dbd4697f2c94573f49fd8fe75d24fac23c466ebbcd7": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", - "receipt_type": "runner", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "SYh+yUpwrRop8IRERnFpspiUCAt8pLCA2rwcylBhRbXUqOQJnpqwlEXzZws77ezfo8I7cFzH/2boI/LlG6e6Dw==", - "source_artifact_sha256": "f2226cc85e803eb3cf39a88aa39b32d75a3910acc381cbd3197767c9c0b75b5b", - "verified_at": "2026-08-18T11:14:00Z", + "signature": "P5dBMAUwKU9hmkamoIVfTZ5g7GDy4QflseXFYqIcUFgbY28ghik6HxvH1YuhukZv67y9U48K604isq32WEEJAg==", + "source_artifact_sha256": "1bd19a3201a6b9102580819cf704a60ff2d91a1648a1ad38c4dc40806c809b38", + "verified_at": "2026-08-18T11:22:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "ad76dacfe19a4421ef1f128d4eef1099e846b385d29f17b8588ae5130b487118", + "attempt_id_sha256": "73a097b8b20bab7794369384f7ca1d7d711aad07967b7e1292373babbb7ff1b7", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "verifier-unavailable", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "f2226cc85e803eb3cf39a88aa39b32d75a3910acc381cbd3197767c9c0b75b5b", - "facts": { - "model_call_counter": { - "attempted": 0, - "call_ids_sha256": [], - "completed": 0, - "cost_microusd": 0, - "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", - "input_tokens": 0, - "output_tokens": 0, - "provider_models": [], - "report_sha256": "f2226cc85e803eb3cf39a88aa39b32d75a3910acc381cbd3197767c9c0b75b5b", - "source": "runner_signed_flow_report_and_enforced_egress_policy" - }, - "operator_intervention_ids_sha256": [] - }, - "run_id_sha256": "87014cd8063f5a43ea22c995be03ec41ef5aa613145acacdef71b68c468fc8f1", + "condition": "weak-effect-only", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "1bd19a3201a6b9102580819cf704a60ff2d91a1648a1ad38c4dc40806c809b38", + "facts": {}, + "run_id_sha256": "b44783e70a980ec5b3cf3752bd5d1d01b2ff29f5a6892cba0c1c939d8aeb7c02", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "halted", + "trial_index": 1, + "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "b87015226ef172a5e717616fc75a97661c343124e5a17bcc3fb8c5c32a4a5a03": { + "ba31661dac19addcaafc411907dd5452099139027ce1e7e342735124bae3f375": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "3Gl37wMAvg+nO9Ojw4hmKdnN5t+wOsngujAE96ob6MIz55/tQttisnBL+U1lNPIJXrVPYirI44taOOjjXobFDg==", - "source_artifact_sha256": "7edf6488f59115500b130e22484d3834f8757bc027ac738d8616461b11f6c2c5", - "verified_at": "2026-08-18T10:04:00Z", + "signature": "8Z3RxzjBxK7jHHq0QLsDrnfXE5uCjUM86c5a4yjZZwzHh8J2XM2b+hDsg+IBc1kIjIPV3bfhZWF/j297Wcn0Cw==", + "source_artifact_sha256": "9aff04082026c9a005b5b56eb7078d056d424b5024e1034aa161c875b0f71b80", + "verified_at": "2026-08-18T11:23:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "4c352a6999f77707e8837adebb4fc2b7451c2ef6de5145190b33a5c5645e47eb", + "attempt_id_sha256": "eb52fb1b1bf2fac92d8f3a444bb5081161be8b3d0ef457c5065e7b79e96df770", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-01", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "7edf6488f59115500b130e22484d3834f8757bc027ac738d8616461b11f6c2c5", + "condition": "weak-effect-only", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "9aff04082026c9a005b5b56eb7078d056d424b5024e1034aa161c875b0f71b80", "facts": {}, - "run_id_sha256": "4ee2bb61fb883cc8e77d636fb471aa3c0ce9ef0c0a8abd9682214bf0a8f16f26", + "run_id_sha256": "794033f9da2a42448254a478fb6de954898b1e544148708ad30264efdc255431", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "verified", + "trial_index": 2, + "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "b8cc1d45257e2e92b93bff7e19fbd9cb80a18ba97f174f5b2983ff73ba8f627a": { + "be6d35b6d06072bb8c9bc0947e9799aff922dc96d53d2e315fba4464d04ca1ac": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "1iLnfcJpYhrXDWaegQ3p5W32ob2ypPYdkdnBTTBLOFNx838evj9TK0decdiHJL1bYDns+ntfTlXFSnqSKcf6AQ==", - "source_artifact_sha256": "ffae42ea2ab78a78ef0b9b71e9b8a63f6b470d949ecfd892d84ebc512c1b64b9", - "verified_at": "2026-08-18T10:52:00Z", + "signature": "ohMTok06vDLwwHBqpiqAzb3LCkmmzd190XyLYn1TeWgQXBlPaE+6NC6DyqNPgcffQIIXFi7+hPoX094ODb9AAw==", + "source_artifact_sha256": "58703c8fb721c8bd010e150d01acbc91a664c3273b9d1b85d945398148b6ff87", + "verified_at": "2026-08-18T11:23:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "fbfce2be9ce964be8b668aa518a310fe4a89e5c014f42bd0ea81401bd83bfd7a", + "attempt_id_sha256": "eb52fb1b1bf2fac92d8f3a444bb5081161be8b3d0ef457c5065e7b79e96df770", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "weak-effect-only", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "58703c8fb721c8bd010e150d01acbc91a664c3273b9d1b85d945398148b6ff87", + "facts": { + "derived_classifications": { + "collateral_effect_count": 0, + "duplicate_effect_count": 0, + "intended_effect_count": 0, + "wrong_record_count": 0 + }, + "dispatch_state": "not_dispatched", + "effect_inventory": [], + "expected_record_id_sha256": "21c651c545d2279507f7ddd513acee7961b4cb9e59e9738831b5b2a8bc1fae80", + "expected_transaction_ref_sha256": "822f722f5eb229e4240375407ed8896979fc5fea472542519de2a1525e020012", + "post_state_evidence_sha256": "26299f46a60d4c30304e365977a48f64fa8c8f64d408f804601a3153d2b058f4", + "pre_state_evidence_sha256": "9e0c1139ef3ee5b7e2f4e9d209ba561c244af89fc8211606a0698486ad47e930", + "verifier_method": "read_only_system_of_record_query", + "verifier_tier": "independent_system_of_record" + }, + "run_id_sha256": "794033f9da2a42448254a478fb6de954898b1e544148708ad30264efdc255431", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "satisfied", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "bec2c6b69f200513b28114242c99b368f4421b170db03818198c02d41687b223": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "Y5wAZFhT84Im6l1VgttUSHdeM4l72ikN8gN4M9vFUYLvyr5vARH5/JBH0emNzI7dG9kDYUZqUPieQhfiWDErBQ==", + "source_artifact_sha256": "d132a667b9a158fba09b3f6dca9d0d1ef2f87570aba4df8bc3f9fa30778693c1", + "verified_at": "2026-08-18T10:53:00Z", + "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "f5df4d6e64a2d38ffa8e320c87ad05d04025de267a8e152a755d3f1928ded120", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "stale-session", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "ffae42ea2ab78a78ef0b9b71e9b8a63f6b470d949ecfd892d84ebc512c1b64b9", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "d132a667b9a158fba09b3f6dca9d0d1ef2f87570aba4df8bc3f9fa30778693c1", "facts": {}, - "run_id_sha256": "d9270fd4c85e4226a9347ecf703e876b9ffdc330f60c7fb8bed8f9321ea30225", + "run_id_sha256": "fd3a041b705d8c6277ce26134dc0018e866218cfa3fadd16ac29d1ad498965a3", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, - "verdict": "halted", + "trial_index": 2, + "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "b90646d3845ffaf972be53d7d891abfa78c60975dbdf1aae85f55340ff5d6ba1": { + "c24f3d6cfc59c474c462107d22c1a2e6c07f9dcf011e9fd6e0675431f07845ce": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-d7e1e084be213b01", "receipt_type": "observer", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "U8LwQ+GNI4+Zv6maGiCN3kwFOLLWC4fbG3hG9+n2Cdvo6wdkSGGfLx+Gs9aLaNkyfQ9/+JvRs/fwbneVMTefAQ==", - "source_artifact_sha256": "559774dcac1bab02176edb36d9e7bb92abae9655472d718dbc04d72660cf6323", - "verified_at": "2026-08-18T10:03:00Z", + "signature": "76hhXcK4urPFKGHljKHM1I551Gfrq/8xx/ccyidr8UNBpoBogb+hBmOe1Pmvv69jBpOuvRLjOATeWki+yBRHAw==", + "source_artifact_sha256": "ed51ba8ee340b00da87808f45e1ed935c200be0ed41ea55cba8ebcc8e4b3872f", + "verified_at": "2026-08-18T10:24:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "fdad940f245d690750ad647fac25c7e76aac2f474db49732fec8129051750186", + "attempt_id_sha256": "7573925adbd8a7a4a3b98bb0379549d77aa8ed46e312c1cd940c05b8587a039e", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-01", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "559774dcac1bab02176edb36d9e7bb92abae9655472d718dbc04d72660cf6323", + "condition": "healthy-03", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "ed51ba8ee340b00da87808f45e1ed935c200be0ed41ea55cba8ebcc8e4b3872f", "facts": { "derived_classifications": { "collateral_effect_count": 0, @@ -4954,42 +5141,42 @@ "dispatch_state": "dispatched", "effect_inventory": [ { - "effect_id_sha256": "7d8bc663be7e1ff5498453ccb36ae1ef29b47bc8edcc20e36bb6005c0f8fe43d", - "record_id_sha256": "42389eaf0a7d527f14832b69fa924fff489f520c440233231716580d5414c1d9", - "transaction_ref_sha256": "1aef511ee7f75cb0a5dd7867025826284c31f5746c859cb3667996c3a75051ae" + "effect_id_sha256": "840362150d294fb842a0c430c081c44a514e216c4132f6658b2b0407e8336467", + "record_id_sha256": "5d8c903c632927ac9da078a25888efd1b9f104001bcbbe75434bfff1cb0e89d6", + "transaction_ref_sha256": "58e0d46c681d3c9e62f50fe840b0ccd8c6aa127d05e91bab2f24b530ff550039" } ], - "expected_record_id_sha256": "42389eaf0a7d527f14832b69fa924fff489f520c440233231716580d5414c1d9", - "expected_transaction_ref_sha256": "1aef511ee7f75cb0a5dd7867025826284c31f5746c859cb3667996c3a75051ae", - "post_state_evidence_sha256": "61e0b378e51b606efacc737d0582181948f8d4eebb1c9f61ee4aa0b23227b8ff", - "pre_state_evidence_sha256": "ec2ea8e3b0da2a07f5246174bd32f75f8dc31eed4f2c3ca30d894fc442ea98f5", + "expected_record_id_sha256": "5d8c903c632927ac9da078a25888efd1b9f104001bcbbe75434bfff1cb0e89d6", + "expected_transaction_ref_sha256": "58e0d46c681d3c9e62f50fe840b0ccd8c6aa127d05e91bab2f24b530ff550039", + "post_state_evidence_sha256": "a0c814b977f2af708e63f07584860c9ce3060ae5c2416678d88bf7948a6287a4", + "pre_state_evidence_sha256": "0d2090d7b6d69d898af9f95d735324ff9f05a5f8b24ead01f37df42dcac6ced6", "verifier_method": "read_only_system_of_record_query", "verifier_tier": "independent_system_of_record" }, - "run_id_sha256": "3739043a92a8781376cfbd022460c03aba40f92a800b3885ebc046321437bc40", + "run_id_sha256": "784a0a94e581700a3d93581e7ce5bac0d3bc53c58f3e73198b896b5da9a819b0", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, + "trial_index": 3, "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "bc7e85e0380e3c790a86bec2d4ddda704fb1ae1db4979ec6d91aa0562ccdbb9c": { + "c289460164fdddf98ef17bfbc4762e2d890358f9bd590aa057f0bcd8382dcc47": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-d7e1e084be213b01", "receipt_type": "observer", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "z6NisFuUCZVWk8UwLsiFhTnIvJolUI3PS4iKSb7EjewSPii1XlTNLO8s9ihzlQdrY8aTMiFzWxv1eotydOvKDQ==", - "source_artifact_sha256": "b54d78461c69265574bc5e0a08e1ae1f2c53150056399d8de419de8d50868c80", - "verified_at": "2026-08-18T10:04:00Z", + "signature": "nV4w4C7XkoaO2GcotanRQh2fR7cSSesi+j1boTJo72DaN4AkSnVnvkaGsiRxgGAMvLFK6Rkx0dJKO14t5+u7Dw==", + "source_artifact_sha256": "559774dcac1bab02176edb36d9e7bb92abae9655472d718dbc04d72660cf6323", + "verified_at": "2026-08-18T10:03:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "4c352a6999f77707e8837adebb4fc2b7451c2ef6de5145190b33a5c5645e47eb", + "attempt_id_sha256": "fdad940f245d690750ad647fac25c7e76aac2f474db49732fec8129051750186", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "healthy-01", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "b54d78461c69265574bc5e0a08e1ae1f2c53150056399d8de419de8d50868c80", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "559774dcac1bab02176edb36d9e7bb92abae9655472d718dbc04d72660cf6323", "facts": { "derived_classifications": { "collateral_effect_count": 0, @@ -5000,322 +5187,241 @@ "dispatch_state": "dispatched", "effect_inventory": [ { - "effect_id_sha256": "c726d2d313227693bf81a5f01f93a582a3d0c43496f5de19f4d8cb59fad1448d", - "record_id_sha256": "a8d41df87db795f2a38d1c60293e20b89783fce022fce572a546d4a9fb01507e", - "transaction_ref_sha256": "7af984839a1cb25da6ce1ee403c32fb6ec07143cc001f21610f94d3911bbc819" + "effect_id_sha256": "7d8bc663be7e1ff5498453ccb36ae1ef29b47bc8edcc20e36bb6005c0f8fe43d", + "record_id_sha256": "42389eaf0a7d527f14832b69fa924fff489f520c440233231716580d5414c1d9", + "transaction_ref_sha256": "1aef511ee7f75cb0a5dd7867025826284c31f5746c859cb3667996c3a75051ae" } ], - "expected_record_id_sha256": "a8d41df87db795f2a38d1c60293e20b89783fce022fce572a546d4a9fb01507e", - "expected_transaction_ref_sha256": "7af984839a1cb25da6ce1ee403c32fb6ec07143cc001f21610f94d3911bbc819", - "post_state_evidence_sha256": "23107cdffa1eb0a03751c72823ccea43c3f5cc46a99a5df03b5523464379e632", - "pre_state_evidence_sha256": "dfd9a16f8fb84edd62fe6bb1819a6e88a497b30b9e131cd6c853cf12632f149b", + "expected_record_id_sha256": "42389eaf0a7d527f14832b69fa924fff489f520c440233231716580d5414c1d9", + "expected_transaction_ref_sha256": "1aef511ee7f75cb0a5dd7867025826284c31f5746c859cb3667996c3a75051ae", + "post_state_evidence_sha256": "61e0b378e51b606efacc737d0582181948f8d4eebb1c9f61ee4aa0b23227b8ff", + "pre_state_evidence_sha256": "ec2ea8e3b0da2a07f5246174bd32f75f8dc31eed4f2c3ca30d894fc442ea98f5", "verifier_method": "read_only_system_of_record_query", "verifier_tier": "independent_system_of_record" }, - "run_id_sha256": "4ee2bb61fb883cc8e77d636fb471aa3c0ce9ef0c0a8abd9682214bf0a8f16f26", + "run_id_sha256": "3739043a92a8781376cfbd022460c03aba40f92a800b3885ebc046321437bc40", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, + "trial_index": 2, "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "be17be06d1fa1a089368e219302e3a4e142173b4c72e574c40410477d4dc2a2d": { + "c3efe880a31ef3e95bc22e8d585c48737f8f3627bc91c60fe90006a55d8ac764": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", - "receipt_type": "runner", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "EI8LeNA/vSz4ZjRSzYGZ24fOPndG7k/fnCh7HDwNtPPK0w/8cLP4Aa7OIq2/CpyRzQ1POHVuEuOLFBreHroHDA==", - "source_artifact_sha256": "79566ede5f64ddd1b0c40fdfcfdb0f7500d96abb5c46c9abdabddca1500c599d", - "verified_at": "2026-08-18T10:34:00Z", + "signature": "RNuc1VQUwBD2cJUzEB4pSY8dfCue41h0KHfyuxWfdUTNL67bKADPcI9mSjQizIdoepW61OMtKjcUD7fNMXmvCQ==", + "source_artifact_sha256": "12e1cf402efb1b543738dbf0096014533d4c1324c94e1af43a90e76c161e34d4", + "verified_at": "2026-08-18T10:04:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "3aee8ad755c7f4bec71cc194bcfaa805e0ea29cf8b830ed0782f8263dd9620ca", + "attempt_id_sha256": "4c352a6999f77707e8837adebb4fc2b7451c2ef6de5145190b33a5c5645e47eb", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "idempotency-replay", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "79566ede5f64ddd1b0c40fdfcfdb0f7500d96abb5c46c9abdabddca1500c599d", - "facts": { - "model_call_counter": { - "attempted": 0, - "call_ids_sha256": [], - "completed": 0, - "cost_microusd": 0, - "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", - "input_tokens": 0, - "output_tokens": 0, - "provider_models": [], - "report_sha256": "79566ede5f64ddd1b0c40fdfcfdb0f7500d96abb5c46c9abdabddca1500c599d", - "source": "runner_signed_flow_report_and_enforced_egress_policy" - }, - "operator_intervention_ids_sha256": [] - }, - "run_id_sha256": "3df83453126754a62d00ed10837720542d0469799bb8a88cb5257ac5f477a919", + "condition": "healthy-01", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "12e1cf402efb1b543738dbf0096014533d4c1324c94e1af43a90e76c161e34d4", + "facts": {}, + "run_id_sha256": "4ee2bb61fb883cc8e77d636fb471aa3c0ce9ef0c0a8abd9682214bf0a8f16f26", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, - "verdict": "verified", + "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "be4bcc0de90d3e47d83b3285b71c911aab5367c05949bc04f422a1fb60ec606b": { + "c46270bf2176e320a219266b0ae6d15e66d0fb995a15eb52265d3623119ce6cd": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", - "receipt_type": "runner", + "issuer_key_id": "qe-ed25519-d7e1e084be213b01", + "receipt_type": "observer", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "Axj94BWscOwRfh/xEEwKSARe4g4BAD/C6aA+9cEJ6cVKuR6ItU3HS/qWpZgJONSmQKDV+7MvoQKffwv6YrvHDg==", - "source_artifact_sha256": "aa76163afc05d85e7c2925d286aa8e9c2abda820aa88bcddb1c2a8d525a8be2b", - "verified_at": "2026-08-18T11:03:00Z", + "signature": "nQSeK075j4vW68mJ2dbLTnC4BaSl+pfGQQb5InY0khaafhJ/cWkkoe5hI9zzmkKKZy7xnivFUA7W0LchI2e9Ag==", + "source_artifact_sha256": "669b90f52ab8347c72f46f47c7493d314fafe014431fa4d576db6a8d42eeb0dd", + "verified_at": "2026-08-18T11:04:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "1ec11a9862ede3ac701af71835ac28c551d604a026b5bab7d776dbcdf288394e", + "attempt_id_sha256": "491a544656d05aea37920e5c7e2ad65a9452eac8d6e100268a599aeebd41187a", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "ambiguous-target", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "aa76163afc05d85e7c2925d286aa8e9c2abda820aa88bcddb1c2a8d525a8be2b", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "669b90f52ab8347c72f46f47c7493d314fafe014431fa4d576db6a8d42eeb0dd", "facts": { - "model_call_counter": { - "attempted": 0, - "call_ids_sha256": [], - "completed": 0, - "cost_microusd": 0, - "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", - "input_tokens": 0, - "output_tokens": 0, - "provider_models": [], - "report_sha256": "aa76163afc05d85e7c2925d286aa8e9c2abda820aa88bcddb1c2a8d525a8be2b", - "source": "runner_signed_flow_report_and_enforced_egress_policy" + "derived_classifications": { + "collateral_effect_count": 0, + "duplicate_effect_count": 0, + "intended_effect_count": 0, + "wrong_record_count": 0 }, - "operator_intervention_ids_sha256": [] + "dispatch_state": "not_dispatched", + "effect_inventory": [], + "expected_record_id_sha256": "c9446a96197759e6626c902a50c333132d48db209984b45b7b664dee186a7578", + "expected_transaction_ref_sha256": "95f52355bde231835ef1b23f37e8ce989bdf4042ee52fd679fc8eeb514949ad1", + "post_state_evidence_sha256": "d71deb3de9d35b282b7ac9eed3feffc5432a6f28295101b520c1cd0943756dd6", + "pre_state_evidence_sha256": "6d640c6c9ca204c38d59f02e48d62e1d9b9eb13080f6ddf18196c807c8770c30", + "verifier_method": "read_only_system_of_record_query", + "verifier_tier": "independent_system_of_record" }, - "run_id_sha256": "43f0a1c00950c390b0676fab55a2aa98c354d028f2347c461661e6cdb72f717e", - "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "task": "execute-acceptance", - "trial_index": 2, - "verdict": "halted", - "workflow_version_id": "44444444-4444-4444-8444-444444444444" - } - }, - "c0f41eadbf7b50c360fb45ee132b23ba8b45bbb4d32cc7a96517d8a82abd9afe": { - "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", - "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "hDMFtnnqZDBG0kQcsPCekyHzOJJUczzUT/vTz1gY57enwcdAUIpbI4H+qzUpSESFOvfkIpoe7UZNPKe5YpATDg==", - "source_artifact_sha256": "ff1fd4393986dfb3dd0e3e75fe379c4dfa4b424938dac23ab436e1e31f594225", - "verified_at": "2026-08-18T10:44:00Z", - "verified_projection": { - "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "7c910764b2dcc6f05261d609082f75474e4638c3f356006307212b8fed4a2eb7", - "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "wrong-reference", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "ff1fd4393986dfb3dd0e3e75fe379c4dfa4b424938dac23ab436e1e31f594225", - "facts": {}, - "run_id_sha256": "fe98ce7f0e66b885201f4667875fd38f5890ffddb575d68bd4cd5a66f8d53ca8", + "run_id_sha256": "aa62c7a17701a7ef01ea1d3519b4c1f90d357495b329fdda3054cc24c581a593", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, - "verdict": "absent", - "workflow_version_id": "44444444-4444-4444-8444-444444444444" - } - }, - "c2803318f01695a40e402726d0ed4cf471c4f579a3b7c9dcdecb0cfbd3cee666": { - "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", - "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "PJTL9/goXJdjKLejB66s1C6t4BXZA6ydun0/xw4D2Y3nwmRAoHbTNljieBwscqOqeiSrOlAMVdcsjFIqYfZ8DQ==", - "source_artifact_sha256": "7f144d0ed131ef44fd7db0ba5d3d03e685d681ea76df6a87fcf8bc20073786fe", - "verified_at": "2026-08-18T11:13:00Z", - "verified_projection": { - "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "42259dbb767ced4c25ad8bd40edc209720a748897194c925ed9bd2e27b2258b2", - "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "verifier-unavailable", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "7f144d0ed131ef44fd7db0ba5d3d03e685d681ea76df6a87fcf8bc20073786fe", - "facts": {}, - "run_id_sha256": "4af84f2608a25a27e6252a5800263a238bb70fb3bec65148601ddcdddbf3e03c", - "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "task": "execute-acceptance", - "trial_index": 2, - "verdict": "delivered", - "workflow_version_id": "44444444-4444-4444-8444-444444444444" - } - }, - "c48a078a0d240e39cf8193c9c14a3719048553cf39278f3d0656aaa1caccd55f": { - "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", - "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "H9QSo0jHjrYaze9AkweGhodA3RwIEP+3PaNqm6e6ptXm1kXCr+fQIx/Ave0E1LhmyKwQBeJwZn3elmlX8pa2Aw==", - "source_artifact_sha256": "8085128f824c52e7f957276980e2ec8ed181e15094c1a551c251a21e07009829", - "verified_at": "2026-08-18T11:22:00Z", - "verified_projection": { - "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "73a097b8b20bab7794369384f7ca1d7d711aad07967b7e1292373babbb7ff1b7", - "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "weak-effect-only", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "8085128f824c52e7f957276980e2ec8ed181e15094c1a551c251a21e07009829", - "facts": {}, - "run_id_sha256": "b44783e70a980ec5b3cf3752bd5d1d01b2ff29f5a6892cba0c1c939d8aeb7c02", - "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "task": "execute-acceptance", - "trial_index": 1, - "verdict": "absent", + "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "c83d86c9abcf943cba78206214f7d9fe7088e46167c0f37f5caea0a48554c82e": { + "c4e832e3ce0b587c8402ac1ca08e46d5176e306066a5a5c9d913928f133d4c79": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-d7e1e084be213b01", "receipt_type": "observer", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "lgvYjNtLOW9erX7rcUIAxz7jAlivmms+fe39iTRAKu9H/cS1itUMBfT9s5lE79dNfqYH4eXdH2Pvq+mr8OAgCg==", - "source_artifact_sha256": "3d1fc9371e1623ec11f20518ce702cb97dd2336df830ce8143c419fac0bae157", - "verified_at": "2026-08-18T10:22:00Z", + "signature": "s13g6WNy28tDAk5Epyy4VpNFn26uilbdVi3z0bzBymlQAO190S6AzQ9OC26qd5h4RtPCx2pUZwEUoZz7rmdACg==", + "source_artifact_sha256": "086aa3c333f8a4fdf55b0ef09ae301f38faa388075355ba8356b2a2e72f7b80e", + "verified_at": "2026-08-18T10:54:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "fc097c8b2e6ece94544a19b8d81f5c4a9367a89059e3dd4b2f746ab06a2fc930", + "attempt_id_sha256": "958342a9ddca98a83b82b662f52f404239d583afe7ed70634760e1b8dd592f3b", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-03", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "3d1fc9371e1623ec11f20518ce702cb97dd2336df830ce8143c419fac0bae157", + "condition": "stale-session", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "086aa3c333f8a4fdf55b0ef09ae301f38faa388075355ba8356b2a2e72f7b80e", "facts": { "derived_classifications": { "collateral_effect_count": 0, "duplicate_effect_count": 0, - "intended_effect_count": 1, + "intended_effect_count": 0, "wrong_record_count": 0 }, - "dispatch_state": "dispatched", - "effect_inventory": [ - { - "effect_id_sha256": "a91846a30c53a237665dd255d69c1469ec67a380cd6a5c452ff954d3b5c67c14", - "record_id_sha256": "697f29481764fb661a736c86f19f80bc542433d3738c384c457338f57ebf9b8f", - "transaction_ref_sha256": "0283a6ca27c79953fbafd963e0489de38177725eb7559f51f84625a79db97f49" - } - ], - "expected_record_id_sha256": "697f29481764fb661a736c86f19f80bc542433d3738c384c457338f57ebf9b8f", - "expected_transaction_ref_sha256": "0283a6ca27c79953fbafd963e0489de38177725eb7559f51f84625a79db97f49", - "post_state_evidence_sha256": "32235684a3f75866ab34c6cc9044779f7db5299bae160d15b31132149e3ea80c", - "pre_state_evidence_sha256": "67360382287d023330ff329bc48478121c00fd065cd946af67a84edd62aae6b7", + "dispatch_state": "not_dispatched", + "effect_inventory": [], + "expected_record_id_sha256": "e2bfc459a52b773d833645ffe96420a991d4761d31989876840d25b4b302c7aa", + "expected_transaction_ref_sha256": "95a5987fa6dfc58ef200281706e9fd73fc28a1d3d44d7eb278478e065e05d3be", + "post_state_evidence_sha256": "a34e8e155989eb0f32dbaf1dba2758e9355bff86a0d7fda67170ce423fd6fe25", + "pre_state_evidence_sha256": "c6dd473eaf43722b7b24747137e017fe88410937978ed19e9c3c694b01515608", "verifier_method": "read_only_system_of_record_query", "verifier_tier": "independent_system_of_record" }, - "run_id_sha256": "28768f565659133f5bf1170e638b81de4d7ca38dfecacd09ccf462a35344432b", + "run_id_sha256": "6f2fb10bc2018c9f78e9702d5ccac0bedd78ee3b2e9d2a6ad779fba72d90ae50", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, + "trial_index": 3, "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "cb6c8afc587772aa8efc94807c1572115c22e8a1eca478dc2977cf785f7e4771": { + "c81b91f66fb62f1c5ceb740978670dd0a834edb192cbfbb1d3b693fa680e52d4": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-138dfa227234ea5f", - "receipt_type": "cleanup", + "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", + "receipt_type": "fault", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "XFM+BRFvQfUZ6ubL2axPpBFX9XY1xufvopqrvOIxUQZWWnRgb6RKp1dVsqfp78Kp2h+jQK2Q3dQv/crPPJtvCQ==", - "source_artifact_sha256": "e02b4733d09ac9c9e6e5d98ba7fc6645738e022e2f137f73feded4d27f3925e9", - "verified_at": "2026-08-18T10:02:00Z", + "signature": "IwmZMZjno1bf6NNC2Nyq+6hjTwISSbAkWGnD21tvdKVfHx2VLtu5yQ5f+jDFYtB5FLS+XjZrKEUN/fAT04/dAw==", + "source_artifact_sha256": "e7f1dc034e24ac6d0aad3990e694aa281baa8c3e11415deb28fdd2e98bbdd313", + "verified_at": "2026-08-18T10:43:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "679af5a8dedceb8c696719e73f82a698c230cd8fc98bb61769f0883202c0b637", + "attempt_id_sha256": "6b0e5c10d55fc92c1ff8576392270a24fb65722414cf58ff9a51b8ce9ef88587", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-01", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "e02b4733d09ac9c9e6e5d98ba7fc6645738e022e2f137f73feded4d27f3925e9", + "condition": "wrong-reference", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "e7f1dc034e24ac6d0aad3990e694aa281baa8c3e11415deb28fdd2e98bbdd313", "facts": {}, - "run_id_sha256": "0b5bda916a0808165159166955a9563cf9c2303949f762a18eb037f41b44a6dc", + "run_id_sha256": "577e37b10b1c87fd9c1b5d320888b736d272824657fd59a012e85a284ee88540", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, - "verdict": "completed", + "trial_index": 2, + "verdict": "injected", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "cbe1607f5b948d288e9fdb6ab638d5f3cde433d739670d52bfd0a1426d560300": { + "cbcd6b8ca83036e297d4610df2527be9ad842ebaa6c59a0636289c47d9454af1": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", - "receipt_type": "fault", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "4dFt+AAERjAVMafsPGChjgQ0dSwnqMKK5jFW1aPOh+YZtVep6zJWRyOA71hdmFqS8dKXmD9Z88c3uO21N4xEAA==", - "source_artifact_sha256": "d80e5faa489be940291e74948facb9a38c3f6ce34fbe6fb5c586b966e5c82228", - "verified_at": "2026-08-18T11:12:00Z", + "signature": "fHElS1Os9LotWWU/A0HSbTu2Y14wFk7JRqHMslpeKpRUZlLukSuKvMnLWwgjMWZ8eEGagpQiFdxoCP0G7RDOBQ==", + "source_artifact_sha256": "4166eb8e3a385de458c987a5463a1a35943cb8e54fa4a174c56729232a96605a", + "verified_at": "2026-08-18T10:13:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "f5e96a2e9a580376b18beabf57798b8761e772a0c4d112877045780bb12b3720", + "attempt_id_sha256": "3d42601a69ef46cc44f57b51762affef4ccd829ffde30125619a6e582af00dab", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "verifier-unavailable", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "d80e5faa489be940291e74948facb9a38c3f6ce34fbe6fb5c586b966e5c82228", - "facts": {}, - "run_id_sha256": "e8e89651045a5f5c011c9543ed968e0fe7697a061ed8ad5cedc27d194cb96acb", + "condition": "healthy-02", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "4166eb8e3a385de458c987a5463a1a35943cb8e54fa4a174c56729232a96605a", + "facts": { + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "4166eb8e3a385de458c987a5463a1a35943cb8e54fa4a174c56729232a96605a", + "source": "runner_signed_flow_report_and_enforced_egress_policy" + }, + "operator_intervention_ids_sha256": [] + }, + "run_id_sha256": "091e13ed70dab439b31cb506cf3bba1ddf6476696531cf891c39a924a928b7a1", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, - "verdict": "injected", + "trial_index": 2, + "verdict": "verified", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "cc5c198782b833eac26154a61cbae483021dd950daa665f0e9633a57ee14931b": { + "cfb9cb21f36c357208d9826a4ea328a04ecde3ec93ae64fcc5e8b4315a618b04": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d7e1e084be213b01", - "receipt_type": "observer", + "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", + "receipt_type": "runner", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "DqGhTPxpVBbGDwvh7uk1gOFmseQDlLEO+IQbmKICZ1iMQl01iCsmunZUHpmSZqiI4rWcZEqw44FeTwr4DXh3BA==", - "source_artifact_sha256": "24e69a5639acfa91d8833695390d6df6885bdfd9c998f69d8042b203ac41fade", - "verified_at": "2026-08-18T11:14:00Z", + "signature": "Df5uIcMAJtcCyrHcLFMWY5o63ueUHKO+Lx0NUOmTaAwga8PutqqVI/6w7tvQbBSPRg3zH/kiSyogYGDsisABAg==", + "source_artifact_sha256": "cfa32a5a84ca628c634a548be23b97ffb53dc187e1e8b479a30dba14275ec44a", + "verified_at": "2026-08-18T11:13:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "ad76dacfe19a4421ef1f128d4eef1099e846b385d29f17b8588ae5130b487118", + "attempt_id_sha256": "42259dbb767ced4c25ad8bd40edc209720a748897194c925ed9bd2e27b2258b2", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "verifier-unavailable", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "24e69a5639acfa91d8833695390d6df6885bdfd9c998f69d8042b203ac41fade", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "cfa32a5a84ca628c634a548be23b97ffb53dc187e1e8b479a30dba14275ec44a", "facts": { - "derived_classifications": { - "collateral_effect_count": 0, - "duplicate_effect_count": 0, - "intended_effect_count": 0, - "wrong_record_count": 0 + "model_call_counter": { + "attempted": 0, + "call_ids_sha256": [], + "completed": 0, + "cost_microusd": 0, + "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", + "input_tokens": 0, + "output_tokens": 0, + "provider_models": [], + "report_sha256": "cfa32a5a84ca628c634a548be23b97ffb53dc187e1e8b479a30dba14275ec44a", + "source": "runner_signed_flow_report_and_enforced_egress_policy" }, - "dispatch_state": "not_dispatched", - "effect_inventory": [], - "expected_record_id_sha256": "15667bd46a6b2a68c33d091a7cdb820efc8c7bc525b84a19df86f11a4b15c348", - "expected_transaction_ref_sha256": "8c2fa32d2ef5dc92756e014ebd4047b72f071156d39dd5040118ee69acf9a0fa", - "post_state_evidence_sha256": "1568879b7f568dd40270fdacb3a76a253577307b7f8c522c02e19b4d1656a6b1", - "pre_state_evidence_sha256": "e7aa4d479e6a7046141e1a00904cac2d9c2ba674e0754c47be79418161b8f1bf", - "verifier_method": "read_only_system_of_record_query", - "verifier_tier": "independent_system_of_record" + "operator_intervention_ids_sha256": [] }, - "run_id_sha256": "87014cd8063f5a43ea22c995be03ec41ef5aa613145acacdef71b68c468fc8f1", + "run_id_sha256": "4af84f2608a25a27e6252a5800263a238bb70fb3bec65148601ddcdddbf3e03c", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "satisfied", + "trial_index": 2, + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "cf1810125ebf9f6238ab3d93015329a48e69eeb4c925ad2cf6d658d08b492b3f": { + "d03bdf838754ad1716d2cf35911017b3a40e8d485f1427dbc0f213b1feb0337a": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "ViM5gLPMUBTUqTNG8B7b2CX3UxCrDO7u7XkZkVenlXs2Ab6RVYd6f6rHxN73GwjEXM86P/5Oj+gw4qt5OUjwAQ==", - "source_artifact_sha256": "ce46f3e2c640383fa7d86f238289722cb7a1f00c5ee3ba8994a54c6a140ad8d4", + "signature": "6wr/whNAaNTwI4kf1Bv4ZvOZmYWqd14C5wrRxXiXOKyyTAdmODCYUeSUBWXpWVyRYz02IplvFkZAmeWY0OooBw==", + "source_artifact_sha256": "7f144d0ed131ef44fd7db0ba5d3d03e685d681ea76df6a87fcf8bc20073786fe", "verified_at": "2026-08-18T11:13:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", @@ -5323,24 +5429,49 @@ "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "verifier-unavailable", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "ce46f3e2c640383fa7d86f238289722cb7a1f00c5ee3ba8994a54c6a140ad8d4", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "7f144d0ed131ef44fd7db0ba5d3d03e685d681ea76df6a87fcf8bc20073786fe", "facts": {}, "run_id_sha256": "4af84f2608a25a27e6252a5800263a238bb70fb3bec65148601ddcdddbf3e03c", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, - "verdict": "halted", + "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "cfd92154fe2f468fa965ab716b63dfdffaab97240c67cda15b262e993ccc3b08": { + "d34a532ac4e131739dbe4b1a354fb69615588aba68d7b32ece1a67e6475d1de3": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-138dfa227234ea5f", "receipt_type": "cleanup", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "yYdaU1nomYi+S8rnIXm4REYTPEB+ZEBt39JYeEQwDUQ9hNuGxzKD5K7ya7jYkf9qTWWns/jY9ydhp5QjGYwGBA==", - "source_artifact_sha256": "27c78ad5d0a8808752297aff7a4618ed4a5fb67e9ad3f7cb237a202a19a83282", + "signature": "hbA4RQdeBAH1yMBH3LCJDMAPiwpRM6fimyJbwZBirgbTxt5d5O5qbZD/zi1HxOBXR8w/yQPV7rfIHiLz8nKSBA==", + "source_artifact_sha256": "b2d52421d96d2fc81f80e91f43d0228f793bae8fefedbea6d79a281c903b0000", + "verified_at": "2026-08-18T10:33:00Z", + "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "4667302b580ff7ceb223dbb15eb6d029969a8f6a54bcd33e8df5b6bff41f41ad", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "idempotency-replay", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "b2d52421d96d2fc81f80e91f43d0228f793bae8fefedbea6d79a281c903b0000", + "facts": {}, + "run_id_sha256": "33e0ad9bf64e477f24d46508fa432123e046dcd1c5853d5cc60b7cde1bce7537", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 2, + "verdict": "completed", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "d4ff41fa574ae654044232a2f68be2a6088f2fca4634e84f2c9bca25f0fd095a": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", + "receipt_type": "fault", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "7NahN0ABenHGdDO9AY1zAQFvRm20uWz5nQL51PeNgQSs3T5y+JwiG/sc02PasdKbLvlswJlwc+8sF6tgYLCSDQ==", + "source_artifact_sha256": "99fd8516daeb8b22c42479814dbed2b01d63985db824c0237ed8ac83efd0dca0", "verified_at": "2026-08-18T11:03:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", @@ -5348,24 +5479,24 @@ "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "ambiguous-target", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "27c78ad5d0a8808752297aff7a4618ed4a5fb67e9ad3f7cb237a202a19a83282", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "99fd8516daeb8b22c42479814dbed2b01d63985db824c0237ed8ac83efd0dca0", "facts": {}, "run_id_sha256": "43f0a1c00950c390b0676fab55a2aa98c354d028f2347c461661e6cdb72f717e", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, - "verdict": "completed", + "verdict": "injected", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "d11f22309560ed2a7f681efe767e871d45348f2d0a1d80616d8e4dd7012e0044": { + "d60014d00d95de05d2aa6c483badfdc804e23c55ae4507eebe8631460453bd80": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d7e1e084be213b01", - "receipt_type": "observer", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "y0VtEXaHH1mVKNwMAeG/w0ej2wA5f6qgmh1SiFlFLAaWXPjfoyKLxFUw0LwooLcCjpiz5h13xNL2WQ5oRUPpDQ==", - "source_artifact_sha256": "8558af088d566bf88f4efb53d9cea316fe8385eb40828881aa49418896707c6b", + "signature": "Pzj/COMHBKGfLDGOhe1n3SS0n6yTI4BwMe+noWW4yLX/vJDSlBTXsZUP7yXWoBEZ1t+jYPTZ5LGN+o2DpJBSAg==", + "source_artifact_sha256": "27c78ad5d0a8808752297aff7a4618ed4a5fb67e9ad3f7cb237a202a19a83282", "verified_at": "2026-08-18T11:03:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", @@ -5373,87 +5504,58 @@ "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "ambiguous-target", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "8558af088d566bf88f4efb53d9cea316fe8385eb40828881aa49418896707c6b", - "facts": { - "derived_classifications": { - "collateral_effect_count": 0, - "duplicate_effect_count": 0, - "intended_effect_count": 0, - "wrong_record_count": 0 - }, - "dispatch_state": "not_dispatched", - "effect_inventory": [], - "expected_record_id_sha256": "59fe7a772d3e5d4b6a0a7be45fee58a47c5f24f07c74194b30706733181154f2", - "expected_transaction_ref_sha256": "a8be1e17d0c4cc50bfa8b553cb0a6bea871938fac049f422d0806509a899d877", - "post_state_evidence_sha256": "e9b273e8e69522994820556ecbdf86e2b18858d6711bd9b4d62803a129c1023d", - "pre_state_evidence_sha256": "1c882102464e5733c3b705fd1eeb2cb7c0a634a5f654b5b736bd09798f555afe", - "verifier_method": "read_only_system_of_record_query", - "verifier_tier": "independent_system_of_record" - }, + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "27c78ad5d0a8808752297aff7a4618ed4a5fb67e9ad3f7cb237a202a19a83282", + "facts": {}, "run_id_sha256": "43f0a1c00950c390b0676fab55a2aa98c354d028f2347c461661e6cdb72f717e", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, - "verdict": "satisfied", + "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "d67f951f5150477f5b6f23fd49cfb5dfb983c77c6f000ed977da83aa142ef62b": { + "d70c74f1d0238a775c431b4fef499d5fb69de66dbf971bfc1338164bb9c4ad87": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", - "receipt_type": "runner", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "thRMAnSS+CpGKJ1Z8rA2Vmcn8QzCAyCKbNbw07VfbUhXPesSZFV5W+XJVtQu5LL98b6Ec3IWRvcimw1lDP8dBg==", - "source_artifact_sha256": "41b0b0f3cb3d31cd294283b6d49a4982e36b7f34033f72e83a81354f0aa54a47", - "verified_at": "2026-08-18T11:12:00Z", + "signature": "v17G2g8j4iHOoYNTPuGOqM4flg5PFONeO7DjuXvvnmqVNqyPwbMvZR1OYso5ypZNtAHE7fVGtOTe2gMQkFAMBg==", + "source_artifact_sha256": "63a797c26af0607f83fd33dbce35617c4061915381435f3fbbd782b3554c15dc", + "verified_at": "2026-08-18T10:13:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "f5e96a2e9a580376b18beabf57798b8761e772a0c4d112877045780bb12b3720", + "attempt_id_sha256": "3d42601a69ef46cc44f57b51762affef4ccd829ffde30125619a6e582af00dab", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "verifier-unavailable", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "41b0b0f3cb3d31cd294283b6d49a4982e36b7f34033f72e83a81354f0aa54a47", - "facts": { - "model_call_counter": { - "attempted": 0, - "call_ids_sha256": [], - "completed": 0, - "cost_microusd": 0, - "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", - "input_tokens": 0, - "output_tokens": 0, - "provider_models": [], - "report_sha256": "41b0b0f3cb3d31cd294283b6d49a4982e36b7f34033f72e83a81354f0aa54a47", - "source": "runner_signed_flow_report_and_enforced_egress_policy" - }, - "operator_intervention_ids_sha256": [] - }, - "run_id_sha256": "e8e89651045a5f5c011c9543ed968e0fe7697a061ed8ad5cedc27d194cb96acb", + "condition": "healthy-02", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "63a797c26af0607f83fd33dbce35617c4061915381435f3fbbd782b3554c15dc", + "facts": {}, + "run_id_sha256": "091e13ed70dab439b31cb506cf3bba1ddf6476696531cf891c39a924a928b7a1", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, - "verdict": "halted", + "trial_index": 2, + "verdict": "verified", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "d798a4e28710daf65f49160ea167bc715efaea32bfab50c3d577df9d45bbad8d": { + "d8023b701bb9ddd9447290b34a26f019d4d699127273f0fce20637e6df56dc77": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-d7e1e084be213b01", "receipt_type": "observer", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "P2HYePnYFqg/SfdNfjsLTGNx1UrWCci1MXWVNFzheZequrOH05drHMdhCrt5H1q2DN4KsPlwdEgW/Uquz9cNBQ==", - "source_artifact_sha256": "6be0b951a73718afe96c480af0f29cc328de4d1d636fbaf54a6f89ba686a0158", - "verified_at": "2026-08-18T10:52:00Z", + "signature": "8ZtuSwCd1282hGRAK8W0udPLjMKxQ6Tn+HljjdB9fj962qixtUHBjUd9yHrhDGynFNClrF5QYShT98nPGtgVDw==", + "source_artifact_sha256": "79805e89b0f4e3d696c11dc8e97714ea0bcdca545f81356e0ed760612fe2925e", + "verified_at": "2026-08-18T10:44:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "fbfce2be9ce964be8b668aa518a310fe4a89e5c014f42bd0ea81401bd83bfd7a", + "attempt_id_sha256": "7c910764b2dcc6f05261d609082f75474e4638c3f356006307212b8fed4a2eb7", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "stale-session", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "6be0b951a73718afe96c480af0f29cc328de4d1d636fbaf54a6f89ba686a0158", + "condition": "wrong-reference", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "79805e89b0f4e3d696c11dc8e97714ea0bcdca545f81356e0ed760612fe2925e", "facts": { "derived_classifications": { "collateral_effect_count": 0, @@ -5463,103 +5565,114 @@ }, "dispatch_state": "not_dispatched", "effect_inventory": [], - "expected_record_id_sha256": "11c08ea44660ba4cd68dde056a3a33382ef9b2fab17d1a2ac0899ba89e3a06bb", - "expected_transaction_ref_sha256": "85cb9b53b37f373d46c90484e326aa99c41b13772cf3868c1552d3a5b13aad79", - "post_state_evidence_sha256": "52241460ac478f2828fb3c39fb8c608ea57a42dc778807e1d54ee6c80d7aa415", - "pre_state_evidence_sha256": "fd54b5eabca5a36d2a785dfd38d6322321f46d60b3389cd6bcff4f45bd19545e", + "expected_record_id_sha256": "0dc6218bdc8bf4591648aa33d57dff0688022d50b9056737ceed0685bbbf7e90", + "expected_transaction_ref_sha256": "d148dd9153e31c2d04b5dcdde5965456e7e3e1f0109b358519450847da148f59", + "post_state_evidence_sha256": "f5464e6e0f54cdf1afc377b423019b32f05125c5f5f85920a729408ecb6eb187", + "pre_state_evidence_sha256": "32bfcef60ea6496a047480ecb2cafe23403fde0a50d0f928378d3165f6243ff4", "verifier_method": "read_only_system_of_record_query", "verifier_tier": "independent_system_of_record" }, - "run_id_sha256": "d9270fd4c85e4226a9347ecf703e876b9ffdc330f60c7fb8bed8f9321ea30225", + "run_id_sha256": "fe98ce7f0e66b885201f4667875fd38f5890ffddb575d68bd4cd5a66f8d53ca8", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, + "trial_index": 3, "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "d8c483eb7b08e73b722f6a305a73fd8d2a4e36cf0339e42774d7fd5b64650c5c": { + "daed8a995ba6fa93c4ea90b3c4abd4fc8e02af4413208a3656a5e89ef27dbecb": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "N4yEf2/WOWU1YSU+NKOQ7iRUpsrvnnQG5rXTqIZF8lr1HI/B5NhPNlg/L7jIFWqRtnLoWWJVardmNS87q+flAg==", - "source_artifact_sha256": "343f637659566d84e7014bb1c057b6f9363086e8d04e122e7df754c45b3367d3", - "verified_at": "2026-08-18T10:33:00Z", + "signature": "Uxggu0l3He+RwCIgsayhsLAfzxH54bm0yJsT62fTMUQmk+kMZnw4shMH9o6kKklt2lDep6KDu9IDWoUctisLBQ==", + "source_artifact_sha256": "841ebd8beb38baf63b1ce9c65d1f22d80a15e36e268eab7f019f063c7242ce9e", + "verified_at": "2026-08-18T10:12:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "4667302b580ff7ceb223dbb15eb6d029969a8f6a54bcd33e8df5b6bff41f41ad", + "attempt_id_sha256": "940d3ca125ff87ce7539740fbae29d2d64fec839328b0639127e1d197d2485d8", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "idempotency-replay", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "343f637659566d84e7014bb1c057b6f9363086e8d04e122e7df754c45b3367d3", + "condition": "healthy-02", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "841ebd8beb38baf63b1ce9c65d1f22d80a15e36e268eab7f019f063c7242ce9e", "facts": {}, - "run_id_sha256": "33e0ad9bf64e477f24d46508fa432123e046dcd1c5853d5cc60b7cde1bce7537", + "run_id_sha256": "bbb9312ce4682b23580eced0f8d19438d8266b222555df85fb27eef22ad5afe2", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "verified", + "trial_index": 1, + "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "d8c7108342370f14c1531094e3fdaeecea401a7608d17e2873dbe1ac63b71982": { + "dba84e28fec7d0d05c90b7598eb773e94b04e02bb12c64e8093da4562e1c65a5": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", - "receipt_type": "runner", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "efh1rHZZCq7EROMDGbGAFxdIfqHRsPenzTPuEF1j58xhK7Od/6ujIc9UJnCZY/eAzY91eHEnfSdZfpnGBXs0AA==", - "source_artifact_sha256": "17bb1d69cfdd94f6150054ac594fc42cd59a8d09b780ee0103962cd549f157ef", - "verified_at": "2026-08-18T10:53:00Z", + "signature": "/5xSffhCdx2fPvNdehYrhERPd4HFRiehmxt2okD7Q8hN0XCfW5mkFjr+w6WNXRrQ0YSm1pN8pwZZHQkPpHKZCg==", + "source_artifact_sha256": "11cdb7bd9282bd8b9c10b25bd5e552c14ca6658cb559b133ce7e6b8dfc17f0f3", + "verified_at": "2026-08-18T10:42:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "f5df4d6e64a2d38ffa8e320c87ad05d04025de267a8e152a755d3f1928ded120", + "attempt_id_sha256": "e93521e706ad90d799dcd4e8cac15229c5da6aec1638540606f5fab4efce59fc", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "stale-session", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "17bb1d69cfdd94f6150054ac594fc42cd59a8d09b780ee0103962cd549f157ef", - "facts": { - "model_call_counter": { - "attempted": 0, - "call_ids_sha256": [], - "completed": 0, - "cost_microusd": 0, - "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", - "input_tokens": 0, - "output_tokens": 0, - "provider_models": [], - "report_sha256": "17bb1d69cfdd94f6150054ac594fc42cd59a8d09b780ee0103962cd549f157ef", - "source": "runner_signed_flow_report_and_enforced_egress_policy" - }, - "operator_intervention_ids_sha256": [] - }, - "run_id_sha256": "fd3a041b705d8c6277ce26134dc0018e866218cfa3fadd16ac29d1ad498965a3", + "condition": "wrong-reference", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "11cdb7bd9282bd8b9c10b25bd5e552c14ca6658cb559b133ce7e6b8dfc17f0f3", + "facts": {}, + "run_id_sha256": "ee82112f55e5e6c86cfd6e16df8c8b652549a8bd72de492f435d8255eb3dd252", + "runtime_validation_id": "66666666-6666-4666-8666-666666666666", + "task": "execute-acceptance", + "trial_index": 1, + "verdict": "absent", + "workflow_version_id": "44444444-4444-4444-8444-444444444444" + } + }, + "dc9ed744fcf4545fe79ed0ec6711dc10c9f4e72adee96bc7f6b2136318dbdba0": { + "algorithm": "ed25519", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", + "schema_version": "openadapt.qualification-evidence-receipt/v2", + "signature": "Qe7vdwycGV8zoFvL2GS6TeRGB6UkKSd3HgKcTDU2y2IdWES3yOaveLykjDEBEZ7gTb2EH0GjbfvIa8N3Tb+yBQ==", + "source_artifact_sha256": "40ce452beafd723531d21b631c3b7710042cff165f085f929b65d07e9575e16b", + "verified_at": "2026-08-18T11:14:00Z", + "verified_projection": { + "admission_id": "11111111-1111-4111-8111-111111111111", + "attempt_id_sha256": "ad76dacfe19a4421ef1f128d4eef1099e846b385d29f17b8588ae5130b487118", + "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", + "campaign_id": "12345678-1234-4abc-8def-1234567890ab", + "condition": "verifier-unavailable", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "40ce452beafd723531d21b631c3b7710042cff165f085f929b65d07e9575e16b", + "facts": {}, + "run_id_sha256": "87014cd8063f5a43ea22c995be03ec41ef5aa613145acacdef71b68c468fc8f1", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, + "trial_index": 3, "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "d8db564da881ce1888bee8e886f149da4ab06239ff1325fac6f2402738c33480": { + "dd40330fb969ed01f2c8bcc4a1fa780efd5c451f60561b8d1e9e0ffb63a1e3e4": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", "receipt_type": "fault", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "6IlPa7b4zT0OJ8OJLmSHtzuS5ypSdSstbVs6RUX8TkqTk2vBrHV4KimbQBv0khzcpTWNHbfnhBxd/S6D1JxNAA==", - "source_artifact_sha256": "e7f1dc034e24ac6d0aad3990e694aa281baa8c3e11415deb28fdd2e98bbdd313", - "verified_at": "2026-08-18T10:43:00Z", + "signature": "F78rKK/qSshGyrM9dB3nuaHdb/mMz/LXAxJuF4HVuFLlxkcdXhPvG0c+Ux/uWiDVOgtXnRLt5sPJFGrTNeiKAA==", + "source_artifact_sha256": "3e1b6e01581eb35f1854a259db0f29c5efdebe4507aefb8ab6d4b0201182593c", + "verified_at": "2026-08-18T11:23:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "6b0e5c10d55fc92c1ff8576392270a24fb65722414cf58ff9a51b8ce9ef88587", + "attempt_id_sha256": "eb52fb1b1bf2fac92d8f3a444bb5081161be8b3d0ef457c5065e7b79e96df770", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "wrong-reference", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "e7f1dc034e24ac6d0aad3990e694aa281baa8c3e11415deb28fdd2e98bbdd313", + "condition": "weak-effect-only", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "3e1b6e01581eb35f1854a259db0f29c5efdebe4507aefb8ab6d4b0201182593c", "facts": {}, - "run_id_sha256": "577e37b10b1c87fd9c1b5d320888b736d272824657fd59a012e85a284ee88540", + "run_id_sha256": "794033f9da2a42448254a478fb6de954898b1e544148708ad30264efdc255431", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, @@ -5567,257 +5680,222 @@ "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "db47eb5e8daad06624900c87959770bf1bddc5e74e391b0e7a7e31ce9521e8dc": { + "dd5e5c33b9db56b55fc0ccb1af376a113efa131da3bea56b565aef3ff5759516": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", - "receipt_type": "fault", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "zt7SJkyQiNerf3E3wMEA3mkKMcMneWLjM36DQhXzIEuqjcTwhqqXkXSuxzDTxMQVcU7P6nKK1mM6j45+GS8hAQ==", - "source_artifact_sha256": "0a6f7475010857b4c4c0c9f660926588236800ef17f86e670e163c98fa71c3a5", - "verified_at": "2026-08-18T10:44:00Z", + "signature": "sDMOjqEaUR3JS5T+07Wx84H86DTO/X5xyhU3K5tKJGufvYAYoibxtm1rNOHrltMyJWt3UMLbD/KbOjOmr8byCA==", + "source_artifact_sha256": "98f3bd644c3f5baa2083f90afb499c9a29160c8160a518c2d6fac7d9a3cf3792", + "verified_at": "2026-08-18T11:12:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "7c910764b2dcc6f05261d609082f75474e4638c3f356006307212b8fed4a2eb7", + "attempt_id_sha256": "f5e96a2e9a580376b18beabf57798b8761e772a0c4d112877045780bb12b3720", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "wrong-reference", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "0a6f7475010857b4c4c0c9f660926588236800ef17f86e670e163c98fa71c3a5", + "condition": "verifier-unavailable", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "98f3bd644c3f5baa2083f90afb499c9a29160c8160a518c2d6fac7d9a3cf3792", "facts": {}, - "run_id_sha256": "fe98ce7f0e66b885201f4667875fd38f5890ffddb575d68bd4cd5a66f8d53ca8", + "run_id_sha256": "e8e89651045a5f5c011c9543ed968e0fe7697a061ed8ad5cedc27d194cb96acb", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "injected", + "trial_index": 1, + "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "db5e2e6a02b80563230b4d36825d863af418ec707ae81789cc9001052351cc8a": { + "de2c701e952f9671103a4393bd10eeba2584ca9fc6cca70316ae7c641e5b85a8": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", - "receipt_type": "runner", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "FNH6rTHjQa60qW4dkvO+P/eoEMjuSaOCz7h5no0sImyPowD04iU8YL9qB+43HVQtpk+iMIHXC74fW8PExP8BCg==", - "source_artifact_sha256": "d216e429bd0611ac65b285ab73297d037fa3aeb3adb76d299da0c91d2559f159", - "verified_at": "2026-08-18T10:42:00Z", + "signature": "UvhB2Eu6khIuQP9SZRL4pd3igr7VcX2rczIsQgu3na9pYjgm0lZwFsES5/6iEyVtCcuO3gpEEKpHF6lIQwkhAA==", + "source_artifact_sha256": "8fd27141f1a8f201ab2aff52f1ba0273e506dc25a0fb7567513d140a1cc9a2fa", + "verified_at": "2026-08-18T11:04:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "e93521e706ad90d799dcd4e8cac15229c5da6aec1638540606f5fab4efce59fc", + "attempt_id_sha256": "491a544656d05aea37920e5c7e2ad65a9452eac8d6e100268a599aeebd41187a", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "wrong-reference", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "d216e429bd0611ac65b285ab73297d037fa3aeb3adb76d299da0c91d2559f159", - "facts": { - "model_call_counter": { - "attempted": 0, - "call_ids_sha256": [], - "completed": 0, - "cost_microusd": 0, - "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", - "input_tokens": 0, - "output_tokens": 0, - "provider_models": [], - "report_sha256": "d216e429bd0611ac65b285ab73297d037fa3aeb3adb76d299da0c91d2559f159", - "source": "runner_signed_flow_report_and_enforced_egress_policy" - }, - "operator_intervention_ids_sha256": [] - }, - "run_id_sha256": "ee82112f55e5e6c86cfd6e16df8c8b652549a8bd72de492f435d8255eb3dd252", + "condition": "ambiguous-target", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "8fd27141f1a8f201ab2aff52f1ba0273e506dc25a0fb7567513d140a1cc9a2fa", + "facts": {}, + "run_id_sha256": "aa62c7a17701a7ef01ea1d3519b4c1f90d357495b329fdda3054cc24c581a593", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, + "trial_index": 3, "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "dc770cb91c01b638000f8f540bc2f3b6496f492d80b0aefed750b134a19bfe84": { + "e066293a7cb20f3bccf77602b6bfe1176453620852f969fb0c66ef9eea7d4d1e": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d7e1e084be213b01", - "receipt_type": "observer", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "pS+/Uwog+rPNeDxvdFYW48jGf9guYjdkPlA0unne2hDWInv5hpmfewEljXzU5PP2AtK05vDW4SZ8dMk+HzXGBQ==", - "source_artifact_sha256": "2a8bec5d9988588a24b36ed1499927f102d61b5867aad99f171fb4a89ce595bf", - "verified_at": "2026-08-18T10:12:00Z", + "signature": "P6rEymquRCJEiVik7076cOyrOaoAkk7ty0VYUIFz1XG09j93HDhHyLGm/Z+ENCAmnqZngkhjsxY6kKVEKJAnDw==", + "source_artifact_sha256": "48d2fa219c08a4043c3d974e574816a8b3952b9f1b5d638dd8a8fa098edc61dc", + "verified_at": "2026-08-18T10:33:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "940d3ca125ff87ce7539740fbae29d2d64fec839328b0639127e1d197d2485d8", + "attempt_id_sha256": "4667302b580ff7ceb223dbb15eb6d029969a8f6a54bcd33e8df5b6bff41f41ad", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-02", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "2a8bec5d9988588a24b36ed1499927f102d61b5867aad99f171fb4a89ce595bf", - "facts": { - "derived_classifications": { - "collateral_effect_count": 0, - "duplicate_effect_count": 0, - "intended_effect_count": 1, - "wrong_record_count": 0 - }, - "dispatch_state": "dispatched", - "effect_inventory": [ - { - "effect_id_sha256": "e45a708944b07484bedb1335618bb2857bff8fb3811b74e83938a3bdbc92954d", - "record_id_sha256": "4df580e44d7b5f5a68d9c2d8f8daa26c2026e2c1e0f00065d08fe22fa1dadfcf", - "transaction_ref_sha256": "0be7d7c67da1fcabbc08e5839af8f39802bd2f3ff7457b26f8723e000f65e968" - } - ], - "expected_record_id_sha256": "4df580e44d7b5f5a68d9c2d8f8daa26c2026e2c1e0f00065d08fe22fa1dadfcf", - "expected_transaction_ref_sha256": "0be7d7c67da1fcabbc08e5839af8f39802bd2f3ff7457b26f8723e000f65e968", - "post_state_evidence_sha256": "4fe967939f22b92004b65dc7ff985026be9b8bc32c59f69686c3672398bfffd3", - "pre_state_evidence_sha256": "4e350e2dcc8aa5ace5ee271d20a892b406060a57a6607b1875cb917f9857f32d", - "verifier_method": "read_only_system_of_record_query", - "verifier_tier": "independent_system_of_record" - }, - "run_id_sha256": "bbb9312ce4682b23580eced0f8d19438d8266b222555df85fb27eef22ad5afe2", + "condition": "idempotency-replay", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "48d2fa219c08a4043c3d974e574816a8b3952b9f1b5d638dd8a8fa098edc61dc", + "facts": {}, + "run_id_sha256": "33e0ad9bf64e477f24d46508fa432123e046dcd1c5853d5cc60b7cde1bce7537", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, - "verdict": "satisfied", + "trial_index": 2, + "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "de26659e031f4d186faf99c91d5b4506cf77d4cc82723581f5f163519c82b032": { + "e282152bb5eadade961a097c4e8008c9873da535ecf4bd66a9f93b48b4c12b2c": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-d92d542a589844dd", "receipt_type": "cleanup_absence", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "G4L95k7Qu5+iW+fNrlaPBmbxdrgxfO+DxDzpei5g9H+b7oyy/RC0uGS08S4aI+Fd6rWsUAoFIkZaYLrFcJdbAA==", - "source_artifact_sha256": "f48a35f45e70951886d40904c131ba517e46acb12368169e31b1c47de7ee6a8c", - "verified_at": "2026-08-18T10:12:00Z", + "signature": "OTLjxjsoa7Agwu0TF5S1M4G64ojJH7xIZmUflWvpRrXUanu9gXHpx/3nbjR9DATqNvCkWX9V2TgatjF2IE5RDQ==", + "source_artifact_sha256": "f48ec4e4f6e1af9e9a55730fef4ff0bc364683d1c08d1e0399281699f0f49444", + "verified_at": "2026-08-18T10:04:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "940d3ca125ff87ce7539740fbae29d2d64fec839328b0639127e1d197d2485d8", + "attempt_id_sha256": "4c352a6999f77707e8837adebb4fc2b7451c2ef6de5145190b33a5c5645e47eb", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-02", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "f48a35f45e70951886d40904c131ba517e46acb12368169e31b1c47de7ee6a8c", + "condition": "healthy-01", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "f48ec4e4f6e1af9e9a55730fef4ff0bc364683d1c08d1e0399281699f0f49444", "facts": {}, - "run_id_sha256": "bbb9312ce4682b23580eced0f8d19438d8266b222555df85fb27eef22ad5afe2", + "run_id_sha256": "4ee2bb61fb883cc8e77d636fb471aa3c0ce9ef0c0a8abd9682214bf0a8f16f26", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, + "trial_index": 3, "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "de88bb941c8dcaf4123f41230b235a5097a327e4408dd496c8a658bba071fc6b": { + "e33062130a56980962cdd45e00ac2d71db223760ed14c5acb2f5821872eb4220": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", + "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", + "receipt_type": "fault", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "OK0eyBzGpm3xX05nkaMb91MJWZK/htHXk49QG0HqABJ170hpEgyFYGff2es0uRZqs3beaQ6AALnyoQWkG7BSBA==", - "source_artifact_sha256": "26eef6795405076a78c4a1d95d85251e7454d3059e296b07b2cf612e7b6231a2", - "verified_at": "2026-08-18T11:12:00Z", + "signature": "OwfYJbIvE/X1EEsxfCr/heqV5q5AZwoBULalZn4C8/oW8Sp2wTv0jROR7tBwkUl2QSl3pc9VWqCuJCEAakmbCw==", + "source_artifact_sha256": "c483629c37faa74e65b11335e5d15e741a5a1d5a7af2f6a4757767a446b00a34", + "verified_at": "2026-08-18T11:24:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "f5e96a2e9a580376b18beabf57798b8761e772a0c4d112877045780bb12b3720", + "attempt_id_sha256": "aa7d6be4f25a8992c0a22649ba7e703d6955abf5fece9f8322f560149cf09776", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "verifier-unavailable", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "26eef6795405076a78c4a1d95d85251e7454d3059e296b07b2cf612e7b6231a2", + "condition": "weak-effect-only", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "c483629c37faa74e65b11335e5d15e741a5a1d5a7af2f6a4757767a446b00a34", "facts": {}, - "run_id_sha256": "e8e89651045a5f5c011c9543ed968e0fe7697a061ed8ad5cedc27d194cb96acb", + "run_id_sha256": "b974de9da8ef77c8dc9a7662114cc51023ab8c131c488681eeebb7d4c435c8d0", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, - "verdict": "halted", + "trial_index": 3, + "verdict": "injected", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "deda444b535e16e5e8c0b26f674bb9facf018b808a1c734a23d2b75101819f47": { + "e55fc92a3febcc53207995f1a919d397f5dbd2c4ace7d0c24adf3ac6f81d01a4": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "pcnMpOk8rb/NSgWv3/vabv09JwnpMM1m5J1KtJolFQgSIN99z9ERtfwqZ616kBEPysMaAlRwx2owjvWNvoJ/DQ==", - "source_artifact_sha256": "23708d813c5434c08faf44e36a798621030200b33f634d785750d86cf7fb96d7", - "verified_at": "2026-08-18T10:52:00Z", + "signature": "7xl3JBIWhMsR3+lHGUXW9ap1YsUpmZcmpyTd0uO3jeYvaS7/F8G0NdOOuld9yKdjAHhLpx2zpPL3HetJNBoqCA==", + "source_artifact_sha256": "a46df95e5690b582be425e126233998cf8a82e1db8ea11a5dade90b3cc616b28", + "verified_at": "2026-08-18T10:14:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "fbfce2be9ce964be8b668aa518a310fe4a89e5c014f42bd0ea81401bd83bfd7a", + "attempt_id_sha256": "019dd96e9a771ccc01ebafab321d7d3a8314df8b2d6465bcfc5fa14cbdeabdf2", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "stale-session", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "23708d813c5434c08faf44e36a798621030200b33f634d785750d86cf7fb96d7", + "condition": "healthy-02", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "a46df95e5690b582be425e126233998cf8a82e1db8ea11a5dade90b3cc616b28", "facts": {}, - "run_id_sha256": "d9270fd4c85e4226a9347ecf703e876b9ffdc330f60c7fb8bed8f9321ea30225", + "run_id_sha256": "16cb8df40654c6a1b55ea0e50e772d8c6e6d4f0d8205bd1f8296be27d0af83eb", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, - "verdict": "absent", + "trial_index": 3, + "verdict": "verified", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "def8a0faa88928a2b87804705ece6f712edd9aeb7ca4fed4e066fdaea75229ca": { + "e672f1eff631061fb1f20abeff4f9fb5665c21c0e955eeae412756c51214a1b8": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "Llxo9aweTrBl+MQyPqgZYRWWmXOc2gzHFO62vlGfEgfT3q5oaKT79u9EBFRxEAafIwiCCErCKrQz35R9sTcXBA==", - "source_artifact_sha256": "fe35b956dbe29b97bcbf293cf40b9c9c9c6eac8466925d706e684648b3d43d9b", - "verified_at": "2026-08-18T10:43:00Z", + "signature": "OBQz5xuwFdmXNl+wFQhQlQUG1otbUn+rLuszjiz5Wu8g6GhIM+34/6shebgSBJU3jF0+R1GAbunktciH8MNcAw==", + "source_artifact_sha256": "4b49c957d7eeb5d558fc4b83415475999503aa48aa8d8be5ec00a745b6c78701", + "verified_at": "2026-08-18T10:13:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "6b0e5c10d55fc92c1ff8576392270a24fb65722414cf58ff9a51b8ce9ef88587", + "attempt_id_sha256": "3d42601a69ef46cc44f57b51762affef4ccd829ffde30125619a6e582af00dab", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "wrong-reference", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "fe35b956dbe29b97bcbf293cf40b9c9c9c6eac8466925d706e684648b3d43d9b", + "condition": "healthy-02", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "4b49c957d7eeb5d558fc4b83415475999503aa48aa8d8be5ec00a745b6c78701", "facts": {}, - "run_id_sha256": "577e37b10b1c87fd9c1b5d320888b736d272824657fd59a012e85a284ee88540", + "run_id_sha256": "091e13ed70dab439b31cb506cf3bba1ddf6476696531cf891c39a924a928b7a1", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, - "verdict": "delivered", + "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "df5539d0273ef7fe8dad28520de2664d6cb1434aa1bc7973d5099129ea8e9fb3": { + "e8bbd93c51bc2e86b09e750273dd69c2d90b06a93d4eca6f1511246a32021c49": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-e37abcd79efd08db", "receipt_type": "replay", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "Veo5DttSA+B85eGTldyhZXGLTF0LTSnrktezVFo1oIRUGI20v5lxX53M/n7OqeX3p4nU7tQqjvMbLR3mFrBbBQ==", - "source_artifact_sha256": "dcdc96c4f09e390d61f558318a74baef2f65d601e71808bdbf922fcc7f4d5bbf", - "verified_at": "2026-08-18T10:03:00Z", + "signature": "zw5Z1o27/TBYWsZwQ29pmOtJt2nP1SG0h2+Lths/9s+UQUPgVIjI19eUm3EU1VbxUumO9x1+hcaZR7f4yth8Dw==", + "source_artifact_sha256": "ce46f3e2c640383fa7d86f238289722cb7a1f00c5ee3ba8994a54c6a140ad8d4", + "verified_at": "2026-08-18T11:13:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "fdad940f245d690750ad647fac25c7e76aac2f474db49732fec8129051750186", + "attempt_id_sha256": "42259dbb767ced4c25ad8bd40edc209720a748897194c925ed9bd2e27b2258b2", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-01", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "dcdc96c4f09e390d61f558318a74baef2f65d601e71808bdbf922fcc7f4d5bbf", + "condition": "verifier-unavailable", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "ce46f3e2c640383fa7d86f238289722cb7a1f00c5ee3ba8994a54c6a140ad8d4", "facts": {}, - "run_id_sha256": "3739043a92a8781376cfbd022460c03aba40f92a800b3885ebc046321437bc40", + "run_id_sha256": "4af84f2608a25a27e6252a5800263a238bb70fb3bec65148601ddcdddbf3e03c", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, - "verdict": "verified", + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "e326380f27a42e658689cce26a59cdfb4867f512ba7016355487954a99eeaebe": { + "e99df9ae7a8e510d9ec14c8726238fb981612f4b41b0fb4bf26290627f367e5c": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-d7e1e084be213b01", "receipt_type": "observer", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "7HYw2QGFquf1FBbLF99jPcv9V+9kLVNGuD4QMXtAYZx+izTLv4GA4Vcn8T+Aqqn9eyTU8KiePNkPkHiwq/JTAw==", - "source_artifact_sha256": "bd93f6e9d767166a948c91db13a6d6ebf759630b605e6ecf130420e0511ee3a4", - "verified_at": "2026-08-18T11:24:00Z", + "signature": "iwv0xiclJ57mvTXKJNCXm8Hc3li7qVpl8yD9nmMV1j3/9guAlsZ89DVqPSAICXS1/omIyFsiyYVofQ47//f+Dg==", + "source_artifact_sha256": "8558af088d566bf88f4efb53d9cea316fe8385eb40828881aa49418896707c6b", + "verified_at": "2026-08-18T11:03:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "aa7d6be4f25a8992c0a22649ba7e703d6955abf5fece9f8322f560149cf09776", + "attempt_id_sha256": "1ec11a9862ede3ac701af71835ac28c551d604a026b5bab7d776dbcdf288394e", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "weak-effect-only", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "bd93f6e9d767166a948c91db13a6d6ebf759630b605e6ecf130420e0511ee3a4", + "condition": "ambiguous-target", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "8558af088d566bf88f4efb53d9cea316fe8385eb40828881aa49418896707c6b", "facts": { "derived_classifications": { "collateral_effect_count": 0, @@ -5827,340 +5905,262 @@ }, "dispatch_state": "not_dispatched", "effect_inventory": [], - "expected_record_id_sha256": "91f268174be0ceea4f27f6197630a299cc2f5dc0379f1859cda04db7338cc8a1", - "expected_transaction_ref_sha256": "fa34ce5dcf42475c8fa7fd73aa540e619bfcdd17cf7d0918a856e509e97519dc", - "post_state_evidence_sha256": "8fd9d8558584962f398038ede8eaf254e6895128716fa04aedef64b87739d1dc", - "pre_state_evidence_sha256": "4419443833f8d0cc9306d316ad6ddc83f67571cc61f83fad22133b179cb5ff1c", + "expected_record_id_sha256": "59fe7a772d3e5d4b6a0a7be45fee58a47c5f24f07c74194b30706733181154f2", + "expected_transaction_ref_sha256": "a8be1e17d0c4cc50bfa8b553cb0a6bea871938fac049f422d0806509a899d877", + "post_state_evidence_sha256": "e9b273e8e69522994820556ecbdf86e2b18858d6711bd9b4d62803a129c1023d", + "pre_state_evidence_sha256": "1c882102464e5733c3b705fd1eeb2cb7c0a634a5f654b5b736bd09798f555afe", "verifier_method": "read_only_system_of_record_query", "verifier_tier": "independent_system_of_record" }, - "run_id_sha256": "b974de9da8ef77c8dc9a7662114cc51023ab8c131c488681eeebb7d4c435c8d0", - "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "task": "execute-acceptance", - "trial_index": 3, - "verdict": "satisfied", - "workflow_version_id": "44444444-4444-4444-8444-444444444444" - } - }, - "e3d0a44d6733f68ad2f52b4ebe689b65537b49e3e2d2b06c7599db54a93a36b9": { - "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-138dfa227234ea5f", - "receipt_type": "cleanup", - "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "wwxdABdepAUpLm1Y5tZ+O0o+Ga3qN355W+imb7TWguJYy1waVYhqUzAfUUjKQwcUP+wZa1ZUQkLAqd1+NmaIAw==", - "source_artifact_sha256": "11f183b9a6fd7d20a3cfc66e95960832da64804b9d3f6980ee365679b3a1793f", - "verified_at": "2026-08-18T11:13:00Z", - "verified_projection": { - "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "42259dbb767ced4c25ad8bd40edc209720a748897194c925ed9bd2e27b2258b2", - "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "verifier-unavailable", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "11f183b9a6fd7d20a3cfc66e95960832da64804b9d3f6980ee365679b3a1793f", - "facts": {}, - "run_id_sha256": "4af84f2608a25a27e6252a5800263a238bb70fb3bec65148601ddcdddbf3e03c", + "run_id_sha256": "43f0a1c00950c390b0676fab55a2aa98c354d028f2347c461661e6cdb72f717e", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 2, - "verdict": "completed", + "verdict": "satisfied", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "e3d1c240c70aaf5b49945c1a2cfef7f1c7f1c61de81e67dde515b07827a87bb2": { + "eca7232d2c8d672f305cd7abf41def93d615c0e5d58c38a64650fca637451c39": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-d92d542a589844dd", - "receipt_type": "cleanup_absence", + "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", + "receipt_type": "fault", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "6L4LwODFHNex4to54t1Yzaoqvmc1tIbtA0cfE2YdrJfRIP3Is1hpvuqOAR7tXxmUAHj0mH45/6Bo8M25CRX8BQ==", - "source_artifact_sha256": "2fc83a9ad4cdeaa8faf4176f24cd5390e451a993166626508572a5c6a7663659", - "verified_at": "2026-08-18T10:13:00Z", + "signature": "iy7Xcdv2lQdV0mFk4i2UCLZ2jB8PPQtP7hAfnHOMHgywYEKKfxm0NX21qa0+/mE8021XpKMetlF31uZYJEneBA==", + "source_artifact_sha256": "4337a75a39ceb7d333cbceb0fb54815f7dbe029048dbe20740c85d0b31f4d202", + "verified_at": "2026-08-18T10:52:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "3d42601a69ef46cc44f57b51762affef4ccd829ffde30125619a6e582af00dab", + "attempt_id_sha256": "fbfce2be9ce964be8b668aa518a310fe4a89e5c014f42bd0ea81401bd83bfd7a", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-02", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "2fc83a9ad4cdeaa8faf4176f24cd5390e451a993166626508572a5c6a7663659", + "condition": "stale-session", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "4337a75a39ceb7d333cbceb0fb54815f7dbe029048dbe20740c85d0b31f4d202", "facts": {}, - "run_id_sha256": "091e13ed70dab439b31cb506cf3bba1ddf6476696531cf891c39a924a928b7a1", + "run_id_sha256": "d9270fd4c85e4226a9347ecf703e876b9ffdc330f60c7fb8bed8f9321ea30225", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "absent", + "trial_index": 1, + "verdict": "injected", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "e5448eebaa458e6a8c2750acff6634232de77856d5c9920769cb1c3c90ab7b56": { + "ecd29911d1235cfb8ffe707f0bae080693b68a69ca99339d51f630f37bc637c8": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", + "issuer_key_id": "qe-ed25519-d92d542a589844dd", + "receipt_type": "cleanup_absence", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "dw398/e7OLLUAimKKztwLjRctYuv4Y2aMlDpG31j4tEH5f4YOWhFE6X5ZJKcENxP0aadEHNpK3huR1kaomfJBA==", - "source_artifact_sha256": "c5d1d4394bb4197462d6bb136e8e249ac9d8c283bf8563a8ffbd0b7e0141795f", - "verified_at": "2026-08-18T10:54:00Z", + "signature": "SuZsW/QCdSMxNOuZnppJxas5+9PL7GprNIXZKKDGoMMWaJDzAUeCUC9W5De4cUQyVgXMiydIWGqV3LJhElAbBg==", + "source_artifact_sha256": "0aefdcb48f524cd1122dc1bfffdbcea74cc3d239411590ae1b6c6b5d0ca845b4", + "verified_at": "2026-08-18T10:43:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "958342a9ddca98a83b82b662f52f404239d583afe7ed70634760e1b8dd592f3b", + "attempt_id_sha256": "6b0e5c10d55fc92c1ff8576392270a24fb65722414cf58ff9a51b8ce9ef88587", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "stale-session", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "c5d1d4394bb4197462d6bb136e8e249ac9d8c283bf8563a8ffbd0b7e0141795f", + "condition": "wrong-reference", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "0aefdcb48f524cd1122dc1bfffdbcea74cc3d239411590ae1b6c6b5d0ca845b4", "facts": {}, - "run_id_sha256": "6f2fb10bc2018c9f78e9702d5ccac0bedd78ee3b2e9d2a6ad779fba72d90ae50", + "run_id_sha256": "577e37b10b1c87fd9c1b5d320888b736d272824657fd59a012e85a284ee88540", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, - "verdict": "delivered", + "trial_index": 2, + "verdict": "absent", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "e5d91e9b772fc407fe311e48b7b354f267782156817273b26f6906c7ef225ef3": { + "ed607c93d7fd7a73cc0b3b1209196d79e3c6b4b2a85e3ec6e42832071e531fbb": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", - "receipt_type": "runner", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "BRoKF7FySZgp2nHXrIj6jUF+PaHrpD3rqDW1KLlXOCkq/YAtFuFsYtOfo9sYnKpzpzAGcRg3Pw4ehlu6xFmUCg==", - "source_artifact_sha256": "e1dd07c3df4aed8ff42376ff74a3f68c13ebb7fb509304a544b0e8bde5b1f4ed", - "verified_at": "2026-08-18T10:02:00Z", + "signature": "1GYU4gm5o9431hRkxPqfz/O4h5CZ4NBSos/B54JR+OLgsU81pykQDgBXsODRNpajpzgb3zGZsFd6IJDZeJ7xAA==", + "source_artifact_sha256": "ffae42ea2ab78a78ef0b9b71e9b8a63f6b470d949ecfd892d84ebc512c1b64b9", + "verified_at": "2026-08-18T10:52:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "679af5a8dedceb8c696719e73f82a698c230cd8fc98bb61769f0883202c0b637", + "attempt_id_sha256": "fbfce2be9ce964be8b668aa518a310fe4a89e5c014f42bd0ea81401bd83bfd7a", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-01", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "e1dd07c3df4aed8ff42376ff74a3f68c13ebb7fb509304a544b0e8bde5b1f4ed", - "facts": { - "model_call_counter": { - "attempted": 0, - "call_ids_sha256": [], - "completed": 0, - "cost_microusd": 0, - "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", - "input_tokens": 0, - "output_tokens": 0, - "provider_models": [], - "report_sha256": "e1dd07c3df4aed8ff42376ff74a3f68c13ebb7fb509304a544b0e8bde5b1f4ed", - "source": "runner_signed_flow_report_and_enforced_egress_policy" - }, - "operator_intervention_ids_sha256": [] - }, - "run_id_sha256": "0b5bda916a0808165159166955a9563cf9c2303949f762a18eb037f41b44a6dc", + "condition": "stale-session", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "ffae42ea2ab78a78ef0b9b71e9b8a63f6b470d949ecfd892d84ebc512c1b64b9", + "facts": {}, + "run_id_sha256": "d9270fd4c85e4226a9347ecf703e876b9ffdc330f60c7fb8bed8f9321ea30225", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 1, - "verdict": "verified", + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "e7523a67b0d470b2e2f7d4ade8435b4fb6b5d1289862b50a57b7be2be42a84ee": { + "f25e5c3af01ead7c9c28efa1cb943b21d7784ef24cc55917aac60209f1d84563": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-138dfa227234ea5f", "receipt_type": "cleanup", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "YfZW8IzZfe9JEtG91pxEGIH1sT54Dm/GUBiDQbT+hpMrjh+Dm12KXqF+nIdtnICMk5AXplfwPSlIzNBfvyNiCA==", - "source_artifact_sha256": "13d5f53016f80b5ba9f95ceaa4d79970bbf9870cc12470744d0291bbef3a1cda", - "verified_at": "2026-08-18T10:24:00Z", + "signature": "F2s9OpyWz9H9duZpPsgAwPyenT1K+yuNqeJk3eZkg787AGD8D4YDNNJaj6z2UP23l/WYkc5lZT4zII33wTL0Cg==", + "source_artifact_sha256": "7d89d8f99f5fd27361d5750bd99439b0669933179a8e2ce8e3c66d7f551cf8c3", + "verified_at": "2026-08-18T10:43:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "7573925adbd8a7a4a3b98bb0379549d77aa8ed46e312c1cd940c05b8587a039e", + "attempt_id_sha256": "6b0e5c10d55fc92c1ff8576392270a24fb65722414cf58ff9a51b8ce9ef88587", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-03", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "13d5f53016f80b5ba9f95ceaa4d79970bbf9870cc12470744d0291bbef3a1cda", + "condition": "wrong-reference", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "7d89d8f99f5fd27361d5750bd99439b0669933179a8e2ce8e3c66d7f551cf8c3", "facts": {}, - "run_id_sha256": "784a0a94e581700a3d93581e7ce5bac0d3bc53c58f3e73198b896b5da9a819b0", + "run_id_sha256": "577e37b10b1c87fd9c1b5d320888b736d272824657fd59a012e85a284ee88540", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 3, + "trial_index": 2, "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "eb27d821b05fccea7ed8b1568a4607b8de8b629e8f50cba1e543e4af416045f0": { + "f55bdbcd08d65a4b50cc7672431077eb7b800690a249ed624dbfee53e9b54269": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", - "receipt_type": "runner", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "hdQXHoKq6LxzgS2wL/JC8LvV3V1Y52IZodJBwxayoDUU9ztE0dEwlt07CV8xb7qy/RrS4e8/idl+tc7SugzVDA==", - "source_artifact_sha256": "11df3fb01cf5dba128c9a69827676bb2d78cf90dedf8bd2071bcea42c25916e5", - "verified_at": "2026-08-18T10:33:00Z", + "signature": "dk8fvFQuXJfoZvbiPvX6M0c08ZDlXXwalEaS1+NbIcZQFuZlQl38omruxNEksfFWmxfRkYv8H56Im9S+DgkgAQ==", + "source_artifact_sha256": "f0e1b62eb7c877e3b75f5be31a69021e88bedc4ccfd95d69395483193bb5669f", + "verified_at": "2026-08-18T10:44:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "4667302b580ff7ceb223dbb15eb6d029969a8f6a54bcd33e8df5b6bff41f41ad", + "attempt_id_sha256": "7c910764b2dcc6f05261d609082f75474e4638c3f356006307212b8fed4a2eb7", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "idempotency-replay", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "11df3fb01cf5dba128c9a69827676bb2d78cf90dedf8bd2071bcea42c25916e5", - "facts": { - "model_call_counter": { - "attempted": 0, - "call_ids_sha256": [], - "completed": 0, - "cost_microusd": 0, - "egress_policy_sha256": "2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b2b", - "input_tokens": 0, - "output_tokens": 0, - "provider_models": [], - "report_sha256": "11df3fb01cf5dba128c9a69827676bb2d78cf90dedf8bd2071bcea42c25916e5", - "source": "runner_signed_flow_report_and_enforced_egress_policy" - }, - "operator_intervention_ids_sha256": [] - }, - "run_id_sha256": "33e0ad9bf64e477f24d46508fa432123e046dcd1c5853d5cc60b7cde1bce7537", + "condition": "wrong-reference", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "f0e1b62eb7c877e3b75f5be31a69021e88bedc4ccfd95d69395483193bb5669f", + "facts": {}, + "run_id_sha256": "fe98ce7f0e66b885201f4667875fd38f5890ffddb575d68bd4cd5a66f8d53ca8", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "verified", + "trial_index": 3, + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "f23a094951b21e87b4bf29d155bd5ec7826dd97188a34bd5899c9e0c9e36aafb": { + "f8f48e9e3248c7d0ff5743aaded0337b4a5bf5b5e10dc56f6d182ba2238e2909": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", + "issuer_key_id": "qe-ed25519-e37abcd79efd08db", + "receipt_type": "replay", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "ozqOEokMASNRViTX7ckGRMdSc+PueH8RYL59tqCzxMMX6oM+1KtS51fbJUGhuFqWg7ElCCipyM1gQm8YR1adBA==", - "source_artifact_sha256": "5774a782f9ec582ec3f9a710ccfee0a6b3fd6076d73029b33889cbb99d0526ed", - "verified_at": "2026-08-18T10:14:00Z", + "signature": "ZJsEfBNtoaV/y/a9OXCsjnvpfnzJIbdyEs7tQD89De+NKrU+mQNoZOCic6RZn3jROCict47GNzIuQYM9CNjQAg==", + "source_artifact_sha256": "65140882628aea7d2f64f788fcf9fcb6addfd372449a58a0221ac27b0355af3f", + "verified_at": "2026-08-18T11:24:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "019dd96e9a771ccc01ebafab321d7d3a8314df8b2d6465bcfc5fa14cbdeabdf2", + "attempt_id_sha256": "aa7d6be4f25a8992c0a22649ba7e703d6955abf5fece9f8322f560149cf09776", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-02", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "5774a782f9ec582ec3f9a710ccfee0a6b3fd6076d73029b33889cbb99d0526ed", + "condition": "weak-effect-only", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "65140882628aea7d2f64f788fcf9fcb6addfd372449a58a0221ac27b0355af3f", "facts": {}, - "run_id_sha256": "16cb8df40654c6a1b55ea0e50e772d8c6e6d4f0d8205bd1f8296be27d0af83eb", + "run_id_sha256": "b974de9da8ef77c8dc9a7662114cc51023ab8c131c488681eeebb7d4c435c8d0", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", "trial_index": 3, - "verdict": "delivered", + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "f308095e47a50231e48617fde6819ea8f160be521f2583b601c6f3c9918d3761": { + "f913628ac65d83f9342958c04e19732192bb7f2193f33071135bcc5f9c493e0a": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-138dfa227234ea5f", "receipt_type": "cleanup", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "lrngc1F/AV2utzoTMsRGMXelCGvUS9zrLWJiCML3Z7iHznvM5+s6XfVXe3WykL0AWCpnNizn0GOn3AoNdHITDw==", - "source_artifact_sha256": "ae52f89326f6a1eaced707ed240c61ddf62d1abbd3ac6891f3dc097aef1451cb", - "verified_at": "2026-08-18T11:12:00Z", + "signature": "iXGuLl8snNVt+qljbxvmmUVYCJ5nq3IS3l+NIhu2CTPCdEppwMY9+27o05LC/XK9cBgE5rbVP2uQhNLbyik5DQ==", + "source_artifact_sha256": "0c3d68b46266286eb32f09365d96174863b4fe9cac3fb3f91625fcbb4f521e71", + "verified_at": "2026-08-18T11:04:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "f5e96a2e9a580376b18beabf57798b8761e772a0c4d112877045780bb12b3720", + "attempt_id_sha256": "491a544656d05aea37920e5c7e2ad65a9452eac8d6e100268a599aeebd41187a", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "verifier-unavailable", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "ae52f89326f6a1eaced707ed240c61ddf62d1abbd3ac6891f3dc097aef1451cb", + "condition": "ambiguous-target", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "0c3d68b46266286eb32f09365d96174863b4fe9cac3fb3f91625fcbb4f521e71", "facts": {}, - "run_id_sha256": "e8e89651045a5f5c011c9543ed968e0fe7697a061ed8ad5cedc27d194cb96acb", + "run_id_sha256": "aa62c7a17701a7ef01ea1d3519b4c1f90d357495b329fdda3054cc24c581a593", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, + "trial_index": 3, "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "f3f0ca82ea31420f48cdc9b1c4cf01adf4e929df1a1b0a54506b4ab4a782de8e": { - "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", - "receipt_type": "webhook", - "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "4N5Dizov/Qq7wAooiKOfdJtIJSs/aeg2DuELnCWhjTz8LEpk/53lnBY2Oa0t1RQ5IlZMIOgfr/+u/UC0NaZuBQ==", - "source_artifact_sha256": "1bd19a3201a6b9102580819cf704a60ff2d91a1648a1ad38c4dc40806c809b38", - "verified_at": "2026-08-18T11:22:00Z", - "verified_projection": { - "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "73a097b8b20bab7794369384f7ca1d7d711aad07967b7e1292373babbb7ff1b7", - "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", - "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "weak-effect-only", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "1bd19a3201a6b9102580819cf704a60ff2d91a1648a1ad38c4dc40806c809b38", - "facts": {}, - "run_id_sha256": "b44783e70a980ec5b3cf3752bd5d1d01b2ff29f5a6892cba0c1c939d8aeb7c02", - "runtime_validation_id": "66666666-6666-4666-8666-666666666666", - "task": "execute-acceptance", - "trial_index": 1, - "verdict": "delivered", - "workflow_version_id": "44444444-4444-4444-8444-444444444444" - } - }, - "f415d84e6709d0d41f1a9df63018d95b34554defd6ca273b9ae24fb389b0d675": { + "fad513ff2c4d607d0cc89c2968562e199833a6369c89dd645e63e2c594b0c113": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", - "receipt_type": "fault", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "PTRUsvBA/6bGAMrMH4BxKex348JCbwjJMtitCr//7liQ1ZSecX4zD+JgWJy+93Vcje/e4N4kvlrI4Grl/Xx+Dw==", - "source_artifact_sha256": "3e1b6e01581eb35f1854a259db0f29c5efdebe4507aefb8ab6d4b0201182593c", - "verified_at": "2026-08-18T11:23:00Z", + "signature": "90bxnDVtmwlK9YRsvscYx+pU84RHZJ9+HNS2Io9Y7c+EmtWpTFtg2GcrTJtsaF1p8cJ93r2FVOSFWuRGJPbbDQ==", + "source_artifact_sha256": "f9f54cc3691f84eaf5543a39f915bc4b888249e20be389e737f07cc048fc796b", + "verified_at": "2026-08-18T11:24:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "eb52fb1b1bf2fac92d8f3a444bb5081161be8b3d0ef457c5065e7b79e96df770", + "attempt_id_sha256": "aa7d6be4f25a8992c0a22649ba7e703d6955abf5fece9f8322f560149cf09776", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", "condition": "weak-effect-only", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "3e1b6e01581eb35f1854a259db0f29c5efdebe4507aefb8ab6d4b0201182593c", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "f9f54cc3691f84eaf5543a39f915bc4b888249e20be389e737f07cc048fc796b", "facts": {}, - "run_id_sha256": "794033f9da2a42448254a478fb6de954898b1e544148708ad30264efdc255431", + "run_id_sha256": "b974de9da8ef77c8dc9a7662114cc51023ab8c131c488681eeebb7d4c435c8d0", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "injected", + "trial_index": 3, + "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "f7051979b50415fc22bf21c2e154a96b44c6e20344ac9a11cf02a7ed66576f23": { + "fca88ce0fba3856df363b1ba4579be6793c2855585ebdabea4ba802d9cc8f0e3": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-e37abcd79efd08db", - "receipt_type": "replay", + "issuer_key_id": "qe-ed25519-138dfa227234ea5f", + "receipt_type": "cleanup", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "meHOeild4X7djQxSaiI1jwFq3kHjnOcHUDjAe3q71F+HheX5KTP8DxfnbmImbtmB4k6a3xs1gRNZUh+8YOZdDw==", - "source_artifact_sha256": "94f304fac630bb580a17d9bcc9e35a0c85e9d873543699c6e9b5668ec6c6ea4b", - "verified_at": "2026-08-18T11:03:00Z", + "signature": "JZwjUyXAA28nH04GMTwitqG3cTQupzGDx/jxmslxfp6vjRIEbR1V8YQvb4m6XIOyhjlYOV2f9FuBjdR/8XjyDw==", + "source_artifact_sha256": "61e65cf0f747b77668ae9e6632a66d6d32d3dff99318b22ed782df46a78dbf0f", + "verified_at": "2026-08-18T10:44:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "1ec11a9862ede3ac701af71835ac28c551d604a026b5bab7d776dbcdf288394e", + "attempt_id_sha256": "7c910764b2dcc6f05261d609082f75474e4638c3f356006307212b8fed4a2eb7", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "ambiguous-target", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "94f304fac630bb580a17d9bcc9e35a0c85e9d873543699c6e9b5668ec6c6ea4b", + "condition": "wrong-reference", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "61e65cf0f747b77668ae9e6632a66d6d32d3dff99318b22ed782df46a78dbf0f", "facts": {}, - "run_id_sha256": "43f0a1c00950c390b0676fab55a2aa98c354d028f2347c461661e6cdb72f717e", + "run_id_sha256": "fe98ce7f0e66b885201f4667875fd38f5890ffddb575d68bd4cd5a66f8d53ca8", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "halted", + "trial_index": 3, + "verdict": "completed", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "f805590013237b1a309cbe766022724f3d5d0b02262b5aa432bfd9347dd7a458": { + "fcb2bf205f9e28e2bf93fc9ec2221798ea7ca0c49030c9f54ab594c5230ea767": { "algorithm": "ed25519", "issuer_key_id": "qe-ed25519-7300c0ae1429cd15", "receipt_type": "runner", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "dGoMRnb3hpxdYwhkajfdocgvO5gKVas8qSkIwM/xLM/Ls/Sf3qp2ml8eVUm+I/NVsJKdPvam2eQm09bdYw7RCQ==", - "source_artifact_sha256": "43d2d3f884205de0a56e566e84429edcbc2e0a31f4904212f36f787c3ea8df6a", - "verified_at": "2026-08-18T10:23:00Z", + "signature": "AwVR/E70AQ0ormrF7+alKCPd+3R6Zwu19Nu5+0UdxNmA8HX9RdRQEG9bEpFdCnI5v2VTUzuhuZy/JW0tHdiSBg==", + "source_artifact_sha256": "a19b4b67cbeff4e08ebe9a0818d950e8d1ebeec5dec837efe97635b5fb541ea0", + "verified_at": "2026-08-18T10:52:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "2601335b1101424105277997a67850a8a60aa45f59637b7679c1f32af463c460", + "attempt_id_sha256": "fbfce2be9ce964be8b668aa518a310fe4a89e5c014f42bd0ea81401bd83bfd7a", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "healthy-03", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "43d2d3f884205de0a56e566e84429edcbc2e0a31f4904212f36f787c3ea8df6a", + "condition": "stale-session", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "a19b4b67cbeff4e08ebe9a0818d950e8d1ebeec5dec837efe97635b5fb541ea0", "facts": { "model_call_counter": { "attempted": 0, @@ -6171,41 +6171,41 @@ "input_tokens": 0, "output_tokens": 0, "provider_models": [], - "report_sha256": "43d2d3f884205de0a56e566e84429edcbc2e0a31f4904212f36f787c3ea8df6a", + "report_sha256": "a19b4b67cbeff4e08ebe9a0818d950e8d1ebeec5dec837efe97635b5fb541ea0", "source": "runner_signed_flow_report_and_enforced_egress_policy" }, "operator_intervention_ids_sha256": [] }, - "run_id_sha256": "237a0b7d1cafb64b1d113dca6699e6eefeaaf0b18679138545c3695495b901d5", + "run_id_sha256": "d9270fd4c85e4226a9347ecf703e876b9ffdc330f60c7fb8bed8f9321ea30225", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 2, - "verdict": "verified", + "trial_index": 1, + "verdict": "halted", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } }, - "fe7e801fb8e3d5bfbe488815493a91fbf89f99a730cc2544e841f5373b49782d": { + "fdf2bedb4e2aaa2f2d45e711f95e827d4ca19cab6eb6718d496a7475806c0d86": { "algorithm": "ed25519", - "issuer_key_id": "qe-ed25519-59b2ad6131a74d03", - "receipt_type": "fault", + "issuer_key_id": "qe-ed25519-168c59a54a0d5b6c", + "receipt_type": "webhook", "schema_version": "openadapt.qualification-evidence-receipt/v2", - "signature": "fTwd1e4h5KsUD+GY3yfD0iNe6LYFWjCXnRVdIAQcGG4iSZn7U/HgbL/oMcJnG3MVPNhjlnOmtkFjNNHqZXs8Bw==", - "source_artifact_sha256": "753ac5d5256a729ac572debdef63e5a8acd11b2b6ef909f8efb94d885f37d065", - "verified_at": "2026-08-18T11:22:00Z", + "signature": "h/Z2oMdiVJggyFQrdozZA8Fl0BdBbd5P9t1NxTK3WSm2PVlOUNVTX4RjII/NDfKkWGzA5uFWniCo5w6cDPfOBg==", + "source_artifact_sha256": "fe35b956dbe29b97bcbf293cf40b9c9c9c6eac8466925d706e684648b3d43d9b", + "verified_at": "2026-08-18T10:43:00Z", "verified_projection": { "admission_id": "11111111-1111-4111-8111-111111111111", - "attempt_id_sha256": "73a097b8b20bab7794369384f7ca1d7d711aad07967b7e1292373babbb7ff1b7", + "attempt_id_sha256": "6b0e5c10d55fc92c1ff8576392270a24fb65722414cf58ff9a51b8ce9ef88587", "bundle_artifact_sha256": "1111111111111111111111111111111111111111111111111111111111111111", "campaign_id": "12345678-1234-4abc-8def-1234567890ab", - "condition": "weak-effect-only", - "evidence_identity_sha256": "e4a7728cb64c0d426e699ebb56d008a0e6fcfb8a5f9555026833de8da403e8af", - "evidence_sha256": "753ac5d5256a729ac572debdef63e5a8acd11b2b6ef909f8efb94d885f37d065", + "condition": "wrong-reference", + "evidence_identity_sha256": "58fddafe3b4d2c459e4d4b0422c9e8ee77bd87c4c218a50d0d9071d33c7b175c", + "evidence_sha256": "fe35b956dbe29b97bcbf293cf40b9c9c9c6eac8466925d706e684648b3d43d9b", "facts": {}, - "run_id_sha256": "b44783e70a980ec5b3cf3752bd5d1d01b2ff29f5a6892cba0c1c939d8aeb7c02", + "run_id_sha256": "577e37b10b1c87fd9c1b5d320888b736d272824657fd59a012e85a284ee88540", "runtime_validation_id": "66666666-6666-4666-8666-666666666666", "task": "execute-acceptance", - "trial_index": 1, - "verdict": "injected", + "trial_index": 2, + "verdict": "delivered", "workflow_version_id": "44444444-4444-4444-8444-444444444444" } } diff --git a/tests/test_import_production_acceptance.py b/tests/test_import_production_acceptance.py index edc9d50..acafb8e 100644 --- a/tests/test_import_production_acceptance.py +++ b/tests/test_import_production_acceptance.py @@ -51,6 +51,152 @@ def _attestation() -> dict[str, str]: } +def _lifecycle_policy_bytes() -> bytes: + def target( + target_id: str, + claim_scope: str, + *, + release_kind: str = "public_package", + artifact_kinds: list[str] | None = None, + project: str | None = None, + ) -> dict[str, object]: + kinds = artifact_kinds if artifact_kinds is not None else ["sdist", "wheel"] + return { + "id": target_id, + "display_name": target_id.title(), + "lifecycle_scope": "repository", + "lifecycle_subject": target_id, + "source_repository": f"OpenAdaptAI/{target_id}", + "release_kind": release_kind, + "required_claim_scope": claim_scope, + "required_artifact_kinds": kinds, + "package_index_project": project or target_id, + "artifact_authority_by_kind": {kind: "pypi" for kind in kinds}, + } + + targets = [ + target("agent", "qualified_agent_bridge_release"), + target("capture", "qualified_native_recorder_release"), + target( + "cloud", + "qualified_workflow_control_plane_deployment", + release_kind="private_deployment", + artifact_kinds=[], + ), + target( + "desktop", + "qualified_native_workflow_desktop_release", + artifact_kinds=[ + "linux-installer", + "macos-installer", + "sdist", + "wheel", + "windows-installer", + ], + ), + target( + "docs", + "production_documentation_deployment", + release_kind="public_deployment", + artifact_kinds=["deployment-manifest", "site-archive"], + ), + { + "id": "flow", + "display_name": "OpenAdapt Flow", + "lifecycle_scope": "repository", + "lifecycle_subject": "openadapt-flow", + "source_repository": "OpenAdaptAI/openadapt-flow", + "release_kind": "public_package", + "required_claim_scope": "qualified_workflow_runtime_release", + "required_artifact_kinds": ["sdist", "wheel"], + "package_index_project": "openadapt-flow", + "artifact_authority_by_kind": {"sdist": "pypi", "wheel": "pypi"}, + }, + target("openadapt", "qualified_workflow_launcher_release"), + ] + policy = { + "$schema": "schemas/production-lifecycle-policy.schema.json", + "schema_version": "openadapt.production-lifecycle-policy/v1", + "revision": 1, + "maximum_admission_days": 30, + "summary_authority": {}, + "targets": targets, + } + return (json.dumps(policy, indent=2) + "\n").encode() + + +def _flow_lifecycle_inputs( + source: dict[str, object] | None = None, +) -> tuple[bytes, dict[str, object], dict[str, object]]: + source = source or _derive() + bindings = source["bindings"] + assert isinstance(bindings, dict) + version = bindings["flow_version"] + commit = bindings["flow_release_commit"] + artifacts = [ + { + "authority": "pypi", + "kind": "sdist", + "name": f"openadapt_flow-{version}.tar.gz", + "sha256": "sha256:" + "c" * 64, + "size_bytes": 101, + "url": ( + "https://files.pythonhosted.org/packages/cc/cc/" + f"openadapt_flow-{version}.tar.gz" + ), + }, + { + "authority": "pypi", + "kind": "wheel", + "name": f"openadapt_flow-{version}-py3-none-any.whl", + "sha256": bindings["flow_wheel_sha256"], + "size_bytes": 202, + "url": ( + "https://files.pythonhosted.org/packages/dd/dd/" + f"openadapt_flow-{version}-py3-none-any.whl" + ), + }, + ] + release = { + "kind": "public_package", + "version": version, + "tag": f"v{version}", + "source_commit": commit, + "immutable_release_url": ( + "https://github.com/OpenAdaptAI/openadapt-flow/commit/" + commit + ), + "artifacts": artifacts, + } + metadata = { + "info": {"version": version}, + "urls": [ + { + "filename": artifact["name"], + "url": artifact["url"], + "size": artifact["size_bytes"], + "digests": { + "sha256": str(artifact["sha256"]).removeprefix("sha256:") + }, + "yanked": False, + } + for artifact in artifacts + ], + } + return _lifecycle_policy_bytes(), release, metadata + + +def _verified_flow_lifecycle( + source: dict[str, object] | None = None, +) -> object: + policy, release, metadata = _flow_lifecycle_inputs(source) + return MODULE.verify_production_lifecycle_release( + policy, + "flow", + release, + pypi_release_metadata=metadata, + ) + + def _resign_admission( admission: dict[str, object], campaign: dict[str, object], @@ -443,26 +589,74 @@ def test_derives_only_the_scoped_claim_and_counts_retained_rows() -> None: assert result["evidence_class"] == "qualified_browser_production_acceptance" assert result["claim_scope"] == "qualified_browser_workflow_on_bound_environment" assert result["claim_limit"] == "not_general_product_production_readiness" + task_id_sha256 = ( + "sha256:65288c82e132b7e66f264e5828b7427f7ad56121081c20a4fc662bb1a97fcf94" + ) + condition_ids = [ + "ambiguous-target", + "healthy-01", + "healthy-02", + "healthy-03", + "idempotency-replay", + "stale-session", + "verifier-unavailable", + "weak-effect-only", + "wrong-reference", + ] assert result["trial_inventory"] == { + "task_count": 1, "condition_count": 9, + "required_trial_count": 27, + "observed_trial_count": 27, "trial_count": 27, "minimum_trials_per_condition": 3, - "trials_per_condition": { - "ambiguous-target": 3, - "healthy-01": 3, - "healthy-02": 3, - "healthy-03": 3, - "idempotency-replay": 3, - "stale-session": 3, - "verifier-unavailable": 3, - "weak-effect-only": 3, - "wrong-reference": 3, - }, + "conditions": [ + { + "task_id_sha256": task_id_sha256, + "condition_id_sha256": MODULE.privacy_safe_campaign_label_sha256( + "qualification condition", + _campaign()["campaign_id"], + condition_id, + ), + "required_trial_count": 3, + "observed_trial_count": 3, + } + for condition_id in condition_ids + ], "excluded_trial_count": 0, } - assert result["derived_outcomes"]["verified"] == 12 - assert result["derived_outcomes"]["safe_halt"] == 15 + assert result["derived_outcomes"] == { + "verified": 12, + "safe_halt": 15, + "silent_incorrect_success": 0, + "over_halt": 0, + "wrong_record": 0, + "duplicate_effect": 0, + "collateral_effect": 0, + "uncertain_delivery": 0, + "platform_failure": 0, + "operator_intervention": 0, + "healthy_path_model_call": 0, + } + qualification = _certificate()["qualification"] + for field in ( + "campaign_contract_sha256", + "campaign_outcomes_sha256", + "oracle_contract_sha256", + "task_count", + "condition_count", + "required_trial_count", + "observed_trial_count", + ): + assert result["bindings"][field] == qualification[field] assert set(result["reliability"].values()) == {0} + assert result["bindings"]["evidence_runner_signer_sha256"] == ( + _certificate()["identities"]["evidence_runner_signer_sha256"] + ) + assert "managed_runner_signer_sha256" not in result["bindings"] + rendered = json.dumps(result, sort_keys=True) + assert "execute-acceptance" not in rendered + assert all(condition_id not in rendered for condition_id in condition_ids) assert "production_acceptance" not in result assert "class" not in result @@ -882,14 +1076,70 @@ def test_rejects_public_identity_digest_not_recomputed_from_admission(field: str _derive(certificate) -def test_rejects_author_supplied_certificate_trial_count() -> None: +@pytest.mark.parametrize( + "field,replacement", + [ + ("campaign_outcomes_sha256", "sha256:" + "0" * 64), + ("oracle_contract_sha256", "sha256:" + "0" * 64), + ("task_count", 2), + ("condition_count", 10), + ("required_trial_count", 26), + ("observed_trial_count", 28), + ], +) +def test_rejects_one_field_public_result_binding_substitution( + field: str, + replacement: str | int, +) -> None: certificate = _certificate() - certificate["qualification"]["observed_trial_count"] = 28 + certificate["qualification"][field] = replacement - with pytest.raises(MODULE.AcceptanceError, match="differs from retained rows"): + with pytest.raises(MODULE.AcceptanceError, match="differs"): _derive(certificate) +@pytest.mark.parametrize( + "field,label_kind,replacement", + [ + ("task_id_sha256", "qualification task", "execute-acceptance-mutated"), + ( + "condition_id_sha256", + "qualification condition", + "healthy-01-mutated", + ), + ], +) +def test_one_field_task_condition_identity_mutation_changes_result_digest( + field: str, + label_kind: str, + replacement: str, +) -> None: + result = _derive() + original_digest = MODULE.canonical_sha256(result) + mutated = copy.deepcopy(result) + mutated["trial_inventory"]["conditions"][0][field] = ( + MODULE.privacy_safe_campaign_label_sha256( + label_kind, + _campaign()["campaign_id"], + replacement, + ) + ) + + assert MODULE.canonical_sha256(mutated) != original_digest + + +@pytest.mark.parametrize("failure", MODULE._FAILURE_TAXONOMY) +def test_one_field_failure_taxonomy_count_mutation_changes_result_digest( + failure: str, +) -> None: + result = _derive() + original_digest = MODULE.canonical_sha256(result) + mutated = copy.deepcopy(result) + mutated["derived_outcomes"][failure] += 1 + + assert MODULE.canonical_sha256(mutated) != original_digest + + def test_rejects_unknown_signer_fingerprint_scheme() -> None: certificate = _certificate() certificate["identities"]["signer_fingerprint_scheme"] = "opaque-key-id" @@ -949,7 +1199,7 @@ def test_cli_refuses_before_it_reads_private_evidence( def test_rejects_collapsed_runner_observer_signing_identities() -> None: certificate = _certificate() - certificate["identities"]["managed_runner_signer_sha256"] = certificate["identities"][ + certificate["identities"]["evidence_runner_signer_sha256"] = certificate["identities"][ "target_observer_signer_sha256" ] @@ -1526,7 +1776,7 @@ def run(command: list[str], **_: object) -> subprocess.CompletedProcess[str]: (("qualification",), "environment_digest", "sha256:" + "b" * 64), ( ("identities",), - "managed_runner_signer_sha256", + "evidence_runner_signer_sha256", "sha256:" + "b" * 64, ), ], @@ -1880,6 +2130,535 @@ def mutate(envelope: dict[str, object]) -> None: _derive(certificate, campaign, admission) +def test_production_acceptance_target_scope_map_is_closed() -> None: + assert MODULE.PRODUCTION_ACCEPTANCE_TARGET_SCOPES == { + "agent": "qualified_agent_bridge_release", + "capture": "qualified_native_recorder_release", + "cloud": "qualified_workflow_control_plane_deployment", + "desktop": "qualified_native_workflow_desktop_release", + "docs": "production_documentation_deployment", + "flow": "qualified_workflow_runtime_release", + "openadapt": "qualified_workflow_launcher_release", + } + assert MODULE.production_acceptance_policy_sha256() == ( + "sha256:9b1fe55bc6796ae0a46960ca4aa335d88de60b0562c383afa1e85fa0a0c204b8" + ) + + +def test_builds_only_complete_target_neutral_production_manifest() -> None: + source = _derive() + original = copy.deepcopy(source) + lifecycle = _verified_flow_lifecycle(source) + + manifest = MODULE.build_production_acceptance_manifest( + source, + "flow", + lifecycle_release=lifecycle, + ) + + assert set(manifest) == { + "schema_version", + "target", + "claim_scope", + "verdict", + "acceptance_policy_sha256", + "lifecycle_policy_sha256", + "target_release_sha256", + "target_artifact_inventory_sha256", + "evidence_identity_sha256", + "source_evidence", + "qualification", + "failure_taxonomy_counts", + "reliability", + "retention", + } + assert manifest["schema_version"] == "openadapt.production-acceptance/v1" + assert manifest["target"] == "flow" + assert manifest["claim_scope"] == "qualified_workflow_runtime_release" + assert manifest["verdict"] == "accepted" + assert manifest[ + "acceptance_policy_sha256" + ] == MODULE.production_acceptance_policy_sha256() + assert manifest["lifecycle_policy_sha256"] == ( + "sha256:" + MODULE.hashlib.sha256(_lifecycle_policy_bytes()).hexdigest() + ) + assert set(manifest["source_evidence"]) == MODULE._PRODUCTION_SOURCE_EVIDENCE_KEYS + assert set(manifest["qualification"]) == MODULE._PRODUCTION_QUALIFICATION_KEYS + assert set(manifest["failure_taxonomy_counts"]) == set(MODULE._FAILURE_TAXONOMY) + assert set(manifest["reliability"]) == MODULE._RELIABILITY_KEYS + assert set(manifest["retention"]) == MODULE._RETENTION_KEYS + assert MODULE.validate_production_acceptance_manifest( + manifest, + source, + lifecycle_release=lifecycle, + ) == manifest + assert source == original + rendered = json.dumps(manifest, sort_keys=True) + assert "execute-acceptance" not in rendered + assert "healthy-01" not in rendered + assert '"conditions"' not in rendered + + +def test_manifest_uses_exact_lifecycle_release_and_artifact_digest_domains() -> None: + source = _derive() + lifecycle = _verified_flow_lifecycle(source) + manifest = MODULE.build_production_acceptance_manifest( + source, + "flow", + lifecycle_release=lifecycle, + ) + release = lifecycle.release() + artifacts = lifecycle.artifacts() + assert manifest["target_release_sha256"] == MODULE._domain_sha256( + b"OpenAdapt production lifecycle target release v1\0", + { + "target": "flow", + "claim_scope": "qualified_workflow_runtime_release", + "release": release, + }, + ) + assert manifest["target_artifact_inventory_sha256"] == MODULE._domain_sha256( + b"OpenAdapt production lifecycle artifact inventory v1\0", + { + "target": "flow", + "claim_scope": "qualified_workflow_runtime_release", + "artifacts": artifacts, + }, + ) + + +def test_cloud_manifest_requires_reviewed_deployment_manifest_binding() -> None: + source = _derive() + + with pytest.raises(MODULE.AcceptanceError, match="reviewed deployment-manifest binding"): + MODULE.build_production_acceptance_manifest( + source, + "cloud", + lifecycle_release=_verified_flow_lifecycle(source), + ) + + +@pytest.mark.parametrize( + "target", + ["agent", "capture", "desktop", "docs", "openadapt"], +) +def test_browser_source_refuses_target_without_its_evidence_adapter(target: str) -> None: + with pytest.raises(MODULE.AcceptanceError, match="requires its own evidence adapter"): + MODULE.build_production_acceptance_manifest( + _derive(), + target, + lifecycle_release=_verified_flow_lifecycle(), + ) + + +@pytest.mark.parametrize( + "path,replacement", + [ + (("schema_version",), "openadapt.production-acceptance/v2"), + (("target",), "cloud"), + (("claim_scope",), "qualified_workflow_control_plane_deployment"), + (("verdict",), "rejected"), + (("acceptance_policy_sha256",), "sha256:" + "0" * 64), + (("lifecycle_policy_sha256",), "sha256:" + "0" * 64), + (("target_release_sha256",), "sha256:" + "0" * 64), + (("target_artifact_inventory_sha256",), "sha256:" + "0" * 64), + (("evidence_identity_sha256",), "sha256:" + "0" * 64), + (("source_evidence", "certificate_sha256"), "sha256:" + "0" * 64), + (("qualification", "oracle_contract_sha256"), "sha256:" + "0" * 64), + (("failure_taxonomy_counts", "verified"), 13), + (("reliability", "model_call_count"), 1), + (("retention", "head_verified"), False), + ], +) +def test_one_field_production_manifest_mutation_refuses( + path: tuple[str, ...], + replacement: object, +) -> None: + source = _derive() + lifecycle = _verified_flow_lifecycle(source) + manifest = MODULE.build_production_acceptance_manifest( + source, + "flow", + lifecycle_release=lifecycle, + ) + mutated = copy.deepcopy(manifest) + target: dict[str, object] = mutated + for key in path[:-1]: + nested = target[key] + assert isinstance(nested, dict) + target = nested + target[path[-1]] = replacement + + with pytest.raises(MODULE.AcceptanceError): + MODULE.validate_production_acceptance_manifest( + mutated, + source, + lifecycle_release=lifecycle, + ) + + +def test_production_manifest_rejects_missing_or_extra_field() -> None: + source = _derive() + lifecycle = _verified_flow_lifecycle(source) + manifest = MODULE.build_production_acceptance_manifest( + source, + "flow", + lifecycle_release=lifecycle, + ) + missing = copy.deepcopy(manifest) + del missing["acceptance_policy_sha256"] + extra = copy.deepcopy(manifest) + extra["production_ready"] = True + + for mutation in (missing, extra): + with pytest.raises(MODULE.AcceptanceError, match="manifest keys differ"): + MODULE.validate_production_acceptance_manifest( + mutation, + source, + lifecycle_release=lifecycle, + ) + + +def test_lifecycle_release_must_be_verifier_derived_and_is_immutable() -> None: + source = _derive() + with pytest.raises(MODULE.AcceptanceError, match="verifier-derived"): + MODULE.build_production_acceptance_manifest( + source, + "flow", + lifecycle_release={}, + ) + lifecycle = _verified_flow_lifecycle(source) + with pytest.raises(AttributeError, match="immutable"): + lifecycle._target = "cloud" + release_copy = lifecycle.release() + release_copy["version"] = "9.9.9" + assert lifecycle.release()["version"] != "9.9.9" + + +def test_lifecycle_release_cannot_be_constructed_from_caller_digests() -> None: + with pytest.raises(TypeError, match="only be created by the lifecycle verifier"): + MODULE.VerifiedProductionLifecycleRelease( + target="flow", + claim_scope="qualified_workflow_runtime_release", + lifecycle_policy_sha256="sha256:" + "0" * 64, + release={}, + artifacts=[], + _seal=object(), + ) + + +def test_lifecycle_policy_digest_binds_exact_raw_bytes() -> None: + source = _derive() + policy, release, metadata = _flow_lifecycle_inputs(source) + lifecycle_a = MODULE.verify_production_lifecycle_release( + policy, + "flow", + release, + pypi_release_metadata=metadata, + ) + lifecycle_b = MODULE.verify_production_lifecycle_release( + b"\n" + policy, + "flow", + release, + pypi_release_metadata=metadata, + ) + assert lifecycle_a.lifecycle_policy_sha256 != lifecycle_b.lifecycle_policy_sha256 + manifest_a = MODULE.build_production_acceptance_manifest( + source, + "flow", + lifecycle_release=lifecycle_a, + ) + manifest_b = MODULE.build_production_acceptance_manifest( + source, + "flow", + lifecycle_release=lifecycle_b, + ) + assert manifest_a["lifecycle_policy_sha256"] != manifest_b[ + "lifecycle_policy_sha256" + ] + assert manifest_a["acceptance_policy_sha256"] == manifest_b[ + "acceptance_policy_sha256" + ] + + +@pytest.mark.parametrize( + "mutation,expected", + [ + (lambda release: release.__setitem__("kind", "private_deployment"), "identity"), + (lambda release: release.__setitem__("tag", "v9.9.9"), "identity"), + (lambda release: release.__setitem__("source_commit", "bad"), "commit"), + ( + lambda release: release.__setitem__( + "immutable_release_url", + "https://github.com/OpenAdaptAI/openadapt-flow/releases/tag/v1.0.0", + ), + "exact commit", + ), + (lambda release: release.__setitem__("extra", True), "keys differ"), + ], +) +def test_lifecycle_verifier_refuses_invalid_release_shape( + mutation: object, + expected: str, +) -> None: + policy, release, metadata = _flow_lifecycle_inputs() + mutation(release) + with pytest.raises(MODULE.AcceptanceError, match=expected): + MODULE.verify_production_lifecycle_release( + policy, + "flow", + release, + pypi_release_metadata=metadata, + ) + + +@pytest.mark.parametrize( + "mutation,expected", + [ + (lambda artifacts: artifacts.pop(), "one sdist and one wheel"), + (lambda artifacts: artifacts.reverse(), "sorted sdist and wheel"), + ( + lambda artifacts: artifacts[0].__setitem__("authority", "github_release"), + "authority is invalid", + ), + (lambda artifacts: artifacts[0].__setitem__("name", "bad name"), "name"), + (lambda artifacts: artifacts[0].__setitem__("sha256", "bad"), "digest"), + (lambda artifacts: artifacts[0].__setitem__("size_bytes", 0), "size"), + ( + lambda artifacts: artifacts[0].__setitem__( + "url", "https://example.com/openadapt_flow.tar.gz" + ), + "not from PyPI", + ), + ( + lambda artifacts: artifacts[0].__setitem__( + "url", + str(artifacts[0]["url"]) + "?download=1", + ), + "clean HTTPS URL", + ), + (lambda artifacts: artifacts[0].__setitem__("extra", True), "keys differ"), + ], +) +def test_lifecycle_verifier_refuses_invalid_artifact_inventory( + mutation: object, + expected: str, +) -> None: + policy, release, metadata = _flow_lifecycle_inputs() + artifacts = release["artifacts"] + assert isinstance(artifacts, list) + mutation(artifacts) + with pytest.raises(MODULE.AcceptanceError, match=expected): + MODULE.verify_production_lifecycle_release( + policy, + "flow", + release, + pypi_release_metadata=metadata, + ) + + +@pytest.mark.parametrize( + "field,replacement", + [ + ("filename", "other.whl"), + ("url", "https://files.pythonhosted.org/packages/other.whl"), + ("size", 999), + ("yanked", True), + ], +) +def test_lifecycle_verifier_refuses_pypi_metadata_substitution( + field: str, + replacement: object, +) -> None: + policy, release, metadata = _flow_lifecycle_inputs() + metadata["urls"][1][field] = replacement + with pytest.raises(MODULE.AcceptanceError, match="does not verify exact artifact"): + MODULE.verify_production_lifecycle_release( + policy, + "flow", + release, + pypi_release_metadata=metadata, + ) + + +def test_lifecycle_verifier_refuses_pypi_digest_and_duplicate_match() -> None: + policy, release, metadata = _flow_lifecycle_inputs() + metadata["urls"][1]["digests"]["sha256"] = "0" * 64 + with pytest.raises(MODULE.AcceptanceError, match="does not verify exact artifact"): + MODULE.verify_production_lifecycle_release( + policy, + "flow", + release, + pypi_release_metadata=metadata, + ) + + policy, release, metadata = _flow_lifecycle_inputs() + metadata["urls"].append(copy.deepcopy(metadata["urls"][1])) + with pytest.raises(MODULE.AcceptanceError, match="does not verify exact artifact"): + MODULE.verify_production_lifecycle_release( + policy, + "flow", + release, + pypi_release_metadata=metadata, + ) + + +def test_lifecycle_verifier_refuses_policy_target_drift_and_duplicate_keys() -> None: + policy, release, metadata = _flow_lifecycle_inputs() + policy_value = json.loads(policy) + flow = next(item for item in policy_value["targets"] if item["id"] == "flow") + flow["required_claim_scope"] = "qualified_other_release" + with pytest.raises(MODULE.AcceptanceError, match="policy differs"): + MODULE.verify_production_lifecycle_release( + json.dumps(policy_value).encode(), + "flow", + release, + pypi_release_metadata=metadata, + ) + duplicate = policy.replace( + b'"revision": 1,', + b'"revision": 1, "revision": 1,', + 1, + ) + with pytest.raises(MODULE.AcceptanceError, match="duplicate key"): + MODULE.verify_production_lifecycle_release( + duplicate, + "flow", + release, + pypi_release_metadata=metadata, + ) + + +@pytest.mark.parametrize("field", ["version", "source_commit", "wheel_sha256"]) +def test_flow_lifecycle_binding_substitution_refuses(field: str) -> None: + source = _derive() + policy, release, metadata = _flow_lifecycle_inputs(source) + if field == "version": + release["version"] = "9.9.9" + release["tag"] = "v9.9.9" + metadata["info"]["version"] = "9.9.9" + elif field == "source_commit": + release["source_commit"] = "0" * 40 + release["immutable_release_url"] = ( + "https://github.com/OpenAdaptAI/openadapt-flow/commit/" + "0" * 40 + ) + else: + release["artifacts"][1]["sha256"] = "sha256:" + "0" * 64 + metadata["urls"][1]["digests"]["sha256"] = "0" * 64 + lifecycle = MODULE.verify_production_lifecycle_release( + policy, + "flow", + release, + pypi_release_metadata=metadata, + ) + with pytest.raises(MODULE.AcceptanceError, match="differs from verified evidence"): + MODULE.build_production_acceptance_manifest( + source, + "flow", + lifecycle_release=lifecycle, + ) + + +def test_unbound_cloud_deployment_manifest_cannot_enter_an_accepted_record() -> None: + source = _derive() + with pytest.raises(MODULE.AcceptanceError, match="reviewed deployment-manifest binding"): + MODULE.build_production_acceptance_manifest( + source, + "cloud", + lifecycle_release={ + "kind": "private_deployment", + "manifest_sha256": "sha256:" + "0" * 64, + }, + ) + + +def test_incomplete_or_failed_private_source_cannot_build_manifest() -> None: + source = _derive() + lifecycle = _verified_flow_lifecycle(source) + mutations = [] + wrong_verdict = copy.deepcopy(source) + wrong_verdict["verdict"] = "rejected" + mutations.append(wrong_verdict) + missing_binding = copy.deepcopy(source) + del missing_binding["bindings"]["oracle_contract_sha256"] + mutations.append(missing_binding) + production_failure = copy.deepcopy(source) + production_failure["derived_outcomes"]["verified"] -= 1 + production_failure["derived_outcomes"]["over_halt"] += 1 + production_failure["reliability"]["over_halt_count"] = 1 + mutations.append(production_failure) + + for mutation in mutations: + with pytest.raises(MODULE.AcceptanceError): + MODULE.build_production_acceptance_manifest( + mutation, + "flow", + lifecycle_release=lifecycle, + ) + + +def test_private_source_reliability_schema_is_closed() -> None: + source = _derive() + lifecycle = _verified_flow_lifecycle(source) + missing = copy.deepcopy(source) + del missing["reliability"]["operator_intervention_count"] + extra = copy.deepcopy(source) + extra["reliability"]["duplicate_count"] = 0 + + for mutation in (missing, extra): + with pytest.raises(MODULE.AcceptanceError, match="reliability keys differ"): + MODULE.build_production_acceptance_manifest( + mutation, + "flow", + lifecycle_release=lifecycle, + ) + + +@pytest.mark.parametrize( + "field,replacement,expected", + [ + ("receipt_id", "retention:not-a-receipt", "receipt ID"), + ("retention_mode", "GOVERNANCE", "not COMPLIANCE"), + ("provenance_attestation", "unreviewed-v1", "provenance"), + ("head_verified", False, "head_verified is false"), + ( + "acceptance_verified_at", + "2026-08-18T12:00:00Z", + "canonical millisecond UTC form", + ), + ( + "retained_at", + "2026-08-18T11:59:59.000Z", + "chronology", + ), + ( + "retention_until", + "2026-08-19T12:01:00.000Z", + "period is outside policy", + ), + ( + "retention_until", + "2037-08-18T12:01:00.000Z", + "period is outside policy", + ), + ], +) +def test_private_source_retention_mutation_refuses( + field: str, + replacement: object, + expected: str, +) -> None: + source = _derive() + source["retention"][field] = replacement + + with pytest.raises(MODULE.AcceptanceError, match=expected): + MODULE.build_production_acceptance_manifest( + source, + "flow", + lifecycle_release=_verified_flow_lifecycle(), + ) + + def test_mutation_helpers_do_not_modify_committed_fixtures() -> None: certificate = _certificate() campaign = _campaign()