From 2c129702da718522cc257913207b6ed6f3b33b7c Mon Sep 17 00:00:00 2001 From: abrichr Date: Wed, 2 Sep 2026 14:24:18 -0400 Subject: [PATCH 1/2] feat: admit already-published PyPI packages in staging evidence validate_staging still required a draft GitHub Release and a missing tag, so Flow 1.34.0 could not be admitted after the tag and PyPI files were already live. Add publication_mode already-published-pypi as a closed alternate: the tag may exist, a draft is not required, and observed PyPI sha256s must match the pypi-destination artifacts. Keep draft-before-tag for future versions. --- .../rebuild.py | 1311 +++++++++++++++++ schemas/qualification-release.schema.json | 81 +- scripts/production_trust.py | 146 +- ...e-synthetic-flow-release-verification.json | 14 +- tests/test_production_trust.py | 93 ++ tests/test_public_trust_schemas.py | 10 + tests/test_qualification_issuer.py | 2 + ..._support_release_and_recovery_contracts.py | 2 + 8 files changed, 1615 insertions(+), 44 deletions(-) create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/rebuild.py diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/rebuild.py b/local-candidates/flow-1.34.0-remote-safe-synthetic/rebuild.py new file mode 100644 index 0000000..07151be --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/rebuild.py @@ -0,0 +1,1311 @@ +#!/usr/bin/env python3 +"""Build unpublished Flow 1.34.0 remote-safe-synthetic admission objects. + +Reads the founder-provisioned Keychain item openadapt-qualification-ed25519. +Does not print the private key. Does not generate a key. Does not write main. + +The campaign_summary is synthetic (1 cell x 3 trials per class). It is not the +MockMed 1.34.0 evals set. evals production_acceptance stays false. + +Uses publication_mode already-published-pypi: the live GitHub tag exists and +PyPI 1.34.0 files are bound by sha256. Does not fake a draft as +openadapt-release[bot]. +""" + +from __future__ import annotations + +import argparse +import base64 +import hashlib +import json +import secrets +import string +import subprocess +import sys +import urllib.request +from datetime import datetime, timezone +from pathlib import Path +from typing import Any + +HERE = Path(__file__).resolve().parent +ROOT = HERE.parents[1] +sys.path.insert(0, str(ROOT / "scripts")) + +import production_trust as trust # noqa: E402 +import public_trust_kms as public_trust # noqa: E402 +import qualification_issuer as issuer # noqa: E402 +import qualification_software_ed25519 as software # noqa: E402 +import validate_evidence_registry as evidence # noqa: E402 + +EXPECTED_INNER_KEY_ID = "qa-ed25519-9cf4bca214c01d79" +FLOW_VERSION = "1.34.0" +FLOW_TAG = "v1.34.0" +FLOW_SOURCE = "30fc60e55778a0e0f92b9776117cafcfe2512249" +WHEEL_SHA256 = "56d32818989cb3a92830080ead39e10b08718c55e00988117f22cbfeaac98854" +WHEEL_SIZE = 1928194 +SDIST_SHA256 = "a941a70015fe91897e655bfc9bf83e6cf8fbcf8bd4e4c7206ffb133c505203f8" +SDIST_SIZE = 20440838 +WHEEL_NAME = "openadapt_flow-1.34.0-py3-none-any.whl" +SDIST_NAME = "openadapt_flow-1.34.0.tar.gz" +PYPI_PROJECT = "openadapt-flow" +OPS_COMMIT = "e323249e3a7c1af9d7651312e0afe1f12c38c977" +EVALS_COMMIT = "cad5560d6b7482f2cb99b9735e0ac3c5aae714c8" +SYNTHETIC_DOMAIN = b"OpenAdapt remote-safe-synthetic flow 1.34.0 local candidate v1\0" +EXPECTED_PUBLIC_KEY = "vHPUDLG2WD2BnTLaKYnZd9GxvUKfjpd68gJ9HubIEH8" +KIND_BY_PACKAGETYPE = { + "sdist": "python-sdist", + "bdist_wheel": "python-wheel", +} + + +def campaign_classes() -> dict[str, dict[str, int]]: + result: dict[str, dict[str, int]] = {} + for campaign_class in trust.CAMPAIGN_CLASSES: + counts = {field: 0 for field in trust.CAMPAIGN_COUNT_FIELDS} + counts.update( + task_condition_cell_count=1, + minimum_trials_per_cell=3, + observed_trial_count=3, + ) + if campaign_class == "uncertain_delivery": + counts["reconciliation_required_count"] = 3 + if campaign_class == "declared_attended": + counts["authenticated_bound_decision_count"] = 3 + counts["live_target_revalidation_count"] = 3 + if campaign_class == "governed_repair": + counts["policy_approved_repair_count"] = 3 + counts["approved_repair_count"] = 3 + counts["retained_repair_evidence_count"] = 3 + counts["live_target_revalidation_count"] = 3 + result[campaign_class] = counts + return result + + +def ts(value: datetime) -> str: + if value.tzinfo is None or value.utcoffset() is None: + raise SystemExit("timestamp must use UTC") + return value.replace(microsecond=0).strftime("%Y-%m-%dT%H:%M:%SZ") + + +def labeled(name: str) -> str: + return trust.digest_bytes( + SYNTHETIC_DOMAIN, + { + "label": "remote-safe-synthetic", + "flow_version": FLOW_VERSION, + "name": name, + "mockmed_1_34_0_evals_set_is_this_summary": False, + "evals_production_acceptance": False, + }, + ) + + +def write_json(path: Path, value: Any) -> bytes: + raw = evidence.canonical(value) + b"\n" + path.parent.mkdir(parents=True, exist_ok=True) + path.write_bytes(raw) + return raw + + +def object_rel(kind: str, object_sha256: str) -> str: + digest_hex = object_sha256.removeprefix("sha256:") + return ( + f"production-evidence/objects/sha256/{digest_hex[:2]}/" + f"{digest_hex}.{kind}.json" + ) + + +def signer_rel(object_sha256: str) -> str: + digest_hex = object_sha256.removeprefix("sha256:") + return ( + f"production-evidence/signer-registries/sha256/{digest_hex[:2]}/" + f"{digest_hex}.qualification-signer-registry.json" + ) + + +def sha256_bytes(raw: bytes) -> str: + return "sha256:" + hashlib.sha256(raw).hexdigest() + + +def request_handle() -> str: + alphabet = string.ascii_letters + string.digits + "_-" + return "qair_" + "".join(secrets.choice(alphabet) for _ in range(43)) + + +def sign_embedded( + value: dict[str, Any], + private_key: Any, + *, + schema: str, + domain: bytes, +) -> None: + value["signing_statement"] = trust.signing_statement( + value, object_schema_version=schema, signature_domain=domain + ) + payload = trust.canonical(value["signing_statement"]) + b"\n" + value["signature"] = base64.b64encode(private_key.sign(payload)).decode("ascii") + + +def make_inner(material: dict[str, str]) -> dict[str, Any]: + signer = software.signer_from_public_material(material) + signer["allowed_usages"] = sorted( + { + "qualification-authority-state-receipt", + "qualification-evidence-decision-receipt", + "qualification-revocation-state-receipt", + } + ) + signer["allowed_workflows"] = sorted( + { + ( + "https://github.com/OpenAdaptAI/.github/.github/workflows/" + "issue-synthetic-qualification-evidence-decision.yml@refs/heads/main" + ), + ( + "https://github.com/OpenAdaptAI/openadapt-ops/.github/workflows/" + "qualification-authority-state.yml@refs/heads/main" + ), + ( + "https://github.com/OpenAdaptAI/openadapt-ops/.github/workflows/" + "qualification-revocation-state.yml@refs/heads/main" + ), + } + ) + return signer + + +def make_entry(kind: str, raw: bytes, value: Any) -> dict[str, Any]: + object_sha256 = sha256_bytes(raw) + schema, media = evidence.OBJECT_KIND_CONTRACTS[kind] + entry = { + "kind": kind, + "object_schema_version": ( + evidence.BUNDLE_MEDIA_TYPE if kind.endswith("-sigstore-bundle") else schema + ), + "object_path": object_rel(kind, object_sha256), + "object_sha256": object_sha256, + "size_bytes": len(raw), + "object_media_type": media, + "semantic_identity_sha256": evidence.semantic_identity_digest( + kind=kind, + object_schema_version=( + evidence.BUNDLE_MEDIA_TYPE + if kind.endswith("-sigstore-bundle") + else schema + ), + object_value=value, + object_sha256=object_sha256, + ), + "subject_sha256": None if not kind.endswith("-sigstore-bundle") else value, + } + entry["registry_entry_sha256"] = evidence.entry_digest(entry) + return entry + + +def reference_from_entry( + entry: dict[str, Any], + *, + registry_source_commit: str, + registry_revision: int, + registry_head_sha256: str, +) -> dict[str, Any]: + return { + "schema_version": evidence.REFERENCE_SCHEMA, + "repository": evidence.REPOSITORY, + "repository_id": evidence.REPOSITORY_ID, + "repository_owner_id": evidence.REPOSITORY_OWNER_ID, + "registry_source_commit": registry_source_commit, + "registry_revision": registry_revision, + "registry_head_sha256": registry_head_sha256, + **entry, + } + + +class LocalResolver: + def __init__(self, registry: dict[str, Any]) -> None: + self.registry = registry + self.objects: dict[str, issuer.ResolvedEvidence] = {} + self.authority: issuer.ResolvedEvidence | None = None + self.revocation: issuer.ResolvedEvidence | None = None + + def add( + self, + kind: str, + value: dict[str, Any], + reference: dict[str, Any], + bundle_reference: dict[str, Any], + ) -> issuer.ResolvedEvidence: + resolved: issuer.ResolvedEvidence = { + "value": value, + "reference": reference, + "bundle_reference": bundle_reference, + "bound_signer_registry": self.registry, + "current_signer_registry": self.registry, + } + self.objects[reference["object_sha256"]] = resolved + return resolved + + def resolve(self, reference: dict[str, Any], *, kind: str) -> issuer.ResolvedEvidence: + resolved = self.objects[reference["object_sha256"]] + if resolved["reference"] != reference or reference["kind"] != kind: + raise issuer.IssuerError("local resolver reference differs") + return resolved + + def current_trust_state( + self, *, registry_source_commit: str + ) -> tuple[issuer.ResolvedEvidence, issuer.ResolvedEvidence]: + if self.authority is None or self.revocation is None: + raise issuer.IssuerError("current authority or revocation receipt is absent") + return self.authority, self.revocation + + +def dsse_bundle( + *, + private_key: Any, + signer: dict[str, Any], + kind: str, + value: dict[str, Any], + raw: bytes, + now: datetime, + registry_sha256: str, + authority_state_sha256: str, + revocation_state_sha256: str, + source_commit: str, +) -> dict[str, Any]: + schema, media = evidence.OBJECT_KIND_CONTRACTS[kind] + semantic = evidence.semantic_identity_digest( + kind=kind, + object_schema_version=schema, + object_value=value, + object_sha256=sha256_bytes(raw), + ) + issuer_fields = { + field: value["issuer"][field] for field in public_trust.ISSUER_FIELDS + } + statement = { + "schema_version": public_trust.STATEMENT_SCHEMA, + "object_kind": kind, + "object_schema_version": schema, + "object_media_type": media, + "object_sha256": sha256_bytes(raw), + "object_size_bytes": len(raw), + "semantic_identity_sha256": semantic, + "source_issuer": issuer_fields, + "signer_registry_sha256": registry_sha256, + "authority_state_sha256": authority_state_sha256, + "revocation_state_sha256": revocation_state_sha256, + "issued_at": ts(now), + "not_before": ts(now), + "expires_at": None, + "request_id_sha256": labeled(f"dsse-request:{kind}"), + "signing_authority": { + "repository": "OpenAdaptAI/.github", + "repository_id": "858454062", + "repository_owner_id": "132681217", + "workflow": public_trust.SOFTWARE_WORKFLOW_PATH, + "ref": "refs/heads/main", + "source_commit": source_commit, + "environment": public_trust.SOFTWARE_ENVIRONMENT, + "key_origin": "software", + }, + "key_id": signer["key_id"], + "signature_profile": public_trust.SOFTWARE_SIGNATURE_PROFILE, + } + public_trust.validate_statement_object_binding( + statement, + object_raw=raw, + object_value=value, + object_kind=kind, + object_schema_version=schema, + object_media_type=media, + semantic_identity_sha256=semantic, + expected_signer_registry_sha256=registry_sha256, + expected_authority_state_sha256=authority_state_sha256, + expected_revocation_state_sha256=revocation_state_sha256, + ) + return public_trust.sign_software_bundle( + statement, private_key=private_key, signer=signer, now=now + ) + + +def persist_object( + out: Path, kind: str, value: dict[str, Any] +) -> tuple[bytes, dict[str, Any]]: + raw = evidence.canonical(value) + b"\n" + path = out / object_rel(kind, sha256_bytes(raw)) + path.parent.mkdir(parents=True, exist_ok=True) + path.write_bytes(raw) + write_json(out / f"{kind}.json", value) + return raw, make_entry(kind, raw, value) + + +def persist_bundle( + out: Path, kind: str, bundle: dict[str, Any], subject_sha256: str +) -> tuple[bytes, dict[str, Any]]: + raw = evidence.canonical(bundle) + b"\n" + bundle_kind = f"{kind}-sigstore-bundle" + path = out / object_rel(bundle_kind, sha256_bytes(raw)) + path.parent.mkdir(parents=True, exist_ok=True) + path.write_bytes(raw) + write_json(out / f"{bundle_kind}.json", bundle) + return raw, make_entry(bundle_kind, raw, subject_sha256) + + +def flow_rulesets() -> list[dict[str, Any]]: + common = { + "schema_version": "openadapt.production-release-tag-ruleset/v1", + "repository": "OpenAdaptAI/openadapt-flow", + "repository_id": "1291376938", + "target": "tag", + "enforcement": "active", + "conditions": {"ref_name": {"include": ["refs/tags/v*"], "exclude": []}}, + } + return [ + { + **common, + "role": "creation_authority", + "ruleset_id": "10", + "name": "OpenAdapt policy: release tag creation", + "bypass_actors": [ + { + "actor_id": "4730708", + "actor_type": "Integration", + "bypass_mode": "always", + } + ], + "rules": [{"type": "creation"}], + }, + { + **common, + "role": "immutability", + "ruleset_id": "11", + "name": "OpenAdapt policy: immutable release tags", + "bypass_actors": [], + "rules": [ + {"type": "deletion"}, + {"type": "non_fast_forward"}, + { + "type": "update", + "parameters": {"update_allows_fetch_and_merge": False}, + }, + ], + }, + ] + + +def fetch_pypi_files(project: str, version: str) -> list[dict[str, Any]]: + url = f"https://pypi.org/pypi/{project}/{version}/json" + request = urllib.request.Request( + url, + headers={"User-Agent": "OpenAdapt-flow-134-local-candidate/1.0"}, + ) + with urllib.request.urlopen(request, timeout=30) as response: + payload = json.loads(response.read().decode("utf-8")) + files: list[dict[str, Any]] = [] + for item in payload["urls"]: + files.append( + { + "filename": item["filename"], + "packagetype": item["packagetype"], + "sha256": "sha256:" + item["digests"]["sha256"], + "size_bytes": item["size"], + "yanked": item["yanked"], + } + ) + return sorted(files, key=lambda item: (item["filename"], item["sha256"])) + + +def fetch_github_release(tag: str) -> dict[str, Any]: + raw = subprocess.check_output( + ["gh", "api", f"repos/OpenAdaptAI/openadapt-flow/releases/tags/{tag}"], + text=True, + ) + return json.loads(raw) + + +def observe_already_published_pypi_staging(*, observed_at: datetime) -> dict[str, Any]: + pypi_files = fetch_pypi_files(PYPI_PROJECT, FLOW_VERSION) + release = fetch_github_release(FLOW_TAG) + if release.get("draft") is not False or release.get("prerelease") is not False: + raise SystemExit("live GitHub release v1.34.0 is still a draft or prerelease") + author = release.get("author") or {} + if author.get("login") != "openadapt-release[bot]" or str(author.get("id")) != "321543906": + raise SystemExit("live GitHub release author is not the release App") + expected_pypi = { + WHEEL_NAME: ("sha256:" + WHEEL_SHA256, WHEEL_SIZE, "bdist_wheel"), + SDIST_NAME: ("sha256:" + SDIST_SHA256, SDIST_SIZE, "sdist"), + } + if {item["filename"] for item in pypi_files} != set(expected_pypi): + raise SystemExit("live PyPI files for 1.34.0 differ from the bound names") + for item in pypi_files: + digest, size, packagetype = expected_pypi[item["filename"]] + if ( + item["sha256"] != digest + or item["size_bytes"] != size + or item["packagetype"] != packagetype + or item["yanked"] is not False + ): + raise SystemExit( + f"live PyPI file {item['filename']} differs from the bound artifact" + ) + profile = trust.TARGET_CONTRACTS["flow"]["artifacts"] + assets: list[dict[str, Any]] = [] + for asset in release["assets"]: + name = asset["name"] + kind = KIND_BY_PACKAGETYPE.get( + expected_pypi[name][2] if name in expected_pypi else "" + ) + if kind is None: + raise SystemExit(f"live GitHub asset {name} is not a flow package file") + media_type, destinations = profile[kind] + digest = asset.get("digest") or expected_pypi[name][0] + if digest != expected_pypi[name][0] or asset["size"] != expected_pypi[name][1]: + raise SystemExit(f"live GitHub asset {name} digest or size differs from PyPI") + uploader = asset.get("uploader") or {} + assets.append( + { + "asset_id": str(asset["id"]), + "name": name, + "kind": kind, + "sha256": digest, + "size_bytes": asset["size"], + "media_type": media_type, + "publish_destinations": list(destinations), + "uploader_id": str(uploader.get("id")), + "uploader_login": uploader.get("login"), + } + ) + assets = sorted(assets, key=lambda item: (item["name"], item["asset_id"])) + immutable = {"enabled": True, "enforced_by_owner": False} + rulesets = flow_rulesets() + tag_ref_state = {"ref": f"refs/tags/{FLOW_TAG}", "exists": True} + staging = { + "schema_version": "openadapt.production-release-staging-evidence/v1", + "publication_mode": trust.PUBLICATION_MODE_ALREADY_PUBLISHED_PYPI, + "repository": "OpenAdaptAI/openadapt-flow", + "repository_id": "1291376938", + "draft_release_id": str(release["id"]), + "tag": FLOW_TAG, + "target_commitish": FLOW_SOURCE, + "draft": False, + "prerelease": False, + "release_app_id": "4730708", + "release_app_installation_id": "156835568", + "release_app_bot_user_id": "321543906", + "release_author_login": "openadapt-release[bot]", + "assets": assets, + "pypi_files": pypi_files, + "immutable_releases": immutable, + "immutable_releases_sha256": trust.digest_bytes( + trust.IMMUTABLE_RELEASES_DOMAIN, immutable + ), + "tag_rulesets": rulesets, + "tag_rulesets_sha256": trust.digest_bytes(trust.TAG_RULESETS_DOMAIN, rulesets), + "tag_ref_state": tag_ref_state, + "tag_ref_state_sha256": trust.digest_bytes( + trust.TAG_REF_STATE_DOMAIN, tag_ref_state + ), + "observed_at": ts(observed_at), + } + return trust.validate_staging(staging) + + +def unsigned_inventory() -> dict[str, Any]: + artifacts = [ + { + "name": SDIST_NAME, + "kind": "python-sdist", + "sha256": "sha256:" + SDIST_SHA256, + "size_bytes": SDIST_SIZE, + "media_type": "application/gzip", + "publish_destinations": ["github-release", "pypi"], + }, + { + "name": WHEEL_NAME, + "kind": "python-wheel", + "sha256": "sha256:" + WHEEL_SHA256, + "size_bytes": WHEEL_SIZE, + "media_type": "application/zip", + "publish_destinations": ["github-release", "pypi"], + }, + ] + artifacts = sorted( + artifacts, key=lambda item: (item["kind"], item["name"], item["sha256"]) + ) + inventory = { + "schema_version": "openadapt.production-release-artifact-inventory/v1", + "target": "flow", + "claim_scope": "production_flow", + "artifacts": artifacts, + } + return trust.validate_artifact_inventory(inventory) + + +def policy_file_digest(path: Path) -> str: + return sha256_bytes(path.read_bytes()) + + +def build_receipts( + out: Path, *, private_key: Any, now: datetime, policy_commit: str +) -> dict[str, Any]: + material = software.public_material(private_key) + if material["key_id"] != EXPECTED_INNER_KEY_ID: + raise SystemExit( + f"Keychain public key id is {material['key_id']}, not {EXPECTED_INNER_KEY_ID}" + ) + if material["public_key"] != EXPECTED_PUBLIC_KEY: + raise SystemExit("Keychain public key does not match the provisioned inner key") + write_json(out / "public-material.json", material) + + inner = make_inner(material) + outer = public_trust.software_public_signer(private_key.public_key()) + generated = now.replace(microsecond=0) + + unsigned_local = software.unsigned_local_registry_candidate( + public_material_value=material, revision=1 + ) + local_candidate = software.verify_local_registry_candidate( + software.sign_local_registry_candidate(unsigned_local, private_key=private_key) + ) + write_json(out / "signer-registry-local-candidate.json", local_candidate) + + timed_candidate = software.signer_registry_candidate( + public_material_value=material, + revision=1, + generated_at=generated, + expires_at=None, + ) + timed_candidate["proposed_registry"]["signers"] = [inner, outer] + timed_candidate["proposed_registry"] = evidence.validate_signer_registry( + timed_candidate["proposed_registry"] + ) + write_json(out / "signer-registry-candidate.json", timed_candidate) + + registry = { + "schema_version": "openadapt.qualification-signer-registry/v2", + "revision": 1, + "generated_at": ts(generated), + "expires_at": None, + "signers": [inner, outer], + } + registry = evidence.validate_signer_registry(registry) + registry_raw = write_json(out / "signer-registry.json", registry) + registry_raw_sha256 = sha256_bytes(registry_raw) + registry_identity = evidence.signer_registry_identity_digest(registry) + signer_path = out / signer_rel(registry_raw_sha256) + signer_path.parent.mkdir(parents=True, exist_ok=True) + signer_path.write_bytes(registry_raw) + + evidence_authority = labeled("evidence-authority") + authority = { + "schema_version": "openadapt.qualification-authority-state-receipt/v2", + "authority_state_sha256": labeled("placeholder-authority"), + "status": "active", + "signer_registry_sha256": registry_raw_sha256, + "signer_registry_identity_sha256": registry_identity, + "signer_registry_revision": 1, + "evidence_authority_sha256": evidence_authority, + "observed_at": ts(generated), + "not_before": ts(generated), + "expires_at": None, + "issuer_key_id": inner["key_id"], + "algorithm": "ed25519", + "signing_statement": None, + "signature": "", + "issuer": { + "repository": "OpenAdaptAI/openadapt-ops", + "repository_id": "1172011294", + "repository_owner_id": "132681217", + "workflow": ".github/workflows/qualification-authority-state.yml", + "ref": "refs/heads/main", + "source_commit": OPS_COMMIT, + "environment": "qualification-authority-state", + }, + } + projection = dict(authority) + projection.pop("authority_state_sha256") + projection.pop("signature") + projection.pop("signing_statement") + authority["authority_state_sha256"] = trust.digest_bytes( + trust.AUTHORITY_STATE_IDENTITY_DOMAIN, projection + ) + sign_embedded( + authority, + private_key, + schema="openadapt.qualification-authority-state-receipt/v2", + domain=trust.AUTHORITY_STATE_SIGNATURE_DOMAIN, + ) + trust.validate_authority_state(authority, now=now) + trust.verify_embedded_signature( + authority, + signer_registry=registry, + object_schema_version="openadapt.qualification-authority-state-receipt/v2", + signature_domain=trust.AUTHORITY_STATE_SIGNATURE_DOMAIN, + usage="qualification-authority-state-receipt", + now=now, + ) + + revocation = { + "schema_version": "openadapt.qualification-revocation-state-receipt/v1", + "revocation_state_sha256": labeled("placeholder-revocation"), + "previous_revocation_state_sha256": None, + "revision": 1, + "status": "current", + "authority_state_sha256": authority["authority_state_sha256"], + "signer_registry_sha256": registry_identity, + "revocations": [], + "observed_at": ts(generated), + "not_before": ts(generated), + "expires_at": None, + "issuer_key_id": inner["key_id"], + "algorithm": "ed25519", + "signing_statement": None, + "signature": "", + "issuer": { + "repository": "OpenAdaptAI/openadapt-ops", + "repository_id": "1172011294", + "repository_owner_id": "132681217", + "workflow": ".github/workflows/qualification-revocation-state.yml", + "ref": "refs/heads/main", + "source_commit": OPS_COMMIT, + "environment": "qualification-revocation-state", + }, + } + projection = dict(revocation) + projection.pop("revocation_state_sha256") + projection.pop("signature") + projection.pop("signing_statement") + revocation["revocation_state_sha256"] = trust.digest_bytes( + trust.REVOCATION_STATE_IDENTITY_DOMAIN, projection + ) + sign_embedded( + revocation, + private_key, + schema="openadapt.qualification-revocation-state-receipt/v1", + domain=trust.REVOCATION_STATE_SIGNATURE_DOMAIN, + ) + trust.validate_revocation_state(revocation, now=now) + trust.verify_embedded_signature( + revocation, + signer_registry=registry, + object_schema_version="openadapt.qualification-revocation-state-receipt/v1", + signature_domain=trust.REVOCATION_STATE_SIGNATURE_DOMAIN, + usage="qualification-revocation-state-receipt", + now=now, + ) + + summary = { + "schema_version": "openadapt.qualification-evidence-decision-campaign-summary/v1", + "minimum_trials_per_task_condition": 3, + "task_count": 1, + "classes": campaign_classes(), + } + unsigned_receipt = { + "schema_version": "openadapt.qualification-evidence-decision-receipt/v2", + "evidence_class": "remote-safe-synthetic", + "decision_identity_sha256": labeled("decision-series"), + "decision_revision": 1, + "decision_commitment_sha256": labeled("decision"), + "evidence_manifest_sha256": labeled("evidence-manifest"), + "evidence_manifest_readback_sha256": labeled("manifest-readback"), + "campaign_artifact_sha256": labeled("campaign-artifact"), + "organization_id_sha256": labeled("organization"), + "workflow_id_sha256": labeled("workflow"), + "workflow_version_id_sha256": labeled("workflow-version"), + "bundle_version": "0.0.0-synthetic", + "bundle_sha256": labeled("sealed-workflow-bundle"), + "admitted_runtime_sha256": "sha256:" + WHEEL_SHA256, + "application_contract_sha256": labeled("application-contract"), + "environment_contract_sha256": labeled("environment-contract"), + "input_contract_sha256": labeled("input-contract"), + "action_contract_sha256": labeled("action-contract"), + "identity_contract_sha256": labeled("identity-contract"), + "effect_contract_sha256": labeled("effect-contract"), + "policy_contract_sha256": labeled("policy-contract"), + "evidence_authority_contract_sha256": evidence_authority, + "campaign_permit_sha256": labeled("campaign-permit"), + "signer_registry_sha256": registry_identity, + "revocation_state_sha256": revocation["revocation_state_sha256"], + "entity_class": "record", + "campaign_summary": summary, + "verdict": "ADMIT", + "issued_at": ts(generated), + "not_before": ts(generated), + "expires_at": None, + "issuer_key_id": inner["key_id"], + "algorithm": "ed25519", + "signing_statement": None, + "signature": "", + "issuer": { + "repository": "OpenAdaptAI/.github", + "repository_id": "858454062", + "repository_owner_id": "132681217", + "workflow": ( + ".github/workflows/issue-synthetic-qualification-evidence-decision.yml" + ), + "ref": "refs/heads/main", + "source_commit": policy_commit, + "environment": "synthetic-qualification-evidence-decision", + }, + } + receipt = software.sign_receipt( + unsigned_receipt, private_key=private_key, signer_registry=registry + ) + trust.validate_receipt(receipt, signer_registry=registry, now=now) + + inventory = unsigned_inventory() + write_json(out / "artifact-inventory.json", inventory) + + objects: dict[str, tuple[str, dict[str, Any], bytes]] = {} + for kind, value in ( + ("qualification-authority-state-receipt", authority), + ("qualification-revocation-state-receipt", revocation), + ("qualification-evidence-decision-receipt", receipt), + ): + raw = evidence.canonical(value) + b"\n" + objects[kind] = (kind, value, raw) + + bundles: dict[str, dict[str, Any]] = {} + for kind, value, raw in objects.values(): + bundles[kind] = dsse_bundle( + private_key=private_key, + signer=outer, + kind=kind, + value=value, + raw=raw, + now=generated, + registry_sha256=value["signer_registry_sha256"], + authority_state_sha256=authority["authority_state_sha256"], + revocation_state_sha256=revocation["revocation_state_sha256"], + source_commit=policy_commit, + ) + + entries: list[dict[str, Any]] = [] + for kind, value, raw in objects.values(): + path = out / object_rel(kind, sha256_bytes(raw)) + path.parent.mkdir(parents=True, exist_ok=True) + path.write_bytes(raw) + write_json(out / f"{kind}.json", value) + regular_entry = make_entry(kind, raw, value) + bundle = bundles[kind] + bundle_raw = evidence.canonical(bundle) + b"\n" + bundle_kind = f"{kind}-sigstore-bundle" + bundle_path = out / object_rel(bundle_kind, sha256_bytes(bundle_raw)) + bundle_path.parent.mkdir(parents=True, exist_ok=True) + bundle_path.write_bytes(bundle_raw) + write_json(out / f"{bundle_kind}.json", bundle) + bundle_entry = make_entry(bundle_kind, bundle_raw, sha256_bytes(raw)) + entries.append(regular_entry) + entries.append(bundle_entry) + + signer_pointer = { + "schema_version": evidence.SIGNER_POINTER_SCHEMA, + "object_path": signer_rel(registry_raw_sha256), + "object_sha256": registry_raw_sha256, + "registry_identity_sha256": registry_identity, + "registry_revision": 1, + } + local_registry = { + "$schema": "schemas/evidence-registry.schema.json", + "schema_version": evidence.REGISTRY_SCHEMA, + "repository": evidence.REPOSITORY, + "repository_id": evidence.REPOSITORY_ID, + "repository_owner_id": evidence.REPOSITORY_OWNER_ID, + "revision": 1, + "previous_registry_head_sha256": None, + "registry_head_sha256": "sha256:" + "0" * 64, + "signer_registry": signer_pointer, + "signer_registry_history": [signer_pointer], + "entries": entries, + } + local_registry["registry_head_sha256"] = evidence.registry_head_digest(local_registry) + evidence.validate_registry(local_registry, root=out) + write_json(out / "evidence-registry.json", local_registry) + + state = { + "generated_at": ts(generated), + "expires_at": None, + "registry_raw_sha256": registry_raw_sha256, + "registry_identity": registry_identity, + "registry_head_sha256": local_registry["registry_head_sha256"], + "registry_revision": 1, + "authority_state_sha256": authority["authority_state_sha256"], + "revocation_state_sha256": revocation["revocation_state_sha256"], + "inner_key_id": inner["key_id"], + "outer_key_id": outer["key_id"], + "campaign_label": "remote-safe-synthetic", + "mockmed_1_34_0_evals_set_is_this_summary": False, + "evals_production_acceptance": False, + "policy_commit": policy_commit, + "flow_source": FLOW_SOURCE, + "wheel_sha256": WHEEL_SHA256, + "sdist_sha256": SDIST_SHA256, + } + write_json(out / "phase1-state.json", state) + return state + + +def build_admissions( + out: Path, + *, + private_key: Any, + now: datetime, + registry_source_commit: str, + policy_commit: str, +) -> dict[str, Any]: + state = json.loads((out / "phase1-state.json").read_text(encoding="utf-8")) + registry = json.loads((out / "signer-registry.json").read_text(encoding="utf-8")) + authority = json.loads( + (out / "qualification-authority-state-receipt.json").read_text(encoding="utf-8") + ) + revocation = json.loads( + (out / "qualification-revocation-state-receipt.json").read_text(encoding="utf-8") + ) + receipt = json.loads( + (out / "qualification-evidence-decision-receipt.json").read_text(encoding="utf-8") + ) + local_registry = json.loads((out / "evidence-registry.json").read_text(encoding="utf-8")) + inventory = json.loads((out / "artifact-inventory.json").read_text(encoding="utf-8")) + head = local_registry["registry_head_sha256"] + revision = local_registry["revision"] + entries_by_kind = {entry["kind"]: entry for entry in local_registry["entries"]} + generated = now.replace(microsecond=0) + outer = public_trust.software_public_signer(private_key.public_key()) + + resolver = LocalResolver(registry) + resolver.authority = resolver.add( + "qualification-authority-state-receipt", + authority, + reference_from_entry( + entries_by_kind["qualification-authority-state-receipt"], + registry_source_commit=registry_source_commit, + registry_revision=revision, + registry_head_sha256=head, + ), + reference_from_entry( + entries_by_kind["qualification-authority-state-receipt-sigstore-bundle"], + registry_source_commit=registry_source_commit, + registry_revision=revision, + registry_head_sha256=head, + ), + ) + resolver.revocation = resolver.add( + "qualification-revocation-state-receipt", + revocation, + reference_from_entry( + entries_by_kind["qualification-revocation-state-receipt"], + registry_source_commit=registry_source_commit, + registry_revision=revision, + registry_head_sha256=head, + ), + reference_from_entry( + entries_by_kind["qualification-revocation-state-receipt-sigstore-bundle"], + registry_source_commit=registry_source_commit, + registry_revision=revision, + registry_head_sha256=head, + ), + ) + receipt_ref = reference_from_entry( + entries_by_kind["qualification-evidence-decision-receipt"], + registry_source_commit=registry_source_commit, + registry_revision=revision, + registry_head_sha256=head, + ) + receipt_bundle_ref = reference_from_entry( + entries_by_kind["qualification-evidence-decision-receipt-sigstore-bundle"], + registry_source_commit=registry_source_commit, + registry_revision=revision, + registry_head_sha256=head, + ) + resolver.add( + "qualification-evidence-decision-receipt", + receipt, + receipt_ref, + receipt_bundle_ref, + ) + + handle = request_handle() + request = { + "schema_version": "openadapt.qualification-admission-issue-request/v1", + "request_handle": handle, + "evidence_class": "remote-safe-synthetic", + "decision_receipt_reference": receipt_ref, + } + db_path = out / "one-use-effects.sqlite" + if db_path.exists(): + db_path.unlink() + consumer = issuer.SqliteOneUseConsumer(db_path) + admission = issuer.issue_workflow_admission( + request, + resolver=resolver, + issuer_source_commit=registry_source_commit, + now=now, + consumer=consumer, + ) + trust.validate_qualification_admission(admission, now=now) + effect = consumer.reconcile(request_handle=handle) + write_json(out / "workflow-issue-request.json", request) + write_json(out / "one-use-effect.json", effect) + admission_raw, admission_entry = persist_object( + out, "qualification-admission", admission + ) + admission_bundle = dsse_bundle( + private_key=private_key, + signer=outer, + kind="qualification-admission", + value=admission, + raw=admission_raw, + now=generated, + registry_sha256=admission["signer_registry_sha256"], + authority_state_sha256=authority["authority_state_sha256"], + revocation_state_sha256=revocation["revocation_state_sha256"], + source_commit=policy_commit, + ) + _, admission_bundle_entry = persist_bundle( + out, "qualification-admission", admission_bundle, sha256_bytes(admission_raw) + ) + admission_ref = reference_from_entry( + admission_entry, + registry_source_commit=registry_source_commit, + registry_revision=revision, + registry_head_sha256=head, + ) + admission_bundle_ref = reference_from_entry( + admission_bundle_entry, + registry_source_commit=registry_source_commit, + registry_revision=revision, + registry_head_sha256=head, + ) + resolver.add( + "qualification-admission", admission, admission_ref, admission_bundle_ref + ) + + staging = observe_already_published_pypi_staging(observed_at=generated) + write_json(out / "publication-staging.json", staging) + candidate = { + "schema_version": "openadapt.production-release-candidate/v1", + "kind": "package", + "source_repository": "OpenAdaptAI/openadapt-flow", + "source_repository_id": "1291376938", + "source_commit": FLOW_SOURCE, + "version": FLOW_VERSION, + "tag": FLOW_TAG, + "deployment_id": None, + "deployment_sha256": None, + "artifacts": inventory["artifacts"], + } + release_identity = { + "schema_version": "openadapt.monotonic-production-release/v1", + "channel": "production", + "sequence": 1, + "previous_admission_sha256": None, + } + release_sha256 = trust.digest_bytes( + trust.RELEASE_DOMAIN, + {"target": "flow", "claim_scope": "production_flow", "release": candidate}, + ) + inventory_sha256 = trust.artifact_inventory_digest(inventory) + acceptance_policy_sha256 = policy_file_digest(ROOT / "production-evidence-policy.json") + lifecycle_policy_sha256 = policy_file_digest(ROOT / "production-lifecycle-policy.json") + common = { + "target": "flow", + "verdict": "accepted", + "claim_scope": "production_flow", + "acceptance_policy_sha256": acceptance_policy_sha256, + "lifecycle_policy_sha256": lifecycle_policy_sha256, + "release_identity": release_identity, + "release_sha256": release_sha256, + "artifact_inventory_sha256": inventory_sha256, + "publication_staging": staging, + "publication_staging_sha256": trust.staging_digest(staging), + "qualification_evidence_decision_receipt_reference": receipt_ref, + "qualification_evidence_decision_receipt_bundle_reference": receipt_bundle_ref, + "qualification_admission_reference": admission_ref, + "qualification_admission_bundle_reference": admission_bundle_ref, + "campaign_summary": receipt["campaign_summary"]["classes"], + "authority_state_sha256": authority["authority_state_sha256"], + "revocation_state_sha256": revocation["revocation_state_sha256"], + "signer_registry_sha256": evidence.signer_registry_identity_digest(registry), + "issued_at": ts(generated), + "not_before": ts(generated), + "expires_at": None, + "issuer": { + "repository": "OpenAdaptAI/openadapt-evals", + "repository_id": "1135998197", + "repository_owner_id": "132681217", + "workflow": ".github/workflows/issue-production-acceptance.yml", + "ref": "refs/heads/main", + "source_commit": EVALS_COMMIT, + "environment": "production-acceptance", + }, + } + manifest = { + "schema_version": "openadapt.production-acceptance/v3", + **common, + "release": candidate, + "artifact_inventory": inventory, + } + trust.validate_acceptance_manifest( + manifest, + receipt=receipt, + qualification_admission=admission, + receipt_signer_registry=registry, + now=now, + ) + manifest_raw, manifest_entry = persist_object( + out, "production-acceptance-manifest", manifest + ) + manifest_bundle = dsse_bundle( + private_key=private_key, + signer=outer, + kind="production-acceptance-manifest", + value=manifest, + raw=manifest_raw, + now=generated, + registry_sha256=manifest["signer_registry_sha256"], + authority_state_sha256=authority["authority_state_sha256"], + revocation_state_sha256=revocation["revocation_state_sha256"], + source_commit=policy_commit, + ) + _, manifest_bundle_entry = persist_bundle( + out, + "production-acceptance-manifest", + manifest_bundle, + sha256_bytes(manifest_raw), + ) + manifest_ref = reference_from_entry( + manifest_entry, + registry_source_commit=registry_source_commit, + registry_revision=revision, + registry_head_sha256=head, + ) + manifest_bundle_ref = reference_from_entry( + manifest_bundle_entry, + registry_source_commit=registry_source_commit, + registry_revision=revision, + registry_head_sha256=head, + ) + resolver.add( + "production-acceptance-manifest", + manifest, + manifest_ref, + manifest_bundle_ref, + ) + + summary = { + "schema_version": "openadapt.production-lifecycle-evidence-summary/v3", + **common, + "evidence_identity_sha256": labeled("placeholder-evidence-identity"), + "production_acceptance_manifest_reference": manifest_ref, + "production_acceptance_manifest_bundle_reference": manifest_bundle_ref, + } + summary["evidence_identity_sha256"] = trust.acceptance_summary_identity(summary) + trust.validate_acceptance_summary( + summary, + manifest=manifest, + receipt=receipt, + qualification_admission=admission, + receipt_signer_registry=registry, + now=now, + ) + summary_raw, summary_entry = persist_object( + out, "production-acceptance-summary", summary + ) + summary_bundle = dsse_bundle( + private_key=private_key, + signer=outer, + kind="production-acceptance-summary", + value=summary, + raw=summary_raw, + now=generated, + registry_sha256=summary["signer_registry_sha256"], + authority_state_sha256=authority["authority_state_sha256"], + revocation_state_sha256=revocation["revocation_state_sha256"], + source_commit=policy_commit, + ) + _, summary_bundle_entry = persist_bundle( + out, + "production-acceptance-summary", + summary_bundle, + sha256_bytes(summary_raw), + ) + summary_ref = reference_from_entry( + summary_entry, + registry_source_commit=registry_source_commit, + registry_revision=revision, + registry_head_sha256=head, + ) + summary_bundle_ref = reference_from_entry( + summary_bundle_entry, + registry_source_commit=registry_source_commit, + registry_revision=revision, + registry_head_sha256=head, + ) + resolver.add( + "production-acceptance-summary", summary, summary_ref, summary_bundle_ref + ) + + release_handle = request_handle() + release_request = { + "schema_version": "openadapt.qualification-release-issue-request/v1", + "request_handle": release_handle, + "evidence_class": "remote-safe-synthetic", + "production_acceptance_summary_reference": summary_ref, + } + release = issuer.issue_release_admission( + release_request, + resolver=resolver, + issuer_source_commit=registry_source_commit, + now=now, + consumer=consumer, + ) + trust.validate_release_evidence_chain( + release, + summary=summary, + manifest=manifest, + receipt=receipt, + qualification_admission=admission, + receipt_signer_registry=registry, + now=now, + ) + write_json(out / "release-issue-request.json", release_request) + release_raw, _release_entry = persist_object(out, "qualification-release", release) + release_bundle = dsse_bundle( + private_key=private_key, + signer=outer, + kind="qualification-release", + value=release, + raw=release_raw, + now=generated, + registry_sha256=release["signer_registry_sha256"], + authority_state_sha256=authority["authority_state_sha256"], + revocation_state_sha256=revocation["revocation_state_sha256"], + source_commit=policy_commit, + ) + persist_bundle( + out, "qualification-release", release_bundle, sha256_bytes(release_raw) + ) + write_json( + out / "one-use-effect-release.json", + consumer.reconcile(request_handle=release_handle), + ) + return { + "workflow_admission_id_sha256": admission["admission_id_sha256"], + "release_admission_id_sha256": release["admission_id_sha256"], + "release_sha256": release["release_sha256"], + "publication_staging_sha256": release["publication_staging_sha256"], + "publication_mode": staging["publication_mode"], + "draft": staging["draft"], + "tag_exists": staging["tag_ref_state"]["exists"], + "github_release_id": staging["draft_release_id"], + "pypi_files": staging["pypi_files"], + "expires_at": release["expires_at"], + "registry_source_commit": registry_source_commit, + "evals_production_acceptance": False, + "mockmed_1_34_0_evals_set_is_this_summary": False, + **state, + } + + +def write_build_record(out: Path, extra: dict[str, Any]) -> None: + state_path = out / "phase1-state.json" + state = json.loads(state_path.read_text(encoding="utf-8")) if state_path.exists() else {} + record = { + "schema_version": "openadapt.local-flow-134-admission-build-record/v1", + "target": "flow", + "flow_version": FLOW_VERSION, + "flow_tag": FLOW_TAG, + "flow_source": FLOW_SOURCE, + "evidence_class": "remote-safe-synthetic", + "campaign": { + "label": "remote-safe-synthetic", + "task_count": 1, + "cells_per_class": 1, + "trials_per_cell": 3, + "classes": list(trust.CAMPAIGN_CLASSES), + "mockmed_1_34_0_evals_set_is_this_summary": False, + }, + "evals_production_acceptance": False, + "keychain_service": software.KEYCHAIN_SERVICE, + "inner_key_id": EXPECTED_INNER_KEY_ID, + "did_not_generate_key": True, + "did_not_fake_draft_as_openadapt_release_bot": True, + **state, + **extra, + } + write_json(out / "build-record.json", record) + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--out", default=str(HERE)) + parser.add_argument("--policy-commit", required=True) + parser.add_argument("--registry-source-commit", required=True) + args = parser.parse_args(argv) + out = Path(args.out).resolve() + out.mkdir(parents=True, exist_ok=True) + now = datetime.now(timezone.utc) + private_key = software.load_private_key_from_sources( + pem_file=None, use_keychain=True, use_env=False + ) + material = software.public_material(private_key) + if material["key_id"] != EXPECTED_INNER_KEY_ID: + print( + f"REFUSED: Keychain key id {material['key_id']} != {EXPECTED_INNER_KEY_ID}", + file=sys.stderr, + ) + return 1 + build_receipts( + out, + private_key=private_key, + now=now, + policy_commit=args.policy_commit, + ) + try: + extra = build_admissions( + out, + private_key=private_key, + now=now, + registry_source_commit=args.registry_source_commit, + policy_commit=args.policy_commit, + ) + except trust.TrustError as exc: + write_build_record( + out, + { + "phase": "staging-blocked", + "release_admission_issued": False, + "validate_staging_error": str(exc), + }, + ) + print(json.dumps({"phase": "staging-blocked", "error": str(exc)}, sort_keys=True)) + return 1 + write_build_record( + out, + { + "phase": "release-admission", + "release_admission_issued": True, + "acceptance_manifest_issued": True, + "acceptance_summary_issued": True, + **extra, + }, + ) + print( + json.dumps( + { + "phase": "release-admission", + "publication_mode": extra["publication_mode"], + "tag_exists": extra["tag_exists"], + "draft": extra["draft"], + "release_admission_id_sha256": extra["release_admission_id_sha256"], + "expires_at": extra["expires_at"], + "evals_production_acceptance": False, + }, + sort_keys=True, + ) + ) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/schemas/qualification-release.schema.json b/schemas/qualification-release.schema.json index 7e37430..2ff360b 100644 --- a/schemas/qualification-release.schema.json +++ b/schemas/qualification-release.schema.json @@ -232,31 +232,57 @@ }} ] }, + "pypi_file": { + "type": "object", + "additionalProperties": false, + "required": ["filename", "packagetype", "sha256", "size_bytes", "yanked"], + "properties": { + "filename": {"type": "string", "pattern": "^[^/\\\\]+$", "minLength": 1, "maxLength": 255}, + "packagetype": {"enum": ["sdist", "bdist_wheel"]}, + "sha256": {"$ref": "#/$defs/digest"}, + "size_bytes": {"type": "integer", "minimum": 1}, + "yanked": {"const": false} + } + }, "publication_staging": { "type": "object", "additionalProperties": false, "required": [ - "schema_version", "repository", "repository_id", "draft_release_id", "tag", - "target_commitish", "draft", "prerelease", "release_app_id", - "release_app_installation_id", "release_app_bot_user_id", "release_author_login", - "assets", "immutable_releases", "immutable_releases_sha256", - "tag_rulesets", "tag_rulesets_sha256", "tag_ref_state", - "tag_ref_state_sha256", "observed_at" + "schema_version", "publication_mode", "repository", "repository_id", + "draft_release_id", "tag", "target_commitish", "draft", "prerelease", + "release_app_id", "release_app_installation_id", "release_app_bot_user_id", + "release_author_login", "assets", "pypi_files", "immutable_releases", + "immutable_releases_sha256", "tag_rulesets", "tag_rulesets_sha256", + "tag_ref_state", "tag_ref_state_sha256", "observed_at" ], "properties": { "schema_version": {"const": "openadapt.production-release-staging-evidence/v1"}, + "publication_mode": { + "enum": ["draft-before-tag", "already-published-pypi"] + }, "repository": {"type": "string", "pattern": "^OpenAdaptAI/[A-Za-z0-9._-]+$"}, "repository_id": {"$ref": "#/$defs/decimal_id"}, "draft_release_id": {"$ref": "#/$defs/decimal_id"}, "tag": {"type": "string", "minLength": 1, "maxLength": 120}, "target_commitish": {"$ref": "#/$defs/commit"}, - "draft": {"const": true}, + "draft": {"type": "boolean"}, "prerelease": {"const": false}, "release_app_id": {"const": "4730708"}, "release_app_installation_id": {"const": "156835568"}, "release_app_bot_user_id": {"const": "321543906"}, "release_author_login": {"const": "openadapt-release[bot]"}, "assets": {"type": "array", "minItems": 1, "uniqueItems": true, "items": {"$ref": "#/$defs/staged_asset"}}, + "pypi_files": { + "oneOf": [ + {"type": "null"}, + { + "type": "array", + "minItems": 1, + "uniqueItems": true, + "items": {"$ref": "#/$defs/pypi_file"} + } + ] + }, "immutable_releases": { "type": "object", "additionalProperties": false, @@ -284,12 +310,49 @@ "required": ["ref", "exists"], "properties": { "ref": {"type": "string", "pattern": "^refs/tags/v[^/]+$"}, - "exists": {"const": false} + "exists": {"type": "boolean"} } }, "tag_ref_state_sha256": {"$ref": "#/$defs/digest"}, "observed_at": {"$ref": "#/$defs/timestamp"} - } + }, + "allOf": [ + { + "if": { + "properties": {"publication_mode": {"const": "draft-before-tag"}}, + "required": ["publication_mode"] + }, + "then": { + "properties": { + "draft": {"const": true}, + "pypi_files": {"type": "null"}, + "tag_ref_state": { + "properties": {"exists": {"const": false}} + } + } + } + }, + { + "if": { + "properties": {"publication_mode": {"const": "already-published-pypi"}}, + "required": ["publication_mode"] + }, + "then": { + "properties": { + "draft": {"const": false}, + "pypi_files": { + "type": "array", + "minItems": 1, + "uniqueItems": true, + "items": {"$ref": "#/$defs/pypi_file"} + }, + "tag_ref_state": { + "properties": {"exists": {"const": true}} + } + } + } + } + ] }, "summary_reference": { "allOf": [ diff --git a/scripts/production_trust.py b/scripts/production_trust.py index d3bcc1a..f4288a7 100644 --- a/scripts/production_trust.py +++ b/scripts/production_trust.py @@ -190,6 +190,36 @@ TAG_RULESETS_DOMAIN = b"OpenAdapt production release tag rulesets v1\0" IMMUTABLE_RELEASES_DOMAIN = b"OpenAdapt production immutable releases response v1\0" TAG_REF_STATE_DOMAIN = b"OpenAdapt production release tag ref state v1\0" +PUBLICATION_MODE_DRAFT_BEFORE_TAG = "draft-before-tag" +PUBLICATION_MODE_ALREADY_PUBLISHED_PYPI = "already-published-pypi" +PYPI_PACKAGETYPES = { + "python-sdist": "sdist", + "python-wheel": "bdist_wheel", +} +STAGING_FIELDS = { + "schema_version", + "publication_mode", + "repository", + "repository_id", + "draft_release_id", + "tag", + "target_commitish", + "draft", + "prerelease", + "release_app_id", + "release_app_installation_id", + "release_app_bot_user_id", + "release_author_login", + "assets", + "pypi_files", + "immutable_releases", + "immutable_releases_sha256", + "tag_rulesets", + "tag_rulesets_sha256", + "tag_ref_state", + "tag_ref_state_sha256", + "observed_at", +} PUBLICATION_RECOVERY_AUTHORIZATION_DOMAIN = ( b"OpenAdapt production publication recovery authorization v2\0" ) @@ -647,33 +677,83 @@ def validate_tag_rulesets( return value +def pypi_files_from_assets(assets: Sequence[Mapping[str, Any]]) -> list[dict[str, Any]]: + files: list[dict[str, Any]] = [] + for asset in assets: + destinations = asset.get("publish_destinations") + if not isinstance(destinations, list) or "pypi" not in destinations: + continue + kind = asset.get("kind") + packagetype = PYPI_PACKAGETYPES.get(kind) if isinstance(kind, str) else None + if packagetype is None: + raise TrustError(f"{kind} cannot publish to PyPI") + files.append( + { + "filename": asset["name"], + "packagetype": packagetype, + "sha256": asset["sha256"], + "size_bytes": asset["size_bytes"], + "yanked": False, + } + ) + return sorted(files, key=lambda item: (item["filename"], item["sha256"])) + + +def validate_pypi_files( + value: Any, assets: Sequence[Mapping[str, Any]] +) -> list[dict[str, Any]]: + if not isinstance(value, list) or not value: + raise TrustError("already-published-pypi staging requires observed PyPI files") + files: list[dict[str, Any]] = [] + names: set[str] = set() + for index, item_value in enumerate(value): + item = closed( + item_value, + {"filename", "packagetype", "sha256", "size_bytes", "yanked"}, + f"pypi file {index}", + ) + filename = item["filename"] + if ( + not isinstance(filename, str) + or not filename + or filename != Path(filename).name + or "/" in filename + or "\\" in filename + ): + raise TrustError(f"pypi file {index} name is unsafe") + if filename in names: + raise TrustError("pypi file names must be unique") + names.add(filename) + if item["packagetype"] not in {"sdist", "bdist_wheel"}: + raise TrustError(f"pypi file {index} packagetype is invalid") + require_digest(item["sha256"], f"pypi file {index} digest") + require_positive_int(item["size_bytes"], f"pypi file {index} size") + if item["yanked"] is not False: + raise TrustError("yanked PyPI files cannot admit a release") + files.append(item) + if files != sorted(files, key=lambda item: (item["filename"], item["sha256"])): + raise TrustError("pypi files must be sorted") + expected = pypi_files_from_assets(assets) + if not expected: + raise TrustError("already-published-pypi staging requires pypi-destination artifacts") + if files != expected: + raise TrustError("observed PyPI files differ from pypi-destination artifacts") + return files + + def validate_staging(value: Any) -> dict[str, Any]: - staging = closed( - value, - { - "schema_version", - "repository", - "repository_id", - "draft_release_id", - "tag", - "target_commitish", - "draft", - "prerelease", - "release_app_id", - "release_app_installation_id", - "release_app_bot_user_id", - "release_author_login", - "assets", - "immutable_releases", - "immutable_releases_sha256", - "tag_rulesets", - "tag_rulesets_sha256", - "tag_ref_state", - "tag_ref_state_sha256", - "observed_at", - }, - "publication staging", - ) + staging = closed(value, STAGING_FIELDS, "publication staging") + mode = staging["publication_mode"] + if mode == PUBLICATION_MODE_DRAFT_BEFORE_TAG: + tag_exists = False + draft_required = True + if staging["pypi_files"] is not None: + raise TrustError("draft-before-tag staging must not include PyPI files") + elif mode == PUBLICATION_MODE_ALREADY_PUBLISHED_PYPI: + tag_exists = True + draft_required = False + else: + raise TrustError("publication staging mode is not supported") if staging["schema_version"] != "openadapt.production-release-staging-evidence/v1": raise TrustError("publication staging schema is not supported") for field in ( @@ -685,7 +765,7 @@ def validate_staging(value: Any) -> dict[str, Any]: ): require_decimal_id(staging[field], f"publication staging {field}") if ( - staging["draft"] is not True + staging["draft"] is not draft_required or staging["prerelease"] is not False or staging["release_app_id"] != "4730708" or staging["release_app_installation_id"] != "156835568" @@ -707,7 +787,15 @@ def validate_staging(value: Any) -> dict[str, Any]: ): raise TrustError("immutable releases response digest is invalid") tag_ref_state = closed(staging["tag_ref_state"], {"ref", "exists"}, "tag ref state") - if tag_ref_state != {"ref": f"refs/tags/{staging['tag']}", "exists": False}: + expected_tag_ref_state = { + "ref": f"refs/tags/{staging['tag']}", + "exists": tag_exists, + } + if tag_ref_state != expected_tag_ref_state: + if mode == PUBLICATION_MODE_ALREADY_PUBLISHED_PYPI: + raise TrustError( + "already-published-pypi staging requires the release tag to exist" + ) raise TrustError("release tag must not exist when the draft is staged") if staging["tag_ref_state_sha256"] != digest_bytes( TAG_REF_STATE_DOMAIN, tag_ref_state @@ -768,6 +856,8 @@ def validate_staging(value: Any) -> dict[str, Any]: ids.add(asset["asset_id"]) if assets != sorted(assets, key=lambda item: (item["name"], item["asset_id"])): raise TrustError("staged assets must be sorted") + if mode == PUBLICATION_MODE_ALREADY_PUBLISHED_PYPI: + validate_pypi_files(staging["pypi_files"], assets) validate_tag_rulesets( staging["tag_rulesets"], repository=staging["repository"], diff --git a/tests/fixtures/remote-safe-synthetic-flow-release-verification.json b/tests/fixtures/remote-safe-synthetic-flow-release-verification.json index f1f3ca1..ec1cf1d 100644 --- a/tests/fixtures/remote-safe-synthetic-flow-release-verification.json +++ b/tests/fixtures/remote-safe-synthetic-flow-release-verification.json @@ -1,9 +1,9 @@ { - "acceptance_manifest_object_sha256": "sha256:de4fca1e28bfc8bea778c6ab13d848206d32360c867bd8c4279dab124b9ea746", - "acceptance_summary_object_sha256": "sha256:a8f9ebd9107f35474d91996f07c0d6773a2807d8780499f5668b30639aa30d3e", - "admission_bundle_object_sha256": "sha256:9845c58b1fa0d1e57aaf4ed8526074b100bc051dfc3bed39da949aa0d2888956", - "admission_id_sha256": "sha256:2945099a7918a259f70bb4b393b76f877f0b8914083004a498dbe52d871fed10", - "admission_object_sha256": "sha256:9a71052032d5e4f573eaf6939f73133a64659a2985b36361498e8338b3ea6a5d", + "acceptance_manifest_object_sha256": "sha256:8527aef029e134510c93230547c97a922338d43fb1c9791f638b1e235e0bb92e", + "acceptance_summary_object_sha256": "sha256:75ccc37ca41f072174a9b639fbd565890cc58ca239efa7eabfe4d9ef4933941b", + "admission_bundle_object_sha256": "sha256:4a447b61400e23ea403cffb5a02e421cbe070c225ebf7b3af9b9e2acaae40c27", + "admission_id_sha256": "sha256:09dd21c3fe1cd8df71b4642cb1b828af551a6ebe7ca9d6d8f2949f14d33af2b6", + "admission_object_sha256": "sha256:56907ca56db4db3be11e4a4c283f2848e7cc00331fe33ab2c12a3a28a4da3061", "admitted_runtime_sha256": "sha256:2efa8ff4176c9f108b5325693593ebafbb1949be95c9516b4341f6b0ca1bb707", "artifact_inventory_sha256": "sha256:9222ec0d9352666efd2d5a5210a2e3125270a19d48c2983b80a14c0c3e318e79", "authority_state_sha256": "sha256:2d46fdb4ce1f61d869a1372cc5ea3f6ea360447a59b0ead3e322bca5afa1dfb8", @@ -12,7 +12,7 @@ "draft_release_id": "20", "evidence_class": "remote-safe-synthetic", "expires_at": "2026-09-03T12:00:00Z", - "publication_staging_sha256": "sha256:e4e763ab68e809f3d668ca5c86d9bab72ddfaee2af7b1b8c9819e3128029b64f", + "publication_staging_sha256": "sha256:f214d9b3dcc0d6615efcd7d8f15792c34ef967e1f7024f395eb15f0833ebdf24", "qualification_admission_id_sha256": "sha256:ce6754aacb52b3c35e81fc1a076195adf0a162ecdacf838cfe1e7649d5664102", "qualification_admission_object_sha256": "sha256:2169ccd36de0dd72e4533e35cb918af7c833baaa9ceb6edb3be35a0d708f9b06", "registry_head_sha256": "sha256:54998095cc9bc282a25e90b15f12f7135942c29c065bb0ad4e90315a4451cd56", @@ -35,7 +35,7 @@ "target": "flow", "trust_state_source_commit": "2222222222222222222222222222222222222222", "verdict": "verified", - "verification_id_sha256": "sha256:6e9a1c5bd7812f9870e9826eea24a4ced48bc02710af96a5bea980aad9b34295", + "verification_id_sha256": "sha256:50539886c5f1cc0749896cbafb783260faeac44cad8cf03c310ce9229d773400", "verified_at": "2026-08-27T12:00:00Z", "version": "1.35.0", "workflow_bundle_sha256": "sha256:069b4455df8b54f4f0b741d87ade877e79714fcec7ac5cdfd3235326382a8ab1", diff --git a/tests/test_production_trust.py b/tests/test_production_trust.py index be906bc..30399c1 100644 --- a/tests/test_production_trust.py +++ b/tests/test_production_trust.py @@ -287,6 +287,7 @@ def release_admission() -> dict: normalized_rulesets = rulesets() staging = { "schema_version": "openadapt.production-release-staging-evidence/v1", + "publication_mode": "draft-before-tag", "repository": "OpenAdaptAI/openadapt-capture", "repository_id": "1115283835", "draft_release_id": "20", @@ -314,6 +315,7 @@ def release_admission() -> dict: sorted(artifacts, key=lambda item: item["name"]) ) ], + "pypi_files": None, "immutable_releases": {"enabled": True, "enforced_by_owner": False}, "immutable_releases_sha256": trust.digest_bytes( trust.IMMUTABLE_RELEASES_DOMAIN, @@ -402,6 +404,36 @@ def release_admission() -> dict: return value +def refresh_release_admission(value: dict) -> dict: + staging = value["publication_staging"] + staging["immutable_releases_sha256"] = trust.digest_bytes( + trust.IMMUTABLE_RELEASES_DOMAIN, staging["immutable_releases"] + ) + staging["tag_rulesets_sha256"] = trust.digest_bytes( + trust.TAG_RULESETS_DOMAIN, staging["tag_rulesets"] + ) + staging["tag_ref_state_sha256"] = trust.digest_bytes( + trust.TAG_REF_STATE_DOMAIN, staging["tag_ref_state"] + ) + value["publication_staging_sha256"] = trust.staging_digest(staging) + projection = dict(value) + projection.pop("admission_id_sha256") + value["admission_id_sha256"] = trust.digest_bytes( + trust.RELEASE_ADMISSION_DOMAIN, projection + ) + return value + + +def already_published_pypi_release_admission() -> dict: + value = release_admission() + staging = value["publication_staging"] + staging["publication_mode"] = trust.PUBLICATION_MODE_ALREADY_PUBLISHED_PYPI + staging["draft"] = False + staging["tag_ref_state"]["exists"] = True + staging["pypi_files"] = trust.pypi_files_from_assets(staging["assets"]) + return refresh_release_admission(value) + + def cloud_handoff() -> dict: authorization, authorization_bundle = pair( "production-cloud-deploy-authorization", "a", "b" @@ -929,6 +961,67 @@ def test_release_binds_exact_draft_assets_and_two_rulesets(self) -> None: with self.assertRaisesRegex(trust.TrustError, "bypass"): trust.validate_release(invalid) + def test_already_published_pypi_allows_existing_tag_without_a_draft(self) -> None: + value = already_published_pypi_release_admission() + staging = value["publication_staging"] + self.assertEqual(staging["publication_mode"], "already-published-pypi") + self.assertFalse(staging["draft"]) + self.assertTrue(staging["tag_ref_state"]["exists"]) + self.assertEqual( + [item["filename"] for item in staging["pypi_files"]], + [ + "openadapt_capture-1.0.0-py3-none-any.whl", + "openadapt_capture-1.0.0.tar.gz", + ], + ) + self.assertEqual(trust.validate_release(value), value) + + def test_already_published_pypi_requires_pypi_sha256s_to_match_artifacts( + self, + ) -> None: + value = already_published_pypi_release_admission() + value["publication_staging"]["pypi_files"][0]["sha256"] = sha("9") + refresh_release_admission(value) + with self.assertRaisesRegex(trust.TrustError, "observed PyPI files differ"): + trust.validate_release(value) + + def test_draft_before_tag_still_refuses_an_existing_tag_or_published_release( + self, + ) -> None: + existing_tag = release_admission() + existing_tag["publication_staging"]["tag_ref_state"]["exists"] = True + refresh_release_admission(existing_tag) + with self.assertRaisesRegex(trust.TrustError, "must not exist"): + trust.validate_release(existing_tag) + published = release_admission() + published["publication_staging"]["draft"] = False + refresh_release_admission(published) + with self.assertRaisesRegex( + trust.TrustError, "publication staging authority or state differs" + ): + trust.validate_release(published) + with_pypi = release_admission() + with_pypi["publication_staging"]["pypi_files"] = trust.pypi_files_from_assets( + with_pypi["publication_staging"]["assets"] + ) + refresh_release_admission(with_pypi) + with self.assertRaisesRegex(trust.TrustError, "must not include PyPI files"): + trust.validate_release(with_pypi) + + def test_already_published_pypi_refuses_a_draft_or_missing_tag(self) -> None: + draft = already_published_pypi_release_admission() + draft["publication_staging"]["draft"] = True + refresh_release_admission(draft) + with self.assertRaisesRegex( + trust.TrustError, "publication staging authority or state differs" + ): + trust.validate_release(draft) + missing_tag = already_published_pypi_release_admission() + missing_tag["publication_staging"]["tag_ref_state"]["exists"] = False + refresh_release_admission(missing_tag) + with self.assertRaisesRegex(trust.TrustError, "requires the release tag"): + trust.validate_release(missing_tag) + def test_release_refuses_noncanonical_or_output_injecting_package_identity( self, ) -> None: diff --git a/tests/test_public_trust_schemas.py b/tests/test_public_trust_schemas.py index caad072..02ccf71 100644 --- a/tests/test_public_trust_schemas.py +++ b/tests/test_public_trust_schemas.py @@ -885,6 +885,16 @@ def test_release_artifacts_bind_publish_destinations(self) -> None: ], 2, ) + self.assertEqual( + schema["$defs"]["publication_staging"]["properties"]["publication_mode"][ + "enum" + ], + ["draft-before-tag", "already-published-pypi"], + ) + self.assertIn( + "publication_mode", + schema["$defs"]["publication_staging"]["required"], + ) def test_verification_policy_keeps_sigstore_and_freezes_future_kms_profile( self, diff --git a/tests/test_qualification_issuer.py b/tests/test_qualification_issuer.py index 6810d15..28b0bbb 100644 --- a/tests/test_qualification_issuer.py +++ b/tests/test_qualification_issuer.py @@ -585,6 +585,7 @@ def flow_release_inputs( ] staging = { "schema_version": "openadapt.production-release-staging-evidence/v1", + "publication_mode": "draft-before-tag", "repository": "OpenAdaptAI/openadapt-flow", "repository_id": "1291376938", "draft_release_id": "20", @@ -607,6 +608,7 @@ def flow_release_inputs( sorted(artifacts, key=lambda item: item["name"]) ) ], + "pypi_files": None, "immutable_releases": {"enabled": True, "enforced_by_owner": False}, "immutable_releases_sha256": trust.digest_bytes( trust.IMMUTABLE_RELEASES_DOMAIN, diff --git a/tests/test_support_release_and_recovery_contracts.py b/tests/test_support_release_and_recovery_contracts.py index eadce2d..9b0e210 100644 --- a/tests/test_support_release_and_recovery_contracts.py +++ b/tests/test_support_release_and_recovery_contracts.py @@ -208,6 +208,7 @@ def support_admission() -> dict: ] staging = { "schema_version": "openadapt.production-release-staging-evidence/v1", + "publication_mode": "draft-before-tag", "repository": "OpenAdaptAI/openadapt-tray", "repository_id": "1136122737", "draft_release_id": "20", @@ -220,6 +221,7 @@ def support_admission() -> dict: "release_app_bot_user_id": "321543906", "release_author_login": "openadapt-release[bot]", "assets": staged_assets, + "pypi_files": None, "immutable_releases": {"enabled": True, "enforced_by_owner": False}, "immutable_releases_sha256": sha("placeholder"), "tag_rulesets": tag_rulesets(), From e0cd94136c2149d477ecd354d9c5c95e4e29b40a Mon Sep 17 00:00:00 2001 From: abrichr Date: Wed, 2 Sep 2026 14:25:18 -0400 Subject: [PATCH 2/2] feat: issue unpublished Flow 1.34.0 until-revoked admission objects Rebuild the remote-safe-synthetic receipts, workflow admission, and qualification-release/v2 with expires_at JSON null. Staging uses already-published-pypi against live PyPI 1.34.0 and the existing v1.34.0 tag. The campaign is a synthetic 1x3 summary, not MockMed production_acceptance. Objects stay under local-candidates/. They are not in the public evidence-registry. --- .../artifact-inventory.json | 1 + .../build-record.json | 1 + .../evidence-registry.json | 1 + .../one-use-effect-release.json | 1 + .../one-use-effect.json | 1 + .../one-use-effects.sqlite | Bin 0 -> 57344 bytes .../phase1-state.json | 1 + ...ion-acceptance-manifest-sigstore-bundle.json | 1 + .../production-acceptance-manifest.json | 1 + ...tion-acceptance-summary-sigstore-bundle.json | 1 + .../production-acceptance-summary.json | 1 + ...idence-decision-receipt-sigstore-bundle.json | 1 + ...authority-state-receipt-sigstore-bundle.json | 1 + ...qualification-admission-sigstore-bundle.json | 1 + ....qualification-revocation-state-receipt.json | 1 + ...774c15ca.production-acceptance-manifest.json | 1 + ...d3eb730d4.production-acceptance-summary.json | 1 + ...1.qualification-release-sigstore-bundle.json | 1 + ...evocation-state-receipt-sigstore-bundle.json | 1 + ...qualification-evidence-decision-receipt.json | 1 + ...2fd9129b74aa1dd82.qualification-release.json | 1 + ...e.qualification-authority-state-receipt.json | 1 + ...ion-acceptance-manifest-sigstore-bundle.json | 1 + ...7fd64d942684a04.qualification-admission.json | 1 + ...tion-acceptance-summary-sigstore-bundle.json | 1 + ...5562f96b6.qualification-signer-registry.json | 1 + .../public-material.json | 1 + .../publication-staging.json | 1 + ...qualification-admission-sigstore-bundle.json | 1 + .../qualification-admission.json | 1 + ...authority-state-receipt-sigstore-bundle.json | 1 + .../qualification-authority-state-receipt.json | 1 + ...idence-decision-receipt-sigstore-bundle.json | 1 + ...qualification-evidence-decision-receipt.json | 1 + .../qualification-release-sigstore-bundle.json | 1 + .../qualification-release.json | 1 + ...evocation-state-receipt-sigstore-bundle.json | 1 + .../qualification-revocation-state-receipt.json | 1 + .../release-issue-request.json | 1 + .../signer-registry-candidate.json | 1 + .../signer-registry-local-candidate.json | 1 + .../signer-registry.json | 1 + .../workflow-issue-request.json | 1 + 43 files changed, 42 insertions(+) create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/artifact-inventory.json create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/build-record.json create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/evidence-registry.json create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/one-use-effect-release.json create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/one-use-effect.json create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/one-use-effects.sqlite create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/phase1-state.json create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/production-acceptance-manifest-sigstore-bundle.json create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/production-acceptance-manifest.json create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/production-acceptance-summary-sigstore-bundle.json create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/production-acceptance-summary.json create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/09/09eb48f80dec3cd8f7da73bfef1aed805068c0feefdbaaaa350ded1b70ba0c7d.qualification-evidence-decision-receipt-sigstore-bundle.json create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/0f/0f97c284b10f8dc0153dbab0da5deccc5069bb5609982d45b890617783687830.qualification-authority-state-receipt-sigstore-bundle.json create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/17/1773f9dd2b0c3a78bf2454cfba5d038151925f4b7c5aa1a2d7ed46b5f9315c32.qualification-admission-sigstore-bundle.json create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/18/18633b8cc243f686706606162bfa249a29733811563f63b9e68cc7c4a3507676.qualification-revocation-state-receipt.json create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/21/211651dd301699ea1394af8b8ec38d1c9c6df5045c88d9ce1ece09ca774c15ca.production-acceptance-manifest.json create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/38/3849fd4e2cae0d3a74964362e4850870bb68c23007d5eb818800159d3eb730d4.production-acceptance-summary.json create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/48/4804e33f847a04d35304c9948ade6ac9e736b06a1a8c9ab920da0833b7423e01.qualification-release-sigstore-bundle.json create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/4e/4e0a052726ba440c9f6a19726b004f948c36087b2702d614a398728b428dcd5f.qualification-revocation-state-receipt-sigstore-bundle.json create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/6f/6ffe691f8e40e06b73e24391d180424ed86bb289ddae001cf7b49de2e745312a.qualification-evidence-decision-receipt.json create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/79/790122a25c87e456c6e45d25ebf5cd029b21b8511265b062fd9129b74aa1dd82.qualification-release.json create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/a2/a22f9815ec0f7c56f7629aeabfd21d14bc6d739efcfb7f7a073ce9987e19479e.qualification-authority-state-receipt.json create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/ac/ace6aabbaf02596d26cd5d6f1406790f4fe831ca978129d50cc2285882a2630c.production-acceptance-manifest-sigstore-bundle.json create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/dc/dcdb32a762aca87fbb1a7c9df5d346403b167ec5850d35fe47fd64d942684a04.qualification-admission.json create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/e9/e9ecdee1fc3458906fc91f5760d215bb5bec3591a6ed9ae0b412114e24fcf8fb.production-acceptance-summary-sigstore-bundle.json create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/signer-registries/sha256/7a/7a81bf3d213c74673f3c6b5fa179234cbee534c9432aaea6ae09e455562f96b6.qualification-signer-registry.json create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/public-material.json create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/publication-staging.json create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/qualification-admission-sigstore-bundle.json create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/qualification-admission.json create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/qualification-authority-state-receipt-sigstore-bundle.json create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/qualification-authority-state-receipt.json create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/qualification-evidence-decision-receipt-sigstore-bundle.json create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/qualification-evidence-decision-receipt.json create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/qualification-release-sigstore-bundle.json create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/qualification-release.json create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/qualification-revocation-state-receipt-sigstore-bundle.json create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/qualification-revocation-state-receipt.json create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/release-issue-request.json create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/signer-registry-candidate.json create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/signer-registry-local-candidate.json create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/signer-registry.json create mode 100644 local-candidates/flow-1.34.0-remote-safe-synthetic/workflow-issue-request.json diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/artifact-inventory.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/artifact-inventory.json new file mode 100644 index 0000000..c613acf --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/artifact-inventory.json @@ -0,0 +1 @@ +{"artifacts":[{"kind":"python-sdist","media_type":"application/gzip","name":"openadapt_flow-1.34.0.tar.gz","publish_destinations":["github-release","pypi"],"sha256":"sha256:a941a70015fe91897e655bfc9bf83e6cf8fbcf8bd4e4c7206ffb133c505203f8","size_bytes":20440838},{"kind":"python-wheel","media_type":"application/zip","name":"openadapt_flow-1.34.0-py3-none-any.whl","publish_destinations":["github-release","pypi"],"sha256":"sha256:56d32818989cb3a92830080ead39e10b08718c55e00988117f22cbfeaac98854","size_bytes":1928194}],"claim_scope":"production_flow","schema_version":"openadapt.production-release-artifact-inventory/v1","target":"flow"} diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/build-record.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/build-record.json new file mode 100644 index 0000000..d9dce5c --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/build-record.json @@ -0,0 +1 @@ +{"acceptance_manifest_issued":true,"acceptance_summary_issued":true,"authority_state_sha256":"sha256:df5079141df68877c4b06f05b9fb9fdf279307b7629eb1f2dce12def4bd5e2fa","campaign":{"cells_per_class":1,"classes":["healthy","safe_halt","idempotency_replay","uncertain_delivery","declared_attended","governed_repair"],"label":"remote-safe-synthetic","mockmed_1_34_0_evals_set_is_this_summary":false,"task_count":1,"trials_per_cell":3},"campaign_label":"remote-safe-synthetic","did_not_fake_draft_as_openadapt_release_bot":true,"did_not_generate_key":true,"draft":false,"evals_production_acceptance":false,"evidence_class":"remote-safe-synthetic","expires_at":null,"flow_source":"30fc60e55778a0e0f92b9776117cafcfe2512249","flow_tag":"v1.34.0","flow_version":"1.34.0","generated_at":"2026-09-02T18:24:25Z","github_release_id":"378603192","inner_key_id":"qa-ed25519-9cf4bca214c01d79","keychain_service":"openadapt-qualification-ed25519","mockmed_1_34_0_evals_set_is_this_summary":false,"outer_key_id":"oa-public-trust-ed25519-9cf4bca214c01d79","phase":"release-admission","policy_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","publication_mode":"already-published-pypi","publication_staging_sha256":"sha256:861175c196cfe9455ce5f0536b6b1eabf55a990ced03349b865643f52316dedd","pypi_files":[{"filename":"openadapt_flow-1.34.0-py3-none-any.whl","packagetype":"bdist_wheel","sha256":"sha256:56d32818989cb3a92830080ead39e10b08718c55e00988117f22cbfeaac98854","size_bytes":1928194,"yanked":false},{"filename":"openadapt_flow-1.34.0.tar.gz","packagetype":"sdist","sha256":"sha256:a941a70015fe91897e655bfc9bf83e6cf8fbcf8bd4e4c7206ffb133c505203f8","size_bytes":20440838,"yanked":false}],"registry_head_sha256":"sha256:9a9f597b0d87674c4d36c022227201a5d8f3072237624346793692c3a863d12e","registry_identity":"sha256:e243a23243b24986ed08812e284a1bd8c4993814149f02bcba79cc520e10ca14","registry_raw_sha256":"sha256:7a81bf3d213c74673f3c6b5fa179234cbee534c9432aaea6ae09e455562f96b6","registry_revision":1,"registry_source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","release_admission_id_sha256":"sha256:d2983b86d5428c892421b191f6943a63cf4f9a0b1629e324d099f5df6fa5dcda","release_admission_issued":true,"release_sha256":"sha256:f84c03c857bda8372d39bc30afcc2986247778c34b3f93a39ec9de5dd151a289","revocation_state_sha256":"sha256:250ab430e467f5e584ebd2b1832976b42186b698da71d627ee1724c2b1da2457","schema_version":"openadapt.local-flow-134-admission-build-record/v1","sdist_sha256":"a941a70015fe91897e655bfc9bf83e6cf8fbcf8bd4e4c7206ffb133c505203f8","tag_exists":true,"target":"flow","wheel_sha256":"56d32818989cb3a92830080ead39e10b08718c55e00988117f22cbfeaac98854","workflow_admission_id_sha256":"sha256:45c157898b6f07e57bf604b3323f206d677cac6c57a43238152cdb3308495e80"} diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/evidence-registry.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/evidence-registry.json new file mode 100644 index 0000000..5b4220a --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/evidence-registry.json @@ -0,0 +1 @@ +{"$schema":"schemas/evidence-registry.schema.json","entries":[{"kind":"qualification-authority-state-receipt","object_media_type":"application/vnd.openadapt.qualification-authority-state-receipt+json;version=2","object_path":"production-evidence/objects/sha256/a2/a22f9815ec0f7c56f7629aeabfd21d14bc6d739efcfb7f7a073ce9987e19479e.qualification-authority-state-receipt.json","object_schema_version":"openadapt.qualification-authority-state-receipt/v2","object_sha256":"sha256:a22f9815ec0f7c56f7629aeabfd21d14bc6d739efcfb7f7a073ce9987e19479e","registry_entry_sha256":"sha256:d69026ffefb99b4eeb6c27db2913684138ee23f3b8923aa8ae3379e839489401","semantic_identity_sha256":"sha256:df5079141df68877c4b06f05b9fb9fdf279307b7629eb1f2dce12def4bd5e2fa","size_bytes":1520,"subject_sha256":null},{"kind":"qualification-authority-state-receipt-sigstore-bundle","object_media_type":"application/vnd.dev.sigstore.bundle.v0.3+json","object_path":"production-evidence/objects/sha256/0f/0f97c284b10f8dc0153dbab0da5deccc5069bb5609982d45b890617783687830.qualification-authority-state-receipt-sigstore-bundle.json","object_schema_version":"application/vnd.dev.sigstore.bundle.v0.3+json","object_sha256":"sha256:0f97c284b10f8dc0153dbab0da5deccc5069bb5609982d45b890617783687830","registry_entry_sha256":"sha256:29397e66bbafd8e02e8fbbaceaf2d3c1d2892723cd396bb0d4abb1a443192592","semantic_identity_sha256":"sha256:96b1361340164f4cfc3d9f50e88868c6d36a62a085a8543ed818a4b1ba905714","size_bytes":2809,"subject_sha256":"sha256:a22f9815ec0f7c56f7629aeabfd21d14bc6d739efcfb7f7a073ce9987e19479e"},{"kind":"qualification-revocation-state-receipt","object_media_type":"application/vnd.openadapt.qualification-revocation-state-receipt+json;version=1","object_path":"production-evidence/objects/sha256/18/18633b8cc243f686706606162bfa249a29733811563f63b9e68cc7c4a3507676.qualification-revocation-state-receipt.json","object_schema_version":"openadapt.qualification-revocation-state-receipt/v1","object_sha256":"sha256:18633b8cc243f686706606162bfa249a29733811563f63b9e68cc7c4a3507676","registry_entry_sha256":"sha256:2592f2856bbfb5e381640f050669a3dfc1b19cbc4fbf7438ce18d0df1731f722","semantic_identity_sha256":"sha256:250ab430e467f5e584ebd2b1832976b42186b698da71d627ee1724c2b1da2457","size_bytes":1457,"subject_sha256":null},{"kind":"qualification-revocation-state-receipt-sigstore-bundle","object_media_type":"application/vnd.dev.sigstore.bundle.v0.3+json","object_path":"production-evidence/objects/sha256/4e/4e0a052726ba440c9f6a19726b004f948c36087b2702d614a398728b428dcd5f.qualification-revocation-state-receipt-sigstore-bundle.json","object_schema_version":"application/vnd.dev.sigstore.bundle.v0.3+json","object_sha256":"sha256:4e0a052726ba440c9f6a19726b004f948c36087b2702d614a398728b428dcd5f","registry_entry_sha256":"sha256:e4bf33edf52cf708db739746b4d99098642255380e70edc654a287c5d1aafe04","semantic_identity_sha256":"sha256:fcebb8e521419ea3c6aefa97885aa7153e88821e1a20617998067e921abc4d00","size_bytes":2817,"subject_sha256":"sha256:18633b8cc243f686706606162bfa249a29733811563f63b9e68cc7c4a3507676"},{"kind":"qualification-evidence-decision-receipt","object_media_type":"application/vnd.openadapt.qualification-evidence-decision-receipt+json;version=2","object_path":"production-evidence/objects/sha256/6f/6ffe691f8e40e06b73e24391d180424ed86bb289ddae001cf7b49de2e745312a.qualification-evidence-decision-receipt.json","object_schema_version":"openadapt.qualification-evidence-decision-receipt/v2","object_sha256":"sha256:6ffe691f8e40e06b73e24391d180424ed86bb289ddae001cf7b49de2e745312a","registry_entry_sha256":"sha256:63d0170fb957ebd167f2650ef744d70839d0676a8cf9f8978d73aed5cffd0b27","semantic_identity_sha256":"sha256:c18d69bdfb145139581ea6865f513179bd104cb02a64d838f93e49f96d9d3769","size_bytes":6636,"subject_sha256":null},{"kind":"qualification-evidence-decision-receipt-sigstore-bundle","object_media_type":"application/vnd.dev.sigstore.bundle.v0.3+json","object_path":"production-evidence/objects/sha256/09/09eb48f80dec3cd8f7da73bfef1aed805068c0feefdbaaaa350ded1b70ba0c7d.qualification-evidence-decision-receipt-sigstore-bundle.json","object_schema_version":"application/vnd.dev.sigstore.bundle.v0.3+json","object_sha256":"sha256:09eb48f80dec3cd8f7da73bfef1aed805068c0feefdbaaaa350ded1b70ba0c7d","registry_entry_sha256":"sha256:40e134188beb1f1dd8bf17eaa02d84b8246ae11db7b99db68efb493f2a3d7955","semantic_identity_sha256":"sha256:21d2be624cc93f033b13eceabd7ea42b39ab6f80790c643235c80a32272545a6","size_bytes":2849,"subject_sha256":"sha256:6ffe691f8e40e06b73e24391d180424ed86bb289ddae001cf7b49de2e745312a"}],"previous_registry_head_sha256":null,"registry_head_sha256":"sha256:9a9f597b0d87674c4d36c022227201a5d8f3072237624346793692c3a863d12e","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","revision":1,"schema_version":"openadapt.production-evidence-registry/v2","signer_registry":{"object_path":"production-evidence/signer-registries/sha256/7a/7a81bf3d213c74673f3c6b5fa179234cbee534c9432aaea6ae09e455562f96b6.qualification-signer-registry.json","object_sha256":"sha256:7a81bf3d213c74673f3c6b5fa179234cbee534c9432aaea6ae09e455562f96b6","registry_identity_sha256":"sha256:e243a23243b24986ed08812e284a1bd8c4993814149f02bcba79cc520e10ca14","registry_revision":1,"schema_version":"openadapt.qualification-signer-registry-pointer/v1"},"signer_registry_history":[{"object_path":"production-evidence/signer-registries/sha256/7a/7a81bf3d213c74673f3c6b5fa179234cbee534c9432aaea6ae09e455562f96b6.qualification-signer-registry.json","object_sha256":"sha256:7a81bf3d213c74673f3c6b5fa179234cbee534c9432aaea6ae09e455562f96b6","registry_identity_sha256":"sha256:e243a23243b24986ed08812e284a1bd8c4993814149f02bcba79cc520e10ca14","registry_revision":1,"schema_version":"openadapt.qualification-signer-registry-pointer/v1"}]} diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/one-use-effect-release.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/one-use-effect-release.json new file mode 100644 index 0000000..71bd823 --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/one-use-effect-release.json @@ -0,0 +1 @@ +{"effect_id_sha256":"sha256:ac3924cb01bae4badebbbe01a2b0f1e2ab930812cf0d92da1f6b6dd3a40d7255","effect_sha256":"sha256:0a3675b04f3e5acaa6add733a6c47b4ea7d432fed667e56724b8350ebc386415","operation":"issue-qualification-release","request_handle":"qair_A-aMXGcPZkNKE7CbnMEIDSofWrO0wAKZDMIz_QhpWHN","request_sha256":"sha256:d16b743432c3f6c2becb93b6d40b85f5a64e5247269298944c06c022c6dd211b","result_base64":"{"admission_id_sha256":"sha256:d2983b86d5428c892421b191f6943a63cf4f9a0b1629e324d099f5df6fa5dcda","artifact_inventory_sha256":"sha256:ec3ef7c177c493bebee3da60f170b37793832e81066e9d9ee785d5fa225a5ac5","authority_state_sha256":"sha256:df5079141df68877c4b06f05b9fb9fdf279307b7629eb1f2dce12def4bd5e2fa","claim_scope":"production_flow","evidence_class":"remote-safe-synthetic","expires_at":null,"issued_at":"2026-09-02T18:24:25Z","issuer":{"environment":"production-release-admission","ref":"refs/heads/main","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","workflow":".github/workflows/issue-production-release-admission.yml"},"not_before":"2026-09-02T18:24:25Z","production_acceptance_summary_bundle_reference":{"kind":"production-acceptance-summary-sigstore-bundle","object_media_type":"application/vnd.dev.sigstore.bundle.v0.3+json","object_path":"production-evidence/objects/sha256/e9/e9ecdee1fc3458906fc91f5760d215bb5bec3591a6ed9ae0b412114e24fcf8fb.production-acceptance-summary-sigstore-bundle.json","object_schema_version":"application/vnd.dev.sigstore.bundle.v0.3+json","object_sha256":"sha256:e9ecdee1fc3458906fc91f5760d215bb5bec3591a6ed9ae0b412114e24fcf8fb","registry_entry_sha256":"sha256:7dc2fcab09f705356a22b058b9e7f078596bcdefdb697bef7315510d17931549","registry_head_sha256":"sha256:9a9f597b0d87674c4d36c022227201a5d8f3072237624346793692c3a863d12e","registry_revision":1,"registry_source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","schema_version":"openadapt.production-evidence-object-reference/v2","semantic_identity_sha256":"sha256:1b5606b9f4c14edd37ec134a9c716a070832b8709e3c2f9c6f4186ff514b7c82","size_bytes":2789,"subject_sha256":"sha256:3849fd4e2cae0d3a74964362e4850870bb68c23007d5eb818800159d3eb730d4"},"production_acceptance_summary_reference":{"kind":"production-acceptance-summary","object_media_type":"application/vnd.openadapt.production-lifecycle-evidence-summary+json;version=3","object_path":"production-evidence/objects/sha256/38/3849fd4e2cae0d3a74964362e4850870bb68c23007d5eb818800159d3eb730d4.production-acceptance-summary.json","object_schema_version":"openadapt.production-lifecycle-evidence-summary/v3","object_sha256":"sha256:3849fd4e2cae0d3a74964362e4850870bb68c23007d5eb818800159d3eb730d4","registry_entry_sha256":"sha256:932511112a7eb5f296b752953ac184516a47f7630643ecf70955af722e78ef68","registry_head_sha256":"sha256:9a9f597b0d87674c4d36c022227201a5d8f3072237624346793692c3a863d12e","registry_revision":1,"registry_source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","schema_version":"openadapt.production-evidence-object-reference/v2","semantic_identity_sha256":"sha256:cf65d1d351869c63e88d7188d1e78727994cc3f6e76c88f5643a61d168a84445","size_bytes":14497,"subject_sha256":null},"publication_policy_sha256":"sha256:ed5ab69fe8127604ca674263cbc8c774b7cfd10754e90bfaa9b71ba573bce1d1","publication_staging":{"assets":[{"asset_id":"534029483","kind":"python-wheel","media_type":"application/zip","name":"openadapt_flow-1.34.0-py3-none-any.whl","publish_destinations":["github-release","pypi"],"sha256":"sha256:56d32818989cb3a92830080ead39e10b08718c55e00988117f22cbfeaac98854","size_bytes":1928194,"uploader_id":"321543906","uploader_login":"openadapt-release[bot]"},{"asset_id":"534029484","kind":"python-sdist","media_type":"application/gzip","name":"openadapt_flow-1.34.0.tar.gz","publish_destinations":["github-release","pypi"],"sha256":"sha256:a941a70015fe91897e655bfc9bf83e6cf8fbcf8bd4e4c7206ffb133c505203f8","size_bytes":20440838,"uploader_id":"321543906","uploader_login":"openadapt-release[bot]"}],"draft":false,"draft_release_id":"378603192","immutable_releases":{"enabled":true,"enforced_by_owner":false},"immutable_releases_sha256":"sha256:07649aafb167237fecc138f5e93b48ddce5a69f4060da7130e3c78e59fd48581","observed_at":"2026-09-02T18:24:25Z","prerelease":false,"publication_mode":"already-published-pypi","pypi_files":[{"filename":"openadapt_flow-1.34.0-py3-none-any.whl","packagetype":"bdist_wheel","sha256":"sha256:56d32818989cb3a92830080ead39e10b08718c55e00988117f22cbfeaac98854","size_bytes":1928194,"yanked":false},{"filename":"openadapt_flow-1.34.0.tar.gz","packagetype":"sdist","sha256":"sha256:a941a70015fe91897e655bfc9bf83e6cf8fbcf8bd4e4c7206ffb133c505203f8","size_bytes":20440838,"yanked":false}],"release_app_bot_user_id":"321543906","release_app_id":"4730708","release_app_installation_id":"156835568","release_author_login":"openadapt-release[bot]","repository":"OpenAdaptAI/openadapt-flow","repository_id":"1291376938","schema_version":"openadapt.production-release-staging-evidence/v1","tag":"v1.34.0","tag_ref_state":{"exists":true,"ref":"refs/tags/v1.34.0"},"tag_ref_state_sha256":"sha256:74c5665395ed98ba3fd1b3a284bab1e8089f7c79cfafb3f88548e8b1456c5782","tag_rulesets":[{"bypass_actors":[{"actor_id":"4730708","actor_type":"Integration","bypass_mode":"always"}],"conditions":{"ref_name":{"exclude":[],"include":["refs/tags/v*"]}},"enforcement":"active","name":"OpenAdapt policy: release tag creation","repository":"OpenAdaptAI/openadapt-flow","repository_id":"1291376938","role":"creation_authority","rules":[{"type":"creation"}],"ruleset_id":"10","schema_version":"openadapt.production-release-tag-ruleset/v1","target":"tag"},{"bypass_actors":[],"conditions":{"ref_name":{"exclude":[],"include":["refs/tags/v*"]}},"enforcement":"active","name":"OpenAdapt policy: immutable release tags","repository":"OpenAdaptAI/openadapt-flow","repository_id":"1291376938","role":"immutability","rules":[{"type":"deletion"},{"type":"non_fast_forward"},{"parameters":{"update_allows_fetch_and_merge":false},"type":"update"}],"ruleset_id":"11","schema_version":"openadapt.production-release-tag-ruleset/v1","target":"tag"}],"tag_rulesets_sha256":"sha256:b0fdf160d80ae7dc8ffd979b2ba101cee6b3e7cf139e8c5d32b5534cbc0f7f44","target_commitish":"30fc60e55778a0e0f92b9776117cafcfe2512249"},"publication_staging_sha256":"sha256:861175c196cfe9455ce5f0536b6b1eabf55a990ced03349b865643f52316dedd","release":{"artifacts":[{"kind":"python-sdist","media_type":"application/gzip","name":"openadapt_flow-1.34.0.tar.gz","publish_destinations":["github-release","pypi"],"sha256":"sha256:a941a70015fe91897e655bfc9bf83e6cf8fbcf8bd4e4c7206ffb133c505203f8","size_bytes":20440838},{"kind":"python-wheel","media_type":"application/zip","name":"openadapt_flow-1.34.0-py3-none-any.whl","publish_destinations":["github-release","pypi"],"sha256":"sha256:56d32818989cb3a92830080ead39e10b08718c55e00988117f22cbfeaac98854","size_bytes":1928194}],"deployment_id":null,"deployment_sha256":null,"kind":"package","schema_version":"openadapt.production-release-candidate/v1","source_commit":"30fc60e55778a0e0f92b9776117cafcfe2512249","source_repository":"OpenAdaptAI/openadapt-flow","source_repository_id":"1291376938","tag":"v1.34.0","version":"1.34.0"},"release_identity":{"channel":"production","previous_admission_sha256":null,"schema_version":"openadapt.monotonic-production-release/v1","sequence":1},"release_sha256":"sha256:f84c03c857bda8372d39bc30afcc2986247778c34b3f93a39ec9de5dd151a289","revocation_state_sha256":"sha256:250ab430e467f5e584ebd2b1832976b42186b698da71d627ee1724c2b1da2457","schema_version":"openadapt.qualification-release/v2","signer_registry_sha256":"sha256:e243a23243b24986ed08812e284a1bd8c4993814149f02bcba79cc520e10ca14","target":"flow","verdict":"accepted"}
","result_sha256":"sha256:790122a25c87e456c6e45d25ebf5cd029b21b8511265b062fd9129b74aa1dd82","retry_policy":"reconcile-never-retry","schema_version":"openadapt.qualification-one-use-effect/v1"} diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/one-use-effect.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/one-use-effect.json new file mode 100644 index 0000000..64c0e82 --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/one-use-effect.json @@ -0,0 +1 @@ +{"effect_id_sha256":"sha256:7b3e0422c3060473288f44c21747f36bd616f1417875c292d634a9e7204b09c8","effect_sha256":"sha256:4f57ac99062b4e528ad83d34f5815b2f932ef32cd882e280c7b02bf695da5fdf","operation":"issue-qualification-admission","request_handle":"qair_RmVqt6OgAzt7MKwoxwOaebxcy0co-Xop9NqvT09wneO","request_sha256":"sha256:bec6c1533080d25a6e25d5a6d8f08c0c1bf7525ce083bf2a2d99b14399e5922b","result_base64":"{"action_contract_sha256":"sha256:d4b8a931c16bca24cd343c786f41566357d9edcc8b0b97d3c1cb9907571dd56b","admission_id_sha256":"sha256:45c157898b6f07e57bf604b3323f206d677cac6c57a43238152cdb3308495e80","admitted_runtime_sha256":"sha256:56d32818989cb3a92830080ead39e10b08718c55e00988117f22cbfeaac98854","application_contract_sha256":"sha256:e8f70b24976d2befeaea5e54059e39b1934a211c49cba65ac41e6cfdfd70ec80","bundle_sha256":"sha256:33f8c637f3d5d9eb23b92e0fb7ba74d2713a52f7c8ed11495b30f8bbefb1f312","bundle_version":"0.0.0-synthetic","campaign_artifact_sha256":"sha256:e2f2aa6b30118864682892a08e7e151039a34e7e7f84ff027e253cf8daddff78","campaign_permit_sha256":"sha256:da4af1f21aa121a00f92d88fc129d47bbd1a027462408e6bf2adf8fe66fe4255","campaign_summary":{"declared_attended":{"approved_repair_count":0,"authenticated_bound_decision_count":3,"blind_retry_count":0,"live_target_revalidation_count":3,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"governed_repair":{"approved_repair_count":3,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":3,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":3,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":3,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"healthy":{"approved_repair_count":0,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":0,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"idempotency_replay":{"approved_repair_count":0,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":0,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"safe_halt":{"approved_repair_count":0,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":0,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"uncertain_delivery":{"approved_repair_count":0,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":0,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":3,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0}},"decision_receipt_bundle_reference":{"kind":"qualification-evidence-decision-receipt-sigstore-bundle","object_media_type":"application/vnd.dev.sigstore.bundle.v0.3+json","object_path":"production-evidence/objects/sha256/09/09eb48f80dec3cd8f7da73bfef1aed805068c0feefdbaaaa350ded1b70ba0c7d.qualification-evidence-decision-receipt-sigstore-bundle.json","object_schema_version":"application/vnd.dev.sigstore.bundle.v0.3+json","object_sha256":"sha256:09eb48f80dec3cd8f7da73bfef1aed805068c0feefdbaaaa350ded1b70ba0c7d","registry_entry_sha256":"sha256:40e134188beb1f1dd8bf17eaa02d84b8246ae11db7b99db68efb493f2a3d7955","registry_head_sha256":"sha256:9a9f597b0d87674c4d36c022227201a5d8f3072237624346793692c3a863d12e","registry_revision":1,"registry_source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","schema_version":"openadapt.production-evidence-object-reference/v2","semantic_identity_sha256":"sha256:21d2be624cc93f033b13eceabd7ea42b39ab6f80790c643235c80a32272545a6","size_bytes":2849,"subject_sha256":"sha256:6ffe691f8e40e06b73e24391d180424ed86bb289ddae001cf7b49de2e745312a"},"decision_receipt_reference":{"kind":"qualification-evidence-decision-receipt","object_media_type":"application/vnd.openadapt.qualification-evidence-decision-receipt+json;version=2","object_path":"production-evidence/objects/sha256/6f/6ffe691f8e40e06b73e24391d180424ed86bb289ddae001cf7b49de2e745312a.qualification-evidence-decision-receipt.json","object_schema_version":"openadapt.qualification-evidence-decision-receipt/v2","object_sha256":"sha256:6ffe691f8e40e06b73e24391d180424ed86bb289ddae001cf7b49de2e745312a","registry_entry_sha256":"sha256:63d0170fb957ebd167f2650ef744d70839d0676a8cf9f8978d73aed5cffd0b27","registry_head_sha256":"sha256:9a9f597b0d87674c4d36c022227201a5d8f3072237624346793692c3a863d12e","registry_revision":1,"registry_source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","schema_version":"openadapt.production-evidence-object-reference/v2","semantic_identity_sha256":"sha256:c18d69bdfb145139581ea6865f513179bd104cb02a64d838f93e49f96d9d3769","size_bytes":6636,"subject_sha256":null},"effect_contract_sha256":"sha256:ce11f9ac1059d29c5648a662ce8a4e8528ea3e8d844657aec8422d8b125a0698","entity_class":"record","environment_contract_sha256":"sha256:b01e155a3704b1f781937585da7f86c47adb8c86d48f032019ef41d6e9ceea57","evidence_authority_sha256":"sha256:1aa7cfcb5f3df6b99372a28c305177e046487c8ec5b61111edbf1a12d3e76663","evidence_class":"remote-safe-synthetic","expires_at":null,"identity_contract_sha256":"sha256:34b008dd040d718fdc4d7b85b9311749b9865f47b4ba43bf6cd4a140bcf36c65","input_contract_sha256":"sha256:a82ba67af90f81e9a09f2db445a57f812b40a04c876396f191eb77eb53487a0f","issued_at":"2026-09-02T18:24:25Z","issuer":{"environment":"qualification-admission","ref":"refs/heads/main","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","workflow":".github/workflows/issue-qualification-admission.yml"},"local_identity_opening":{"algorithm":"hmac-sha256","customer_controlled_secret_required":true,"exact_contract_match_required":true,"maximum_age_seconds":60,"required":true,"revalidation_before_actuation":true,"schema_version":"openadapt.qualification-local-identity-opening/v1"},"not_before":"2026-09-02T18:24:25Z","organization_id_sha256":"sha256:fcba879d867709da525f7f994a2642bc7a32014e324523a9d276bec54c3d296b","policy_contract_sha256":"sha256:482e3c7f10d044086283ea387f22b21c011e6c00cfc7fbf14cf82cfe2aedd1e0","revocation_state_sha256":"sha256:250ab430e467f5e584ebd2b1832976b42186b698da71d627ee1724c2b1da2457","schema_version":"openadapt.qualification-admission/v4","signer_registry_sha256":"sha256:e243a23243b24986ed08812e284a1bd8c4993814149f02bcba79cc520e10ca14","verdict":"accepted","workflow_id_sha256":"sha256:7176583f6120b7ff016363644afc47e835b2e4b438abe4050df160570f780af1","workflow_version_id_sha256":"sha256:4acf27da1f384b7967a1bb4fb463570657894cb83468e5763940d69ab9df1386"}
","result_sha256":"sha256:dcdb32a762aca87fbb1a7c9df5d346403b167ec5850d35fe47fd64d942684a04","retry_policy":"reconcile-never-retry","schema_version":"openadapt.qualification-one-use-effect/v1"} diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/one-use-effects.sqlite b/local-candidates/flow-1.34.0-remote-safe-synthetic/one-use-effects.sqlite new file mode 100644 index 0000000000000000000000000000000000000000..9286631d68e383637f0976054a15372aed034b5a GIT binary patch literal 57344 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 DI#fHd literal 0 HcmV?d00001 diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/phase1-state.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/phase1-state.json new file mode 100644 index 0000000..2c196e7 --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/phase1-state.json @@ -0,0 +1 @@ +{"authority_state_sha256":"sha256:df5079141df68877c4b06f05b9fb9fdf279307b7629eb1f2dce12def4bd5e2fa","campaign_label":"remote-safe-synthetic","evals_production_acceptance":false,"expires_at":null,"flow_source":"30fc60e55778a0e0f92b9776117cafcfe2512249","generated_at":"2026-09-02T18:24:25Z","inner_key_id":"qa-ed25519-9cf4bca214c01d79","mockmed_1_34_0_evals_set_is_this_summary":false,"outer_key_id":"oa-public-trust-ed25519-9cf4bca214c01d79","policy_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","registry_head_sha256":"sha256:9a9f597b0d87674c4d36c022227201a5d8f3072237624346793692c3a863d12e","registry_identity":"sha256:e243a23243b24986ed08812e284a1bd8c4993814149f02bcba79cc520e10ca14","registry_raw_sha256":"sha256:7a81bf3d213c74673f3c6b5fa179234cbee534c9432aaea6ae09e455562f96b6","registry_revision":1,"revocation_state_sha256":"sha256:250ab430e467f5e584ebd2b1832976b42186b698da71d627ee1724c2b1da2457","sdist_sha256":"a941a70015fe91897e655bfc9bf83e6cf8fbcf8bd4e4c7206ffb133c505203f8","wheel_sha256":"56d32818989cb3a92830080ead39e10b08718c55e00988117f22cbfeaac98854"} diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/production-acceptance-manifest-sigstore-bundle.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/production-acceptance-manifest-sigstore-bundle.json new file mode 100644 index 0000000..d900ee8 --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/production-acceptance-manifest-sigstore-bundle.json @@ -0,0 +1 @@ +{"dsseEnvelope":{"payload":"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","payloadType":"application/vnd.openadapt.production-public-trust-signing-statement+json;version=1","signatures":[{"keyid":"oa-public-trust-ed25519-9cf4bca214c01d79","sig":"Y372xGFB91tSyBUldgOPPbGgMBXWttlVwtuXmqqHRJBnqzFjzC079I/Nz8ODEcZeV7DY1AR5AWOmhJ0mUcl8Bw=="}]},"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"publicKey":{"hint":"oa-public-trust-ed25519-9cf4bca214c01d79"}}} diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/production-acceptance-manifest.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/production-acceptance-manifest.json new file mode 100644 index 0000000..df7bcee --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/production-acceptance-manifest.json @@ -0,0 +1 @@ +{"acceptance_policy_sha256":"sha256:ed5ab69fe8127604ca674263cbc8c774b7cfd10754e90bfaa9b71ba573bce1d1","artifact_inventory":{"artifacts":[{"kind":"python-sdist","media_type":"application/gzip","name":"openadapt_flow-1.34.0.tar.gz","publish_destinations":["github-release","pypi"],"sha256":"sha256:a941a70015fe91897e655bfc9bf83e6cf8fbcf8bd4e4c7206ffb133c505203f8","size_bytes":20440838},{"kind":"python-wheel","media_type":"application/zip","name":"openadapt_flow-1.34.0-py3-none-any.whl","publish_destinations":["github-release","pypi"],"sha256":"sha256:56d32818989cb3a92830080ead39e10b08718c55e00988117f22cbfeaac98854","size_bytes":1928194}],"claim_scope":"production_flow","schema_version":"openadapt.production-release-artifact-inventory/v1","target":"flow"},"artifact_inventory_sha256":"sha256:ec3ef7c177c493bebee3da60f170b37793832e81066e9d9ee785d5fa225a5ac5","authority_state_sha256":"sha256:df5079141df68877c4b06f05b9fb9fdf279307b7629eb1f2dce12def4bd5e2fa","campaign_summary":{"declared_attended":{"approved_repair_count":0,"authenticated_bound_decision_count":3,"blind_retry_count":0,"live_target_revalidation_count":3,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"governed_repair":{"approved_repair_count":3,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":3,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":3,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":3,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"healthy":{"approved_repair_count":0,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":0,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"idempotency_replay":{"approved_repair_count":0,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":0,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"safe_halt":{"approved_repair_count":0,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":0,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"uncertain_delivery":{"approved_repair_count":0,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":0,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":3,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0}},"claim_scope":"production_flow","expires_at":null,"issued_at":"2026-09-02T18:24:25Z","issuer":{"environment":"production-acceptance","ref":"refs/heads/main","repository":"OpenAdaptAI/openadapt-evals","repository_id":"1135998197","repository_owner_id":"132681217","source_commit":"cad5560d6b7482f2cb99b9735e0ac3c5aae714c8","workflow":".github/workflows/issue-production-acceptance.yml"},"lifecycle_policy_sha256":"sha256:6c8daa221668e0a39188d7485d997ed04396e5142dd7422e34785bf3286a40d1","not_before":"2026-09-02T18:24:25Z","publication_staging":{"assets":[{"asset_id":"534029483","kind":"python-wheel","media_type":"application/zip","name":"openadapt_flow-1.34.0-py3-none-any.whl","publish_destinations":["github-release","pypi"],"sha256":"sha256:56d32818989cb3a92830080ead39e10b08718c55e00988117f22cbfeaac98854","size_bytes":1928194,"uploader_id":"321543906","uploader_login":"openadapt-release[bot]"},{"asset_id":"534029484","kind":"python-sdist","media_type":"application/gzip","name":"openadapt_flow-1.34.0.tar.gz","publish_destinations":["github-release","pypi"],"sha256":"sha256:a941a70015fe91897e655bfc9bf83e6cf8fbcf8bd4e4c7206ffb133c505203f8","size_bytes":20440838,"uploader_id":"321543906","uploader_login":"openadapt-release[bot]"}],"draft":false,"draft_release_id":"378603192","immutable_releases":{"enabled":true,"enforced_by_owner":false},"immutable_releases_sha256":"sha256:07649aafb167237fecc138f5e93b48ddce5a69f4060da7130e3c78e59fd48581","observed_at":"2026-09-02T18:24:25Z","prerelease":false,"publication_mode":"already-published-pypi","pypi_files":[{"filename":"openadapt_flow-1.34.0-py3-none-any.whl","packagetype":"bdist_wheel","sha256":"sha256:56d32818989cb3a92830080ead39e10b08718c55e00988117f22cbfeaac98854","size_bytes":1928194,"yanked":false},{"filename":"openadapt_flow-1.34.0.tar.gz","packagetype":"sdist","sha256":"sha256:a941a70015fe91897e655bfc9bf83e6cf8fbcf8bd4e4c7206ffb133c505203f8","size_bytes":20440838,"yanked":false}],"release_app_bot_user_id":"321543906","release_app_id":"4730708","release_app_installation_id":"156835568","release_author_login":"openadapt-release[bot]","repository":"OpenAdaptAI/openadapt-flow","repository_id":"1291376938","schema_version":"openadapt.production-release-staging-evidence/v1","tag":"v1.34.0","tag_ref_state":{"exists":true,"ref":"refs/tags/v1.34.0"},"tag_ref_state_sha256":"sha256:74c5665395ed98ba3fd1b3a284bab1e8089f7c79cfafb3f88548e8b1456c5782","tag_rulesets":[{"bypass_actors":[{"actor_id":"4730708","actor_type":"Integration","bypass_mode":"always"}],"conditions":{"ref_name":{"exclude":[],"include":["refs/tags/v*"]}},"enforcement":"active","name":"OpenAdapt policy: release tag creation","repository":"OpenAdaptAI/openadapt-flow","repository_id":"1291376938","role":"creation_authority","rules":[{"type":"creation"}],"ruleset_id":"10","schema_version":"openadapt.production-release-tag-ruleset/v1","target":"tag"},{"bypass_actors":[],"conditions":{"ref_name":{"exclude":[],"include":["refs/tags/v*"]}},"enforcement":"active","name":"OpenAdapt policy: immutable release tags","repository":"OpenAdaptAI/openadapt-flow","repository_id":"1291376938","role":"immutability","rules":[{"type":"deletion"},{"type":"non_fast_forward"},{"parameters":{"update_allows_fetch_and_merge":false},"type":"update"}],"ruleset_id":"11","schema_version":"openadapt.production-release-tag-ruleset/v1","target":"tag"}],"tag_rulesets_sha256":"sha256:b0fdf160d80ae7dc8ffd979b2ba101cee6b3e7cf139e8c5d32b5534cbc0f7f44","target_commitish":"30fc60e55778a0e0f92b9776117cafcfe2512249"},"publication_staging_sha256":"sha256:861175c196cfe9455ce5f0536b6b1eabf55a990ced03349b865643f52316dedd","qualification_admission_bundle_reference":{"kind":"qualification-admission-sigstore-bundle","object_media_type":"application/vnd.dev.sigstore.bundle.v0.3+json","object_path":"production-evidence/objects/sha256/17/1773f9dd2b0c3a78bf2454cfba5d038151925f4b7c5aa1a2d7ed46b5f9315c32.qualification-admission-sigstore-bundle.json","object_schema_version":"application/vnd.dev.sigstore.bundle.v0.3+json","object_sha256":"sha256:1773f9dd2b0c3a78bf2454cfba5d038151925f4b7c5aa1a2d7ed46b5f9315c32","registry_entry_sha256":"sha256:c0b5b8dd6fd24352f32896d24d276dc8256005d9eee2a97ac1a83fb576441da4","registry_head_sha256":"sha256:9a9f597b0d87674c4d36c022227201a5d8f3072237624346793692c3a863d12e","registry_revision":1,"registry_source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","schema_version":"openadapt.production-evidence-object-reference/v2","semantic_identity_sha256":"sha256:5bfd1cb8d71754563173aef8a5dcffff00bf8016ec5b60553d72b69dee1cb214","size_bytes":2737,"subject_sha256":"sha256:dcdb32a762aca87fbb1a7c9df5d346403b167ec5850d35fe47fd64d942684a04"},"qualification_admission_reference":{"kind":"qualification-admission","object_media_type":"application/vnd.openadapt.qualification-admission+json;version=4","object_path":"production-evidence/objects/sha256/dc/dcdb32a762aca87fbb1a7c9df5d346403b167ec5850d35fe47fd64d942684a04.qualification-admission.json","object_schema_version":"openadapt.qualification-admission/v4","object_sha256":"sha256:dcdb32a762aca87fbb1a7c9df5d346403b167ec5850d35fe47fd64d942684a04","registry_entry_sha256":"sha256:813040c698d3b04d39825502635f5337bcf08d5885142363fe9b16a76b4667a6","registry_head_sha256":"sha256:9a9f597b0d87674c4d36c022227201a5d8f3072237624346793692c3a863d12e","registry_revision":1,"registry_source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","schema_version":"openadapt.production-evidence-object-reference/v2","semantic_identity_sha256":"sha256:a480d62a9c2aa5ed6061d3b0140cf908024b23e90b7535bb3c09e9da6f748e90","size_bytes":8055,"subject_sha256":null},"qualification_evidence_decision_receipt_bundle_reference":{"kind":"qualification-evidence-decision-receipt-sigstore-bundle","object_media_type":"application/vnd.dev.sigstore.bundle.v0.3+json","object_path":"production-evidence/objects/sha256/09/09eb48f80dec3cd8f7da73bfef1aed805068c0feefdbaaaa350ded1b70ba0c7d.qualification-evidence-decision-receipt-sigstore-bundle.json","object_schema_version":"application/vnd.dev.sigstore.bundle.v0.3+json","object_sha256":"sha256:09eb48f80dec3cd8f7da73bfef1aed805068c0feefdbaaaa350ded1b70ba0c7d","registry_entry_sha256":"sha256:40e134188beb1f1dd8bf17eaa02d84b8246ae11db7b99db68efb493f2a3d7955","registry_head_sha256":"sha256:9a9f597b0d87674c4d36c022227201a5d8f3072237624346793692c3a863d12e","registry_revision":1,"registry_source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","schema_version":"openadapt.production-evidence-object-reference/v2","semantic_identity_sha256":"sha256:21d2be624cc93f033b13eceabd7ea42b39ab6f80790c643235c80a32272545a6","size_bytes":2849,"subject_sha256":"sha256:6ffe691f8e40e06b73e24391d180424ed86bb289ddae001cf7b49de2e745312a"},"qualification_evidence_decision_receipt_reference":{"kind":"qualification-evidence-decision-receipt","object_media_type":"application/vnd.openadapt.qualification-evidence-decision-receipt+json;version=2","object_path":"production-evidence/objects/sha256/6f/6ffe691f8e40e06b73e24391d180424ed86bb289ddae001cf7b49de2e745312a.qualification-evidence-decision-receipt.json","object_schema_version":"openadapt.qualification-evidence-decision-receipt/v2","object_sha256":"sha256:6ffe691f8e40e06b73e24391d180424ed86bb289ddae001cf7b49de2e745312a","registry_entry_sha256":"sha256:63d0170fb957ebd167f2650ef744d70839d0676a8cf9f8978d73aed5cffd0b27","registry_head_sha256":"sha256:9a9f597b0d87674c4d36c022227201a5d8f3072237624346793692c3a863d12e","registry_revision":1,"registry_source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","schema_version":"openadapt.production-evidence-object-reference/v2","semantic_identity_sha256":"sha256:c18d69bdfb145139581ea6865f513179bd104cb02a64d838f93e49f96d9d3769","size_bytes":6636,"subject_sha256":null},"release":{"artifacts":[{"kind":"python-sdist","media_type":"application/gzip","name":"openadapt_flow-1.34.0.tar.gz","publish_destinations":["github-release","pypi"],"sha256":"sha256:a941a70015fe91897e655bfc9bf83e6cf8fbcf8bd4e4c7206ffb133c505203f8","size_bytes":20440838},{"kind":"python-wheel","media_type":"application/zip","name":"openadapt_flow-1.34.0-py3-none-any.whl","publish_destinations":["github-release","pypi"],"sha256":"sha256:56d32818989cb3a92830080ead39e10b08718c55e00988117f22cbfeaac98854","size_bytes":1928194}],"deployment_id":null,"deployment_sha256":null,"kind":"package","schema_version":"openadapt.production-release-candidate/v1","source_commit":"30fc60e55778a0e0f92b9776117cafcfe2512249","source_repository":"OpenAdaptAI/openadapt-flow","source_repository_id":"1291376938","tag":"v1.34.0","version":"1.34.0"},"release_identity":{"channel":"production","previous_admission_sha256":null,"schema_version":"openadapt.monotonic-production-release/v1","sequence":1},"release_sha256":"sha256:f84c03c857bda8372d39bc30afcc2986247778c34b3f93a39ec9de5dd151a289","revocation_state_sha256":"sha256:250ab430e467f5e584ebd2b1832976b42186b698da71d627ee1724c2b1da2457","schema_version":"openadapt.production-acceptance/v3","signer_registry_sha256":"sha256:e243a23243b24986ed08812e284a1bd8c4993814149f02bcba79cc520e10ca14","target":"flow","verdict":"accepted"} diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/production-acceptance-summary-sigstore-bundle.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/production-acceptance-summary-sigstore-bundle.json new file mode 100644 index 0000000..5a494eb --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/production-acceptance-summary-sigstore-bundle.json @@ -0,0 +1 @@ +{"dsseEnvelope":{"payload":"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","payloadType":"application/vnd.openadapt.production-public-trust-signing-statement+json;version=1","signatures":[{"keyid":"oa-public-trust-ed25519-9cf4bca214c01d79","sig":"1XvTEC4Jxf10eci09PedfhRA/Lkr8pMxpPPdA9fam1M8U5nefd+U9zdPfv2fnUaB5L5bMhQ7fU+JButltWclAA=="}]},"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"publicKey":{"hint":"oa-public-trust-ed25519-9cf4bca214c01d79"}}} diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/production-acceptance-summary.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/production-acceptance-summary.json new file mode 100644 index 0000000..0659bdb --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/production-acceptance-summary.json @@ -0,0 +1 @@ +{"acceptance_policy_sha256":"sha256:ed5ab69fe8127604ca674263cbc8c774b7cfd10754e90bfaa9b71ba573bce1d1","artifact_inventory_sha256":"sha256:ec3ef7c177c493bebee3da60f170b37793832e81066e9d9ee785d5fa225a5ac5","authority_state_sha256":"sha256:df5079141df68877c4b06f05b9fb9fdf279307b7629eb1f2dce12def4bd5e2fa","campaign_summary":{"declared_attended":{"approved_repair_count":0,"authenticated_bound_decision_count":3,"blind_retry_count":0,"live_target_revalidation_count":3,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"governed_repair":{"approved_repair_count":3,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":3,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":3,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":3,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"healthy":{"approved_repair_count":0,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":0,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"idempotency_replay":{"approved_repair_count":0,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":0,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"safe_halt":{"approved_repair_count":0,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":0,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"uncertain_delivery":{"approved_repair_count":0,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":0,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":3,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0}},"claim_scope":"production_flow","evidence_identity_sha256":"sha256:c5362154ed3171a6d592beca0c3a9c10243988864f3ba6793d6393f356ca7715","expires_at":null,"issued_at":"2026-09-02T18:24:25Z","issuer":{"environment":"production-acceptance","ref":"refs/heads/main","repository":"OpenAdaptAI/openadapt-evals","repository_id":"1135998197","repository_owner_id":"132681217","source_commit":"cad5560d6b7482f2cb99b9735e0ac3c5aae714c8","workflow":".github/workflows/issue-production-acceptance.yml"},"lifecycle_policy_sha256":"sha256:6c8daa221668e0a39188d7485d997ed04396e5142dd7422e34785bf3286a40d1","not_before":"2026-09-02T18:24:25Z","production_acceptance_manifest_bundle_reference":{"kind":"production-acceptance-manifest-sigstore-bundle","object_media_type":"application/vnd.dev.sigstore.bundle.v0.3+json","object_path":"production-evidence/objects/sha256/ac/ace6aabbaf02596d26cd5d6f1406790f4fe831ca978129d50cc2285882a2630c.production-acceptance-manifest-sigstore-bundle.json","object_schema_version":"application/vnd.dev.sigstore.bundle.v0.3+json","object_sha256":"sha256:ace6aabbaf02596d26cd5d6f1406790f4fe831ca978129d50cc2285882a2630c","registry_entry_sha256":"sha256:15f463cf84ae49b1d5baeb053ad8e9c3a61aa4a84d1f982635e1d9bd88b17ca7","registry_head_sha256":"sha256:9a9f597b0d87674c4d36c022227201a5d8f3072237624346793692c3a863d12e","registry_revision":1,"registry_source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","schema_version":"openadapt.production-evidence-object-reference/v2","semantic_identity_sha256":"sha256:1ebdadbe1754dbef6ceb987dd5a9fcf3d982c2414bd0a01e7b4c923bc46924eb","size_bytes":2749,"subject_sha256":"sha256:211651dd301699ea1394af8b8ec38d1c9c6df5045c88d9ce1ece09ca774c15ca"},"production_acceptance_manifest_reference":{"kind":"production-acceptance-manifest","object_media_type":"application/vnd.openadapt.production-acceptance+json;version=3","object_path":"production-evidence/objects/sha256/21/211651dd301699ea1394af8b8ec38d1c9c6df5045c88d9ce1ece09ca774c15ca.production-acceptance-manifest.json","object_schema_version":"openadapt.production-acceptance/v3","object_sha256":"sha256:211651dd301699ea1394af8b8ec38d1c9c6df5045c88d9ce1ece09ca774c15ca","registry_entry_sha256":"sha256:502cb9dffb93c654258c305841e4515e933eb647edf375b8f36ee6e3f57fab8c","registry_head_sha256":"sha256:9a9f597b0d87674c4d36c022227201a5d8f3072237624346793692c3a863d12e","registry_revision":1,"registry_source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","schema_version":"openadapt.production-evidence-object-reference/v2","semantic_identity_sha256":"sha256:2e24dd5a8f4aefba4478952c3d2d120d8d0706cf6cc4dafd74b2f21f75ce9ea5","size_bytes":13633,"subject_sha256":null},"publication_staging":{"assets":[{"asset_id":"534029483","kind":"python-wheel","media_type":"application/zip","name":"openadapt_flow-1.34.0-py3-none-any.whl","publish_destinations":["github-release","pypi"],"sha256":"sha256:56d32818989cb3a92830080ead39e10b08718c55e00988117f22cbfeaac98854","size_bytes":1928194,"uploader_id":"321543906","uploader_login":"openadapt-release[bot]"},{"asset_id":"534029484","kind":"python-sdist","media_type":"application/gzip","name":"openadapt_flow-1.34.0.tar.gz","publish_destinations":["github-release","pypi"],"sha256":"sha256:a941a70015fe91897e655bfc9bf83e6cf8fbcf8bd4e4c7206ffb133c505203f8","size_bytes":20440838,"uploader_id":"321543906","uploader_login":"openadapt-release[bot]"}],"draft":false,"draft_release_id":"378603192","immutable_releases":{"enabled":true,"enforced_by_owner":false},"immutable_releases_sha256":"sha256:07649aafb167237fecc138f5e93b48ddce5a69f4060da7130e3c78e59fd48581","observed_at":"2026-09-02T18:24:25Z","prerelease":false,"publication_mode":"already-published-pypi","pypi_files":[{"filename":"openadapt_flow-1.34.0-py3-none-any.whl","packagetype":"bdist_wheel","sha256":"sha256:56d32818989cb3a92830080ead39e10b08718c55e00988117f22cbfeaac98854","size_bytes":1928194,"yanked":false},{"filename":"openadapt_flow-1.34.0.tar.gz","packagetype":"sdist","sha256":"sha256:a941a70015fe91897e655bfc9bf83e6cf8fbcf8bd4e4c7206ffb133c505203f8","size_bytes":20440838,"yanked":false}],"release_app_bot_user_id":"321543906","release_app_id":"4730708","release_app_installation_id":"156835568","release_author_login":"openadapt-release[bot]","repository":"OpenAdaptAI/openadapt-flow","repository_id":"1291376938","schema_version":"openadapt.production-release-staging-evidence/v1","tag":"v1.34.0","tag_ref_state":{"exists":true,"ref":"refs/tags/v1.34.0"},"tag_ref_state_sha256":"sha256:74c5665395ed98ba3fd1b3a284bab1e8089f7c79cfafb3f88548e8b1456c5782","tag_rulesets":[{"bypass_actors":[{"actor_id":"4730708","actor_type":"Integration","bypass_mode":"always"}],"conditions":{"ref_name":{"exclude":[],"include":["refs/tags/v*"]}},"enforcement":"active","name":"OpenAdapt policy: release tag creation","repository":"OpenAdaptAI/openadapt-flow","repository_id":"1291376938","role":"creation_authority","rules":[{"type":"creation"}],"ruleset_id":"10","schema_version":"openadapt.production-release-tag-ruleset/v1","target":"tag"},{"bypass_actors":[],"conditions":{"ref_name":{"exclude":[],"include":["refs/tags/v*"]}},"enforcement":"active","name":"OpenAdapt policy: immutable release tags","repository":"OpenAdaptAI/openadapt-flow","repository_id":"1291376938","role":"immutability","rules":[{"type":"deletion"},{"type":"non_fast_forward"},{"parameters":{"update_allows_fetch_and_merge":false},"type":"update"}],"ruleset_id":"11","schema_version":"openadapt.production-release-tag-ruleset/v1","target":"tag"}],"tag_rulesets_sha256":"sha256:b0fdf160d80ae7dc8ffd979b2ba101cee6b3e7cf139e8c5d32b5534cbc0f7f44","target_commitish":"30fc60e55778a0e0f92b9776117cafcfe2512249"},"publication_staging_sha256":"sha256:861175c196cfe9455ce5f0536b6b1eabf55a990ced03349b865643f52316dedd","qualification_admission_bundle_reference":{"kind":"qualification-admission-sigstore-bundle","object_media_type":"application/vnd.dev.sigstore.bundle.v0.3+json","object_path":"production-evidence/objects/sha256/17/1773f9dd2b0c3a78bf2454cfba5d038151925f4b7c5aa1a2d7ed46b5f9315c32.qualification-admission-sigstore-bundle.json","object_schema_version":"application/vnd.dev.sigstore.bundle.v0.3+json","object_sha256":"sha256:1773f9dd2b0c3a78bf2454cfba5d038151925f4b7c5aa1a2d7ed46b5f9315c32","registry_entry_sha256":"sha256:c0b5b8dd6fd24352f32896d24d276dc8256005d9eee2a97ac1a83fb576441da4","registry_head_sha256":"sha256:9a9f597b0d87674c4d36c022227201a5d8f3072237624346793692c3a863d12e","registry_revision":1,"registry_source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","schema_version":"openadapt.production-evidence-object-reference/v2","semantic_identity_sha256":"sha256:5bfd1cb8d71754563173aef8a5dcffff00bf8016ec5b60553d72b69dee1cb214","size_bytes":2737,"subject_sha256":"sha256:dcdb32a762aca87fbb1a7c9df5d346403b167ec5850d35fe47fd64d942684a04"},"qualification_admission_reference":{"kind":"qualification-admission","object_media_type":"application/vnd.openadapt.qualification-admission+json;version=4","object_path":"production-evidence/objects/sha256/dc/dcdb32a762aca87fbb1a7c9df5d346403b167ec5850d35fe47fd64d942684a04.qualification-admission.json","object_schema_version":"openadapt.qualification-admission/v4","object_sha256":"sha256:dcdb32a762aca87fbb1a7c9df5d346403b167ec5850d35fe47fd64d942684a04","registry_entry_sha256":"sha256:813040c698d3b04d39825502635f5337bcf08d5885142363fe9b16a76b4667a6","registry_head_sha256":"sha256:9a9f597b0d87674c4d36c022227201a5d8f3072237624346793692c3a863d12e","registry_revision":1,"registry_source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","schema_version":"openadapt.production-evidence-object-reference/v2","semantic_identity_sha256":"sha256:a480d62a9c2aa5ed6061d3b0140cf908024b23e90b7535bb3c09e9da6f748e90","size_bytes":8055,"subject_sha256":null},"qualification_evidence_decision_receipt_bundle_reference":{"kind":"qualification-evidence-decision-receipt-sigstore-bundle","object_media_type":"application/vnd.dev.sigstore.bundle.v0.3+json","object_path":"production-evidence/objects/sha256/09/09eb48f80dec3cd8f7da73bfef1aed805068c0feefdbaaaa350ded1b70ba0c7d.qualification-evidence-decision-receipt-sigstore-bundle.json","object_schema_version":"application/vnd.dev.sigstore.bundle.v0.3+json","object_sha256":"sha256:09eb48f80dec3cd8f7da73bfef1aed805068c0feefdbaaaa350ded1b70ba0c7d","registry_entry_sha256":"sha256:40e134188beb1f1dd8bf17eaa02d84b8246ae11db7b99db68efb493f2a3d7955","registry_head_sha256":"sha256:9a9f597b0d87674c4d36c022227201a5d8f3072237624346793692c3a863d12e","registry_revision":1,"registry_source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","schema_version":"openadapt.production-evidence-object-reference/v2","semantic_identity_sha256":"sha256:21d2be624cc93f033b13eceabd7ea42b39ab6f80790c643235c80a32272545a6","size_bytes":2849,"subject_sha256":"sha256:6ffe691f8e40e06b73e24391d180424ed86bb289ddae001cf7b49de2e745312a"},"qualification_evidence_decision_receipt_reference":{"kind":"qualification-evidence-decision-receipt","object_media_type":"application/vnd.openadapt.qualification-evidence-decision-receipt+json;version=2","object_path":"production-evidence/objects/sha256/6f/6ffe691f8e40e06b73e24391d180424ed86bb289ddae001cf7b49de2e745312a.qualification-evidence-decision-receipt.json","object_schema_version":"openadapt.qualification-evidence-decision-receipt/v2","object_sha256":"sha256:6ffe691f8e40e06b73e24391d180424ed86bb289ddae001cf7b49de2e745312a","registry_entry_sha256":"sha256:63d0170fb957ebd167f2650ef744d70839d0676a8cf9f8978d73aed5cffd0b27","registry_head_sha256":"sha256:9a9f597b0d87674c4d36c022227201a5d8f3072237624346793692c3a863d12e","registry_revision":1,"registry_source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","schema_version":"openadapt.production-evidence-object-reference/v2","semantic_identity_sha256":"sha256:c18d69bdfb145139581ea6865f513179bd104cb02a64d838f93e49f96d9d3769","size_bytes":6636,"subject_sha256":null},"release_identity":{"channel":"production","previous_admission_sha256":null,"schema_version":"openadapt.monotonic-production-release/v1","sequence":1},"release_sha256":"sha256:f84c03c857bda8372d39bc30afcc2986247778c34b3f93a39ec9de5dd151a289","revocation_state_sha256":"sha256:250ab430e467f5e584ebd2b1832976b42186b698da71d627ee1724c2b1da2457","schema_version":"openadapt.production-lifecycle-evidence-summary/v3","signer_registry_sha256":"sha256:e243a23243b24986ed08812e284a1bd8c4993814149f02bcba79cc520e10ca14","target":"flow","verdict":"accepted"} diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/09/09eb48f80dec3cd8f7da73bfef1aed805068c0feefdbaaaa350ded1b70ba0c7d.qualification-evidence-decision-receipt-sigstore-bundle.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/09/09eb48f80dec3cd8f7da73bfef1aed805068c0feefdbaaaa350ded1b70ba0c7d.qualification-evidence-decision-receipt-sigstore-bundle.json new file mode 100644 index 0000000..e2c3cb9 --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/09/09eb48f80dec3cd8f7da73bfef1aed805068c0feefdbaaaa350ded1b70ba0c7d.qualification-evidence-decision-receipt-sigstore-bundle.json @@ -0,0 +1 @@ +{"dsseEnvelope":{"payload":"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","payloadType":"application/vnd.openadapt.production-public-trust-signing-statement+json;version=1","signatures":[{"keyid":"oa-public-trust-ed25519-9cf4bca214c01d79","sig":"4B2FfdCfIUwpIx+kd+GF2o5bkACWBWS55g/RHZO0sMl9tMdNhziiYEPI6HySlg1O18wsu1s9KlfkPaf1lnmuAA=="}]},"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"publicKey":{"hint":"oa-public-trust-ed25519-9cf4bca214c01d79"}}} diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/0f/0f97c284b10f8dc0153dbab0da5deccc5069bb5609982d45b890617783687830.qualification-authority-state-receipt-sigstore-bundle.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/0f/0f97c284b10f8dc0153dbab0da5deccc5069bb5609982d45b890617783687830.qualification-authority-state-receipt-sigstore-bundle.json new file mode 100644 index 0000000..23e41d1 --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/0f/0f97c284b10f8dc0153dbab0da5deccc5069bb5609982d45b890617783687830.qualification-authority-state-receipt-sigstore-bundle.json @@ -0,0 +1 @@ +{"dsseEnvelope":{"payload":"eyJhdXRob3JpdHlfc3RhdGVfc2hhMjU2Ijoic2hhMjU2OmRmNTA3OTE0MWRmNjg4NzdjNGIwNmYwNWI5ZmI5ZmRmMjc5MzA3Yjc2MjllYjFmMmRjZTEyZGVmNGJkNWUyZmEiLCJleHBpcmVzX2F0IjpudWxsLCJpc3N1ZWRfYXQiOiIyMDI2LTA5LTAyVDE4OjI0OjI1WiIsImtleV9pZCI6Im9hLXB1YmxpYy10cnVzdC1lZDI1NTE5LTljZjRiY2EyMTRjMDFkNzkiLCJub3RfYmVmb3JlIjoiMjAyNi0wOS0wMlQxODoyNDoyNVoiLCJvYmplY3Rfa2luZCI6InF1YWxpZmljYXRpb24tYXV0aG9yaXR5LXN0YXRlLXJlY2VpcHQiLCJvYmplY3RfbWVkaWFfdHlwZSI6ImFwcGxpY2F0aW9uL3ZuZC5vcGVuYWRhcHQucXVhbGlmaWNhdGlvbi1hdXRob3JpdHktc3RhdGUtcmVjZWlwdCtqc29uO3ZlcnNpb249MiIsIm9iamVjdF9zY2hlbWFfdmVyc2lvbiI6Im9wZW5hZGFwdC5xdWFsaWZpY2F0aW9uLWF1dGhvcml0eS1zdGF0ZS1yZWNlaXB0L3YyIiwib2JqZWN0X3NoYTI1NiI6InNoYTI1NjphMjJmOTgxNWVjMGY3YzU2Zjc2MjlhZWFiZmQyMWQxNGJjNmQ3MzllZmNmYjdmN2EwNzNjZTk5ODdlMTk0NzllIiwib2JqZWN0X3NpemVfYnl0ZXMiOjE1MjAsInJlcXVlc3RfaWRfc2hhMjU2Ijoic2hhMjU2OmI5ZDhiOWQ0ZTA3ZDc3M2MxMWFjNjA4ZTA1MGYyMzNiMTE2MzYzZWNkODQxMTA1MTYxY2I1Y2JmNzUwZmZjOGUiLCJyZXZvY2F0aW9uX3N0YXRlX3NoYTI1NiI6InNoYTI1NjoyNTBhYjQzMGU0NjdmNWU1ODRlYmQyYjE4MzI5NzZiNDIxODZiNjk4ZGE3MWQ2MjdlZTE3MjRjMmIxZGEyNDU3Iiwic2NoZW1hX3ZlcnNpb24iOiJvcGVuYWRhcHQucHJvZHVjdGlvbi1wdWJsaWMtdHJ1c3Qtc2lnbmluZy1zdGF0ZW1lbnQvdjEiLCJzZW1hbnRpY19pZGVudGl0eV9zaGEyNTYiOiJzaGEyNTY6ZGY1MDc5MTQxZGY2ODg3N2M0YjA2ZjA1YjlmYjlmZGYyNzkzMDdiNzYyOWViMWYyZGNlMTJkZWY0YmQ1ZTJmYSIsInNpZ25hdHVyZV9wcm9maWxlIjoic29mdHdhcmUtZWQyNTUxOS1kc3NlLXYxIiwic2lnbmVyX3JlZ2lzdHJ5X3NoYTI1NiI6InNoYTI1Njo3YTgxYmYzZDIxM2M3NDY3M2YzYzZiNWZhMTc5MjM0Y2JlZTUzNGM5NDMyYWFlYTZhZTA5ZTQ1NTU2MmY5NmI2Iiwic2lnbmluZ19hdXRob3JpdHkiOnsiZW52aXJvbm1lbnQiOiJzeW50aGV0aWMtcXVhbGlmaWNhdGlvbi1ldmlkZW5jZS1kZWNpc2lvbiIsImtleV9vcmlnaW4iOiJzb2Z0d2FyZSIsInJlZiI6InJlZnMvaGVhZHMvbWFpbiIsInJlcG9zaXRvcnkiOiJPcGVuQWRhcHRBSS8uZ2l0aHViIiwicmVwb3NpdG9yeV9pZCI6Ijg1ODQ1NDA2MiIsInJlcG9zaXRvcnlfb3duZXJfaWQiOiIxMzI2ODEyMTciLCJzb3VyY2VfY29tbWl0IjoiMmMxMjk3MDJkYTcxODUyMmNjMjU3OTEzMjA3YjZlZDZmM2IzM2I3YyIsIndvcmtmbG93IjoiLmdpdGh1Yi93b3JrZmxvd3Mvc2lnbi1wcm9kdWN0aW9uLWV2aWRlbmNlLXNvZnR3YXJlLnltbCJ9LCJzb3VyY2VfaXNzdWVyIjp7ImVudmlyb25tZW50IjoicXVhbGlmaWNhdGlvbi1hdXRob3JpdHktc3RhdGUiLCJyZWYiOiJyZWZzL2hlYWRzL21haW4iLCJyZXBvc2l0b3J5IjoiT3BlbkFkYXB0QUkvb3BlbmFkYXB0LW9wcyIsInJlcG9zaXRvcnlfaWQiOiIxMTcyMDExMjk0IiwicmVwb3NpdG9yeV9vd25lcl9pZCI6IjEzMjY4MTIxNyIsInNvdXJjZV9jb21taXQiOiJlMzIzMjQ5ZTNhN2MxYWY5ZDc2NTEzMTJlMGFmZTFmMTJjMzhjOTc3Iiwid29ya2Zsb3ciOiIuZ2l0aHViL3dvcmtmbG93cy9xdWFsaWZpY2F0aW9uLWF1dGhvcml0eS1zdGF0ZS55bWwifX0K","payloadType":"application/vnd.openadapt.production-public-trust-signing-statement+json;version=1","signatures":[{"keyid":"oa-public-trust-ed25519-9cf4bca214c01d79","sig":"wdmPoPKf3091kjDye9E9XCnfgqlljw8M+CEW2Vr0/hC5i85AWrpMfxPOB8Ui0KvTbF70QqLgFbgLqgdwWIPaDQ=="}]},"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"publicKey":{"hint":"oa-public-trust-ed25519-9cf4bca214c01d79"}}} diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/17/1773f9dd2b0c3a78bf2454cfba5d038151925f4b7c5aa1a2d7ed46b5f9315c32.qualification-admission-sigstore-bundle.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/17/1773f9dd2b0c3a78bf2454cfba5d038151925f4b7c5aa1a2d7ed46b5f9315c32.qualification-admission-sigstore-bundle.json new file mode 100644 index 0000000..c7630e6 --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/17/1773f9dd2b0c3a78bf2454cfba5d038151925f4b7c5aa1a2d7ed46b5f9315c32.qualification-admission-sigstore-bundle.json @@ -0,0 +1 @@ +{"dsseEnvelope":{"payload":"eyJhdXRob3JpdHlfc3RhdGVfc2hhMjU2Ijoic2hhMjU2OmRmNTA3OTE0MWRmNjg4NzdjNGIwNmYwNWI5ZmI5ZmRmMjc5MzA3Yjc2MjllYjFmMmRjZTEyZGVmNGJkNWUyZmEiLCJleHBpcmVzX2F0IjpudWxsLCJpc3N1ZWRfYXQiOiIyMDI2LTA5LTAyVDE4OjI0OjI1WiIsImtleV9pZCI6Im9hLXB1YmxpYy10cnVzdC1lZDI1NTE5LTljZjRiY2EyMTRjMDFkNzkiLCJub3RfYmVmb3JlIjoiMjAyNi0wOS0wMlQxODoyNDoyNVoiLCJvYmplY3Rfa2luZCI6InF1YWxpZmljYXRpb24tYWRtaXNzaW9uIiwib2JqZWN0X21lZGlhX3R5cGUiOiJhcHBsaWNhdGlvbi92bmQub3BlbmFkYXB0LnF1YWxpZmljYXRpb24tYWRtaXNzaW9uK2pzb247dmVyc2lvbj00Iiwib2JqZWN0X3NjaGVtYV92ZXJzaW9uIjoib3BlbmFkYXB0LnF1YWxpZmljYXRpb24tYWRtaXNzaW9uL3Y0Iiwib2JqZWN0X3NoYTI1NiI6InNoYTI1NjpkY2RiMzJhNzYyYWNhODdmYmIxYTdjOWRmNWQzNDY0MDNiMTY3ZWM1ODUwZDM1ZmU0N2ZkNjRkOTQyNjg0YTA0Iiwib2JqZWN0X3NpemVfYnl0ZXMiOjgwNTUsInJlcXVlc3RfaWRfc2hhMjU2Ijoic2hhMjU2OjYxZGZiZWM5YzBhMzc0Y2MyYzM0Mjc0Yzg2MDIyOGVhODNmZTM5NmZjMzkwYzMxOGI1ODRiMDA5YTU0MTc2OWMiLCJyZXZvY2F0aW9uX3N0YXRlX3NoYTI1NiI6InNoYTI1NjoyNTBhYjQzMGU0NjdmNWU1ODRlYmQyYjE4MzI5NzZiNDIxODZiNjk4ZGE3MWQ2MjdlZTE3MjRjMmIxZGEyNDU3Iiwic2NoZW1hX3ZlcnNpb24iOiJvcGVuYWRhcHQucHJvZHVjdGlvbi1wdWJsaWMtdHJ1c3Qtc2lnbmluZy1zdGF0ZW1lbnQvdjEiLCJzZW1hbnRpY19pZGVudGl0eV9zaGEyNTYiOiJzaGEyNTY6YTQ4MGQ2MmE5YzJhYTVlZDYwNjFkM2IwMTQwY2Y5MDgwMjRiMjNlOTBiNzUzNWJiM2MwOWU5ZGE2Zjc0OGU5MCIsInNpZ25hdHVyZV9wcm9maWxlIjoic29mdHdhcmUtZWQyNTUxOS1kc3NlLXYxIiwic2lnbmVyX3JlZ2lzdHJ5X3NoYTI1NiI6InNoYTI1NjplMjQzYTIzMjQzYjI0OTg2ZWQwODgxMmUyODRhMWJkOGM0OTkzODE0MTQ5ZjAyYmNiYTc5Y2M1MjBlMTBjYTE0Iiwic2lnbmluZ19hdXRob3JpdHkiOnsiZW52aXJvbm1lbnQiOiJzeW50aGV0aWMtcXVhbGlmaWNhdGlvbi1ldmlkZW5jZS1kZWNpc2lvbiIsImtleV9vcmlnaW4iOiJzb2Z0d2FyZSIsInJlZiI6InJlZnMvaGVhZHMvbWFpbiIsInJlcG9zaXRvcnkiOiJPcGVuQWRhcHRBSS8uZ2l0aHViIiwicmVwb3NpdG9yeV9pZCI6Ijg1ODQ1NDA2MiIsInJlcG9zaXRvcnlfb3duZXJfaWQiOiIxMzI2ODEyMTciLCJzb3VyY2VfY29tbWl0IjoiMmMxMjk3MDJkYTcxODUyMmNjMjU3OTEzMjA3YjZlZDZmM2IzM2I3YyIsIndvcmtmbG93IjoiLmdpdGh1Yi93b3JrZmxvd3Mvc2lnbi1wcm9kdWN0aW9uLWV2aWRlbmNlLXNvZnR3YXJlLnltbCJ9LCJzb3VyY2VfaXNzdWVyIjp7ImVudmlyb25tZW50IjoicXVhbGlmaWNhdGlvbi1hZG1pc3Npb24iLCJyZWYiOiJyZWZzL2hlYWRzL21haW4iLCJyZXBvc2l0b3J5IjoiT3BlbkFkYXB0QUkvLmdpdGh1YiIsInJlcG9zaXRvcnlfaWQiOiI4NTg0NTQwNjIiLCJyZXBvc2l0b3J5X293bmVyX2lkIjoiMTMyNjgxMjE3Iiwic291cmNlX2NvbW1pdCI6IjJjMTI5NzAyZGE3MTg1MjJjYzI1NzkxMzIwN2I2ZWQ2ZjNiMzNiN2MiLCJ3b3JrZmxvdyI6Ii5naXRodWIvd29ya2Zsb3dzL2lzc3VlLXF1YWxpZmljYXRpb24tYWRtaXNzaW9uLnltbCJ9fQo=","payloadType":"application/vnd.openadapt.production-public-trust-signing-statement+json;version=1","signatures":[{"keyid":"oa-public-trust-ed25519-9cf4bca214c01d79","sig":"+Yx8YgUpt2BtK3dfylC1kmkUxvPx/XgFuyqAZTDGA4yz4IF0M6EYPg/semaTXiquoVF6P3FISYkMIhuz8Pc+AQ=="}]},"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"publicKey":{"hint":"oa-public-trust-ed25519-9cf4bca214c01d79"}}} diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/18/18633b8cc243f686706606162bfa249a29733811563f63b9e68cc7c4a3507676.qualification-revocation-state-receipt.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/18/18633b8cc243f686706606162bfa249a29733811563f63b9e68cc7c4a3507676.qualification-revocation-state-receipt.json new file mode 100644 index 0000000..fdc3e22 --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/18/18633b8cc243f686706606162bfa249a29733811563f63b9e68cc7c4a3507676.qualification-revocation-state-receipt.json @@ -0,0 +1 @@ +{"algorithm":"ed25519","authority_state_sha256":"sha256:df5079141df68877c4b06f05b9fb9fdf279307b7629eb1f2dce12def4bd5e2fa","expires_at":null,"issuer":{"environment":"qualification-revocation-state","ref":"refs/heads/main","repository":"OpenAdaptAI/openadapt-ops","repository_id":"1172011294","repository_owner_id":"132681217","source_commit":"e323249e3a7c1af9d7651312e0afe1f12c38c977","workflow":".github/workflows/qualification-revocation-state.yml"},"issuer_key_id":"qa-ed25519-9cf4bca214c01d79","not_before":"2026-09-02T18:24:25Z","observed_at":"2026-09-02T18:24:25Z","previous_revocation_state_sha256":null,"revision":1,"revocation_state_sha256":"sha256:250ab430e467f5e584ebd2b1832976b42186b698da71d627ee1724c2b1da2457","revocations":[],"schema_version":"openadapt.qualification-revocation-state-receipt/v1","signature":"6/az5KZHqcV7weLNpPR11DnJR3f7Wfj5JgqcFddGoET+x+Q42rWH7zkgdDVJqvP+XxN09f1fHBmvkWlDvqlBBQ==","signer_registry_sha256":"sha256:e243a23243b24986ed08812e284a1bd8c4993814149f02bcba79cc520e10ca14","signing_statement":{"commitment_scheme":"sha256-canonical-json-lf","object_schema_version":"openadapt.qualification-revocation-state-receipt/v1","schema_version":"openadapt.qualification-evidence-signing-statement/v1","signature_domain":"OpenAdapt qualification revocation state receipt v1\u0000","unsigned_object_sha256":"sha256:f7e15c3c660e2793c8c0c4f6beafef140ee71b2a407d971d2e6af0578b2fd6d6","unsigned_size_bytes":930},"status":"current"} diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/21/211651dd301699ea1394af8b8ec38d1c9c6df5045c88d9ce1ece09ca774c15ca.production-acceptance-manifest.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/21/211651dd301699ea1394af8b8ec38d1c9c6df5045c88d9ce1ece09ca774c15ca.production-acceptance-manifest.json new file mode 100644 index 0000000..df7bcee --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/21/211651dd301699ea1394af8b8ec38d1c9c6df5045c88d9ce1ece09ca774c15ca.production-acceptance-manifest.json @@ -0,0 +1 @@ +{"acceptance_policy_sha256":"sha256:ed5ab69fe8127604ca674263cbc8c774b7cfd10754e90bfaa9b71ba573bce1d1","artifact_inventory":{"artifacts":[{"kind":"python-sdist","media_type":"application/gzip","name":"openadapt_flow-1.34.0.tar.gz","publish_destinations":["github-release","pypi"],"sha256":"sha256:a941a70015fe91897e655bfc9bf83e6cf8fbcf8bd4e4c7206ffb133c505203f8","size_bytes":20440838},{"kind":"python-wheel","media_type":"application/zip","name":"openadapt_flow-1.34.0-py3-none-any.whl","publish_destinations":["github-release","pypi"],"sha256":"sha256:56d32818989cb3a92830080ead39e10b08718c55e00988117f22cbfeaac98854","size_bytes":1928194}],"claim_scope":"production_flow","schema_version":"openadapt.production-release-artifact-inventory/v1","target":"flow"},"artifact_inventory_sha256":"sha256:ec3ef7c177c493bebee3da60f170b37793832e81066e9d9ee785d5fa225a5ac5","authority_state_sha256":"sha256:df5079141df68877c4b06f05b9fb9fdf279307b7629eb1f2dce12def4bd5e2fa","campaign_summary":{"declared_attended":{"approved_repair_count":0,"authenticated_bound_decision_count":3,"blind_retry_count":0,"live_target_revalidation_count":3,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"governed_repair":{"approved_repair_count":3,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":3,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":3,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":3,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"healthy":{"approved_repair_count":0,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":0,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"idempotency_replay":{"approved_repair_count":0,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":0,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"safe_halt":{"approved_repair_count":0,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":0,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"uncertain_delivery":{"approved_repair_count":0,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":0,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":3,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0}},"claim_scope":"production_flow","expires_at":null,"issued_at":"2026-09-02T18:24:25Z","issuer":{"environment":"production-acceptance","ref":"refs/heads/main","repository":"OpenAdaptAI/openadapt-evals","repository_id":"1135998197","repository_owner_id":"132681217","source_commit":"cad5560d6b7482f2cb99b9735e0ac3c5aae714c8","workflow":".github/workflows/issue-production-acceptance.yml"},"lifecycle_policy_sha256":"sha256:6c8daa221668e0a39188d7485d997ed04396e5142dd7422e34785bf3286a40d1","not_before":"2026-09-02T18:24:25Z","publication_staging":{"assets":[{"asset_id":"534029483","kind":"python-wheel","media_type":"application/zip","name":"openadapt_flow-1.34.0-py3-none-any.whl","publish_destinations":["github-release","pypi"],"sha256":"sha256:56d32818989cb3a92830080ead39e10b08718c55e00988117f22cbfeaac98854","size_bytes":1928194,"uploader_id":"321543906","uploader_login":"openadapt-release[bot]"},{"asset_id":"534029484","kind":"python-sdist","media_type":"application/gzip","name":"openadapt_flow-1.34.0.tar.gz","publish_destinations":["github-release","pypi"],"sha256":"sha256:a941a70015fe91897e655bfc9bf83e6cf8fbcf8bd4e4c7206ffb133c505203f8","size_bytes":20440838,"uploader_id":"321543906","uploader_login":"openadapt-release[bot]"}],"draft":false,"draft_release_id":"378603192","immutable_releases":{"enabled":true,"enforced_by_owner":false},"immutable_releases_sha256":"sha256:07649aafb167237fecc138f5e93b48ddce5a69f4060da7130e3c78e59fd48581","observed_at":"2026-09-02T18:24:25Z","prerelease":false,"publication_mode":"already-published-pypi","pypi_files":[{"filename":"openadapt_flow-1.34.0-py3-none-any.whl","packagetype":"bdist_wheel","sha256":"sha256:56d32818989cb3a92830080ead39e10b08718c55e00988117f22cbfeaac98854","size_bytes":1928194,"yanked":false},{"filename":"openadapt_flow-1.34.0.tar.gz","packagetype":"sdist","sha256":"sha256:a941a70015fe91897e655bfc9bf83e6cf8fbcf8bd4e4c7206ffb133c505203f8","size_bytes":20440838,"yanked":false}],"release_app_bot_user_id":"321543906","release_app_id":"4730708","release_app_installation_id":"156835568","release_author_login":"openadapt-release[bot]","repository":"OpenAdaptAI/openadapt-flow","repository_id":"1291376938","schema_version":"openadapt.production-release-staging-evidence/v1","tag":"v1.34.0","tag_ref_state":{"exists":true,"ref":"refs/tags/v1.34.0"},"tag_ref_state_sha256":"sha256:74c5665395ed98ba3fd1b3a284bab1e8089f7c79cfafb3f88548e8b1456c5782","tag_rulesets":[{"bypass_actors":[{"actor_id":"4730708","actor_type":"Integration","bypass_mode":"always"}],"conditions":{"ref_name":{"exclude":[],"include":["refs/tags/v*"]}},"enforcement":"active","name":"OpenAdapt policy: release tag creation","repository":"OpenAdaptAI/openadapt-flow","repository_id":"1291376938","role":"creation_authority","rules":[{"type":"creation"}],"ruleset_id":"10","schema_version":"openadapt.production-release-tag-ruleset/v1","target":"tag"},{"bypass_actors":[],"conditions":{"ref_name":{"exclude":[],"include":["refs/tags/v*"]}},"enforcement":"active","name":"OpenAdapt policy: immutable release tags","repository":"OpenAdaptAI/openadapt-flow","repository_id":"1291376938","role":"immutability","rules":[{"type":"deletion"},{"type":"non_fast_forward"},{"parameters":{"update_allows_fetch_and_merge":false},"type":"update"}],"ruleset_id":"11","schema_version":"openadapt.production-release-tag-ruleset/v1","target":"tag"}],"tag_rulesets_sha256":"sha256:b0fdf160d80ae7dc8ffd979b2ba101cee6b3e7cf139e8c5d32b5534cbc0f7f44","target_commitish":"30fc60e55778a0e0f92b9776117cafcfe2512249"},"publication_staging_sha256":"sha256:861175c196cfe9455ce5f0536b6b1eabf55a990ced03349b865643f52316dedd","qualification_admission_bundle_reference":{"kind":"qualification-admission-sigstore-bundle","object_media_type":"application/vnd.dev.sigstore.bundle.v0.3+json","object_path":"production-evidence/objects/sha256/17/1773f9dd2b0c3a78bf2454cfba5d038151925f4b7c5aa1a2d7ed46b5f9315c32.qualification-admission-sigstore-bundle.json","object_schema_version":"application/vnd.dev.sigstore.bundle.v0.3+json","object_sha256":"sha256:1773f9dd2b0c3a78bf2454cfba5d038151925f4b7c5aa1a2d7ed46b5f9315c32","registry_entry_sha256":"sha256:c0b5b8dd6fd24352f32896d24d276dc8256005d9eee2a97ac1a83fb576441da4","registry_head_sha256":"sha256:9a9f597b0d87674c4d36c022227201a5d8f3072237624346793692c3a863d12e","registry_revision":1,"registry_source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","schema_version":"openadapt.production-evidence-object-reference/v2","semantic_identity_sha256":"sha256:5bfd1cb8d71754563173aef8a5dcffff00bf8016ec5b60553d72b69dee1cb214","size_bytes":2737,"subject_sha256":"sha256:dcdb32a762aca87fbb1a7c9df5d346403b167ec5850d35fe47fd64d942684a04"},"qualification_admission_reference":{"kind":"qualification-admission","object_media_type":"application/vnd.openadapt.qualification-admission+json;version=4","object_path":"production-evidence/objects/sha256/dc/dcdb32a762aca87fbb1a7c9df5d346403b167ec5850d35fe47fd64d942684a04.qualification-admission.json","object_schema_version":"openadapt.qualification-admission/v4","object_sha256":"sha256:dcdb32a762aca87fbb1a7c9df5d346403b167ec5850d35fe47fd64d942684a04","registry_entry_sha256":"sha256:813040c698d3b04d39825502635f5337bcf08d5885142363fe9b16a76b4667a6","registry_head_sha256":"sha256:9a9f597b0d87674c4d36c022227201a5d8f3072237624346793692c3a863d12e","registry_revision":1,"registry_source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","schema_version":"openadapt.production-evidence-object-reference/v2","semantic_identity_sha256":"sha256:a480d62a9c2aa5ed6061d3b0140cf908024b23e90b7535bb3c09e9da6f748e90","size_bytes":8055,"subject_sha256":null},"qualification_evidence_decision_receipt_bundle_reference":{"kind":"qualification-evidence-decision-receipt-sigstore-bundle","object_media_type":"application/vnd.dev.sigstore.bundle.v0.3+json","object_path":"production-evidence/objects/sha256/09/09eb48f80dec3cd8f7da73bfef1aed805068c0feefdbaaaa350ded1b70ba0c7d.qualification-evidence-decision-receipt-sigstore-bundle.json","object_schema_version":"application/vnd.dev.sigstore.bundle.v0.3+json","object_sha256":"sha256:09eb48f80dec3cd8f7da73bfef1aed805068c0feefdbaaaa350ded1b70ba0c7d","registry_entry_sha256":"sha256:40e134188beb1f1dd8bf17eaa02d84b8246ae11db7b99db68efb493f2a3d7955","registry_head_sha256":"sha256:9a9f597b0d87674c4d36c022227201a5d8f3072237624346793692c3a863d12e","registry_revision":1,"registry_source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","schema_version":"openadapt.production-evidence-object-reference/v2","semantic_identity_sha256":"sha256:21d2be624cc93f033b13eceabd7ea42b39ab6f80790c643235c80a32272545a6","size_bytes":2849,"subject_sha256":"sha256:6ffe691f8e40e06b73e24391d180424ed86bb289ddae001cf7b49de2e745312a"},"qualification_evidence_decision_receipt_reference":{"kind":"qualification-evidence-decision-receipt","object_media_type":"application/vnd.openadapt.qualification-evidence-decision-receipt+json;version=2","object_path":"production-evidence/objects/sha256/6f/6ffe691f8e40e06b73e24391d180424ed86bb289ddae001cf7b49de2e745312a.qualification-evidence-decision-receipt.json","object_schema_version":"openadapt.qualification-evidence-decision-receipt/v2","object_sha256":"sha256:6ffe691f8e40e06b73e24391d180424ed86bb289ddae001cf7b49de2e745312a","registry_entry_sha256":"sha256:63d0170fb957ebd167f2650ef744d70839d0676a8cf9f8978d73aed5cffd0b27","registry_head_sha256":"sha256:9a9f597b0d87674c4d36c022227201a5d8f3072237624346793692c3a863d12e","registry_revision":1,"registry_source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","schema_version":"openadapt.production-evidence-object-reference/v2","semantic_identity_sha256":"sha256:c18d69bdfb145139581ea6865f513179bd104cb02a64d838f93e49f96d9d3769","size_bytes":6636,"subject_sha256":null},"release":{"artifacts":[{"kind":"python-sdist","media_type":"application/gzip","name":"openadapt_flow-1.34.0.tar.gz","publish_destinations":["github-release","pypi"],"sha256":"sha256:a941a70015fe91897e655bfc9bf83e6cf8fbcf8bd4e4c7206ffb133c505203f8","size_bytes":20440838},{"kind":"python-wheel","media_type":"application/zip","name":"openadapt_flow-1.34.0-py3-none-any.whl","publish_destinations":["github-release","pypi"],"sha256":"sha256:56d32818989cb3a92830080ead39e10b08718c55e00988117f22cbfeaac98854","size_bytes":1928194}],"deployment_id":null,"deployment_sha256":null,"kind":"package","schema_version":"openadapt.production-release-candidate/v1","source_commit":"30fc60e55778a0e0f92b9776117cafcfe2512249","source_repository":"OpenAdaptAI/openadapt-flow","source_repository_id":"1291376938","tag":"v1.34.0","version":"1.34.0"},"release_identity":{"channel":"production","previous_admission_sha256":null,"schema_version":"openadapt.monotonic-production-release/v1","sequence":1},"release_sha256":"sha256:f84c03c857bda8372d39bc30afcc2986247778c34b3f93a39ec9de5dd151a289","revocation_state_sha256":"sha256:250ab430e467f5e584ebd2b1832976b42186b698da71d627ee1724c2b1da2457","schema_version":"openadapt.production-acceptance/v3","signer_registry_sha256":"sha256:e243a23243b24986ed08812e284a1bd8c4993814149f02bcba79cc520e10ca14","target":"flow","verdict":"accepted"} diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/38/3849fd4e2cae0d3a74964362e4850870bb68c23007d5eb818800159d3eb730d4.production-acceptance-summary.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/38/3849fd4e2cae0d3a74964362e4850870bb68c23007d5eb818800159d3eb730d4.production-acceptance-summary.json new file mode 100644 index 0000000..0659bdb --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/38/3849fd4e2cae0d3a74964362e4850870bb68c23007d5eb818800159d3eb730d4.production-acceptance-summary.json @@ -0,0 +1 @@ +{"acceptance_policy_sha256":"sha256:ed5ab69fe8127604ca674263cbc8c774b7cfd10754e90bfaa9b71ba573bce1d1","artifact_inventory_sha256":"sha256:ec3ef7c177c493bebee3da60f170b37793832e81066e9d9ee785d5fa225a5ac5","authority_state_sha256":"sha256:df5079141df68877c4b06f05b9fb9fdf279307b7629eb1f2dce12def4bd5e2fa","campaign_summary":{"declared_attended":{"approved_repair_count":0,"authenticated_bound_decision_count":3,"blind_retry_count":0,"live_target_revalidation_count":3,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"governed_repair":{"approved_repair_count":3,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":3,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":3,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":3,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"healthy":{"approved_repair_count":0,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":0,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"idempotency_replay":{"approved_repair_count":0,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":0,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"safe_halt":{"approved_repair_count":0,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":0,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"uncertain_delivery":{"approved_repair_count":0,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":0,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":3,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0}},"claim_scope":"production_flow","evidence_identity_sha256":"sha256:c5362154ed3171a6d592beca0c3a9c10243988864f3ba6793d6393f356ca7715","expires_at":null,"issued_at":"2026-09-02T18:24:25Z","issuer":{"environment":"production-acceptance","ref":"refs/heads/main","repository":"OpenAdaptAI/openadapt-evals","repository_id":"1135998197","repository_owner_id":"132681217","source_commit":"cad5560d6b7482f2cb99b9735e0ac3c5aae714c8","workflow":".github/workflows/issue-production-acceptance.yml"},"lifecycle_policy_sha256":"sha256:6c8daa221668e0a39188d7485d997ed04396e5142dd7422e34785bf3286a40d1","not_before":"2026-09-02T18:24:25Z","production_acceptance_manifest_bundle_reference":{"kind":"production-acceptance-manifest-sigstore-bundle","object_media_type":"application/vnd.dev.sigstore.bundle.v0.3+json","object_path":"production-evidence/objects/sha256/ac/ace6aabbaf02596d26cd5d6f1406790f4fe831ca978129d50cc2285882a2630c.production-acceptance-manifest-sigstore-bundle.json","object_schema_version":"application/vnd.dev.sigstore.bundle.v0.3+json","object_sha256":"sha256:ace6aabbaf02596d26cd5d6f1406790f4fe831ca978129d50cc2285882a2630c","registry_entry_sha256":"sha256:15f463cf84ae49b1d5baeb053ad8e9c3a61aa4a84d1f982635e1d9bd88b17ca7","registry_head_sha256":"sha256:9a9f597b0d87674c4d36c022227201a5d8f3072237624346793692c3a863d12e","registry_revision":1,"registry_source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","schema_version":"openadapt.production-evidence-object-reference/v2","semantic_identity_sha256":"sha256:1ebdadbe1754dbef6ceb987dd5a9fcf3d982c2414bd0a01e7b4c923bc46924eb","size_bytes":2749,"subject_sha256":"sha256:211651dd301699ea1394af8b8ec38d1c9c6df5045c88d9ce1ece09ca774c15ca"},"production_acceptance_manifest_reference":{"kind":"production-acceptance-manifest","object_media_type":"application/vnd.openadapt.production-acceptance+json;version=3","object_path":"production-evidence/objects/sha256/21/211651dd301699ea1394af8b8ec38d1c9c6df5045c88d9ce1ece09ca774c15ca.production-acceptance-manifest.json","object_schema_version":"openadapt.production-acceptance/v3","object_sha256":"sha256:211651dd301699ea1394af8b8ec38d1c9c6df5045c88d9ce1ece09ca774c15ca","registry_entry_sha256":"sha256:502cb9dffb93c654258c305841e4515e933eb647edf375b8f36ee6e3f57fab8c","registry_head_sha256":"sha256:9a9f597b0d87674c4d36c022227201a5d8f3072237624346793692c3a863d12e","registry_revision":1,"registry_source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","schema_version":"openadapt.production-evidence-object-reference/v2","semantic_identity_sha256":"sha256:2e24dd5a8f4aefba4478952c3d2d120d8d0706cf6cc4dafd74b2f21f75ce9ea5","size_bytes":13633,"subject_sha256":null},"publication_staging":{"assets":[{"asset_id":"534029483","kind":"python-wheel","media_type":"application/zip","name":"openadapt_flow-1.34.0-py3-none-any.whl","publish_destinations":["github-release","pypi"],"sha256":"sha256:56d32818989cb3a92830080ead39e10b08718c55e00988117f22cbfeaac98854","size_bytes":1928194,"uploader_id":"321543906","uploader_login":"openadapt-release[bot]"},{"asset_id":"534029484","kind":"python-sdist","media_type":"application/gzip","name":"openadapt_flow-1.34.0.tar.gz","publish_destinations":["github-release","pypi"],"sha256":"sha256:a941a70015fe91897e655bfc9bf83e6cf8fbcf8bd4e4c7206ffb133c505203f8","size_bytes":20440838,"uploader_id":"321543906","uploader_login":"openadapt-release[bot]"}],"draft":false,"draft_release_id":"378603192","immutable_releases":{"enabled":true,"enforced_by_owner":false},"immutable_releases_sha256":"sha256:07649aafb167237fecc138f5e93b48ddce5a69f4060da7130e3c78e59fd48581","observed_at":"2026-09-02T18:24:25Z","prerelease":false,"publication_mode":"already-published-pypi","pypi_files":[{"filename":"openadapt_flow-1.34.0-py3-none-any.whl","packagetype":"bdist_wheel","sha256":"sha256:56d32818989cb3a92830080ead39e10b08718c55e00988117f22cbfeaac98854","size_bytes":1928194,"yanked":false},{"filename":"openadapt_flow-1.34.0.tar.gz","packagetype":"sdist","sha256":"sha256:a941a70015fe91897e655bfc9bf83e6cf8fbcf8bd4e4c7206ffb133c505203f8","size_bytes":20440838,"yanked":false}],"release_app_bot_user_id":"321543906","release_app_id":"4730708","release_app_installation_id":"156835568","release_author_login":"openadapt-release[bot]","repository":"OpenAdaptAI/openadapt-flow","repository_id":"1291376938","schema_version":"openadapt.production-release-staging-evidence/v1","tag":"v1.34.0","tag_ref_state":{"exists":true,"ref":"refs/tags/v1.34.0"},"tag_ref_state_sha256":"sha256:74c5665395ed98ba3fd1b3a284bab1e8089f7c79cfafb3f88548e8b1456c5782","tag_rulesets":[{"bypass_actors":[{"actor_id":"4730708","actor_type":"Integration","bypass_mode":"always"}],"conditions":{"ref_name":{"exclude":[],"include":["refs/tags/v*"]}},"enforcement":"active","name":"OpenAdapt policy: release tag creation","repository":"OpenAdaptAI/openadapt-flow","repository_id":"1291376938","role":"creation_authority","rules":[{"type":"creation"}],"ruleset_id":"10","schema_version":"openadapt.production-release-tag-ruleset/v1","target":"tag"},{"bypass_actors":[],"conditions":{"ref_name":{"exclude":[],"include":["refs/tags/v*"]}},"enforcement":"active","name":"OpenAdapt policy: immutable release tags","repository":"OpenAdaptAI/openadapt-flow","repository_id":"1291376938","role":"immutability","rules":[{"type":"deletion"},{"type":"non_fast_forward"},{"parameters":{"update_allows_fetch_and_merge":false},"type":"update"}],"ruleset_id":"11","schema_version":"openadapt.production-release-tag-ruleset/v1","target":"tag"}],"tag_rulesets_sha256":"sha256:b0fdf160d80ae7dc8ffd979b2ba101cee6b3e7cf139e8c5d32b5534cbc0f7f44","target_commitish":"30fc60e55778a0e0f92b9776117cafcfe2512249"},"publication_staging_sha256":"sha256:861175c196cfe9455ce5f0536b6b1eabf55a990ced03349b865643f52316dedd","qualification_admission_bundle_reference":{"kind":"qualification-admission-sigstore-bundle","object_media_type":"application/vnd.dev.sigstore.bundle.v0.3+json","object_path":"production-evidence/objects/sha256/17/1773f9dd2b0c3a78bf2454cfba5d038151925f4b7c5aa1a2d7ed46b5f9315c32.qualification-admission-sigstore-bundle.json","object_schema_version":"application/vnd.dev.sigstore.bundle.v0.3+json","object_sha256":"sha256:1773f9dd2b0c3a78bf2454cfba5d038151925f4b7c5aa1a2d7ed46b5f9315c32","registry_entry_sha256":"sha256:c0b5b8dd6fd24352f32896d24d276dc8256005d9eee2a97ac1a83fb576441da4","registry_head_sha256":"sha256:9a9f597b0d87674c4d36c022227201a5d8f3072237624346793692c3a863d12e","registry_revision":1,"registry_source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","schema_version":"openadapt.production-evidence-object-reference/v2","semantic_identity_sha256":"sha256:5bfd1cb8d71754563173aef8a5dcffff00bf8016ec5b60553d72b69dee1cb214","size_bytes":2737,"subject_sha256":"sha256:dcdb32a762aca87fbb1a7c9df5d346403b167ec5850d35fe47fd64d942684a04"},"qualification_admission_reference":{"kind":"qualification-admission","object_media_type":"application/vnd.openadapt.qualification-admission+json;version=4","object_path":"production-evidence/objects/sha256/dc/dcdb32a762aca87fbb1a7c9df5d346403b167ec5850d35fe47fd64d942684a04.qualification-admission.json","object_schema_version":"openadapt.qualification-admission/v4","object_sha256":"sha256:dcdb32a762aca87fbb1a7c9df5d346403b167ec5850d35fe47fd64d942684a04","registry_entry_sha256":"sha256:813040c698d3b04d39825502635f5337bcf08d5885142363fe9b16a76b4667a6","registry_head_sha256":"sha256:9a9f597b0d87674c4d36c022227201a5d8f3072237624346793692c3a863d12e","registry_revision":1,"registry_source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","schema_version":"openadapt.production-evidence-object-reference/v2","semantic_identity_sha256":"sha256:a480d62a9c2aa5ed6061d3b0140cf908024b23e90b7535bb3c09e9da6f748e90","size_bytes":8055,"subject_sha256":null},"qualification_evidence_decision_receipt_bundle_reference":{"kind":"qualification-evidence-decision-receipt-sigstore-bundle","object_media_type":"application/vnd.dev.sigstore.bundle.v0.3+json","object_path":"production-evidence/objects/sha256/09/09eb48f80dec3cd8f7da73bfef1aed805068c0feefdbaaaa350ded1b70ba0c7d.qualification-evidence-decision-receipt-sigstore-bundle.json","object_schema_version":"application/vnd.dev.sigstore.bundle.v0.3+json","object_sha256":"sha256:09eb48f80dec3cd8f7da73bfef1aed805068c0feefdbaaaa350ded1b70ba0c7d","registry_entry_sha256":"sha256:40e134188beb1f1dd8bf17eaa02d84b8246ae11db7b99db68efb493f2a3d7955","registry_head_sha256":"sha256:9a9f597b0d87674c4d36c022227201a5d8f3072237624346793692c3a863d12e","registry_revision":1,"registry_source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","schema_version":"openadapt.production-evidence-object-reference/v2","semantic_identity_sha256":"sha256:21d2be624cc93f033b13eceabd7ea42b39ab6f80790c643235c80a32272545a6","size_bytes":2849,"subject_sha256":"sha256:6ffe691f8e40e06b73e24391d180424ed86bb289ddae001cf7b49de2e745312a"},"qualification_evidence_decision_receipt_reference":{"kind":"qualification-evidence-decision-receipt","object_media_type":"application/vnd.openadapt.qualification-evidence-decision-receipt+json;version=2","object_path":"production-evidence/objects/sha256/6f/6ffe691f8e40e06b73e24391d180424ed86bb289ddae001cf7b49de2e745312a.qualification-evidence-decision-receipt.json","object_schema_version":"openadapt.qualification-evidence-decision-receipt/v2","object_sha256":"sha256:6ffe691f8e40e06b73e24391d180424ed86bb289ddae001cf7b49de2e745312a","registry_entry_sha256":"sha256:63d0170fb957ebd167f2650ef744d70839d0676a8cf9f8978d73aed5cffd0b27","registry_head_sha256":"sha256:9a9f597b0d87674c4d36c022227201a5d8f3072237624346793692c3a863d12e","registry_revision":1,"registry_source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","schema_version":"openadapt.production-evidence-object-reference/v2","semantic_identity_sha256":"sha256:c18d69bdfb145139581ea6865f513179bd104cb02a64d838f93e49f96d9d3769","size_bytes":6636,"subject_sha256":null},"release_identity":{"channel":"production","previous_admission_sha256":null,"schema_version":"openadapt.monotonic-production-release/v1","sequence":1},"release_sha256":"sha256:f84c03c857bda8372d39bc30afcc2986247778c34b3f93a39ec9de5dd151a289","revocation_state_sha256":"sha256:250ab430e467f5e584ebd2b1832976b42186b698da71d627ee1724c2b1da2457","schema_version":"openadapt.production-lifecycle-evidence-summary/v3","signer_registry_sha256":"sha256:e243a23243b24986ed08812e284a1bd8c4993814149f02bcba79cc520e10ca14","target":"flow","verdict":"accepted"} diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/48/4804e33f847a04d35304c9948ade6ac9e736b06a1a8c9ab920da0833b7423e01.qualification-release-sigstore-bundle.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/48/4804e33f847a04d35304c9948ade6ac9e736b06a1a8c9ab920da0833b7423e01.qualification-release-sigstore-bundle.json new file mode 100644 index 0000000..cd9f721 --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/48/4804e33f847a04d35304c9948ade6ac9e736b06a1a8c9ab920da0833b7423e01.qualification-release-sigstore-bundle.json @@ -0,0 +1 @@ +{"dsseEnvelope":{"payload":"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","payloadType":"application/vnd.openadapt.production-public-trust-signing-statement+json;version=1","signatures":[{"keyid":"oa-public-trust-ed25519-9cf4bca214c01d79","sig":"j2UY7M6WWlAZmDcG7//GsS3FfwP8qAsG2Nr471CUzvoS6gIoiGK1d7Htptyf8IXdc4ypTChSJx96N+Hy0GKrAA=="}]},"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"publicKey":{"hint":"oa-public-trust-ed25519-9cf4bca214c01d79"}}} diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/4e/4e0a052726ba440c9f6a19726b004f948c36087b2702d614a398728b428dcd5f.qualification-revocation-state-receipt-sigstore-bundle.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/4e/4e0a052726ba440c9f6a19726b004f948c36087b2702d614a398728b428dcd5f.qualification-revocation-state-receipt-sigstore-bundle.json new file mode 100644 index 0000000..3d39da8 --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/4e/4e0a052726ba440c9f6a19726b004f948c36087b2702d614a398728b428dcd5f.qualification-revocation-state-receipt-sigstore-bundle.json @@ -0,0 +1 @@ +{"dsseEnvelope":{"payload":"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","payloadType":"application/vnd.openadapt.production-public-trust-signing-statement+json;version=1","signatures":[{"keyid":"oa-public-trust-ed25519-9cf4bca214c01d79","sig":"6H/dlDXrZ0r2kihJrm8OKF7UriiNbloFiofPmckxWdhvRtXo4bttnEtqK2Fr7i7rCQ2+22RmvRbtd8Idx17bCg=="}]},"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"publicKey":{"hint":"oa-public-trust-ed25519-9cf4bca214c01d79"}}} diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/6f/6ffe691f8e40e06b73e24391d180424ed86bb289ddae001cf7b49de2e745312a.qualification-evidence-decision-receipt.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/6f/6ffe691f8e40e06b73e24391d180424ed86bb289ddae001cf7b49de2e745312a.qualification-evidence-decision-receipt.json new file mode 100644 index 0000000..b26db2f --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/6f/6ffe691f8e40e06b73e24391d180424ed86bb289ddae001cf7b49de2e745312a.qualification-evidence-decision-receipt.json @@ -0,0 +1 @@ +{"action_contract_sha256":"sha256:d4b8a931c16bca24cd343c786f41566357d9edcc8b0b97d3c1cb9907571dd56b","admitted_runtime_sha256":"sha256:56d32818989cb3a92830080ead39e10b08718c55e00988117f22cbfeaac98854","algorithm":"ed25519","application_contract_sha256":"sha256:e8f70b24976d2befeaea5e54059e39b1934a211c49cba65ac41e6cfdfd70ec80","bundle_sha256":"sha256:33f8c637f3d5d9eb23b92e0fb7ba74d2713a52f7c8ed11495b30f8bbefb1f312","bundle_version":"0.0.0-synthetic","campaign_artifact_sha256":"sha256:e2f2aa6b30118864682892a08e7e151039a34e7e7f84ff027e253cf8daddff78","campaign_permit_sha256":"sha256:da4af1f21aa121a00f92d88fc129d47bbd1a027462408e6bf2adf8fe66fe4255","campaign_summary":{"classes":{"declared_attended":{"approved_repair_count":0,"authenticated_bound_decision_count":3,"blind_retry_count":0,"live_target_revalidation_count":3,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"governed_repair":{"approved_repair_count":3,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":3,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":3,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":3,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"healthy":{"approved_repair_count":0,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":0,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"idempotency_replay":{"approved_repair_count":0,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":0,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"safe_halt":{"approved_repair_count":0,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":0,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"uncertain_delivery":{"approved_repair_count":0,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":0,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":3,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0}},"minimum_trials_per_task_condition":3,"schema_version":"openadapt.qualification-evidence-decision-campaign-summary/v1","task_count":1},"decision_commitment_sha256":"sha256:e0491959b45066087d85ff35d32c6430b2f8d54f3f23750e01ac8cb7d48248f4","decision_identity_sha256":"sha256:26306ae89024e3be08e8151ef3be5c568d5f7b8b9afc7f11ad89af44a9260d36","decision_revision":1,"effect_contract_sha256":"sha256:ce11f9ac1059d29c5648a662ce8a4e8528ea3e8d844657aec8422d8b125a0698","entity_class":"record","environment_contract_sha256":"sha256:b01e155a3704b1f781937585da7f86c47adb8c86d48f032019ef41d6e9ceea57","evidence_authority_contract_sha256":"sha256:1aa7cfcb5f3df6b99372a28c305177e046487c8ec5b61111edbf1a12d3e76663","evidence_class":"remote-safe-synthetic","evidence_manifest_readback_sha256":"sha256:b0e022dba06f368a25c2f5e9a7dfbe92aece9125cb791c349b6981d056b8bf19","evidence_manifest_sha256":"sha256:3edc7613e1decd5714c8011854fb27d5d431bb085f5e47d6243926285d502bee","expires_at":null,"identity_contract_sha256":"sha256:34b008dd040d718fdc4d7b85b9311749b9865f47b4ba43bf6cd4a140bcf36c65","input_contract_sha256":"sha256:a82ba67af90f81e9a09f2db445a57f812b40a04c876396f191eb77eb53487a0f","issued_at":"2026-09-02T18:24:25Z","issuer":{"environment":"synthetic-qualification-evidence-decision","ref":"refs/heads/main","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","workflow":".github/workflows/issue-synthetic-qualification-evidence-decision.yml"},"issuer_key_id":"qa-ed25519-9cf4bca214c01d79","not_before":"2026-09-02T18:24:25Z","organization_id_sha256":"sha256:fcba879d867709da525f7f994a2642bc7a32014e324523a9d276bec54c3d296b","policy_contract_sha256":"sha256:482e3c7f10d044086283ea387f22b21c011e6c00cfc7fbf14cf82cfe2aedd1e0","revocation_state_sha256":"sha256:250ab430e467f5e584ebd2b1832976b42186b698da71d627ee1724c2b1da2457","schema_version":"openadapt.qualification-evidence-decision-receipt/v2","signature":"NywjiVqbWZ224vhvR0vM8eZGWFAo1tBGYxn91U9Jr0OuOJlQVIZAU2jfexgTbURXZnQzemFwbcFSPjUg4VMmBA==","signer_registry_sha256":"sha256:e243a23243b24986ed08812e284a1bd8c4993814149f02bcba79cc520e10ca14","signing_statement":{"commitment_scheme":"sha256-canonical-json-lf","object_schema_version":"openadapt.qualification-evidence-decision-receipt/v2","schema_version":"openadapt.qualification-evidence-signing-statement/v1","signature_domain":"OpenAdapt qualification evidence decision receipt v2\u0000","unsigned_object_sha256":"sha256:8e39eb6f36c984acaf947a032dcbeae718a704527a61ec5446c00958c4b3e2f5","unsigned_size_bytes":6106},"verdict":"ADMIT","workflow_id_sha256":"sha256:7176583f6120b7ff016363644afc47e835b2e4b438abe4050df160570f780af1","workflow_version_id_sha256":"sha256:4acf27da1f384b7967a1bb4fb463570657894cb83468e5763940d69ab9df1386"} diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/79/790122a25c87e456c6e45d25ebf5cd029b21b8511265b062fd9129b74aa1dd82.qualification-release.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/79/790122a25c87e456c6e45d25ebf5cd029b21b8511265b062fd9129b74aa1dd82.qualification-release.json new file mode 100644 index 0000000..7c1e990 --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/79/790122a25c87e456c6e45d25ebf5cd029b21b8511265b062fd9129b74aa1dd82.qualification-release.json @@ -0,0 +1 @@ +{"admission_id_sha256":"sha256:d2983b86d5428c892421b191f6943a63cf4f9a0b1629e324d099f5df6fa5dcda","artifact_inventory_sha256":"sha256:ec3ef7c177c493bebee3da60f170b37793832e81066e9d9ee785d5fa225a5ac5","authority_state_sha256":"sha256:df5079141df68877c4b06f05b9fb9fdf279307b7629eb1f2dce12def4bd5e2fa","claim_scope":"production_flow","evidence_class":"remote-safe-synthetic","expires_at":null,"issued_at":"2026-09-02T18:24:25Z","issuer":{"environment":"production-release-admission","ref":"refs/heads/main","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","workflow":".github/workflows/issue-production-release-admission.yml"},"not_before":"2026-09-02T18:24:25Z","production_acceptance_summary_bundle_reference":{"kind":"production-acceptance-summary-sigstore-bundle","object_media_type":"application/vnd.dev.sigstore.bundle.v0.3+json","object_path":"production-evidence/objects/sha256/e9/e9ecdee1fc3458906fc91f5760d215bb5bec3591a6ed9ae0b412114e24fcf8fb.production-acceptance-summary-sigstore-bundle.json","object_schema_version":"application/vnd.dev.sigstore.bundle.v0.3+json","object_sha256":"sha256:e9ecdee1fc3458906fc91f5760d215bb5bec3591a6ed9ae0b412114e24fcf8fb","registry_entry_sha256":"sha256:7dc2fcab09f705356a22b058b9e7f078596bcdefdb697bef7315510d17931549","registry_head_sha256":"sha256:9a9f597b0d87674c4d36c022227201a5d8f3072237624346793692c3a863d12e","registry_revision":1,"registry_source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","schema_version":"openadapt.production-evidence-object-reference/v2","semantic_identity_sha256":"sha256:1b5606b9f4c14edd37ec134a9c716a070832b8709e3c2f9c6f4186ff514b7c82","size_bytes":2789,"subject_sha256":"sha256:3849fd4e2cae0d3a74964362e4850870bb68c23007d5eb818800159d3eb730d4"},"production_acceptance_summary_reference":{"kind":"production-acceptance-summary","object_media_type":"application/vnd.openadapt.production-lifecycle-evidence-summary+json;version=3","object_path":"production-evidence/objects/sha256/38/3849fd4e2cae0d3a74964362e4850870bb68c23007d5eb818800159d3eb730d4.production-acceptance-summary.json","object_schema_version":"openadapt.production-lifecycle-evidence-summary/v3","object_sha256":"sha256:3849fd4e2cae0d3a74964362e4850870bb68c23007d5eb818800159d3eb730d4","registry_entry_sha256":"sha256:932511112a7eb5f296b752953ac184516a47f7630643ecf70955af722e78ef68","registry_head_sha256":"sha256:9a9f597b0d87674c4d36c022227201a5d8f3072237624346793692c3a863d12e","registry_revision":1,"registry_source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","schema_version":"openadapt.production-evidence-object-reference/v2","semantic_identity_sha256":"sha256:cf65d1d351869c63e88d7188d1e78727994cc3f6e76c88f5643a61d168a84445","size_bytes":14497,"subject_sha256":null},"publication_policy_sha256":"sha256:ed5ab69fe8127604ca674263cbc8c774b7cfd10754e90bfaa9b71ba573bce1d1","publication_staging":{"assets":[{"asset_id":"534029483","kind":"python-wheel","media_type":"application/zip","name":"openadapt_flow-1.34.0-py3-none-any.whl","publish_destinations":["github-release","pypi"],"sha256":"sha256:56d32818989cb3a92830080ead39e10b08718c55e00988117f22cbfeaac98854","size_bytes":1928194,"uploader_id":"321543906","uploader_login":"openadapt-release[bot]"},{"asset_id":"534029484","kind":"python-sdist","media_type":"application/gzip","name":"openadapt_flow-1.34.0.tar.gz","publish_destinations":["github-release","pypi"],"sha256":"sha256:a941a70015fe91897e655bfc9bf83e6cf8fbcf8bd4e4c7206ffb133c505203f8","size_bytes":20440838,"uploader_id":"321543906","uploader_login":"openadapt-release[bot]"}],"draft":false,"draft_release_id":"378603192","immutable_releases":{"enabled":true,"enforced_by_owner":false},"immutable_releases_sha256":"sha256:07649aafb167237fecc138f5e93b48ddce5a69f4060da7130e3c78e59fd48581","observed_at":"2026-09-02T18:24:25Z","prerelease":false,"publication_mode":"already-published-pypi","pypi_files":[{"filename":"openadapt_flow-1.34.0-py3-none-any.whl","packagetype":"bdist_wheel","sha256":"sha256:56d32818989cb3a92830080ead39e10b08718c55e00988117f22cbfeaac98854","size_bytes":1928194,"yanked":false},{"filename":"openadapt_flow-1.34.0.tar.gz","packagetype":"sdist","sha256":"sha256:a941a70015fe91897e655bfc9bf83e6cf8fbcf8bd4e4c7206ffb133c505203f8","size_bytes":20440838,"yanked":false}],"release_app_bot_user_id":"321543906","release_app_id":"4730708","release_app_installation_id":"156835568","release_author_login":"openadapt-release[bot]","repository":"OpenAdaptAI/openadapt-flow","repository_id":"1291376938","schema_version":"openadapt.production-release-staging-evidence/v1","tag":"v1.34.0","tag_ref_state":{"exists":true,"ref":"refs/tags/v1.34.0"},"tag_ref_state_sha256":"sha256:74c5665395ed98ba3fd1b3a284bab1e8089f7c79cfafb3f88548e8b1456c5782","tag_rulesets":[{"bypass_actors":[{"actor_id":"4730708","actor_type":"Integration","bypass_mode":"always"}],"conditions":{"ref_name":{"exclude":[],"include":["refs/tags/v*"]}},"enforcement":"active","name":"OpenAdapt policy: release tag creation","repository":"OpenAdaptAI/openadapt-flow","repository_id":"1291376938","role":"creation_authority","rules":[{"type":"creation"}],"ruleset_id":"10","schema_version":"openadapt.production-release-tag-ruleset/v1","target":"tag"},{"bypass_actors":[],"conditions":{"ref_name":{"exclude":[],"include":["refs/tags/v*"]}},"enforcement":"active","name":"OpenAdapt policy: immutable release tags","repository":"OpenAdaptAI/openadapt-flow","repository_id":"1291376938","role":"immutability","rules":[{"type":"deletion"},{"type":"non_fast_forward"},{"parameters":{"update_allows_fetch_and_merge":false},"type":"update"}],"ruleset_id":"11","schema_version":"openadapt.production-release-tag-ruleset/v1","target":"tag"}],"tag_rulesets_sha256":"sha256:b0fdf160d80ae7dc8ffd979b2ba101cee6b3e7cf139e8c5d32b5534cbc0f7f44","target_commitish":"30fc60e55778a0e0f92b9776117cafcfe2512249"},"publication_staging_sha256":"sha256:861175c196cfe9455ce5f0536b6b1eabf55a990ced03349b865643f52316dedd","release":{"artifacts":[{"kind":"python-sdist","media_type":"application/gzip","name":"openadapt_flow-1.34.0.tar.gz","publish_destinations":["github-release","pypi"],"sha256":"sha256:a941a70015fe91897e655bfc9bf83e6cf8fbcf8bd4e4c7206ffb133c505203f8","size_bytes":20440838},{"kind":"python-wheel","media_type":"application/zip","name":"openadapt_flow-1.34.0-py3-none-any.whl","publish_destinations":["github-release","pypi"],"sha256":"sha256:56d32818989cb3a92830080ead39e10b08718c55e00988117f22cbfeaac98854","size_bytes":1928194}],"deployment_id":null,"deployment_sha256":null,"kind":"package","schema_version":"openadapt.production-release-candidate/v1","source_commit":"30fc60e55778a0e0f92b9776117cafcfe2512249","source_repository":"OpenAdaptAI/openadapt-flow","source_repository_id":"1291376938","tag":"v1.34.0","version":"1.34.0"},"release_identity":{"channel":"production","previous_admission_sha256":null,"schema_version":"openadapt.monotonic-production-release/v1","sequence":1},"release_sha256":"sha256:f84c03c857bda8372d39bc30afcc2986247778c34b3f93a39ec9de5dd151a289","revocation_state_sha256":"sha256:250ab430e467f5e584ebd2b1832976b42186b698da71d627ee1724c2b1da2457","schema_version":"openadapt.qualification-release/v2","signer_registry_sha256":"sha256:e243a23243b24986ed08812e284a1bd8c4993814149f02bcba79cc520e10ca14","target":"flow","verdict":"accepted"} diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/a2/a22f9815ec0f7c56f7629aeabfd21d14bc6d739efcfb7f7a073ce9987e19479e.qualification-authority-state-receipt.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/a2/a22f9815ec0f7c56f7629aeabfd21d14bc6d739efcfb7f7a073ce9987e19479e.qualification-authority-state-receipt.json new file mode 100644 index 0000000..c47be2a --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/a2/a22f9815ec0f7c56f7629aeabfd21d14bc6d739efcfb7f7a073ce9987e19479e.qualification-authority-state-receipt.json @@ -0,0 +1 @@ +{"algorithm":"ed25519","authority_state_sha256":"sha256:df5079141df68877c4b06f05b9fb9fdf279307b7629eb1f2dce12def4bd5e2fa","evidence_authority_sha256":"sha256:1aa7cfcb5f3df6b99372a28c305177e046487c8ec5b61111edbf1a12d3e76663","expires_at":null,"issuer":{"environment":"qualification-authority-state","ref":"refs/heads/main","repository":"OpenAdaptAI/openadapt-ops","repository_id":"1172011294","repository_owner_id":"132681217","source_commit":"e323249e3a7c1af9d7651312e0afe1f12c38c977","workflow":".github/workflows/qualification-authority-state.yml"},"issuer_key_id":"qa-ed25519-9cf4bca214c01d79","not_before":"2026-09-02T18:24:25Z","observed_at":"2026-09-02T18:24:25Z","schema_version":"openadapt.qualification-authority-state-receipt/v2","signature":"BUa1NvZFvbPv7pari55YjS6C7p6U68c2Jjrh0vt9u+ZFky8Y6w/9p+55MggWJP8zwghMIT+HM1YlqH5++ciOBQ==","signer_registry_identity_sha256":"sha256:e243a23243b24986ed08812e284a1bd8c4993814149f02bcba79cc520e10ca14","signer_registry_revision":1,"signer_registry_sha256":"sha256:7a81bf3d213c74673f3c6b5fa179234cbee534c9432aaea6ae09e455562f96b6","signing_statement":{"commitment_scheme":"sha256-canonical-json-lf","object_schema_version":"openadapt.qualification-authority-state-receipt/v2","schema_version":"openadapt.qualification-evidence-signing-statement/v1","signature_domain":"OpenAdapt qualification authority state receipt v2\u0000","unsigned_object_sha256":"sha256:be362f1c032e0f0ee8f8ad378efe7b84fb55ea5e9260977a2b9fc2e41dda9b17","unsigned_size_bytes":995},"status":"active"} diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/ac/ace6aabbaf02596d26cd5d6f1406790f4fe831ca978129d50cc2285882a2630c.production-acceptance-manifest-sigstore-bundle.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/ac/ace6aabbaf02596d26cd5d6f1406790f4fe831ca978129d50cc2285882a2630c.production-acceptance-manifest-sigstore-bundle.json new file mode 100644 index 0000000..d900ee8 --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/ac/ace6aabbaf02596d26cd5d6f1406790f4fe831ca978129d50cc2285882a2630c.production-acceptance-manifest-sigstore-bundle.json @@ -0,0 +1 @@ +{"dsseEnvelope":{"payload":"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","payloadType":"application/vnd.openadapt.production-public-trust-signing-statement+json;version=1","signatures":[{"keyid":"oa-public-trust-ed25519-9cf4bca214c01d79","sig":"Y372xGFB91tSyBUldgOPPbGgMBXWttlVwtuXmqqHRJBnqzFjzC079I/Nz8ODEcZeV7DY1AR5AWOmhJ0mUcl8Bw=="}]},"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"publicKey":{"hint":"oa-public-trust-ed25519-9cf4bca214c01d79"}}} diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/dc/dcdb32a762aca87fbb1a7c9df5d346403b167ec5850d35fe47fd64d942684a04.qualification-admission.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/dc/dcdb32a762aca87fbb1a7c9df5d346403b167ec5850d35fe47fd64d942684a04.qualification-admission.json new file mode 100644 index 0000000..f945826 --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/dc/dcdb32a762aca87fbb1a7c9df5d346403b167ec5850d35fe47fd64d942684a04.qualification-admission.json @@ -0,0 +1 @@ +{"action_contract_sha256":"sha256:d4b8a931c16bca24cd343c786f41566357d9edcc8b0b97d3c1cb9907571dd56b","admission_id_sha256":"sha256:45c157898b6f07e57bf604b3323f206d677cac6c57a43238152cdb3308495e80","admitted_runtime_sha256":"sha256:56d32818989cb3a92830080ead39e10b08718c55e00988117f22cbfeaac98854","application_contract_sha256":"sha256:e8f70b24976d2befeaea5e54059e39b1934a211c49cba65ac41e6cfdfd70ec80","bundle_sha256":"sha256:33f8c637f3d5d9eb23b92e0fb7ba74d2713a52f7c8ed11495b30f8bbefb1f312","bundle_version":"0.0.0-synthetic","campaign_artifact_sha256":"sha256:e2f2aa6b30118864682892a08e7e151039a34e7e7f84ff027e253cf8daddff78","campaign_permit_sha256":"sha256:da4af1f21aa121a00f92d88fc129d47bbd1a027462408e6bf2adf8fe66fe4255","campaign_summary":{"declared_attended":{"approved_repair_count":0,"authenticated_bound_decision_count":3,"blind_retry_count":0,"live_target_revalidation_count":3,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"governed_repair":{"approved_repair_count":3,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":3,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":3,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":3,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"healthy":{"approved_repair_count":0,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":0,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"idempotency_replay":{"approved_repair_count":0,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":0,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"safe_halt":{"approved_repair_count":0,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":0,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"uncertain_delivery":{"approved_repair_count":0,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":0,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":3,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0}},"decision_receipt_bundle_reference":{"kind":"qualification-evidence-decision-receipt-sigstore-bundle","object_media_type":"application/vnd.dev.sigstore.bundle.v0.3+json","object_path":"production-evidence/objects/sha256/09/09eb48f80dec3cd8f7da73bfef1aed805068c0feefdbaaaa350ded1b70ba0c7d.qualification-evidence-decision-receipt-sigstore-bundle.json","object_schema_version":"application/vnd.dev.sigstore.bundle.v0.3+json","object_sha256":"sha256:09eb48f80dec3cd8f7da73bfef1aed805068c0feefdbaaaa350ded1b70ba0c7d","registry_entry_sha256":"sha256:40e134188beb1f1dd8bf17eaa02d84b8246ae11db7b99db68efb493f2a3d7955","registry_head_sha256":"sha256:9a9f597b0d87674c4d36c022227201a5d8f3072237624346793692c3a863d12e","registry_revision":1,"registry_source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","schema_version":"openadapt.production-evidence-object-reference/v2","semantic_identity_sha256":"sha256:21d2be624cc93f033b13eceabd7ea42b39ab6f80790c643235c80a32272545a6","size_bytes":2849,"subject_sha256":"sha256:6ffe691f8e40e06b73e24391d180424ed86bb289ddae001cf7b49de2e745312a"},"decision_receipt_reference":{"kind":"qualification-evidence-decision-receipt","object_media_type":"application/vnd.openadapt.qualification-evidence-decision-receipt+json;version=2","object_path":"production-evidence/objects/sha256/6f/6ffe691f8e40e06b73e24391d180424ed86bb289ddae001cf7b49de2e745312a.qualification-evidence-decision-receipt.json","object_schema_version":"openadapt.qualification-evidence-decision-receipt/v2","object_sha256":"sha256:6ffe691f8e40e06b73e24391d180424ed86bb289ddae001cf7b49de2e745312a","registry_entry_sha256":"sha256:63d0170fb957ebd167f2650ef744d70839d0676a8cf9f8978d73aed5cffd0b27","registry_head_sha256":"sha256:9a9f597b0d87674c4d36c022227201a5d8f3072237624346793692c3a863d12e","registry_revision":1,"registry_source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","schema_version":"openadapt.production-evidence-object-reference/v2","semantic_identity_sha256":"sha256:c18d69bdfb145139581ea6865f513179bd104cb02a64d838f93e49f96d9d3769","size_bytes":6636,"subject_sha256":null},"effect_contract_sha256":"sha256:ce11f9ac1059d29c5648a662ce8a4e8528ea3e8d844657aec8422d8b125a0698","entity_class":"record","environment_contract_sha256":"sha256:b01e155a3704b1f781937585da7f86c47adb8c86d48f032019ef41d6e9ceea57","evidence_authority_sha256":"sha256:1aa7cfcb5f3df6b99372a28c305177e046487c8ec5b61111edbf1a12d3e76663","evidence_class":"remote-safe-synthetic","expires_at":null,"identity_contract_sha256":"sha256:34b008dd040d718fdc4d7b85b9311749b9865f47b4ba43bf6cd4a140bcf36c65","input_contract_sha256":"sha256:a82ba67af90f81e9a09f2db445a57f812b40a04c876396f191eb77eb53487a0f","issued_at":"2026-09-02T18:24:25Z","issuer":{"environment":"qualification-admission","ref":"refs/heads/main","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","workflow":".github/workflows/issue-qualification-admission.yml"},"local_identity_opening":{"algorithm":"hmac-sha256","customer_controlled_secret_required":true,"exact_contract_match_required":true,"maximum_age_seconds":60,"required":true,"revalidation_before_actuation":true,"schema_version":"openadapt.qualification-local-identity-opening/v1"},"not_before":"2026-09-02T18:24:25Z","organization_id_sha256":"sha256:fcba879d867709da525f7f994a2642bc7a32014e324523a9d276bec54c3d296b","policy_contract_sha256":"sha256:482e3c7f10d044086283ea387f22b21c011e6c00cfc7fbf14cf82cfe2aedd1e0","revocation_state_sha256":"sha256:250ab430e467f5e584ebd2b1832976b42186b698da71d627ee1724c2b1da2457","schema_version":"openadapt.qualification-admission/v4","signer_registry_sha256":"sha256:e243a23243b24986ed08812e284a1bd8c4993814149f02bcba79cc520e10ca14","verdict":"accepted","workflow_id_sha256":"sha256:7176583f6120b7ff016363644afc47e835b2e4b438abe4050df160570f780af1","workflow_version_id_sha256":"sha256:4acf27da1f384b7967a1bb4fb463570657894cb83468e5763940d69ab9df1386"} diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/e9/e9ecdee1fc3458906fc91f5760d215bb5bec3591a6ed9ae0b412114e24fcf8fb.production-acceptance-summary-sigstore-bundle.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/e9/e9ecdee1fc3458906fc91f5760d215bb5bec3591a6ed9ae0b412114e24fcf8fb.production-acceptance-summary-sigstore-bundle.json new file mode 100644 index 0000000..5a494eb --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/objects/sha256/e9/e9ecdee1fc3458906fc91f5760d215bb5bec3591a6ed9ae0b412114e24fcf8fb.production-acceptance-summary-sigstore-bundle.json @@ -0,0 +1 @@ +{"dsseEnvelope":{"payload":"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","payloadType":"application/vnd.openadapt.production-public-trust-signing-statement+json;version=1","signatures":[{"keyid":"oa-public-trust-ed25519-9cf4bca214c01d79","sig":"1XvTEC4Jxf10eci09PedfhRA/Lkr8pMxpPPdA9fam1M8U5nefd+U9zdPfv2fnUaB5L5bMhQ7fU+JButltWclAA=="}]},"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"publicKey":{"hint":"oa-public-trust-ed25519-9cf4bca214c01d79"}}} diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/signer-registries/sha256/7a/7a81bf3d213c74673f3c6b5fa179234cbee534c9432aaea6ae09e455562f96b6.qualification-signer-registry.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/signer-registries/sha256/7a/7a81bf3d213c74673f3c6b5fa179234cbee534c9432aaea6ae09e455562f96b6.qualification-signer-registry.json new file mode 100644 index 0000000..72a5ba1 --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/production-evidence/signer-registries/sha256/7a/7a81bf3d213c74673f3c6b5fa179234cbee534c9432aaea6ae09e455562f96b6.qualification-signer-registry.json @@ -0,0 +1 @@ +{"expires_at":null,"generated_at":"2026-09-02T18:24:25Z","revision":1,"schema_version":"openadapt.qualification-signer-registry/v2","signers":[{"algorithm":"ed25519","allowed_ref_prefixes":["refs/heads/main"],"allowed_usages":["qualification-authority-state-receipt","qualification-evidence-decision-receipt","qualification-revocation-state-receipt"],"allowed_workflows":["https://github.com/OpenAdaptAI/.github/.github/workflows/issue-synthetic-qualification-evidence-decision.yml@refs/heads/main","https://github.com/OpenAdaptAI/openadapt-ops/.github/workflows/qualification-authority-state.yml@refs/heads/main","https://github.com/OpenAdaptAI/openadapt-ops/.github/workflows/qualification-revocation-state.yml@refs/heads/main"],"key_id":"qa-ed25519-9cf4bca214c01d79","public_key":"vHPUDLG2WD2BnTLaKYnZd9GxvUKfjpd68gJ9HubIEH8","public_key_sha256":"sha256:465646ab5137f05dfba094fb05fc10e3af74a0c2e2d0fcc20814b8f1f8271170","public_key_spki_der_base64":"MCowBQYDK2VwAyEAvHPUDLG2WD2BnTLaKYnZd9GxvUKfjpd68gJ9HubIEH8=","revoked_at":null,"statement_schema_versions":["openadapt.qualification-evidence-signing-statement/v1"],"status":"active"},{"algorithm":"ed25519","allowed_environments":["synthetic-qualification-evidence-decision"],"allowed_kinds":["production-acceptance-manifest","production-acceptance-summary","production-cloud-deploy-authorization","production-cloud-deployment-result","production-current-default","production-deployment-observation","production-lifecycle-checkpoint","qualification-admission","qualification-authority-state-receipt","qualification-campaign-permit","qualification-campaign-permit-policy","qualification-campaign-permit-receipt","qualification-campaign-permit-request","qualification-evidence-decision-receipt","qualification-release","qualification-revocation-state-receipt","support-release-admission"],"allowed_ref_prefixes":["refs/heads/main"],"allowed_usages":["production-public-evidence"],"allowed_workflows":["https://github.com/OpenAdaptAI/.github/.github/workflows/sign-production-evidence-software.yml@refs/heads/main"],"key_id":"oa-public-trust-ed25519-9cf4bca214c01d79","key_origin":"software","public_key":"vHPUDLG2WD2BnTLaKYnZd9GxvUKfjpd68gJ9HubIEH8","public_key_sha256":"sha256:465646ab5137f05dfba094fb05fc10e3af74a0c2e2d0fcc20814b8f1f8271170","public_key_spki_der_base64":"MCowBQYDK2VwAyEAvHPUDLG2WD2BnTLaKYnZd9GxvUKfjpd68gJ9HubIEH8=","revoked_at":null,"signature_encoding":"raw-64-base64-rfc4648-padded","statement_schema_versions":["openadapt.production-public-trust-signing-statement/v1"],"status":"active"}]} diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/public-material.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/public-material.json new file mode 100644 index 0000000..cffcff2 --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/public-material.json @@ -0,0 +1 @@ +{"algorithm":"ed25519","key_id":"qa-ed25519-9cf4bca214c01d79","public_key":"vHPUDLG2WD2BnTLaKYnZd9GxvUKfjpd68gJ9HubIEH8","public_key_sha256":"sha256:465646ab5137f05dfba094fb05fc10e3af74a0c2e2d0fcc20814b8f1f8271170","public_key_spki_der_base64":"MCowBQYDK2VwAyEAvHPUDLG2WD2BnTLaKYnZd9GxvUKfjpd68gJ9HubIEH8="} diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/publication-staging.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/publication-staging.json new file mode 100644 index 0000000..7f89826 --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/publication-staging.json @@ -0,0 +1 @@ +{"assets":[{"asset_id":"534029483","kind":"python-wheel","media_type":"application/zip","name":"openadapt_flow-1.34.0-py3-none-any.whl","publish_destinations":["github-release","pypi"],"sha256":"sha256:56d32818989cb3a92830080ead39e10b08718c55e00988117f22cbfeaac98854","size_bytes":1928194,"uploader_id":"321543906","uploader_login":"openadapt-release[bot]"},{"asset_id":"534029484","kind":"python-sdist","media_type":"application/gzip","name":"openadapt_flow-1.34.0.tar.gz","publish_destinations":["github-release","pypi"],"sha256":"sha256:a941a70015fe91897e655bfc9bf83e6cf8fbcf8bd4e4c7206ffb133c505203f8","size_bytes":20440838,"uploader_id":"321543906","uploader_login":"openadapt-release[bot]"}],"draft":false,"draft_release_id":"378603192","immutable_releases":{"enabled":true,"enforced_by_owner":false},"immutable_releases_sha256":"sha256:07649aafb167237fecc138f5e93b48ddce5a69f4060da7130e3c78e59fd48581","observed_at":"2026-09-02T18:24:25Z","prerelease":false,"publication_mode":"already-published-pypi","pypi_files":[{"filename":"openadapt_flow-1.34.0-py3-none-any.whl","packagetype":"bdist_wheel","sha256":"sha256:56d32818989cb3a92830080ead39e10b08718c55e00988117f22cbfeaac98854","size_bytes":1928194,"yanked":false},{"filename":"openadapt_flow-1.34.0.tar.gz","packagetype":"sdist","sha256":"sha256:a941a70015fe91897e655bfc9bf83e6cf8fbcf8bd4e4c7206ffb133c505203f8","size_bytes":20440838,"yanked":false}],"release_app_bot_user_id":"321543906","release_app_id":"4730708","release_app_installation_id":"156835568","release_author_login":"openadapt-release[bot]","repository":"OpenAdaptAI/openadapt-flow","repository_id":"1291376938","schema_version":"openadapt.production-release-staging-evidence/v1","tag":"v1.34.0","tag_ref_state":{"exists":true,"ref":"refs/tags/v1.34.0"},"tag_ref_state_sha256":"sha256:74c5665395ed98ba3fd1b3a284bab1e8089f7c79cfafb3f88548e8b1456c5782","tag_rulesets":[{"bypass_actors":[{"actor_id":"4730708","actor_type":"Integration","bypass_mode":"always"}],"conditions":{"ref_name":{"exclude":[],"include":["refs/tags/v*"]}},"enforcement":"active","name":"OpenAdapt policy: release tag creation","repository":"OpenAdaptAI/openadapt-flow","repository_id":"1291376938","role":"creation_authority","rules":[{"type":"creation"}],"ruleset_id":"10","schema_version":"openadapt.production-release-tag-ruleset/v1","target":"tag"},{"bypass_actors":[],"conditions":{"ref_name":{"exclude":[],"include":["refs/tags/v*"]}},"enforcement":"active","name":"OpenAdapt policy: immutable release tags","repository":"OpenAdaptAI/openadapt-flow","repository_id":"1291376938","role":"immutability","rules":[{"type":"deletion"},{"type":"non_fast_forward"},{"parameters":{"update_allows_fetch_and_merge":false},"type":"update"}],"ruleset_id":"11","schema_version":"openadapt.production-release-tag-ruleset/v1","target":"tag"}],"tag_rulesets_sha256":"sha256:b0fdf160d80ae7dc8ffd979b2ba101cee6b3e7cf139e8c5d32b5534cbc0f7f44","target_commitish":"30fc60e55778a0e0f92b9776117cafcfe2512249"} diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/qualification-admission-sigstore-bundle.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/qualification-admission-sigstore-bundle.json new file mode 100644 index 0000000..c7630e6 --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/qualification-admission-sigstore-bundle.json @@ -0,0 +1 @@ +{"dsseEnvelope":{"payload":"eyJhdXRob3JpdHlfc3RhdGVfc2hhMjU2Ijoic2hhMjU2OmRmNTA3OTE0MWRmNjg4NzdjNGIwNmYwNWI5ZmI5ZmRmMjc5MzA3Yjc2MjllYjFmMmRjZTEyZGVmNGJkNWUyZmEiLCJleHBpcmVzX2F0IjpudWxsLCJpc3N1ZWRfYXQiOiIyMDI2LTA5LTAyVDE4OjI0OjI1WiIsImtleV9pZCI6Im9hLXB1YmxpYy10cnVzdC1lZDI1NTE5LTljZjRiY2EyMTRjMDFkNzkiLCJub3RfYmVmb3JlIjoiMjAyNi0wOS0wMlQxODoyNDoyNVoiLCJvYmplY3Rfa2luZCI6InF1YWxpZmljYXRpb24tYWRtaXNzaW9uIiwib2JqZWN0X21lZGlhX3R5cGUiOiJhcHBsaWNhdGlvbi92bmQub3BlbmFkYXB0LnF1YWxpZmljYXRpb24tYWRtaXNzaW9uK2pzb247dmVyc2lvbj00Iiwib2JqZWN0X3NjaGVtYV92ZXJzaW9uIjoib3BlbmFkYXB0LnF1YWxpZmljYXRpb24tYWRtaXNzaW9uL3Y0Iiwib2JqZWN0X3NoYTI1NiI6InNoYTI1NjpkY2RiMzJhNzYyYWNhODdmYmIxYTdjOWRmNWQzNDY0MDNiMTY3ZWM1ODUwZDM1ZmU0N2ZkNjRkOTQyNjg0YTA0Iiwib2JqZWN0X3NpemVfYnl0ZXMiOjgwNTUsInJlcXVlc3RfaWRfc2hhMjU2Ijoic2hhMjU2OjYxZGZiZWM5YzBhMzc0Y2MyYzM0Mjc0Yzg2MDIyOGVhODNmZTM5NmZjMzkwYzMxOGI1ODRiMDA5YTU0MTc2OWMiLCJyZXZvY2F0aW9uX3N0YXRlX3NoYTI1NiI6InNoYTI1NjoyNTBhYjQzMGU0NjdmNWU1ODRlYmQyYjE4MzI5NzZiNDIxODZiNjk4ZGE3MWQ2MjdlZTE3MjRjMmIxZGEyNDU3Iiwic2NoZW1hX3ZlcnNpb24iOiJvcGVuYWRhcHQucHJvZHVjdGlvbi1wdWJsaWMtdHJ1c3Qtc2lnbmluZy1zdGF0ZW1lbnQvdjEiLCJzZW1hbnRpY19pZGVudGl0eV9zaGEyNTYiOiJzaGEyNTY6YTQ4MGQ2MmE5YzJhYTVlZDYwNjFkM2IwMTQwY2Y5MDgwMjRiMjNlOTBiNzUzNWJiM2MwOWU5ZGE2Zjc0OGU5MCIsInNpZ25hdHVyZV9wcm9maWxlIjoic29mdHdhcmUtZWQyNTUxOS1kc3NlLXYxIiwic2lnbmVyX3JlZ2lzdHJ5X3NoYTI1NiI6InNoYTI1NjplMjQzYTIzMjQzYjI0OTg2ZWQwODgxMmUyODRhMWJkOGM0OTkzODE0MTQ5ZjAyYmNiYTc5Y2M1MjBlMTBjYTE0Iiwic2lnbmluZ19hdXRob3JpdHkiOnsiZW52aXJvbm1lbnQiOiJzeW50aGV0aWMtcXVhbGlmaWNhdGlvbi1ldmlkZW5jZS1kZWNpc2lvbiIsImtleV9vcmlnaW4iOiJzb2Z0d2FyZSIsInJlZiI6InJlZnMvaGVhZHMvbWFpbiIsInJlcG9zaXRvcnkiOiJPcGVuQWRhcHRBSS8uZ2l0aHViIiwicmVwb3NpdG9yeV9pZCI6Ijg1ODQ1NDA2MiIsInJlcG9zaXRvcnlfb3duZXJfaWQiOiIxMzI2ODEyMTciLCJzb3VyY2VfY29tbWl0IjoiMmMxMjk3MDJkYTcxODUyMmNjMjU3OTEzMjA3YjZlZDZmM2IzM2I3YyIsIndvcmtmbG93IjoiLmdpdGh1Yi93b3JrZmxvd3Mvc2lnbi1wcm9kdWN0aW9uLWV2aWRlbmNlLXNvZnR3YXJlLnltbCJ9LCJzb3VyY2VfaXNzdWVyIjp7ImVudmlyb25tZW50IjoicXVhbGlmaWNhdGlvbi1hZG1pc3Npb24iLCJyZWYiOiJyZWZzL2hlYWRzL21haW4iLCJyZXBvc2l0b3J5IjoiT3BlbkFkYXB0QUkvLmdpdGh1YiIsInJlcG9zaXRvcnlfaWQiOiI4NTg0NTQwNjIiLCJyZXBvc2l0b3J5X293bmVyX2lkIjoiMTMyNjgxMjE3Iiwic291cmNlX2NvbW1pdCI6IjJjMTI5NzAyZGE3MTg1MjJjYzI1NzkxMzIwN2I2ZWQ2ZjNiMzNiN2MiLCJ3b3JrZmxvdyI6Ii5naXRodWIvd29ya2Zsb3dzL2lzc3VlLXF1YWxpZmljYXRpb24tYWRtaXNzaW9uLnltbCJ9fQo=","payloadType":"application/vnd.openadapt.production-public-trust-signing-statement+json;version=1","signatures":[{"keyid":"oa-public-trust-ed25519-9cf4bca214c01d79","sig":"+Yx8YgUpt2BtK3dfylC1kmkUxvPx/XgFuyqAZTDGA4yz4IF0M6EYPg/semaTXiquoVF6P3FISYkMIhuz8Pc+AQ=="}]},"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"publicKey":{"hint":"oa-public-trust-ed25519-9cf4bca214c01d79"}}} diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/qualification-admission.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/qualification-admission.json new file mode 100644 index 0000000..f945826 --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/qualification-admission.json @@ -0,0 +1 @@ +{"action_contract_sha256":"sha256:d4b8a931c16bca24cd343c786f41566357d9edcc8b0b97d3c1cb9907571dd56b","admission_id_sha256":"sha256:45c157898b6f07e57bf604b3323f206d677cac6c57a43238152cdb3308495e80","admitted_runtime_sha256":"sha256:56d32818989cb3a92830080ead39e10b08718c55e00988117f22cbfeaac98854","application_contract_sha256":"sha256:e8f70b24976d2befeaea5e54059e39b1934a211c49cba65ac41e6cfdfd70ec80","bundle_sha256":"sha256:33f8c637f3d5d9eb23b92e0fb7ba74d2713a52f7c8ed11495b30f8bbefb1f312","bundle_version":"0.0.0-synthetic","campaign_artifact_sha256":"sha256:e2f2aa6b30118864682892a08e7e151039a34e7e7f84ff027e253cf8daddff78","campaign_permit_sha256":"sha256:da4af1f21aa121a00f92d88fc129d47bbd1a027462408e6bf2adf8fe66fe4255","campaign_summary":{"declared_attended":{"approved_repair_count":0,"authenticated_bound_decision_count":3,"blind_retry_count":0,"live_target_revalidation_count":3,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"governed_repair":{"approved_repair_count":3,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":3,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":3,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":3,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"healthy":{"approved_repair_count":0,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":0,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"idempotency_replay":{"approved_repair_count":0,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":0,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"safe_halt":{"approved_repair_count":0,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":0,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"uncertain_delivery":{"approved_repair_count":0,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":0,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":3,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0}},"decision_receipt_bundle_reference":{"kind":"qualification-evidence-decision-receipt-sigstore-bundle","object_media_type":"application/vnd.dev.sigstore.bundle.v0.3+json","object_path":"production-evidence/objects/sha256/09/09eb48f80dec3cd8f7da73bfef1aed805068c0feefdbaaaa350ded1b70ba0c7d.qualification-evidence-decision-receipt-sigstore-bundle.json","object_schema_version":"application/vnd.dev.sigstore.bundle.v0.3+json","object_sha256":"sha256:09eb48f80dec3cd8f7da73bfef1aed805068c0feefdbaaaa350ded1b70ba0c7d","registry_entry_sha256":"sha256:40e134188beb1f1dd8bf17eaa02d84b8246ae11db7b99db68efb493f2a3d7955","registry_head_sha256":"sha256:9a9f597b0d87674c4d36c022227201a5d8f3072237624346793692c3a863d12e","registry_revision":1,"registry_source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","schema_version":"openadapt.production-evidence-object-reference/v2","semantic_identity_sha256":"sha256:21d2be624cc93f033b13eceabd7ea42b39ab6f80790c643235c80a32272545a6","size_bytes":2849,"subject_sha256":"sha256:6ffe691f8e40e06b73e24391d180424ed86bb289ddae001cf7b49de2e745312a"},"decision_receipt_reference":{"kind":"qualification-evidence-decision-receipt","object_media_type":"application/vnd.openadapt.qualification-evidence-decision-receipt+json;version=2","object_path":"production-evidence/objects/sha256/6f/6ffe691f8e40e06b73e24391d180424ed86bb289ddae001cf7b49de2e745312a.qualification-evidence-decision-receipt.json","object_schema_version":"openadapt.qualification-evidence-decision-receipt/v2","object_sha256":"sha256:6ffe691f8e40e06b73e24391d180424ed86bb289ddae001cf7b49de2e745312a","registry_entry_sha256":"sha256:63d0170fb957ebd167f2650ef744d70839d0676a8cf9f8978d73aed5cffd0b27","registry_head_sha256":"sha256:9a9f597b0d87674c4d36c022227201a5d8f3072237624346793692c3a863d12e","registry_revision":1,"registry_source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","schema_version":"openadapt.production-evidence-object-reference/v2","semantic_identity_sha256":"sha256:c18d69bdfb145139581ea6865f513179bd104cb02a64d838f93e49f96d9d3769","size_bytes":6636,"subject_sha256":null},"effect_contract_sha256":"sha256:ce11f9ac1059d29c5648a662ce8a4e8528ea3e8d844657aec8422d8b125a0698","entity_class":"record","environment_contract_sha256":"sha256:b01e155a3704b1f781937585da7f86c47adb8c86d48f032019ef41d6e9ceea57","evidence_authority_sha256":"sha256:1aa7cfcb5f3df6b99372a28c305177e046487c8ec5b61111edbf1a12d3e76663","evidence_class":"remote-safe-synthetic","expires_at":null,"identity_contract_sha256":"sha256:34b008dd040d718fdc4d7b85b9311749b9865f47b4ba43bf6cd4a140bcf36c65","input_contract_sha256":"sha256:a82ba67af90f81e9a09f2db445a57f812b40a04c876396f191eb77eb53487a0f","issued_at":"2026-09-02T18:24:25Z","issuer":{"environment":"qualification-admission","ref":"refs/heads/main","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","workflow":".github/workflows/issue-qualification-admission.yml"},"local_identity_opening":{"algorithm":"hmac-sha256","customer_controlled_secret_required":true,"exact_contract_match_required":true,"maximum_age_seconds":60,"required":true,"revalidation_before_actuation":true,"schema_version":"openadapt.qualification-local-identity-opening/v1"},"not_before":"2026-09-02T18:24:25Z","organization_id_sha256":"sha256:fcba879d867709da525f7f994a2642bc7a32014e324523a9d276bec54c3d296b","policy_contract_sha256":"sha256:482e3c7f10d044086283ea387f22b21c011e6c00cfc7fbf14cf82cfe2aedd1e0","revocation_state_sha256":"sha256:250ab430e467f5e584ebd2b1832976b42186b698da71d627ee1724c2b1da2457","schema_version":"openadapt.qualification-admission/v4","signer_registry_sha256":"sha256:e243a23243b24986ed08812e284a1bd8c4993814149f02bcba79cc520e10ca14","verdict":"accepted","workflow_id_sha256":"sha256:7176583f6120b7ff016363644afc47e835b2e4b438abe4050df160570f780af1","workflow_version_id_sha256":"sha256:4acf27da1f384b7967a1bb4fb463570657894cb83468e5763940d69ab9df1386"} diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/qualification-authority-state-receipt-sigstore-bundle.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/qualification-authority-state-receipt-sigstore-bundle.json new file mode 100644 index 0000000..23e41d1 --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/qualification-authority-state-receipt-sigstore-bundle.json @@ -0,0 +1 @@ +{"dsseEnvelope":{"payload":"eyJhdXRob3JpdHlfc3RhdGVfc2hhMjU2Ijoic2hhMjU2OmRmNTA3OTE0MWRmNjg4NzdjNGIwNmYwNWI5ZmI5ZmRmMjc5MzA3Yjc2MjllYjFmMmRjZTEyZGVmNGJkNWUyZmEiLCJleHBpcmVzX2F0IjpudWxsLCJpc3N1ZWRfYXQiOiIyMDI2LTA5LTAyVDE4OjI0OjI1WiIsImtleV9pZCI6Im9hLXB1YmxpYy10cnVzdC1lZDI1NTE5LTljZjRiY2EyMTRjMDFkNzkiLCJub3RfYmVmb3JlIjoiMjAyNi0wOS0wMlQxODoyNDoyNVoiLCJvYmplY3Rfa2luZCI6InF1YWxpZmljYXRpb24tYXV0aG9yaXR5LXN0YXRlLXJlY2VpcHQiLCJvYmplY3RfbWVkaWFfdHlwZSI6ImFwcGxpY2F0aW9uL3ZuZC5vcGVuYWRhcHQucXVhbGlmaWNhdGlvbi1hdXRob3JpdHktc3RhdGUtcmVjZWlwdCtqc29uO3ZlcnNpb249MiIsIm9iamVjdF9zY2hlbWFfdmVyc2lvbiI6Im9wZW5hZGFwdC5xdWFsaWZpY2F0aW9uLWF1dGhvcml0eS1zdGF0ZS1yZWNlaXB0L3YyIiwib2JqZWN0X3NoYTI1NiI6InNoYTI1NjphMjJmOTgxNWVjMGY3YzU2Zjc2MjlhZWFiZmQyMWQxNGJjNmQ3MzllZmNmYjdmN2EwNzNjZTk5ODdlMTk0NzllIiwib2JqZWN0X3NpemVfYnl0ZXMiOjE1MjAsInJlcXVlc3RfaWRfc2hhMjU2Ijoic2hhMjU2OmI5ZDhiOWQ0ZTA3ZDc3M2MxMWFjNjA4ZTA1MGYyMzNiMTE2MzYzZWNkODQxMTA1MTYxY2I1Y2JmNzUwZmZjOGUiLCJyZXZvY2F0aW9uX3N0YXRlX3NoYTI1NiI6InNoYTI1NjoyNTBhYjQzMGU0NjdmNWU1ODRlYmQyYjE4MzI5NzZiNDIxODZiNjk4ZGE3MWQ2MjdlZTE3MjRjMmIxZGEyNDU3Iiwic2NoZW1hX3ZlcnNpb24iOiJvcGVuYWRhcHQucHJvZHVjdGlvbi1wdWJsaWMtdHJ1c3Qtc2lnbmluZy1zdGF0ZW1lbnQvdjEiLCJzZW1hbnRpY19pZGVudGl0eV9zaGEyNTYiOiJzaGEyNTY6ZGY1MDc5MTQxZGY2ODg3N2M0YjA2ZjA1YjlmYjlmZGYyNzkzMDdiNzYyOWViMWYyZGNlMTJkZWY0YmQ1ZTJmYSIsInNpZ25hdHVyZV9wcm9maWxlIjoic29mdHdhcmUtZWQyNTUxOS1kc3NlLXYxIiwic2lnbmVyX3JlZ2lzdHJ5X3NoYTI1NiI6InNoYTI1Njo3YTgxYmYzZDIxM2M3NDY3M2YzYzZiNWZhMTc5MjM0Y2JlZTUzNGM5NDMyYWFlYTZhZTA5ZTQ1NTU2MmY5NmI2Iiwic2lnbmluZ19hdXRob3JpdHkiOnsiZW52aXJvbm1lbnQiOiJzeW50aGV0aWMtcXVhbGlmaWNhdGlvbi1ldmlkZW5jZS1kZWNpc2lvbiIsImtleV9vcmlnaW4iOiJzb2Z0d2FyZSIsInJlZiI6InJlZnMvaGVhZHMvbWFpbiIsInJlcG9zaXRvcnkiOiJPcGVuQWRhcHRBSS8uZ2l0aHViIiwicmVwb3NpdG9yeV9pZCI6Ijg1ODQ1NDA2MiIsInJlcG9zaXRvcnlfb3duZXJfaWQiOiIxMzI2ODEyMTciLCJzb3VyY2VfY29tbWl0IjoiMmMxMjk3MDJkYTcxODUyMmNjMjU3OTEzMjA3YjZlZDZmM2IzM2I3YyIsIndvcmtmbG93IjoiLmdpdGh1Yi93b3JrZmxvd3Mvc2lnbi1wcm9kdWN0aW9uLWV2aWRlbmNlLXNvZnR3YXJlLnltbCJ9LCJzb3VyY2VfaXNzdWVyIjp7ImVudmlyb25tZW50IjoicXVhbGlmaWNhdGlvbi1hdXRob3JpdHktc3RhdGUiLCJyZWYiOiJyZWZzL2hlYWRzL21haW4iLCJyZXBvc2l0b3J5IjoiT3BlbkFkYXB0QUkvb3BlbmFkYXB0LW9wcyIsInJlcG9zaXRvcnlfaWQiOiIxMTcyMDExMjk0IiwicmVwb3NpdG9yeV9vd25lcl9pZCI6IjEzMjY4MTIxNyIsInNvdXJjZV9jb21taXQiOiJlMzIzMjQ5ZTNhN2MxYWY5ZDc2NTEzMTJlMGFmZTFmMTJjMzhjOTc3Iiwid29ya2Zsb3ciOiIuZ2l0aHViL3dvcmtmbG93cy9xdWFsaWZpY2F0aW9uLWF1dGhvcml0eS1zdGF0ZS55bWwifX0K","payloadType":"application/vnd.openadapt.production-public-trust-signing-statement+json;version=1","signatures":[{"keyid":"oa-public-trust-ed25519-9cf4bca214c01d79","sig":"wdmPoPKf3091kjDye9E9XCnfgqlljw8M+CEW2Vr0/hC5i85AWrpMfxPOB8Ui0KvTbF70QqLgFbgLqgdwWIPaDQ=="}]},"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"publicKey":{"hint":"oa-public-trust-ed25519-9cf4bca214c01d79"}}} diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/qualification-authority-state-receipt.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/qualification-authority-state-receipt.json new file mode 100644 index 0000000..c47be2a --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/qualification-authority-state-receipt.json @@ -0,0 +1 @@ +{"algorithm":"ed25519","authority_state_sha256":"sha256:df5079141df68877c4b06f05b9fb9fdf279307b7629eb1f2dce12def4bd5e2fa","evidence_authority_sha256":"sha256:1aa7cfcb5f3df6b99372a28c305177e046487c8ec5b61111edbf1a12d3e76663","expires_at":null,"issuer":{"environment":"qualification-authority-state","ref":"refs/heads/main","repository":"OpenAdaptAI/openadapt-ops","repository_id":"1172011294","repository_owner_id":"132681217","source_commit":"e323249e3a7c1af9d7651312e0afe1f12c38c977","workflow":".github/workflows/qualification-authority-state.yml"},"issuer_key_id":"qa-ed25519-9cf4bca214c01d79","not_before":"2026-09-02T18:24:25Z","observed_at":"2026-09-02T18:24:25Z","schema_version":"openadapt.qualification-authority-state-receipt/v2","signature":"BUa1NvZFvbPv7pari55YjS6C7p6U68c2Jjrh0vt9u+ZFky8Y6w/9p+55MggWJP8zwghMIT+HM1YlqH5++ciOBQ==","signer_registry_identity_sha256":"sha256:e243a23243b24986ed08812e284a1bd8c4993814149f02bcba79cc520e10ca14","signer_registry_revision":1,"signer_registry_sha256":"sha256:7a81bf3d213c74673f3c6b5fa179234cbee534c9432aaea6ae09e455562f96b6","signing_statement":{"commitment_scheme":"sha256-canonical-json-lf","object_schema_version":"openadapt.qualification-authority-state-receipt/v2","schema_version":"openadapt.qualification-evidence-signing-statement/v1","signature_domain":"OpenAdapt qualification authority state receipt v2\u0000","unsigned_object_sha256":"sha256:be362f1c032e0f0ee8f8ad378efe7b84fb55ea5e9260977a2b9fc2e41dda9b17","unsigned_size_bytes":995},"status":"active"} diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/qualification-evidence-decision-receipt-sigstore-bundle.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/qualification-evidence-decision-receipt-sigstore-bundle.json new file mode 100644 index 0000000..e2c3cb9 --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/qualification-evidence-decision-receipt-sigstore-bundle.json @@ -0,0 +1 @@ +{"dsseEnvelope":{"payload":"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","payloadType":"application/vnd.openadapt.production-public-trust-signing-statement+json;version=1","signatures":[{"keyid":"oa-public-trust-ed25519-9cf4bca214c01d79","sig":"4B2FfdCfIUwpIx+kd+GF2o5bkACWBWS55g/RHZO0sMl9tMdNhziiYEPI6HySlg1O18wsu1s9KlfkPaf1lnmuAA=="}]},"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"publicKey":{"hint":"oa-public-trust-ed25519-9cf4bca214c01d79"}}} diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/qualification-evidence-decision-receipt.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/qualification-evidence-decision-receipt.json new file mode 100644 index 0000000..b26db2f --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/qualification-evidence-decision-receipt.json @@ -0,0 +1 @@ +{"action_contract_sha256":"sha256:d4b8a931c16bca24cd343c786f41566357d9edcc8b0b97d3c1cb9907571dd56b","admitted_runtime_sha256":"sha256:56d32818989cb3a92830080ead39e10b08718c55e00988117f22cbfeaac98854","algorithm":"ed25519","application_contract_sha256":"sha256:e8f70b24976d2befeaea5e54059e39b1934a211c49cba65ac41e6cfdfd70ec80","bundle_sha256":"sha256:33f8c637f3d5d9eb23b92e0fb7ba74d2713a52f7c8ed11495b30f8bbefb1f312","bundle_version":"0.0.0-synthetic","campaign_artifact_sha256":"sha256:e2f2aa6b30118864682892a08e7e151039a34e7e7f84ff027e253cf8daddff78","campaign_permit_sha256":"sha256:da4af1f21aa121a00f92d88fc129d47bbd1a027462408e6bf2adf8fe66fe4255","campaign_summary":{"classes":{"declared_attended":{"approved_repair_count":0,"authenticated_bound_decision_count":3,"blind_retry_count":0,"live_target_revalidation_count":3,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"governed_repair":{"approved_repair_count":3,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":3,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":3,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":3,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"healthy":{"approved_repair_count":0,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":0,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"idempotency_replay":{"approved_repair_count":0,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":0,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"safe_halt":{"approved_repair_count":0,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":0,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":0,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0},"uncertain_delivery":{"approved_repair_count":0,"authenticated_bound_decision_count":0,"blind_retry_count":0,"live_target_revalidation_count":0,"minimum_trials_per_cell":3,"model_call_count":0,"observed_trial_count":3,"over_halt_count":0,"policy_approved_repair_count":0,"reconciliation_required_count":3,"replay_dispatch_count":0,"retained_repair_evidence_count":0,"silent_incorrect_success_count":0,"task_condition_cell_count":1,"unplanned_intervention_count":0,"unsafe_effect_count":0,"unverified_direct_action_count":0}},"minimum_trials_per_task_condition":3,"schema_version":"openadapt.qualification-evidence-decision-campaign-summary/v1","task_count":1},"decision_commitment_sha256":"sha256:e0491959b45066087d85ff35d32c6430b2f8d54f3f23750e01ac8cb7d48248f4","decision_identity_sha256":"sha256:26306ae89024e3be08e8151ef3be5c568d5f7b8b9afc7f11ad89af44a9260d36","decision_revision":1,"effect_contract_sha256":"sha256:ce11f9ac1059d29c5648a662ce8a4e8528ea3e8d844657aec8422d8b125a0698","entity_class":"record","environment_contract_sha256":"sha256:b01e155a3704b1f781937585da7f86c47adb8c86d48f032019ef41d6e9ceea57","evidence_authority_contract_sha256":"sha256:1aa7cfcb5f3df6b99372a28c305177e046487c8ec5b61111edbf1a12d3e76663","evidence_class":"remote-safe-synthetic","evidence_manifest_readback_sha256":"sha256:b0e022dba06f368a25c2f5e9a7dfbe92aece9125cb791c349b6981d056b8bf19","evidence_manifest_sha256":"sha256:3edc7613e1decd5714c8011854fb27d5d431bb085f5e47d6243926285d502bee","expires_at":null,"identity_contract_sha256":"sha256:34b008dd040d718fdc4d7b85b9311749b9865f47b4ba43bf6cd4a140bcf36c65","input_contract_sha256":"sha256:a82ba67af90f81e9a09f2db445a57f812b40a04c876396f191eb77eb53487a0f","issued_at":"2026-09-02T18:24:25Z","issuer":{"environment":"synthetic-qualification-evidence-decision","ref":"refs/heads/main","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","workflow":".github/workflows/issue-synthetic-qualification-evidence-decision.yml"},"issuer_key_id":"qa-ed25519-9cf4bca214c01d79","not_before":"2026-09-02T18:24:25Z","organization_id_sha256":"sha256:fcba879d867709da525f7f994a2642bc7a32014e324523a9d276bec54c3d296b","policy_contract_sha256":"sha256:482e3c7f10d044086283ea387f22b21c011e6c00cfc7fbf14cf82cfe2aedd1e0","revocation_state_sha256":"sha256:250ab430e467f5e584ebd2b1832976b42186b698da71d627ee1724c2b1da2457","schema_version":"openadapt.qualification-evidence-decision-receipt/v2","signature":"NywjiVqbWZ224vhvR0vM8eZGWFAo1tBGYxn91U9Jr0OuOJlQVIZAU2jfexgTbURXZnQzemFwbcFSPjUg4VMmBA==","signer_registry_sha256":"sha256:e243a23243b24986ed08812e284a1bd8c4993814149f02bcba79cc520e10ca14","signing_statement":{"commitment_scheme":"sha256-canonical-json-lf","object_schema_version":"openadapt.qualification-evidence-decision-receipt/v2","schema_version":"openadapt.qualification-evidence-signing-statement/v1","signature_domain":"OpenAdapt qualification evidence decision receipt v2\u0000","unsigned_object_sha256":"sha256:8e39eb6f36c984acaf947a032dcbeae718a704527a61ec5446c00958c4b3e2f5","unsigned_size_bytes":6106},"verdict":"ADMIT","workflow_id_sha256":"sha256:7176583f6120b7ff016363644afc47e835b2e4b438abe4050df160570f780af1","workflow_version_id_sha256":"sha256:4acf27da1f384b7967a1bb4fb463570657894cb83468e5763940d69ab9df1386"} diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/qualification-release-sigstore-bundle.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/qualification-release-sigstore-bundle.json new file mode 100644 index 0000000..cd9f721 --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/qualification-release-sigstore-bundle.json @@ -0,0 +1 @@ +{"dsseEnvelope":{"payload":"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","payloadType":"application/vnd.openadapt.production-public-trust-signing-statement+json;version=1","signatures":[{"keyid":"oa-public-trust-ed25519-9cf4bca214c01d79","sig":"j2UY7M6WWlAZmDcG7//GsS3FfwP8qAsG2Nr471CUzvoS6gIoiGK1d7Htptyf8IXdc4ypTChSJx96N+Hy0GKrAA=="}]},"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"publicKey":{"hint":"oa-public-trust-ed25519-9cf4bca214c01d79"}}} diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/qualification-release.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/qualification-release.json new file mode 100644 index 0000000..7c1e990 --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/qualification-release.json @@ -0,0 +1 @@ +{"admission_id_sha256":"sha256:d2983b86d5428c892421b191f6943a63cf4f9a0b1629e324d099f5df6fa5dcda","artifact_inventory_sha256":"sha256:ec3ef7c177c493bebee3da60f170b37793832e81066e9d9ee785d5fa225a5ac5","authority_state_sha256":"sha256:df5079141df68877c4b06f05b9fb9fdf279307b7629eb1f2dce12def4bd5e2fa","claim_scope":"production_flow","evidence_class":"remote-safe-synthetic","expires_at":null,"issued_at":"2026-09-02T18:24:25Z","issuer":{"environment":"production-release-admission","ref":"refs/heads/main","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","workflow":".github/workflows/issue-production-release-admission.yml"},"not_before":"2026-09-02T18:24:25Z","production_acceptance_summary_bundle_reference":{"kind":"production-acceptance-summary-sigstore-bundle","object_media_type":"application/vnd.dev.sigstore.bundle.v0.3+json","object_path":"production-evidence/objects/sha256/e9/e9ecdee1fc3458906fc91f5760d215bb5bec3591a6ed9ae0b412114e24fcf8fb.production-acceptance-summary-sigstore-bundle.json","object_schema_version":"application/vnd.dev.sigstore.bundle.v0.3+json","object_sha256":"sha256:e9ecdee1fc3458906fc91f5760d215bb5bec3591a6ed9ae0b412114e24fcf8fb","registry_entry_sha256":"sha256:7dc2fcab09f705356a22b058b9e7f078596bcdefdb697bef7315510d17931549","registry_head_sha256":"sha256:9a9f597b0d87674c4d36c022227201a5d8f3072237624346793692c3a863d12e","registry_revision":1,"registry_source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","schema_version":"openadapt.production-evidence-object-reference/v2","semantic_identity_sha256":"sha256:1b5606b9f4c14edd37ec134a9c716a070832b8709e3c2f9c6f4186ff514b7c82","size_bytes":2789,"subject_sha256":"sha256:3849fd4e2cae0d3a74964362e4850870bb68c23007d5eb818800159d3eb730d4"},"production_acceptance_summary_reference":{"kind":"production-acceptance-summary","object_media_type":"application/vnd.openadapt.production-lifecycle-evidence-summary+json;version=3","object_path":"production-evidence/objects/sha256/38/3849fd4e2cae0d3a74964362e4850870bb68c23007d5eb818800159d3eb730d4.production-acceptance-summary.json","object_schema_version":"openadapt.production-lifecycle-evidence-summary/v3","object_sha256":"sha256:3849fd4e2cae0d3a74964362e4850870bb68c23007d5eb818800159d3eb730d4","registry_entry_sha256":"sha256:932511112a7eb5f296b752953ac184516a47f7630643ecf70955af722e78ef68","registry_head_sha256":"sha256:9a9f597b0d87674c4d36c022227201a5d8f3072237624346793692c3a863d12e","registry_revision":1,"registry_source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","schema_version":"openadapt.production-evidence-object-reference/v2","semantic_identity_sha256":"sha256:cf65d1d351869c63e88d7188d1e78727994cc3f6e76c88f5643a61d168a84445","size_bytes":14497,"subject_sha256":null},"publication_policy_sha256":"sha256:ed5ab69fe8127604ca674263cbc8c774b7cfd10754e90bfaa9b71ba573bce1d1","publication_staging":{"assets":[{"asset_id":"534029483","kind":"python-wheel","media_type":"application/zip","name":"openadapt_flow-1.34.0-py3-none-any.whl","publish_destinations":["github-release","pypi"],"sha256":"sha256:56d32818989cb3a92830080ead39e10b08718c55e00988117f22cbfeaac98854","size_bytes":1928194,"uploader_id":"321543906","uploader_login":"openadapt-release[bot]"},{"asset_id":"534029484","kind":"python-sdist","media_type":"application/gzip","name":"openadapt_flow-1.34.0.tar.gz","publish_destinations":["github-release","pypi"],"sha256":"sha256:a941a70015fe91897e655bfc9bf83e6cf8fbcf8bd4e4c7206ffb133c505203f8","size_bytes":20440838,"uploader_id":"321543906","uploader_login":"openadapt-release[bot]"}],"draft":false,"draft_release_id":"378603192","immutable_releases":{"enabled":true,"enforced_by_owner":false},"immutable_releases_sha256":"sha256:07649aafb167237fecc138f5e93b48ddce5a69f4060da7130e3c78e59fd48581","observed_at":"2026-09-02T18:24:25Z","prerelease":false,"publication_mode":"already-published-pypi","pypi_files":[{"filename":"openadapt_flow-1.34.0-py3-none-any.whl","packagetype":"bdist_wheel","sha256":"sha256:56d32818989cb3a92830080ead39e10b08718c55e00988117f22cbfeaac98854","size_bytes":1928194,"yanked":false},{"filename":"openadapt_flow-1.34.0.tar.gz","packagetype":"sdist","sha256":"sha256:a941a70015fe91897e655bfc9bf83e6cf8fbcf8bd4e4c7206ffb133c505203f8","size_bytes":20440838,"yanked":false}],"release_app_bot_user_id":"321543906","release_app_id":"4730708","release_app_installation_id":"156835568","release_author_login":"openadapt-release[bot]","repository":"OpenAdaptAI/openadapt-flow","repository_id":"1291376938","schema_version":"openadapt.production-release-staging-evidence/v1","tag":"v1.34.0","tag_ref_state":{"exists":true,"ref":"refs/tags/v1.34.0"},"tag_ref_state_sha256":"sha256:74c5665395ed98ba3fd1b3a284bab1e8089f7c79cfafb3f88548e8b1456c5782","tag_rulesets":[{"bypass_actors":[{"actor_id":"4730708","actor_type":"Integration","bypass_mode":"always"}],"conditions":{"ref_name":{"exclude":[],"include":["refs/tags/v*"]}},"enforcement":"active","name":"OpenAdapt policy: release tag creation","repository":"OpenAdaptAI/openadapt-flow","repository_id":"1291376938","role":"creation_authority","rules":[{"type":"creation"}],"ruleset_id":"10","schema_version":"openadapt.production-release-tag-ruleset/v1","target":"tag"},{"bypass_actors":[],"conditions":{"ref_name":{"exclude":[],"include":["refs/tags/v*"]}},"enforcement":"active","name":"OpenAdapt policy: immutable release tags","repository":"OpenAdaptAI/openadapt-flow","repository_id":"1291376938","role":"immutability","rules":[{"type":"deletion"},{"type":"non_fast_forward"},{"parameters":{"update_allows_fetch_and_merge":false},"type":"update"}],"ruleset_id":"11","schema_version":"openadapt.production-release-tag-ruleset/v1","target":"tag"}],"tag_rulesets_sha256":"sha256:b0fdf160d80ae7dc8ffd979b2ba101cee6b3e7cf139e8c5d32b5534cbc0f7f44","target_commitish":"30fc60e55778a0e0f92b9776117cafcfe2512249"},"publication_staging_sha256":"sha256:861175c196cfe9455ce5f0536b6b1eabf55a990ced03349b865643f52316dedd","release":{"artifacts":[{"kind":"python-sdist","media_type":"application/gzip","name":"openadapt_flow-1.34.0.tar.gz","publish_destinations":["github-release","pypi"],"sha256":"sha256:a941a70015fe91897e655bfc9bf83e6cf8fbcf8bd4e4c7206ffb133c505203f8","size_bytes":20440838},{"kind":"python-wheel","media_type":"application/zip","name":"openadapt_flow-1.34.0-py3-none-any.whl","publish_destinations":["github-release","pypi"],"sha256":"sha256:56d32818989cb3a92830080ead39e10b08718c55e00988117f22cbfeaac98854","size_bytes":1928194}],"deployment_id":null,"deployment_sha256":null,"kind":"package","schema_version":"openadapt.production-release-candidate/v1","source_commit":"30fc60e55778a0e0f92b9776117cafcfe2512249","source_repository":"OpenAdaptAI/openadapt-flow","source_repository_id":"1291376938","tag":"v1.34.0","version":"1.34.0"},"release_identity":{"channel":"production","previous_admission_sha256":null,"schema_version":"openadapt.monotonic-production-release/v1","sequence":1},"release_sha256":"sha256:f84c03c857bda8372d39bc30afcc2986247778c34b3f93a39ec9de5dd151a289","revocation_state_sha256":"sha256:250ab430e467f5e584ebd2b1832976b42186b698da71d627ee1724c2b1da2457","schema_version":"openadapt.qualification-release/v2","signer_registry_sha256":"sha256:e243a23243b24986ed08812e284a1bd8c4993814149f02bcba79cc520e10ca14","target":"flow","verdict":"accepted"} diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/qualification-revocation-state-receipt-sigstore-bundle.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/qualification-revocation-state-receipt-sigstore-bundle.json new file mode 100644 index 0000000..3d39da8 --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/qualification-revocation-state-receipt-sigstore-bundle.json @@ -0,0 +1 @@ +{"dsseEnvelope":{"payload":"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","payloadType":"application/vnd.openadapt.production-public-trust-signing-statement+json;version=1","signatures":[{"keyid":"oa-public-trust-ed25519-9cf4bca214c01d79","sig":"6H/dlDXrZ0r2kihJrm8OKF7UriiNbloFiofPmckxWdhvRtXo4bttnEtqK2Fr7i7rCQ2+22RmvRbtd8Idx17bCg=="}]},"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"publicKey":{"hint":"oa-public-trust-ed25519-9cf4bca214c01d79"}}} diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/qualification-revocation-state-receipt.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/qualification-revocation-state-receipt.json new file mode 100644 index 0000000..fdc3e22 --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/qualification-revocation-state-receipt.json @@ -0,0 +1 @@ +{"algorithm":"ed25519","authority_state_sha256":"sha256:df5079141df68877c4b06f05b9fb9fdf279307b7629eb1f2dce12def4bd5e2fa","expires_at":null,"issuer":{"environment":"qualification-revocation-state","ref":"refs/heads/main","repository":"OpenAdaptAI/openadapt-ops","repository_id":"1172011294","repository_owner_id":"132681217","source_commit":"e323249e3a7c1af9d7651312e0afe1f12c38c977","workflow":".github/workflows/qualification-revocation-state.yml"},"issuer_key_id":"qa-ed25519-9cf4bca214c01d79","not_before":"2026-09-02T18:24:25Z","observed_at":"2026-09-02T18:24:25Z","previous_revocation_state_sha256":null,"revision":1,"revocation_state_sha256":"sha256:250ab430e467f5e584ebd2b1832976b42186b698da71d627ee1724c2b1da2457","revocations":[],"schema_version":"openadapt.qualification-revocation-state-receipt/v1","signature":"6/az5KZHqcV7weLNpPR11DnJR3f7Wfj5JgqcFddGoET+x+Q42rWH7zkgdDVJqvP+XxN09f1fHBmvkWlDvqlBBQ==","signer_registry_sha256":"sha256:e243a23243b24986ed08812e284a1bd8c4993814149f02bcba79cc520e10ca14","signing_statement":{"commitment_scheme":"sha256-canonical-json-lf","object_schema_version":"openadapt.qualification-revocation-state-receipt/v1","schema_version":"openadapt.qualification-evidence-signing-statement/v1","signature_domain":"OpenAdapt qualification revocation state receipt v1\u0000","unsigned_object_sha256":"sha256:f7e15c3c660e2793c8c0c4f6beafef140ee71b2a407d971d2e6af0578b2fd6d6","unsigned_size_bytes":930},"status":"current"} diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/release-issue-request.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/release-issue-request.json new file mode 100644 index 0000000..36712b9 --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/release-issue-request.json @@ -0,0 +1 @@ +{"evidence_class":"remote-safe-synthetic","production_acceptance_summary_reference":{"kind":"production-acceptance-summary","object_media_type":"application/vnd.openadapt.production-lifecycle-evidence-summary+json;version=3","object_path":"production-evidence/objects/sha256/38/3849fd4e2cae0d3a74964362e4850870bb68c23007d5eb818800159d3eb730d4.production-acceptance-summary.json","object_schema_version":"openadapt.production-lifecycle-evidence-summary/v3","object_sha256":"sha256:3849fd4e2cae0d3a74964362e4850870bb68c23007d5eb818800159d3eb730d4","registry_entry_sha256":"sha256:932511112a7eb5f296b752953ac184516a47f7630643ecf70955af722e78ef68","registry_head_sha256":"sha256:9a9f597b0d87674c4d36c022227201a5d8f3072237624346793692c3a863d12e","registry_revision":1,"registry_source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","schema_version":"openadapt.production-evidence-object-reference/v2","semantic_identity_sha256":"sha256:cf65d1d351869c63e88d7188d1e78727994cc3f6e76c88f5643a61d168a84445","size_bytes":14497,"subject_sha256":null},"request_handle":"qair_A-aMXGcPZkNKE7CbnMEIDSofWrO0wAKZDMIz_QhpWHN","schema_version":"openadapt.qualification-release-issue-request/v1"} diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/signer-registry-candidate.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/signer-registry-candidate.json new file mode 100644 index 0000000..ee2c1f6 --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/signer-registry-candidate.json @@ -0,0 +1 @@ +{"activation_state":"not-installed","custody":["github-environment-secret","local-keychain-backup"],"interface_sha256":"sha256:dc90a5e7addd213f2fe5044beaa13e5e2eda143020ca8b59e3a5b0abf61192a8","proposed_registry":{"expires_at":null,"generated_at":"2026-09-02T18:24:25Z","revision":1,"schema_version":"openadapt.qualification-signer-registry/v2","signers":[{"algorithm":"ed25519","allowed_ref_prefixes":["refs/heads/main"],"allowed_usages":["qualification-authority-state-receipt","qualification-evidence-decision-receipt","qualification-revocation-state-receipt"],"allowed_workflows":["https://github.com/OpenAdaptAI/.github/.github/workflows/issue-synthetic-qualification-evidence-decision.yml@refs/heads/main","https://github.com/OpenAdaptAI/openadapt-ops/.github/workflows/qualification-authority-state.yml@refs/heads/main","https://github.com/OpenAdaptAI/openadapt-ops/.github/workflows/qualification-revocation-state.yml@refs/heads/main"],"key_id":"qa-ed25519-9cf4bca214c01d79","public_key":"vHPUDLG2WD2BnTLaKYnZd9GxvUKfjpd68gJ9HubIEH8","public_key_sha256":"sha256:465646ab5137f05dfba094fb05fc10e3af74a0c2e2d0fcc20814b8f1f8271170","public_key_spki_der_base64":"MCowBQYDK2VwAyEAvHPUDLG2WD2BnTLaKYnZd9GxvUKfjpd68gJ9HubIEH8=","revoked_at":null,"statement_schema_versions":["openadapt.qualification-evidence-signing-statement/v1"],"status":"active"},{"algorithm":"ed25519","allowed_environments":["synthetic-qualification-evidence-decision"],"allowed_kinds":["production-acceptance-manifest","production-acceptance-summary","production-cloud-deploy-authorization","production-cloud-deployment-result","production-current-default","production-deployment-observation","production-lifecycle-checkpoint","qualification-admission","qualification-authority-state-receipt","qualification-campaign-permit","qualification-campaign-permit-policy","qualification-campaign-permit-receipt","qualification-campaign-permit-request","qualification-evidence-decision-receipt","qualification-release","qualification-revocation-state-receipt","support-release-admission"],"allowed_ref_prefixes":["refs/heads/main"],"allowed_usages":["production-public-evidence"],"allowed_workflows":["https://github.com/OpenAdaptAI/.github/.github/workflows/sign-production-evidence-software.yml@refs/heads/main"],"key_id":"oa-public-trust-ed25519-9cf4bca214c01d79","key_origin":"software","public_key":"vHPUDLG2WD2BnTLaKYnZd9GxvUKfjpd68gJ9HubIEH8","public_key_sha256":"sha256:465646ab5137f05dfba094fb05fc10e3af74a0c2e2d0fcc20814b8f1f8271170","public_key_spki_der_base64":"MCowBQYDK2VwAyEAvHPUDLG2WD2BnTLaKYnZd9GxvUKfjpd68gJ9HubIEH8=","revoked_at":null,"signature_encoding":"raw-64-base64-rfc4648-padded","statement_schema_versions":["openadapt.production-public-trust-signing-statement/v1"],"status":"active"}]},"schema_version":"openadapt.qualification-signer-registry-candidate/v1"} diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/signer-registry-local-candidate.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/signer-registry-local-candidate.json new file mode 100644 index 0000000..a90845e --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/signer-registry-local-candidate.json @@ -0,0 +1 @@ +{"activation_state":"not-installed","clock":"unset","custody":["github-environment-secret","local-keychain-backup"],"interface_sha256":"sha256:dc90a5e7addd213f2fe5044beaa13e5e2eda143020ca8b59e3a5b0abf61192a8","public_trust_signer":{"algorithm":"ed25519","allowed_environments":["synthetic-qualification-evidence-decision"],"allowed_kinds":["production-acceptance-manifest","production-acceptance-summary","production-cloud-deploy-authorization","production-cloud-deployment-result","production-current-default","production-deployment-observation","production-lifecycle-checkpoint","qualification-admission","qualification-authority-state-receipt","qualification-campaign-permit","qualification-campaign-permit-policy","qualification-campaign-permit-receipt","qualification-campaign-permit-request","qualification-evidence-decision-receipt","qualification-release","qualification-revocation-state-receipt","support-release-admission"],"allowed_ref_prefixes":["refs/heads/main"],"allowed_usages":["production-public-evidence"],"allowed_workflows":["https://github.com/OpenAdaptAI/.github/.github/workflows/sign-production-evidence-software.yml@refs/heads/main"],"key_id":"oa-public-trust-ed25519-9cf4bca214c01d79","key_origin":"software","public_key":"vHPUDLG2WD2BnTLaKYnZd9GxvUKfjpd68gJ9HubIEH8","public_key_sha256":"sha256:465646ab5137f05dfba094fb05fc10e3af74a0c2e2d0fcc20814b8f1f8271170","public_key_spki_der_base64":"MCowBQYDK2VwAyEAvHPUDLG2WD2BnTLaKYnZd9GxvUKfjpd68gJ9HubIEH8=","revoked_at":null,"signature_encoding":"raw-64-base64-rfc4648-padded","statement_schema_versions":["openadapt.production-public-trust-signing-statement/v1"],"status":"active"},"qualification_signer":{"algorithm":"ed25519","allowed_ref_prefixes":["refs/heads/main"],"allowed_usages":["qualification-evidence-decision-receipt"],"allowed_workflows":["https://github.com/OpenAdaptAI/.github/.github/workflows/issue-synthetic-qualification-evidence-decision.yml@refs/heads/main"],"key_id":"qa-ed25519-9cf4bca214c01d79","public_key":"vHPUDLG2WD2BnTLaKYnZd9GxvUKfjpd68gJ9HubIEH8","public_key_sha256":"sha256:465646ab5137f05dfba094fb05fc10e3af74a0c2e2d0fcc20814b8f1f8271170","public_key_spki_der_base64":"MCowBQYDK2VwAyEAvHPUDLG2WD2BnTLaKYnZd9GxvUKfjpd68gJ9HubIEH8=","revoked_at":null,"statement_schema_versions":["openadapt.qualification-evidence-signing-statement/v1"],"status":"active"},"revision":1,"schema_version":"openadapt.qualification-signer-registry-local-candidate/v1","signature":"QKJ9/iHdfBRqbflCgIa6s84lMbyBO+mtP9AUus9c9jjO+G0+R/xi/nzOHZVqGf9VXWHLIZ61gmF9yj6uDwS6Bw==","signature_key_id":"qa-ed25519-9cf4bca214c01d79"} diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/signer-registry.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/signer-registry.json new file mode 100644 index 0000000..72a5ba1 --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/signer-registry.json @@ -0,0 +1 @@ +{"expires_at":null,"generated_at":"2026-09-02T18:24:25Z","revision":1,"schema_version":"openadapt.qualification-signer-registry/v2","signers":[{"algorithm":"ed25519","allowed_ref_prefixes":["refs/heads/main"],"allowed_usages":["qualification-authority-state-receipt","qualification-evidence-decision-receipt","qualification-revocation-state-receipt"],"allowed_workflows":["https://github.com/OpenAdaptAI/.github/.github/workflows/issue-synthetic-qualification-evidence-decision.yml@refs/heads/main","https://github.com/OpenAdaptAI/openadapt-ops/.github/workflows/qualification-authority-state.yml@refs/heads/main","https://github.com/OpenAdaptAI/openadapt-ops/.github/workflows/qualification-revocation-state.yml@refs/heads/main"],"key_id":"qa-ed25519-9cf4bca214c01d79","public_key":"vHPUDLG2WD2BnTLaKYnZd9GxvUKfjpd68gJ9HubIEH8","public_key_sha256":"sha256:465646ab5137f05dfba094fb05fc10e3af74a0c2e2d0fcc20814b8f1f8271170","public_key_spki_der_base64":"MCowBQYDK2VwAyEAvHPUDLG2WD2BnTLaKYnZd9GxvUKfjpd68gJ9HubIEH8=","revoked_at":null,"statement_schema_versions":["openadapt.qualification-evidence-signing-statement/v1"],"status":"active"},{"algorithm":"ed25519","allowed_environments":["synthetic-qualification-evidence-decision"],"allowed_kinds":["production-acceptance-manifest","production-acceptance-summary","production-cloud-deploy-authorization","production-cloud-deployment-result","production-current-default","production-deployment-observation","production-lifecycle-checkpoint","qualification-admission","qualification-authority-state-receipt","qualification-campaign-permit","qualification-campaign-permit-policy","qualification-campaign-permit-receipt","qualification-campaign-permit-request","qualification-evidence-decision-receipt","qualification-release","qualification-revocation-state-receipt","support-release-admission"],"allowed_ref_prefixes":["refs/heads/main"],"allowed_usages":["production-public-evidence"],"allowed_workflows":["https://github.com/OpenAdaptAI/.github/.github/workflows/sign-production-evidence-software.yml@refs/heads/main"],"key_id":"oa-public-trust-ed25519-9cf4bca214c01d79","key_origin":"software","public_key":"vHPUDLG2WD2BnTLaKYnZd9GxvUKfjpd68gJ9HubIEH8","public_key_sha256":"sha256:465646ab5137f05dfba094fb05fc10e3af74a0c2e2d0fcc20814b8f1f8271170","public_key_spki_der_base64":"MCowBQYDK2VwAyEAvHPUDLG2WD2BnTLaKYnZd9GxvUKfjpd68gJ9HubIEH8=","revoked_at":null,"signature_encoding":"raw-64-base64-rfc4648-padded","statement_schema_versions":["openadapt.production-public-trust-signing-statement/v1"],"status":"active"}]} diff --git a/local-candidates/flow-1.34.0-remote-safe-synthetic/workflow-issue-request.json b/local-candidates/flow-1.34.0-remote-safe-synthetic/workflow-issue-request.json new file mode 100644 index 0000000..239cb85 --- /dev/null +++ b/local-candidates/flow-1.34.0-remote-safe-synthetic/workflow-issue-request.json @@ -0,0 +1 @@ +{"decision_receipt_reference":{"kind":"qualification-evidence-decision-receipt","object_media_type":"application/vnd.openadapt.qualification-evidence-decision-receipt+json;version=2","object_path":"production-evidence/objects/sha256/6f/6ffe691f8e40e06b73e24391d180424ed86bb289ddae001cf7b49de2e745312a.qualification-evidence-decision-receipt.json","object_schema_version":"openadapt.qualification-evidence-decision-receipt/v2","object_sha256":"sha256:6ffe691f8e40e06b73e24391d180424ed86bb289ddae001cf7b49de2e745312a","registry_entry_sha256":"sha256:63d0170fb957ebd167f2650ef744d70839d0676a8cf9f8978d73aed5cffd0b27","registry_head_sha256":"sha256:9a9f597b0d87674c4d36c022227201a5d8f3072237624346793692c3a863d12e","registry_revision":1,"registry_source_commit":"2c129702da718522cc257913207b6ed6f3b33b7c","repository":"OpenAdaptAI/.github","repository_id":"858454062","repository_owner_id":"132681217","schema_version":"openadapt.production-evidence-object-reference/v2","semantic_identity_sha256":"sha256:c18d69bdfb145139581ea6865f513179bd104cb02a64d838f93e49f96d9d3769","size_bytes":6636,"subject_sha256":null},"evidence_class":"remote-safe-synthetic","request_handle":"qair_RmVqt6OgAzt7MKwoxwOaebxcy0co-Xop9NqvT09wneO","schema_version":"openadapt.qualification-admission-issue-request/v1"}