palonexus 0.3.2__tar.gz → 0.3.3__tar.gz

{palonexus-0.3.2 → palonexus-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: palonexus
-Version: 0.3.2
+Version: 0.3.3
 Summary: Python SDK for the PaloNexus agent control plane
 Project-URL: Homepage, https://github.com/rogerchucker/palonexus-sdk
 Project-URL: Repository, https://github.com/rogerchucker/palonexus-sdk

palonexus-0.3.3/src/palonexus/_build.py

@@ -0,0 +1,2 @@
+# generated by the PaloNexus build hook
+SOURCE_REVISION = "0a3e3eacb5853a48f269e00991b4871d16ff3d9b"

{palonexus-0.3.2 → palonexus-0.3.3}/src/palonexus/_sdist_provenance.py

@@ -1,3 +1,3 @@
 # generated by the PaloNexus build hook
 SDIST_MARKER = "palonexus-sdk-sdist-v1"
-SOURCE_REVISION = "58e2607d1c2ed32be5a4fc7c9a334be66bd8e347"
+SOURCE_REVISION = "0a3e3eacb5853a48f269e00991b4871d16ff3d9b"

{palonexus-0.3.2 → palonexus-0.3.3}/src/palonexus/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.3.2'
-__version_tuple__ = version_tuple = (0, 3, 2)
+__version__ = version = '0.3.3'
+__version_tuple__ = version_tuple = (0, 3, 3)
 
 __commit_id__ = commit_id = None

{palonexus-0.3.2 → palonexus-0.3.3}/src/palonexus/cli/commands.py

@@ -36,6 +36,11 @@ from palonexus.developer.credentials import (
     CredentialStore,
     CredentialStoreUnavailable,
 )
+from palonexus.developer.evidence import (
+    build_preexchange_evidence,
+    build_runtime_attestation,
+    ensure_runtime_evidence_credential,
+)
 from palonexus.developer.runner import Runner
 from palonexus.developer.scaffold import (
     ScaffoldError,
@@ -1060,6 +1065,23 @@ def _strict_input(path: Path) -> tuple[dict[str, Any], str]:
     return value, hashlib.sha256(canonical_json(value)).hexdigest()
 
 
+def _require_runtime_evidence_expiry(value: object) -> str:
+    if not isinstance(value, str) or not value:
+        raise CommandError("runtime lease is missing its evidence expiry")
+    try:
+        expires = datetime.fromisoformat(value.replace("Z", "+00:00"))
+    except ValueError as error:
+        raise CommandError("runtime lease has an invalid evidence expiry") from error
+    if expires.tzinfo is None or expires <= datetime.now(UTC):
+        raise CommandError("runtime lease has an invalid evidence expiry")
+    return (
+        expires.astimezone(UTC)
+        .replace(microsecond=0)
+        .isoformat()
+        .replace("+00:00", "Z")
+    )
+
+
 def _strict_json_pairs(pairs: list[tuple[str, Any]]) -> dict[str, Any]:
     value: dict[str, Any] = {}
     for key, item in pairs:
@@ -1077,6 +1099,9 @@ def run_agent(args: Namespace) -> int:
     try:
         if guard is None:
             guard = generate_agent_credential()
+        evidence_guard = ensure_runtime_evidence_credential(guard)
+        if evidence_guard != guard:
+            guard = evidence_guard
             store.save("guard:" + str(descriptor["name"]), guard)
         artifact = "sha256:" + descriptor["descriptor_digest"]
         # Enrollment proofs are one-time. Each process start creates a fresh
@@ -1094,6 +1119,29 @@ def run_agent(args: Namespace) -> int:
             guard_version="pnxs/0.1.0",
         )
         runtime = client.redeem_runtime(session, agent, enrollment)
+        registration_profile = _project_registration_profile()
+        created_at = (
+            datetime.now(UTC).replace(microsecond=0).isoformat().replace("+00:00", "Z")
+        )
+        expires_at = _require_runtime_evidence_expiry(runtime.get("expires_at"))
+        attestation = build_runtime_attestation(
+            tenant_id=str(session["tenant_id"]),
+            agent_id=str(agent["agent_id"]),
+            runtime_id=str(runtime["runtime_id"]),
+            descriptor_digest=str(descriptor["descriptor_digest"]),
+            runtime_profile=registration_profile["runtime_profile"],
+            guard=guard,
+            created_at=created_at,
+            expires_at=expires_at,
+        )
+        client.submit_runtime_attestation(
+            session,
+            agent,
+            guard,
+            runtime,
+            attestation,
+            idempotency_key=str(uuid.uuid4()),
+        )
         run_key = str(uuid.uuid4())
         run = client.create_developer_run(
             session,
@@ -1104,6 +1152,7 @@ def run_agent(args: Namespace) -> int:
             idempotency_key=run_key,
         )
         persisted: dict[str, Any] = {}
+        preexchange_batch: dict[str, Any] = {}
         persisted_spawn: dict[str, Any] = {}
         spawn_runtime = (
             _subagent_runtime(
@@ -1184,6 +1233,34 @@ def run_agent(args: Namespace) -> int:
                     descriptor, envelope["action"], envelope["resource"]
                 )
                 try:
+                    if not preexchange_batch:
+                        occurred_at = (
+                            datetime.now(UTC)
+                            .replace(microsecond=0)
+                            .isoformat()
+                            .replace("+00:00", "Z")
+                        )
+                        preexchange_batch.update(
+                            build_preexchange_evidence(
+                                attestation=attestation,
+                                guard=guard,
+                                run_id=str(run["runId"]),
+                                root_action_id=str(run["rootId"]),
+                                action=str(envelope["action"]),
+                                resource=str(envelope["resource"]),
+                                payload=envelope["payload"],
+                                descriptor_digest=str(descriptor["descriptor_digest"]),
+                                occurred_at=occurred_at,
+                            )
+                        )
+                    client.submit_runtime_evidence(
+                        session,
+                        agent,
+                        guard,
+                        runtime,
+                        preexchange_batch,
+                        idempotency_key=str(preexchange_batch["idempotencyKey"]),
+                    )
                     action = client.create_developer_action(
                         session,
                         agent,

{palonexus-0.3.2 → palonexus-0.3.3}/src/palonexus/developer/client.py

@@ -1842,6 +1842,115 @@ class DeveloperClient:
             },
         )
 
+    def submit_runtime_attestation(
+        self,
+        session: dict[str, Any],
+        agent: dict[str, Any],
+        guard: dict[str, Any],
+        runtime: dict[str, Any],
+        attestation: dict[str, Any],
+        *,
+        idempotency_key: str,
+    ) -> dict[str, Any]:
+        path = "/v1/developer/runtime-attestations"
+        body = canonical_json(attestation)
+        proof = self.mounted_proof(
+            _decode_private_key(guard.get("private_key")),
+            mode="runtime_proof",
+            tenant_id=_require_string(session.get("tenant_id"), "tenant ID"),
+            agent_id=_require_string(agent.get("agent_id"), "agent ID"),
+            agent_generation=_require_positive_int(
+                int(agent.get("agent_generation", "0")), "agent generation"
+            ),
+            method="POST",
+            path=path,
+            body=body,
+            runtime_id=_require_string(runtime.get("runtime_id"), "runtime ID"),
+        )
+        response = self._request(
+            "POST",
+            path,
+            body=body,
+            headers={
+                "X-Palonexus-Developer-Proof": proof,
+                "Idempotency-Key": idempotency_key,
+            },
+            expected={200, 201},
+            allowed_fields={
+                "attestationId",
+                "runtimeSessionId",
+                "manifestHash",
+                "verificationState",
+                "duplicate",
+            },
+        )
+        if (
+            response.get("attestationId") != attestation.get("attestationId")
+            or response.get("runtimeSessionId") != runtime.get("runtime_id")
+            or response.get("manifestHash") != attestation.get("manifestHash")
+            or response.get("verificationState") != "verified"
+            or type(response.get("duplicate")) is not bool
+        ):
+            raise ProtocolError("runtime attestation acknowledgement is not bound")
+        return response
+
+    def submit_runtime_evidence(
+        self,
+        session: dict[str, Any],
+        agent: dict[str, Any],
+        guard: dict[str, Any],
+        runtime: dict[str, Any],
+        batch: dict[str, Any],
+        *,
+        idempotency_key: str,
+    ) -> dict[str, Any]:
+        path = "/v1/developer/runtime-evidence"
+        body = canonical_json(batch)
+        proof = self.mounted_proof(
+            _decode_private_key(guard.get("private_key")),
+            mode="runtime_proof",
+            tenant_id=_require_string(session.get("tenant_id"), "tenant ID"),
+            agent_id=_require_string(agent.get("agent_id"), "agent ID"),
+            agent_generation=_require_positive_int(
+                int(agent.get("agent_generation", "0")), "agent generation"
+            ),
+            method="POST",
+            path=path,
+            body=body,
+            runtime_id=_require_string(runtime.get("runtime_id"), "runtime ID"),
+        )
+        response = self._request(
+            "POST",
+            path,
+            body=body,
+            headers={
+                "X-Palonexus-Developer-Proof": proof,
+                "Idempotency-Key": idempotency_key,
+            },
+            expected={200, 201},
+            allowed_fields={
+                "batchId",
+                "receiptCount",
+                "finalReceiptHash",
+                "achievedLevel",
+                "deliveryState",
+                "duplicate",
+            },
+        )
+        receipts = batch.get("receipts")
+        if (
+            not isinstance(receipts, list)
+            or not receipts
+            or response.get("batchId") != batch.get("batchId")
+            or response.get("receiptCount") != len(receipts)
+            or response.get("finalReceiptHash") != receipts[-1].get("receiptHash")
+            or type(response.get("duplicate")) is not bool
+            or not isinstance(response.get("achievedLevel"), str)
+            or not isinstance(response.get("deliveryState"), str)
+        ):
+            raise ProtocolError("runtime evidence acknowledgement is not bound")
+        return response
+
     def create_developer_run(
         self,
         session: dict[str, Any],

palonexus-0.3.3/src/palonexus/developer/evidence.py

@@ -0,0 +1,422 @@
+# SPDX-License-Identifier: MIT
+"""Signed runtime assurance evidence for guarded developer runs."""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import json
+import re
+import secrets
+import uuid
+from typing import Any
+
+import rfc8785
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
+
+VERSION = "palonexus.harness.assurance/v1"
+_HEX_DIGEST = re.compile(r"^[0-9a-f]{64}$")
+_UTC_SECOND = re.compile(r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$")
+_LAYERS = (
+    ("identity.session", "harness-identity-session", "harness_adapter"),
+    ("run.ownership", "harness-run-ownership", "harness_adapter"),
+    ("tool.discovery", "pnxs-tool-discovery", "harness_adapter"),
+    ("tool.invocation", "pnxs-tool-invocation", "harness_adapter"),
+    ("mcp.access", "runtime-guard-mcp-access", "runtime_guard"),
+    ("policy.decision", "control-plane-authz", "control_plane"),
+    ("authority.delegation", "agent-idp-exact-delegation", "agent_idp_sts"),
+    ("credential.exchange", "agent-idp-sts-exchange", "agent_idp_sts"),
+    ("target.enforcement", "registered-target-verifier", "registered_target"),
+)
+
+
+def _canonical(value: Any) -> bytes:
+    try:
+        return rfc8785.dumps(value)
+    except (TypeError, ValueError) as error:
+        raise ValueError("runtime evidence is not canonical JSON") from error
+
+
+def _digest(value: Any) -> str:
+    return "sha256:" + hashlib.sha256(_canonical(value)).hexdigest()
+
+
+def _b64url(value: bytes) -> str:
+    return base64.urlsafe_b64encode(value).rstrip(b"=").decode("ascii")
+
+
+def _decode(value: object, *, field: str) -> bytes:
+    if not isinstance(value, str) or not value:
+        raise ValueError(f"invalid {field}")
+    try:
+        decoded = base64.urlsafe_b64decode(value + "=" * (-len(value) % 4))
+    except (ValueError, TypeError) as error:
+        raise ValueError(f"invalid {field}") from error
+    if len(decoded) != 32 or _b64url(decoded) != value:
+        raise ValueError(f"invalid {field}")
+    return decoded
+
+
+def _public_x(value: object, *, field: str) -> str:
+    if not isinstance(value, str):
+        raise ValueError(f"invalid {field}")
+    try:
+        parsed = json.loads(value)
+    except (json.JSONDecodeError, TypeError) as error:
+        raise ValueError(f"invalid {field}") from error
+    if not isinstance(parsed, dict) or set(parsed) != {"crv", "kty", "x"}:
+        raise ValueError(f"invalid {field}")
+    if parsed["crv"] != "Ed25519" or parsed["kty"] != "OKP":
+        raise ValueError(f"invalid {field}")
+    x = parsed["x"]
+    if not isinstance(x, str):
+        raise ValueError(f"invalid {field}")
+    _decode(x, field=field)
+    return x
+
+
+def _new_credential() -> dict[str, str]:
+    private = Ed25519PrivateKey.generate()
+    private_raw = private.private_bytes(
+        serialization.Encoding.Raw,
+        serialization.PrivateFormat.Raw,
+        serialization.NoEncryption(),
+    )
+    public_raw = private.public_key().public_bytes(
+        serialization.Encoding.Raw, serialization.PublicFormat.Raw
+    )
+    public = {"crv": "Ed25519", "kty": "OKP", "x": _b64url(public_raw)}
+    return {
+        "private_key": _b64url(private_raw),
+        "public_key_jwk": _canonical(public).decode("utf-8"),
+    }
+
+
+def ensure_runtime_evidence_credential(guard: dict[str, str]) -> dict[str, str]:
+    """Return a guard credential with a distinct harness-receipt signing key."""
+
+    value = dict(guard)
+    _decode(value.get("private_key"), field="guard private key")
+    _public_x(value.get("public_key_jwk"), field="guard public key")
+    private = value.get("harness_receipt_private_key")
+    public = value.get("harness_receipt_public_key_jwk")
+    if private is None and public is None:
+        receipt = _new_credential()
+        value["harness_receipt_private_key"] = receipt["private_key"]
+        value["harness_receipt_public_key_jwk"] = receipt["public_key_jwk"]
+    elif private is None or public is None:
+        raise ValueError("incomplete harness receipt credential")
+    _decode(value.get("harness_receipt_private_key"), field="receipt private key")
+    _public_x(value.get("harness_receipt_public_key_jwk"), field="receipt public key")
+    if value["public_key_jwk"] == value["harness_receipt_public_key_jwk"]:
+        raise ValueError("runtime guard and harness receipt keys must be distinct")
+    return value
+
+
+def _key_id(prefix: str, x: str) -> str:
+    return prefix + hashlib.sha256(x.encode("ascii")).hexdigest()[:32]
+
+
+def _jwk(x: str, key_id: str) -> dict[str, str]:
+    return {
+        "kty": "OKP",
+        "crv": "Ed25519",
+        "x": x,
+        "kid": key_id,
+        "use": "sig",
+        "alg": "EdDSA",
+    }
+
+
+def _binding(
+    *, x: str, key_id: str, signer_class: str, purpose: str, token: bool
+) -> dict[str, Any]:
+    return {
+        "keyId": key_id,
+        "algorithm": "Ed25519",
+        "publicKeyJwk": _jwk(x, key_id),
+        "signerClass": signer_class,
+        "purpose": purpose,
+        "grantsAuthority": False,
+        "tokenRequestPermitted": token,
+    }
+
+
+def _require_digest(value: object, field: str) -> str:
+    if not isinstance(value, str) or _HEX_DIGEST.fullmatch(value) is None:
+        raise ValueError(f"invalid {field}")
+    return value
+
+
+def _require_time(value: str, field: str) -> str:
+    if _UTC_SECOND.fullmatch(value) is None:
+        raise ValueError(f"invalid {field}")
+    return value
+
+
+def build_runtime_attestation(
+    *,
+    tenant_id: str,
+    agent_id: str,
+    runtime_id: str,
+    descriptor_digest: str,
+    runtime_profile: dict[str, Any],
+    guard: dict[str, str],
+    created_at: str,
+    expires_at: str,
+    evidence_id: str | None = None,
+    manifest_id: str | None = None,
+    freshness_nonce: str | None = None,
+) -> dict[str, Any]:
+    guard = ensure_runtime_evidence_credential(guard)
+    descriptor_digest = _require_digest(descriptor_digest, "descriptor digest")
+    profile_digest = _require_digest(
+        runtime_profile.get("digest"), "runtime profile digest"
+    )
+    profile_id = runtime_profile.get("id") or runtime_profile.get("kind")
+    if not all(
+        isinstance(item, str) and item
+        for item in (tenant_id, agent_id, runtime_id, profile_id)
+    ):
+        raise ValueError("incomplete runtime evidence identity")
+    if (
+        type(runtime_profile.get("version")) is not int
+        or runtime_profile["version"] < 1
+    ):
+        raise ValueError("invalid runtime profile version")
+    created_at = _require_time(created_at, "created time")
+    expires_at = _require_time(expires_at, "expiry time")
+    evidence_id = evidence_id or secrets.token_hex(32)
+    if _HEX_DIGEST.fullmatch(evidence_id) is None:
+        raise ValueError("invalid runtime evidence ID")
+    manifest_id = manifest_id or str(uuid.uuid4())
+    freshness_nonce = freshness_nonce or secrets.token_hex(16)
+    if not manifest_id or not freshness_nonce:
+        raise ValueError("invalid runtime evidence nonce")
+
+    guard_x = _public_x(guard["public_key_jwk"], field="guard public key")
+    receipt_x = _public_x(
+        guard["harness_receipt_public_key_jwk"], field="receipt public key"
+    )
+    guard_key_id = _key_id("pnxs-runtime-guard-", guard_x)
+    receipt_key_id = _key_id("pnxs-harness-receipt-", receipt_x)
+    required = [
+        {
+            "order": order,
+            "layerId": layer,
+            "adapterId": adapter,
+            "signerClass": signer,
+            "requiredWhen": "always",
+        }
+        for order, (layer, adapter, signer) in enumerate(_LAYERS, start=1)
+    ]
+    adapter_version = "1.0.0"
+    enforcement = [
+        {
+            "layerId": layer,
+            "adapterId": adapter,
+            "version": adapter_version,
+            "digest": _digest(
+                {
+                    "purpose": "palonexus.runtime-enforcement-adapter.v1",
+                    "descriptorDigest": descriptor_digest,
+                    "runtimeProfileDigest": profile_digest,
+                    "layerId": layer,
+                    "adapterId": adapter,
+                    "signerClass": signer,
+                }
+            ),
+            "signerClass": signer,
+        }
+        for layer, adapter, signer in _LAYERS
+    ]
+    framework = {
+        "layerId": "framework.lifecycle",
+        "adapterId": "pnxs-plain-python",
+        "version": adapter_version,
+        "digest": _digest(
+            {
+                "purpose": "palonexus.runtime-framework-adapter.v1",
+                "descriptorDigest": descriptor_digest,
+                "runtimeProfileDigest": profile_digest,
+            }
+        ),
+        "signerClass": "harness_adapter",
+    }
+    manifest = {
+        "version": VERSION,
+        "manifestId": manifest_id,
+        "tenantId": tenant_id,
+        "agentId": agent_id,
+        "profileId": profile_id,
+        "runtimeSessionId": runtime_id,
+        "harnessPackageDigest": "sha256:" + descriptor_digest,
+        # A plain-Python runtime has no container. The registered runtime-profile
+        # digest is the immutable runtime environment identity for this field.
+        "containerImageDigest": "sha256:" + profile_digest,
+        "frameworkAdapter": framework,
+        "enforcementAdapters": enforcement,
+        "requiredReceipts": required,
+        "requiredLayerManifestHash": _digest(required),
+        "harnessReceiptKey": _binding(
+            x=receipt_x,
+            key_id=receipt_key_id,
+            signer_class="harness_adapter",
+            purpose="evidence_receipt",
+            token=False,
+        ),
+        "guardWorkloadKey": _binding(
+            x=guard_x,
+            key_id=guard_key_id,
+            signer_class="runtime_guard",
+            purpose="workload_proof_and_evidence",
+            token=True,
+        ),
+        "proofConfirmationMethod": "ed25519-jwk-thumbprint",
+        "createdAt": created_at,
+        "expiresAt": expires_at,
+        "freshnessNonce": freshness_nonce,
+        "workloadIdentityEvidenceDigest": _digest(
+            {
+                "tenantId": tenant_id,
+                "agentId": agent_id,
+                "runtimeSessionId": runtime_id,
+                "guardPublicKeyJwk": _jwk(guard_x, guard_key_id),
+            }
+        ),
+    }
+    unsigned = {
+        "version": VERSION,
+        "attestationId": "runtime-guard:" + evidence_id,
+        "manifest": manifest,
+        "manifestHash": _digest(manifest),
+        "attestedAt": created_at,
+        "signerKeyId": guard_key_id,
+        "signatureAlgorithm": "Ed25519",
+    }
+    private = Ed25519PrivateKey.from_private_bytes(
+        _decode(guard["private_key"], field="guard private key")
+    )
+    return {**unsigned, "signature": _b64url(private.sign(_canonical(unsigned)))}
+
+
+def build_preexchange_evidence(
+    *,
+    attestation: dict[str, Any],
+    guard: dict[str, str],
+    run_id: str,
+    root_action_id: str,
+    action: str,
+    resource: str,
+    payload: dict[str, Any],
+    descriptor_digest: str,
+    occurred_at: str,
+    batch_id: str | None = None,
+    idempotency_key: str | None = None,
+) -> dict[str, Any]:
+    guard = ensure_runtime_evidence_credential(guard)
+    descriptor_digest = _require_digest(descriptor_digest, "descriptor digest")
+    occurred_at = _require_time(occurred_at, "receipt time")
+    if not all(
+        isinstance(item, str) and item
+        for item in (run_id, root_action_id, action, resource)
+    ):
+        raise ValueError("incomplete pre-exchange evidence context")
+    if not isinstance(payload, dict):
+        raise ValueError("invalid action payload")
+    manifest = attestation.get("manifest")
+    if not isinstance(manifest, dict) or attestation.get("manifestHash") != _digest(
+        manifest
+    ):
+        raise ValueError("invalid runtime attestation")
+    required = manifest.get("requiredReceipts")
+    if not isinstance(required, list) or [
+        (item.get("layerId"), item.get("adapterId"), item.get("signerClass"))
+        for item in required[:5]
+    ] != list(_LAYERS[:5]):
+        raise ValueError("runtime manifest does not carry the pre-exchange contract")
+
+    receipt_private = Ed25519PrivateKey.from_private_bytes(
+        _decode(guard["harness_receipt_private_key"], field="receipt private key")
+    )
+    guard_private = Ed25519PrivateKey.from_private_bytes(
+        _decode(guard["private_key"], field="guard private key")
+    )
+    base_context = {
+        "tenantId": manifest["tenantId"],
+        "agentId": manifest["agentId"],
+        "runtimeSessionId": manifest["runtimeSessionId"],
+        "runId": run_id,
+        "rootActionId": root_action_id,
+        "canonicalAction": action,
+        "resource": resource,
+        "payloadDigest": _digest(payload),
+        "descriptorDigest": descriptor_digest,
+    }
+    reasons = {
+        "identity.session": "runtime_identity_observed",
+        "run.ownership": "runtime_run_ownership_observed",
+        "tool.discovery": "declared_tool_discovered",
+        "tool.invocation": "guarded_tool_invocation_observed",
+        "mcp.access": "runtime_guard_mcp_access_observed",
+    }
+    receipts: list[dict[str, Any]] = []
+    prior: str | None = None
+    for sequence, (layer, adapter, signer_class) in enumerate(_LAYERS[:5], start=1):
+        binding_name = (
+            "guardWorkloadKey"
+            if signer_class == "runtime_guard"
+            else "harnessReceiptKey"
+        )
+        private = guard_private if signer_class == "runtime_guard" else receipt_private
+        unsigned = {
+            "version": VERSION,
+            "receiptId": str(uuid.uuid4()),
+            "tenantId": manifest["tenantId"],
+            "agentId": manifest["agentId"],
+            "runId": run_id,
+            "taskId": root_action_id,
+            "rootActionId": root_action_id,
+            "attestationId": attestation["attestationId"],
+            "manifestHash": attestation["manifestHash"],
+            "layerId": layer,
+            "adapterId": adapter,
+            "signerClass": signer_class,
+            "policyVersion": "pnxs-runtime-assurance/v1",
+            "catalogVersion": "1",
+            "decision": "not_applicable",
+            "priorReceiptHash": prior,
+            "inputDigest": _digest(
+                {**base_context, "layerId": layer, "phase": "input"}
+            ),
+            "outputDigest": _digest(
+                {**base_context, "layerId": layer, "outcome": "observed"}
+            ),
+            "outcome": "observed",
+            "reasonCode": reasons[layer],
+            "sequence": sequence,
+            "occurredAt": occurred_at,
+            "signerKeyId": manifest[binding_name]["keyId"],
+            "signatureAlgorithm": "Ed25519",
+        }
+        signed = {**unsigned, "signature": _b64url(private.sign(_canonical(unsigned)))}
+        receipt = {**signed, "receiptHash": _digest(signed)}
+        receipts.append(receipt)
+        prior = receipt["receiptHash"]
+    return {
+        "version": VERSION,
+        "batchId": batch_id or str(uuid.uuid4()),
+        "tenantId": manifest["tenantId"],
+        "submitterSignerClass": "runtime_guard",
+        "receipts": receipts,
+        "submittedAt": occurred_at,
+        "idempotencyKey": idempotency_key or str(uuid.uuid4()),
+    }
+
+
+__all__ = [
+    "build_preexchange_evidence",
+    "build_runtime_attestation",
+    "ensure_runtime_evidence_credential",
+]

palonexus-0.3.2/src/palonexus/_build.py

@@ -1,2 +0,0 @@
-# generated by the PaloNexus build hook
-SOURCE_REVISION = "58e2607d1c2ed32be5a4fc7c9a334be66bd8e347"