xoonya 2.1.0 → 2.3.0

package/examples/package_quickstart.js

@@ -0,0 +1,1007 @@
+"use strict";
+
+const assert = require("assert");
+const crypto = require("crypto");
+const proof = require("../index.js");
+
+function main() {
+  const proofCenter = proof.buildDefaultProofCenter();
+  assert.strictEqual(proofCenter.proof_model.event_version, "canonical-event-bundle/v1", "proof center event version missing");
+  assert.strictEqual(proofCenter.proof_model.receipt_version, "receipt/v1", "proof center receipt version missing");
+  const proofCenterSummary = proof.summarizeDefaultProofCenter();
+  assert.strictEqual(proofCenterSummary.proof_bundle_version, "proof-bundle/v1", "proof center summary bundle version missing");
+  assert.strictEqual(proofCenterSummary.helper_count >= 5, true, "proof center summary helper count missing");
+  const proofLoops = proof.buildDefaultProofLoopCatalog();
+  assert.strictEqual(proofLoops.loop_count >= 2, true, "proof loop catalog missing");
+  const proofLoopSummary = proof.summarizeDefaultProofLoops();
+  assert.strictEqual(proofLoopSummary.loop_refs.includes("default.proof.bundle.loop"), true, "proof loop summary missing");
+  const proofLoop = proof.getDefaultProofLoop("default.proof.bundle.loop");
+  assert.strictEqual(proofLoop.stage_count, 5, "proof loop stage count missing");
+  const transactionProofHandoffCenter = proof.buildTransactionProofHandoffCenter();
+  assert.strictEqual(transactionProofHandoffCenter.recommended_loop, "default.proof.bundle.loop", "transaction proof handoff center loop missing");
+  const transactionProofHandoffSummary = proof.summarizeTransactionProofHandoffCenter();
+  assert.strictEqual(transactionProofHandoffSummary.supported_source_refs.includes("transaction.registry.anchor"), true, "transaction proof handoff summary missing");
+  const interactionSpineHandoffCenter = proof.buildInteractionSpineProofHandoffCenter();
+  assert.strictEqual(interactionSpineHandoffCenter.recommended_loop, "default.proof.bundle.loop", "interaction spine handoff center loop missing");
+  const interactionSpineHandoffSummary = proof.summarizeInteractionSpineProofHandoffCenter();
+  assert.strictEqual(interactionSpineHandoffSummary.supported_source_refs.includes("spine.job.commitment"), true, "interaction spine handoff summary missing");
+  const resultPackageHandoffCenter = proof.buildInteractionResultPackageHandoffCenter();
+  assert.strictEqual(resultPackageHandoffCenter.recommended_loop, "default.proof.bundle.loop", "result package handoff center loop missing");
+  const resultPackageHandoffSummary = proof.summarizeInteractionResultPackageHandoffCenter();
+  assert.strictEqual(resultPackageHandoffSummary.supported_source_refs.includes("result.spine.job.commitment"), true, "result package handoff summary missing");
+
+  const integrationSummary = proof.summarizeIntegrations({
+    source: "builtin",
+    certification_state: "certified",
+    integration_maturity: "production_default"
+  });
+  assert.strictEqual(integrationSummary.ok, true, "proof integration summary missing");
+  assert.strictEqual(integrationSummary.certified_integration_count >= 5, true, "proof integration certification breadth missing");
+  const legacyMaterialIntegration = proof.getIntegration("builtin.identity.legacy_material");
+  assert.strictEqual(legacyMaterialIntegration.operational_readiness, "production", "proof integration readiness missing");
+  const stagedVerifierIntegration = proof.getIntegration("partner.verifier.lattice_notary");
+  assert.strictEqual(stagedVerifierIntegration.registration.registration_state, "staging_registered", "staged verifier registration missing");
+  const snapshot = proof.exportIntegrationRegistrySnapshot({
+    proof_scope: "profile_verification"
+  });
+  assert.strictEqual(snapshot.integration_count >= 3, true, "proof integration snapshot missing profile-verification breadth");
+
+  const identityMaterial = proof.makeIdentityMaterial("01", "aa11bb22cc33dd44");
+  const identity = proof.createIdentity(identityMaterial);
+  const eventPayload = {
+    subject: "proof-quickstart",
+    amount: 1,
+    currency: "unit"
+  };
+  const payloadBytes = Buffer.from(JSON.stringify(eventPayload), "utf8");
+  const receipt = proof.createReceipt(identity.identity_material_hex, payloadBytes);
+
+  const verification = proof.verifyReceipt(receipt.opreturn_hex, payloadBytes);
+  assert.strictEqual(verification.valid, true, "receipt verification failed");
+
+  const envelope = proof.createProofEnvelopeV1(receipt.opreturn_hex, [
+    {
+      proof_id: "proof-1",
+      proof_type: "attestation",
+      role: "primary",
+      media_type: "application/json",
+      proof_hash_sha256: "11".repeat(32),
+      locator: "memory://proof-1"
+    }
+  ]);
+  const proofVerification = proof.verifyProofEnvelopeV1(envelope);
+  assert.strictEqual(proofVerification.valid, true, "proof verification failed");
+
+  const event = proof.canonicalizeEvent({
+    version: "canonical-event-bundle/v1",
+    domain_id: "quickstart.domain",
+    sequence: "1",
+    actor_id: identity.agent_id,
+    adapter_source: "examples/package_quickstart",
+    event_type: "proof.quickstart.executed",
+    event_hash: proof.hashEvent({
+      version: "canonical-event-bundle/v1",
+      domain_id: "quickstart.domain",
+      sequence: "1",
+      actor_id: identity.agent_id,
+      adapter_source: "examples/package_quickstart",
+      event_type: "proof.quickstart.payload",
+      event_hash: proof.hashEvent({
+        version: "canonical-event-bundle/v1",
+        domain_id: "quickstart.payload",
+        sequence: "1",
+        actor_id: identity.agent_id,
+        adapter_source: "examples/package_quickstart",
+        event_type: "proof.quickstart.payload.digest",
+        event_hash: crypto.createHash("sha256").update(payloadBytes).digest("hex")
+      })
+    }),
+    semantic_slots: eventPayload
+  });
+  const canonicalReceipt = proof.emitReceipt(event, {
+    legacy_identity_material_hex: identity.identity_material_hex
+  });
+  const bundle = proof.buildProofBundle({
+    ceb: event,
+    receipt: canonicalReceipt,
+    evidence_refs: ["memory://proof-quickstart/event"]
+  });
+  const bundleVerification = proof.verifyProofBundle(bundle);
+  assert.strictEqual(bundleVerification.valid, true, "proof bundle verification failed");
+  const guidedLoop = proof.runDefaultProofLoop("default.proof.bundle.loop", {
+    event,
+    options: {
+      legacy_identity_material_hex: identity.identity_material_hex
+    },
+    evidence_refs: ["memory://proof-quickstart/guided-loop"]
+  });
+  assert.strictEqual(guidedLoop.loop.loop_ref, "default.proof.bundle.loop", "guided proof loop ref missing");
+  assert.strictEqual(guidedLoop.bundle_verification.valid, true, "guided proof loop bundle verification failed");
+  const guidedLoopSummary = proof.summarizeGuidedProofLoopBundle(guidedLoop);
+  assert.strictEqual(guidedLoopSummary.bundle_valid, true, "guided proof loop summary bundle validity missing");
+  assert.strictEqual(guidedLoopSummary.receipt_valid, true, "guided proof loop summary receipt validity missing");
+  const transactionProofHandoff = proof.runTransactionProofHandoff({
+    handoff_bundle: {
+      source_ref: "transaction.registry.anchor",
+      transaction_id: "txn-quickstart-1",
+      receipt_id: "txn-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/transaction-proof",
+      task_refs: ["registry.pack.bundle", "anchoring.pack.preview"],
+      delivery_count: 1,
+      payment_ledger_count: 1
+    },
+    options: {
+      legacy_identity_material_hex: identity.identity_material_hex
+    }
+  });
+  assert.strictEqual(transactionProofHandoff.bundle_verification.valid, true, "transaction proof handoff bundle verification failed");
+  const transactionProofHandoffBundleSummary = proof.summarizeTransactionProofHandoff(transactionProofHandoff);
+  assert.strictEqual(transactionProofHandoffBundleSummary.bundle_valid, true, "transaction proof handoff summary validity missing");
+  assert.strictEqual(
+    transactionProofHandoffBundleSummary.recommended_loop,
+    "default.proof.bundle.loop",
+    "transaction proof handoff summary recommended loop missing"
+  );
+  const interactionSpineProofHandoff = proof.runInteractionSpineProofHandoff({
+    handoff_bundle: {
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-spine-quickstart-1",
+      receipt_id: "txn-spine-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/spine-proof",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      delivery_count: 1,
+      payment_ledger_count: 1,
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness"
+    },
+    options: {
+      legacy_identity_material_hex: identity.identity_material_hex
+    }
+  });
+  assert.strictEqual(interactionSpineProofHandoff.bundle_verification.valid, true, "interaction spine proof handoff bundle verification failed");
+  const interactionSpineProofHandoffBundleSummary = proof.summarizeInteractionSpineProofHandoff(interactionSpineProofHandoff);
+  assert.strictEqual(interactionSpineProofHandoffBundleSummary.bundle_valid, true, "interaction spine proof handoff summary validity missing");
+  assert.strictEqual(
+    interactionSpineProofHandoffBundleSummary.committed_ref,
+    "transaction.job.commitment",
+    "interaction spine proof handoff summary committed ref missing"
+  );
+  const resultPackageProofHandoff = proof.runInteractionResultPackageHandoff({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-quickstart-1",
+      receipt_id: "txn-result-package-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      delivery_count: 1,
+      payment_ledger_count: 1,
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    },
+    options: {
+      legacy_identity_material_hex: identity.identity_material_hex
+    }
+  });
+  assert.strictEqual(resultPackageProofHandoff.bundle_verification.valid, true, "result package proof handoff bundle verification failed");
+  const resultPackageProofHandoffBundleSummary = proof.summarizeInteractionResultPackageHandoff(resultPackageProofHandoff);
+  assert.strictEqual(resultPackageProofHandoffBundleSummary.bundle_valid, true, "result package proof handoff summary validity missing");
+  assert.strictEqual(
+    resultPackageProofHandoffBundleSummary.result_package_ref,
+    "result.spine.job.commitment",
+    "result package proof handoff summary package ref missing"
+  );
+  const resultPackageProofReview = proof.reviewInteractionResultPackageHandoff({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      delivery_count: 1,
+      payment_ledger_count: 1,
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageProofReview.accepted, true, "result package proof review acceptance missing");
+  assert.strictEqual(resultPackageProofReview.next_surface, "/v1/proof-center/result-package-handoff/run", "result package proof review next surface missing");
+  assert.strictEqual(resultPackageProofReview.durability_summary.review_ref, "review.result.spine.job.commitment", "result package proof review ref missing");
+  assert.strictEqual(resultPackageProofReview.durability_summary.run_ready, true, "result package proof review run readiness missing");
+  const resultPackageProofReviewSummary = proof.summarizeReviewedInteractionResultPackageHandoff({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageProofReviewSummary.review_ref, "review.result.spine.job.commitment", "result package proof review summary ref missing");
+  assert.strictEqual(resultPackageProofReviewSummary.run_ready, true, "result package proof review summary run readiness missing");
+  const resultPackageExtensionReadiness = proof.summarizeReviewExtensionReadiness({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageExtensionReadiness.extension_ready_ref, "extension.review.result.spine.job.commitment", "result package extension readiness ref missing");
+  assert.strictEqual(resultPackageExtensionReadiness.proof_extension_ready, true, "result package extension readiness proof readiness missing");
+  const resultPackageExtensionBoundary = proof.summarizeReviewExtensionBoundary({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageExtensionBoundary.extension_ready_ref, "extension.review.result.spine.job.commitment", "result package extension boundary ref missing");
+  assert.strictEqual(resultPackageExtensionBoundary.stable_boundary_ids.includes("proof_run"), true, "result package extension boundary ids missing");
+  const resultPackageReusableDefaultContinuation = proof.summarizeReviewReusableDefaultContinuation({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageReusableDefaultContinuation.reusable_default_ref, "default.review.result.spine.job.commitment", "result package reusable default continuation ref missing");
+  assert.strictEqual(resultPackageReusableDefaultContinuation.default_followthrough.review_summary_surface, "/v1/proof-center/result-package-handoff/review/summary", "result package reusable default continuation review summary surface missing");
+  assert.strictEqual(resultPackageReusableDefaultContinuation.default_followthrough.reusable_by_default, true, "result package reusable default continuation reusable-by-default missing");
+  const resultPackageReusableDefaultBoundary = proof.summarizeReviewReusableDefaultBoundary({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageReusableDefaultBoundary.reusable_default_ref, "default.review.result.spine.job.commitment", "result package reusable default boundary ref missing");
+  assert.strictEqual(resultPackageReusableDefaultBoundary.stable_boundary_ids.includes("proof_run"), true, "result package reusable default boundary ids missing");
+  const resultPackageCompositionContract = proof.summarizeReviewCompositionContract({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageCompositionContract.composition_contract_ref, "contract.default.review.result.spine.job.commitment", "result package composition contract ref missing");
+  assert.strictEqual(resultPackageCompositionContract.next_surface, "/v1/proof-center/result-package-handoff/run", "result package composition contract next surface missing");
+  assert.strictEqual(resultPackageCompositionContract.contract_ready, true, "result package composition contract contract-ready missing");
+  const resultPackageCompositionContractBoundary = proof.summarizeReviewCompositionContractBoundary({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageCompositionContractBoundary.composition_contract_ref, "contract.default.review.result.spine.job.commitment", "result package composition contract boundary ref missing");
+  assert.strictEqual(resultPackageCompositionContractBoundary.stable_boundary_ids.includes("proof_run"), true, "result package composition contract boundary ids missing");
+  const resultPackageCompositionContractCarry = proof.summarizeReviewCompositionContractCarry({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageCompositionContractCarry.composition_contract_ref, "contract.default.review.result.spine.job.commitment", "result package composition contract carry ref missing");
+  assert.strictEqual(resultPackageCompositionContractCarry.public_contract_ids.includes("proof_run"), true, "result package composition contract carry ids missing");
+  assert.strictEqual(resultPackageCompositionContractCarry.contract_ready, true, "result package composition contract carry contract-ready missing");
+  const resultPackageBridgeSummary = proof.summarizeReviewBridgeSummary({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageBridgeSummary.adapter_bridge_ref, "bridge.contract.default.review.result.spine.job.commitment", "result package bridge summary ref missing");
+  assert.strictEqual(resultPackageBridgeSummary.next_surface, "/v1/proof-center/result-package-handoff/run", "result package bridge summary next surface missing");
+  assert.strictEqual(resultPackageBridgeSummary.bridge_ready, true, "result package bridge summary bridge-ready missing");
+  const resultPackageBridgeBoundary = proof.summarizeReviewBridgeBoundary({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageBridgeBoundary.adapter_bridge_ref, "bridge.contract.default.review.result.spine.job.commitment", "result package bridge boundary ref missing");
+  assert.strictEqual(resultPackageBridgeBoundary.stable_boundary_ids.includes("proof_run"), true, "result package bridge boundary ids missing");
+  const resultPackageBridgeCarry = proof.summarizeReviewBridgeCarry({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageBridgeCarry.adapter_bridge_ref, "bridge.contract.default.review.result.spine.job.commitment", "result package bridge carry ref missing");
+  assert.strictEqual(resultPackageBridgeCarry.stable_bridge_ids.includes("proof_run"), true, "result package bridge carry ids missing");
+  assert.strictEqual(resultPackageBridgeCarry.bridge_ready, true, "result package bridge carry bridge-ready missing");
+  const resultPackageBridgeRun = proof.summarizeReviewBridgeRun({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageBridgeRun.adapter_bridge_ref, "bridge.contract.default.review.result.spine.job.commitment", "result package bridge run ref missing");
+  assert.strictEqual(resultPackageBridgeRun.accepted_bridge_ids.includes("proof_run"), true, "result package bridge run accepted ids missing");
+  assert.strictEqual(resultPackageBridgeRun.run_surface, "/v1/proof-center/result-package-handoff/run", "result package bridge run surface missing");
+  const resultPackageHandoffContinuity = proof.summarizeReviewHandoffContinuity({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageHandoffContinuity.handoff_contract_ref, "handoff.bridge.contract.default.review.result.spine.job.commitment", "result package handoff continuity ref missing");
+  assert.strictEqual(resultPackageHandoffContinuity.stable_handoff_ids.includes("proof_run"), true, "result package handoff continuity ids missing");
+  assert.strictEqual(resultPackageHandoffContinuity.run_surface, "/v1/proof-center/result-package-handoff/run", "result package handoff continuity surface missing");
+  const resultPackageHandoffIntake = proof.summarizeReviewHandoffIntake({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageHandoffIntake.handoff_surface_ref, "surface.handoff.bridge.contract.default.review.result.spine.job.commitment", "result package handoff intake ref missing");
+  assert.strictEqual(resultPackageHandoffIntake.adapter_consumable, true, "result package handoff intake consumable missing");
+  const resultPackageHandoffIntakeBoundary = proof.summarizeReviewHandoffIntakeBoundary({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageHandoffIntakeBoundary.handoff_surface_ref, "surface.handoff.bridge.contract.default.review.result.spine.job.commitment", "result package handoff intake boundary ref missing");
+  assert.strictEqual(resultPackageHandoffIntakeBoundary.stable_boundary_ids.includes("proof_run"), true, "result package handoff intake boundary ids missing");
+  const resultPackageHandoffIntakeCarry = proof.summarizeReviewHandoffIntakeCarry({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageHandoffIntakeCarry.handoff_surface_ref, "surface.handoff.bridge.contract.default.review.result.spine.job.commitment", "result package handoff intake carry ref missing");
+  assert.strictEqual(resultPackageHandoffIntakeCarry.stable_handoff_surface_ids.includes("proof_run"), true, "result package handoff intake carry ids missing");
+  assert.strictEqual(resultPackageHandoffIntakeCarry.adapter_consumable, true, "result package handoff intake carry consumable missing");
+  const resultPackageHandoffPackageIntake = proof.summarizeReviewHandoffPackageIntake({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageHandoffPackageIntake.handoff_package_ref, "package.surface.handoff.bridge.contract.default.review.result.spine.job.commitment", "result package handoff package intake ref missing");
+  assert.strictEqual(resultPackageHandoffPackageIntake.adapter_usable, true, "result package handoff package intake usable missing");
+  const resultPackageHandoffPackageCarry = proof.summarizeReviewHandoffPackageCarry({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageHandoffPackageCarry.handoff_package_ref, "package.surface.handoff.bridge.contract.default.review.result.spine.job.commitment", "result package handoff package carry ref missing");
+  assert.strictEqual(resultPackageHandoffPackageCarry.stable_handoff_package_ids.includes("proof_run"), true, "result package handoff package carry ids missing");
+  assert.strictEqual(resultPackageHandoffPackageCarry.adapter_usable, true, "result package handoff package carry usable missing");
+  const resultPackageHandoffPackageRun = proof.summarizeReviewHandoffPackageRun({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageHandoffPackageRun.handoff_package_ref, "package.surface.handoff.bridge.contract.default.review.result.spine.job.commitment", "result package handoff package run ref missing");
+  assert.strictEqual(resultPackageHandoffPackageRun.accepted_handoff_package_ids.includes("proof_run"), true, "result package handoff package run accepted ids missing");
+  assert.strictEqual(resultPackageHandoffPackageRun.run_surface, "/v1/proof-center/result-package-handoff/run", "result package handoff package run surface missing");
+  const resultPackageExecutionPackage = proof.summarizeReviewExecutionPackage({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageExecutionPackage.execution_package_ref, "execution.package.surface.handoff.bridge.contract.default.review.result.spine.job.commitment", "result package execution package ref missing");
+  assert.strictEqual(resultPackageExecutionPackage.accepted_execution_package_ids.includes("proof_run"), true, "result package execution package accepted ids missing");
+  assert.strictEqual(resultPackageExecutionPackage.run_surface, "/v1/proof-center/result-package-handoff/run", "result package execution package surface missing");
+  const resultPackageExecutionPackageCarry = proof.summarizeReviewExecutionPackageCarry({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageExecutionPackageCarry.execution_package_ref, "execution.package.surface.handoff.bridge.contract.default.review.result.spine.job.commitment", "result package execution package carry ref missing");
+  assert.strictEqual(resultPackageExecutionPackageCarry.accepted_execution_package_ids.includes("proof_run"), true, "result package execution package carry ids missing");
+  assert.strictEqual(resultPackageExecutionPackageCarry.adapter_ready, true, "result package execution package carry ready missing");
+  const resultPackageExecutionPackageRun = proof.summarizeReviewExecutionPackageRun({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageExecutionPackageRun.execution_package_ref, "execution.package.surface.handoff.bridge.contract.default.review.result.spine.job.commitment", "result package execution package run ref missing");
+  assert.strictEqual(resultPackageExecutionPackageRun.accepted_execution_package_ids.includes("proof_run"), true, "result package execution package run ids missing");
+  assert.strictEqual(resultPackageExecutionPackageRun.execution_ready_by_default, true, "result package execution package run ready missing");
+  assert.strictEqual(resultPackageExecutionPackageRun.run_surface, "/v1/proof-center/result-package-handoff/run", "result package execution package run surface missing");
+  const resultPackageExecutionContract = proof.summarizeReviewExecutionContract({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageExecutionContract.execution_contract_ref, "contract.execution.package.surface.handoff.bridge.contract.default.review.result.spine.job.commitment", "result package execution contract ref missing");
+  assert.strictEqual(resultPackageExecutionContract.accepted_execution_contract_ids.includes("proof_run"), true, "result package execution contract ids missing");
+  assert.strictEqual(resultPackageExecutionContract.adapter_operable, true, "result package execution contract operable missing");
+  assert.strictEqual(resultPackageExecutionContract.run_surface, "/v1/proof-center/result-package-handoff/run", "result package execution contract surface missing");
+  const resultPackageExecutionContractCarry = proof.summarizeReviewExecutionContractCarry({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageExecutionContractCarry.execution_contract_ref, "contract.execution.package.surface.handoff.bridge.contract.default.review.result.spine.job.commitment", "result package execution contract carry ref missing");
+  assert.strictEqual(resultPackageExecutionContractCarry.accepted_execution_contract_ids.includes("proof_run"), true, "result package execution contract carry ids missing");
+  assert.strictEqual(resultPackageExecutionContractCarry.adapter_operable, true, "result package execution contract carry operable missing");
+  const resultPackageExecutionContractRun = proof.summarizeReviewExecutionContractRun({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageExecutionContractRun.execution_contract_ref, "contract.execution.package.surface.handoff.bridge.contract.default.review.result.spine.job.commitment", "result package execution contract run ref missing");
+  assert.strictEqual(resultPackageExecutionContractRun.accepted_execution_contract_ids.includes("proof_run"), true, "result package execution contract run ids missing");
+  assert.strictEqual(resultPackageExecutionContractRun.execution_operable_by_default, true, "result package execution contract run operable missing");
+  assert.strictEqual(resultPackageExecutionContractRun.run_surface, "/v1/proof-center/result-package-handoff/run", "result package execution contract run surface missing");
+  const resultPackageOperatingContract = proof.summarizeReviewOperatingContract({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageOperatingContract.operating_contract_ref, "operating.contract.execution.package.surface.handoff.bridge.contract.default.review.result.spine.job.commitment", "result package operating contract ref missing");
+  assert.strictEqual(resultPackageOperatingContract.accepted_operating_contract_ids.includes("proof_run"), true, "result package operating contract ids missing");
+  assert.strictEqual(resultPackageOperatingContract.adapter_stable, true, "result package operating contract stable missing");
+  assert.strictEqual(resultPackageOperatingContract.run_surface, "/v1/proof-center/result-package-handoff/run", "result package operating contract surface missing");
+  const resultPackageOperatingContractCarry = proof.summarizeReviewOperatingContractCarry({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageOperatingContractCarry.operating_contract_ref, "operating.contract.execution.package.surface.handoff.bridge.contract.default.review.result.spine.job.commitment", "result package operating contract carry ref missing");
+  assert.strictEqual(resultPackageOperatingContractCarry.accepted_operating_contract_ids.includes("proof_run"), true, "result package operating contract carry ids missing");
+  assert.strictEqual(resultPackageOperatingContractCarry.adapter_stable, true, "result package operating contract carry stable missing");
+  const resultPackageOperatingContractRun = proof.summarizeReviewOperatingContractRun({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageOperatingContractRun.operating_contract_ref, "operating.contract.execution.package.surface.handoff.bridge.contract.default.review.result.spine.job.commitment", "result package operating contract run ref missing");
+  assert.strictEqual(resultPackageOperatingContractRun.accepted_operating_contract_ids.includes("proof_run"), true, "result package operating contract run ids missing");
+  assert.strictEqual(resultPackageOperatingContractRun.operating_stable_by_default, true, "result package operating contract run stable missing");
+  assert.strictEqual(resultPackageOperatingContractRun.run_surface, "/v1/proof-center/result-package-handoff/run", "result package operating contract run surface missing");
+  const resultPackageOperatingInterface = proof.summarizeReviewOperatingInterface({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageOperatingInterface.operating_interface_ref, "interface.operating.contract.execution.package.surface.handoff.bridge.contract.default.review.result.spine.job.commitment", "result package operating interface ref missing");
+  assert.strictEqual(resultPackageOperatingInterface.accepted_operating_interface_ids.includes("proof_run"), true, "result package operating interface ids missing");
+  assert.strictEqual(resultPackageOperatingInterface.adapter_reliable, true, "result package operating interface reliable missing");
+  assert.strictEqual(resultPackageOperatingInterface.run_surface, "/v1/proof-center/result-package-handoff/run", "result package operating interface surface missing");
+  const resultPackageOperatingInterfaceCarry = proof.summarizeReviewOperatingInterfaceCarry({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageOperatingInterfaceCarry.operating_interface_ref, "interface.operating.contract.execution.package.surface.handoff.bridge.contract.default.review.result.spine.job.commitment", "result package operating interface carry ref missing");
+  assert.strictEqual(resultPackageOperatingInterfaceCarry.accepted_operating_interface_ids.includes("proof_run"), true, "result package operating interface carry ids missing");
+  assert.strictEqual(resultPackageOperatingInterfaceCarry.adapter_reliable, true, "result package operating interface carry reliable missing");
+  const resultPackageOperatingInterfaceRun = proof.summarizeReviewOperatingInterfaceRun({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageOperatingInterfaceRun.operating_interface_ref, "interface.operating.contract.execution.package.surface.handoff.bridge.contract.default.review.result.spine.job.commitment", "result package operating interface run ref missing");
+  assert.strictEqual(resultPackageOperatingInterfaceRun.accepted_operating_interface_ids.includes("proof_run"), true, "result package operating interface run ids missing");
+  assert.strictEqual(resultPackageOperatingInterfaceRun.operating_interface_reliable_by_default, true, "result package operating interface run reliable missing");
+  assert.strictEqual(resultPackageOperatingInterfaceRun.run_surface, "/v1/proof-center/result-package-handoff/run", "result package operating interface run surface missing");
+  const resultPackageOperatingIntegration = proof.summarizeReviewOperatingIntegration({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageOperatingIntegration.operating_integration_ref, "integration.interface.operating.contract.execution.package.surface.handoff.bridge.contract.default.review.result.spine.job.commitment", "result package operating integration ref missing");
+  assert.strictEqual(resultPackageOperatingIntegration.accepted_operating_integration_ids.includes("proof_run"), true, "result package operating integration ids missing");
+  assert.strictEqual(resultPackageOperatingIntegration.adapter_integrable, true, "result package operating integration integrable missing");
+  assert.strictEqual(resultPackageOperatingIntegration.run_surface, "/v1/proof-center/result-package-handoff/run", "result package operating integration surface missing");
+  const resultPackageOperatingIntegrationCarry = proof.summarizeReviewOperatingIntegrationCarry({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageOperatingIntegrationCarry.operating_integration_ref, "integration.interface.operating.contract.execution.package.surface.handoff.bridge.contract.default.review.result.spine.job.commitment", "result package operating integration carry ref missing");
+  assert.strictEqual(resultPackageOperatingIntegrationCarry.accepted_operating_integration_ids.includes("proof_run"), true, "result package operating integration carry ids missing");
+  assert.strictEqual(resultPackageOperatingIntegrationCarry.adapter_integrable, true, "result package operating integration carry integrable missing");
+  const resultPackageOperatingIntegrationRun = proof.summarizeReviewOperatingIntegrationRun({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageOperatingIntegrationRun.operating_integration_ref, "integration.interface.operating.contract.execution.package.surface.handoff.bridge.contract.default.review.result.spine.job.commitment", "result package operating integration run ref missing");
+  assert.strictEqual(resultPackageOperatingIntegrationRun.accepted_operating_integration_ids.includes("proof_run"), true, "result package operating integration run ids missing");
+  assert.strictEqual(resultPackageOperatingIntegrationRun.operating_integration_integrable_by_default, true, "result package operating integration run integrable missing");
+  assert.strictEqual(resultPackageOperatingIntegrationRun.run_surface, "/v1/proof-center/result-package-handoff/run", "result package operating integration run surface missing");
+  const resultPackageOperatingPath = proof.summarizeReviewOperatingPath({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageOperatingPath.operating_path_ref, "path.integration.interface.operating.contract.execution.package.surface.handoff.bridge.contract.default.review.result.spine.job.commitment", "result package operating path ref missing");
+  assert.strictEqual(resultPackageOperatingPath.accepted_operating_path_ids.includes("proof_run"), true, "result package operating path ids missing");
+  assert.strictEqual(resultPackageOperatingPath.adapter_ready_by_default, true, "result package operating path default readiness missing");
+  assert.strictEqual(resultPackageOperatingPath.run_surface, "/v1/proof-center/result-package-handoff/run", "result package operating path surface missing");
+  const resultPackageOperatingPathCarry = proof.summarizeReviewOperatingPathCarry({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageOperatingPathCarry.operating_path_ref, "path.integration.interface.operating.contract.execution.package.surface.handoff.bridge.contract.default.review.result.spine.job.commitment", "result package operating path carry ref missing");
+  assert.strictEqual(resultPackageOperatingPathCarry.accepted_operating_path_ids.includes("proof_run"), true, "result package operating path carry ids missing");
+  assert.strictEqual(resultPackageOperatingPathCarry.adapter_ready_by_default, true, "result package operating path carry default readiness missing");
+  const resultPackageOperatingPathRun = proof.summarizeReviewOperatingPathRun({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageOperatingPathRun.operating_path_ref, "path.integration.interface.operating.contract.execution.package.surface.handoff.bridge.contract.default.review.result.spine.job.commitment", "result package operating path run ref missing");
+  assert.strictEqual(resultPackageOperatingPathRun.accepted_operating_path_ids.includes("proof_run"), true, "result package operating path run ids missing");
+  assert.strictEqual(resultPackageOperatingPathRun.operating_path_ready_by_default, true, "result package operating path run ready missing");
+  assert.strictEqual(resultPackageOperatingPathRun.run_surface, "/v1/proof-center/result-package-handoff/run", "result package operating path run surface missing");
+  const resultPackageCompleteDefaultPath = proof.summarizeReviewCompleteDefaultPath({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageCompleteDefaultPath.complete_default_path_ref, "complete.path.integration.interface.operating.contract.execution.package.surface.handoff.bridge.contract.default.review.result.spine.job.commitment", "result package complete default path ref missing");
+  assert.strictEqual(resultPackageCompleteDefaultPath.accepted_complete_default_path_ids.includes("proof_run"), true, "result package complete default path ids missing");
+  assert.strictEqual(resultPackageCompleteDefaultPath.adapter_complete_by_default, true, "result package complete default path complete missing");
+  assert.strictEqual(resultPackageCompleteDefaultPath.run_surface, "/v1/proof-center/result-package-handoff/run", "result package complete default path surface missing");
+  const resultPackageCompleteDefaultPathCarry = proof.summarizeReviewCompleteDefaultPathCarry({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageCompleteDefaultPathCarry.complete_default_path_ref, "complete.path.integration.interface.operating.contract.execution.package.surface.handoff.bridge.contract.default.review.result.spine.job.commitment", "result package complete default path carry ref missing");
+  assert.strictEqual(resultPackageCompleteDefaultPathCarry.accepted_complete_default_path_ids.includes("proof_run"), true, "result package complete default path carry ids missing");
+  assert.strictEqual(resultPackageCompleteDefaultPathCarry.adapter_complete_by_default, true, "result package complete default path carry complete missing");
+  const resultPackageCompleteDefaultPathRun = proof.summarizeReviewCompleteDefaultPathRun({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageCompleteDefaultPathRun.complete_default_path_ref, "complete.path.integration.interface.operating.contract.execution.package.surface.handoff.bridge.contract.default.review.result.spine.job.commitment", "result package complete default path run ref missing");
+  assert.strictEqual(resultPackageCompleteDefaultPathRun.accepted_complete_default_path_ids.includes("proof_run"), true, "result package complete default path run ids missing");
+  assert.strictEqual(resultPackageCompleteDefaultPathRun.complete_default_path_ready, true, "result package complete default path run ready missing");
+  assert.strictEqual(resultPackageCompleteDefaultPathRun.run_surface, "/v1/proof-center/result-package-handoff/run", "result package complete default path run surface missing");
+  const resultPackageHandoffRun = proof.summarizeReviewHandoffRun({
+    handoff_bundle: {
+      result_package_ref: "result.spine.job.commitment",
+      source_ref: "spine.job.commitment",
+      transaction_id: "txn-result-package-review-quickstart-1",
+      receipt_id: "txn-result-package-review-receipt-quickstart-1",
+      proof_ref: "memory://proof-quickstart/result-package-review-proof",
+      committed_ref: "transaction.job.commitment",
+      precommit_pack_ref: "precommit.job.commitment.readiness",
+      payment_protocol: "x402",
+      settlement_mode: "evm_payment",
+      treasury_destination_id: "treasury_acct_demo",
+      task_refs: ["jobs.quote", "admission.preview", "jobs.reserve", "jobs.commit"],
+      seam_layers: ["execution_consequence", "payment_settlement_treasury", "proof_handoff"]
+    }
+  });
+  assert.strictEqual(resultPackageHandoffRun.handoff_contract_ref, "handoff.bridge.contract.default.review.result.spine.job.commitment", "result package handoff run ref missing");
+  assert.strictEqual(resultPackageHandoffRun.accepted_handoff_ids.includes("proof_run"), true, "result package handoff run accepted ids missing");
+  assert.strictEqual(resultPackageHandoffRun.run_surface, "/v1/proof-center/result-package-handoff/run", "result package handoff run surface missing");
+
+  console.log("xoonya package quickstart passed");
+}
+
+main();