xoonya 3.1.17 → 3.2.0

package/scripts/verify_service.js

@@ -1,3038 +0,0 @@
-const assert = require('assert');
-const http = require('http');
-const { createServer } = require('../server.js');
-const sdk = require('../index.js');
-
-async function postJson(baseUrl, path, payload) {
-  const response = await fetch(`${baseUrl}${path}`, {
-    method: 'POST',
-    headers: {
-      'content-type': 'application/json',
-    },
-    body: JSON.stringify(payload),
-  });
-  return {
-    status: response.status,
-    json: await response.json(),
-  };
-}
-
-async function getJson(baseUrl, path) {
-  const response = await fetch(`${baseUrl}${path}`);
-  return {
-    status: response.status,
-    json: await response.json(),
-  };
-}
-
-function canonicalize(value) {
-  if (Array.isArray(value)) {
-    return `[${value.map((item) => canonicalize(item)).join(',')}]`;
-  }
-  if (value && typeof value === 'object') {
-    const keys = Object.keys(value).sort();
-    return `{${keys.map((key) => `${JSON.stringify(key)}:${canonicalize(value[key])}`).join(',')}}`;
-  }
-  return JSON.stringify(value);
-}
-
-async function main() {
-  const server = createServer();
-  await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
-  const address = server.address();
-  const baseUrl = `http://127.0.0.1:${address.port}`;
-
-  try {
-    const healthResponse = await fetch(`${baseUrl}/health`);
-    const healthJson = await healthResponse.json();
-    assert.strictEqual(healthResponse.status, 200, 'health endpoint failed');
-    assert.strictEqual(healthJson.status, 'ok', 'health payload invalid');
-
-    const openApiResponse = await getJson(baseUrl, '/openapi.json');
-    assert.strictEqual(openApiResponse.status, 200, 'openapi route failed');
-    assert.strictEqual(openApiResponse.json.openapi, '3.1.0', 'openapi version missing');
-    assert.strictEqual(openApiResponse.json.info.title, 'xoonya Public HTTP Contract', 'openapi title missing');
-    assert.strictEqual(typeof openApiResponse.json.paths['/v1/proof-bundles/verify'], 'object', 'openapi proof route missing');
-
-    const openApiSummaryResponse = await getJson(baseUrl, '/v1/openapi/summary');
-    assert.strictEqual(openApiSummaryResponse.status, 200, 'openapi summary route failed');
-    assert.strictEqual(openApiSummaryResponse.json.product, 'xoonya', 'openapi summary product missing');
-    assert.strictEqual(openApiSummaryResponse.json.path_count >= 10, true, 'openapi summary path count missing');
-
-    const asyncApiResponse = await getJson(baseUrl, '/asyncapi.json');
-    assert.strictEqual(asyncApiResponse.status, 200, 'asyncapi route failed');
-    assert.strictEqual(asyncApiResponse.json.asyncapi, '3.0.0', 'asyncapi version missing');
-    assert.strictEqual(asyncApiResponse.json.info.title, 'xoonya Event Contract', 'asyncapi title missing');
-    assert.strictEqual(typeof asyncApiResponse.json.channels['proof/bundles/build'], 'object', 'asyncapi proof channel missing');
-
-    const asyncApiSummaryResponse = await getJson(baseUrl, '/v1/asyncapi/summary');
-    assert.strictEqual(asyncApiSummaryResponse.status, 200, 'asyncapi summary route failed');
-    assert.strictEqual(asyncApiSummaryResponse.json.product, 'xoonya', 'asyncapi summary product missing');
-    assert.strictEqual(asyncApiSummaryResponse.json.channel_count >= 5, true, 'asyncapi summary channel count missing');
-
-    const cloudeventsResponse = await getJson(baseUrl, '/cloudevents.json');
-    assert.strictEqual(cloudeventsResponse.status, 200, 'cloudevents route failed');
-    assert.strictEqual(cloudeventsResponse.json.specversion, '1.0', 'cloudevents specversion missing');
-    assert.strictEqual(cloudeventsResponse.json.product, 'xoonya', 'cloudevents product missing');
-    assert.strictEqual(Array.isArray(cloudeventsResponse.json.event_families), true, 'cloudevents event families missing');
-    assert.strictEqual(cloudeventsResponse.json.event_families.length >= 5, true, 'cloudevents event family count missing');
-
-    const cloudeventsSummaryResponse = await getJson(baseUrl, '/v1/cloudevents/summary');
-    assert.strictEqual(cloudeventsSummaryResponse.status, 200, 'cloudevents summary route failed');
-    assert.strictEqual(cloudeventsSummaryResponse.json.product, 'xoonya', 'cloudevents summary product missing');
-    assert.strictEqual(cloudeventsSummaryResponse.json.stable_surface_count >= 5, true, 'cloudevents summary stable surface count missing');
-
-    const authProfilesResponse = await getJson(baseUrl, '/v1/auth-profiles');
-    assert.strictEqual(authProfilesResponse.status, 200, 'auth profiles route failed');
-    assert.strictEqual(authProfilesResponse.json.product, 'xoonya', 'auth profiles product missing');
-    assert.strictEqual(authProfilesResponse.json.primary_posture, 'proof_verification_with_oauth_oidc_and_token_exchange_interop', 'auth profiles posture missing');
-    assert.strictEqual(Array.isArray(authProfilesResponse.json.supported_interop_profiles), true, 'auth profile list missing');
-    assert.strictEqual(authProfilesResponse.json.supported_interop_profiles.length >= 3, true, 'auth profile count missing');
-
-    const authProfilesSummaryResponse = await getJson(baseUrl, '/v1/auth-profiles/summary');
-    assert.strictEqual(authProfilesSummaryResponse.status, 200, 'auth profiles summary route failed');
-    assert.strictEqual(authProfilesSummaryResponse.json.product, 'xoonya', 'auth profiles summary product missing');
-    assert.strictEqual(authProfilesSummaryResponse.json.profile_count >= 3, true, 'auth profiles summary count missing');
-
-    const identityInteropResponse = await getJson(baseUrl, '/v1/identity-interop');
-    assert.strictEqual(identityInteropResponse.status, 200, 'identity interop route failed');
-    assert.strictEqual(identityInteropResponse.json.product, 'xoonya', 'identity interop product missing');
-    assert.strictEqual(identityInteropResponse.json.primary_posture, 'native_proof_and_attestation_followthrough_with_jwt_and_did_vc_interop', 'identity interop posture missing');
-    assert.strictEqual(Array.isArray(identityInteropResponse.json.supported_interop_profiles), true, 'identity interop profiles missing');
-    assert.strictEqual(identityInteropResponse.json.supported_interop_profiles.length >= 4, true, 'identity interop profile count missing');
-
-    const identityInteropSummaryResponse = await getJson(baseUrl, '/v1/identity-interop/summary');
-    assert.strictEqual(identityInteropSummaryResponse.status, 200, 'identity interop summary route failed');
-    assert.strictEqual(identityInteropSummaryResponse.json.product, 'xoonya', 'identity interop summary product missing');
-    assert.strictEqual(identityInteropSummaryResponse.json.profile_count >= 4, true, 'identity interop summary count missing');
-
-    const trustPortabilityResponse = await getJson(baseUrl, '/v1/proof-center/trust-portability');
-    assert.strictEqual(trustPortabilityResponse.status, 200, 'trust portability route failed');
-    assert.strictEqual(trustPortabilityResponse.json.product, 'xoonya', 'trust portability product missing');
-    assert.strictEqual(trustPortabilityResponse.json.category, 'xoonya-trust-portability-pack', 'trust portability category missing');
-    assert.strictEqual(Array.isArray(trustPortabilityResponse.json.portability_profiles), true, 'trust portability profiles missing');
-    assert.strictEqual(trustPortabilityResponse.json.portability_profiles.length >= 4, true, 'trust portability profile count missing');
-
-    const trustPortabilitySummaryResponse = await getJson(baseUrl, '/v1/proof-center/trust-portability/summary');
-    assert.strictEqual(trustPortabilitySummaryResponse.status, 200, 'trust portability summary route failed');
-    assert.strictEqual(trustPortabilitySummaryResponse.json.product, 'xoonya', 'trust portability summary product missing');
-    assert.strictEqual(trustPortabilitySummaryResponse.json.profile_count >= 4, true, 'trust portability summary profile count missing');
-
-    const governanceDisputesSummaryResponse = await getJson(baseUrl, '/v1/proof-center/governance/disputes/summary');
-    assert.strictEqual(governanceDisputesSummaryResponse.status, 200, 'governance disputes summary route failed');
-    assert.strictEqual(governanceDisputesSummaryResponse.json.ok, true, 'governance disputes summary ok missing');
-    assert.strictEqual(typeof governanceDisputesSummaryResponse.json.case_count, 'number', 'governance disputes summary case count missing');
-    assert.strictEqual(typeof governanceDisputesSummaryResponse.json.open_case_count, 'number', 'governance disputes summary open case count missing');
-
-    const trustPortabilityDetailResponse = await getJson(baseUrl, '/v1/proof-center/trust-portability/agent_identity_portability');
-    assert.strictEqual(trustPortabilityDetailResponse.status, 200, 'trust portability detail route failed');
-    assert.strictEqual(trustPortabilityDetailResponse.json.profile.profile_id, 'agent_identity_portability', 'trust portability detail profile missing');
-
-    const proofTruthResponse = await getJson(baseUrl, '/v1/proof-truth');
-    assert.strictEqual(proofTruthResponse.status, 200, 'proof truth route failed');
-    assert.strictEqual(proofTruthResponse.json.category, 'xoonya-proof-truth-model', 'proof truth category missing');
-    assert.strictEqual(proofTruthResponse.json.pack_version, 'xoonya-proof-truth-model-v1', 'proof truth version missing');
-    assert.strictEqual(proofTruthResponse.json.canonical_objects.length >= 6, true, 'proof truth object count missing');
-
-    const proofTruthSummaryResponse = await getJson(baseUrl, '/v1/proof-truth/summary');
-    assert.strictEqual(proofTruthSummaryResponse.status, 200, 'proof truth summary route failed');
-    assert.strictEqual(proofTruthSummaryResponse.json.category, 'xoonya-proof-truth-model', 'proof truth summary category missing');
-    assert.strictEqual(proofTruthSummaryResponse.json.pack_version, 'xoonya-proof-truth-model-v1', 'proof truth summary version missing');
-
-    const proofBundleTruthDetailResponse = await getJson(baseUrl, '/v1/proof-truth/proof_bundle');
-    assert.strictEqual(proofBundleTruthDetailResponse.status, 200, 'proof truth proof_bundle detail route failed');
-    assert.strictEqual(proofBundleTruthDetailResponse.json.object.object_id, 'proof_bundle', 'proof truth proof_bundle detail missing');
-
-    const xnyaTruthDetailResponse = await getJson(baseUrl, '/v1/proof-truth/xnya_native_artifact');
-    assert.strictEqual(xnyaTruthDetailResponse.status, 200, 'proof truth xnya detail route failed');
-    assert.strictEqual(xnyaTruthDetailResponse.json.object.object_id, 'xnya_native_artifact', 'proof truth xnya detail missing');
-
-    const defaultPathResponse = await getJson(baseUrl, '/v1/default-path');
-    assert.strictEqual(defaultPathResponse.status, 200, 'default path route failed');
-    assert.strictEqual(defaultPathResponse.json.category, 'xoonya-default-path-model', 'default path category missing');
-    assert.strictEqual(defaultPathResponse.json.pack_version, 'xoonya-default-path-model-v1', 'default path version missing');
-    assert.strictEqual(defaultPathResponse.json.supported_surface_count >= 5, true, 'default path surface count missing');
-
-    const defaultPathSummaryResponse = await getJson(baseUrl, '/v1/default-path/summary');
-    assert.strictEqual(defaultPathSummaryResponse.status, 200, 'default path summary route failed');
-    assert.strictEqual(defaultPathSummaryResponse.json.category, 'xoonya-default-path-model', 'default path summary category missing');
-    assert.strictEqual(defaultPathSummaryResponse.json.pack_version, 'xoonya-default-path-model-v1', 'default path summary version missing');
-    assert.strictEqual(defaultPathSummaryResponse.json.default_path_stage_count, 7, 'default path stage count missing');
-
-    const cliDefaultPathDetailResponse = await getJson(baseUrl, '/v1/default-path/cli_terminal');
-    assert.strictEqual(cliDefaultPathDetailResponse.status, 200, 'cli default path detail route failed');
-    assert.strictEqual(cliDefaultPathDetailResponse.json.surface.surface_id, 'cli_terminal', 'cli default path detail missing');
-
-    const handoffDefaultPathDetailResponse = await getJson(baseUrl, '/v1/default-path/carried_handoff_review');
-    assert.strictEqual(handoffDefaultPathDetailResponse.status, 200, 'carried handoff default path detail route failed');
-    assert.strictEqual(handoffDefaultPathDetailResponse.json.surface.surface_id, 'carried_handoff_review', 'carried handoff default path detail missing');
-
-    const followthroughTruthResponse = await getJson(baseUrl, '/v1/followthrough-truth');
-    assert.strictEqual(followthroughTruthResponse.status, 200, 'followthrough truth route failed');
-    assert.strictEqual(followthroughTruthResponse.json.category, 'xoonya-followthrough-truth-model', 'followthrough truth category missing');
-    assert.strictEqual(followthroughTruthResponse.json.pack_version, 'xoonya-followthrough-truth-model-v1', 'followthrough truth version missing');
-    assert.strictEqual(followthroughTruthResponse.json.profile_count >= 4, true, 'followthrough truth profile count missing');
-
-    const followthroughTruthSummaryResponse = await getJson(baseUrl, '/v1/followthrough-truth/summary');
-    assert.strictEqual(followthroughTruthSummaryResponse.status, 200, 'followthrough truth summary route failed');
-    assert.strictEqual(followthroughTruthSummaryResponse.json.category, 'xoonya-followthrough-truth-model', 'followthrough truth summary category missing');
-    assert.strictEqual(followthroughTruthSummaryResponse.json.pack_version, 'xoonya-followthrough-truth-model-v1', 'followthrough truth summary version missing');
-    assert.strictEqual(followthroughTruthSummaryResponse.json.bounded_live_profile_count >= 3, true, 'followthrough truth bounded live count missing');
-
-    const bridgeFollowthroughDetailResponse = await getJson(baseUrl, '/v1/followthrough-truth/bridge_followthrough');
-    assert.strictEqual(bridgeFollowthroughDetailResponse.status, 200, 'bridge followthrough detail route failed');
-    assert.strictEqual(bridgeFollowthroughDetailResponse.json.profile.profile_id, 'bridge_followthrough', 'bridge followthrough detail missing');
-
-    const governanceFollowthroughDetailResponse = await getJson(baseUrl, '/v1/followthrough-truth/governance_followthrough');
-    assert.strictEqual(governanceFollowthroughDetailResponse.status, 200, 'governance followthrough detail route failed');
-    assert.strictEqual(governanceFollowthroughDetailResponse.json.profile.profile_id, 'governance_followthrough', 'governance followthrough detail missing');
-
-    const providerLaneResponse = await getJson(baseUrl, '/v1/providers');
-    assert.strictEqual(providerLaneResponse.status, 200, 'provider lane route failed');
-    assert.strictEqual(providerLaneResponse.json.product, 'xoonya', 'provider lane product missing');
-    assert.strictEqual(providerLaneResponse.json.lane_state, 'first_party_provider_family_present', 'provider lane state missing');
-
-    const providerLaneSummaryResponse = await getJson(baseUrl, '/v1/providers/summary');
-    assert.strictEqual(providerLaneSummaryResponse.status, 200, 'provider lane summary route failed');
-    assert.strictEqual(providerLaneSummaryResponse.json.featured_provider_count >= 2, true, 'provider lane count missing');
-
-    const frameworkLaneResponse = await getJson(baseUrl, '/v1/frameworks');
-    assert.strictEqual(frameworkLaneResponse.status, 200, 'framework lane route failed');
-    assert.strictEqual(frameworkLaneResponse.json.product, 'xoonya', 'framework lane product missing');
-    assert.strictEqual(frameworkLaneResponse.json.lane_state, 'first_party_framework_family_present', 'framework lane state missing');
-
-    const frameworkLaneSummaryResponse = await getJson(baseUrl, '/v1/frameworks/summary');
-    assert.strictEqual(frameworkLaneSummaryResponse.status, 200, 'framework lane summary route failed');
-    assert.strictEqual(frameworkLaneSummaryResponse.json.featured_framework_count >= 4, true, 'framework lane count missing');
-
-    const integrationMatrixResponse = await getJson(baseUrl, '/v1/integration-matrix');
-    assert.strictEqual(integrationMatrixResponse.status, 200, 'integration matrix route failed');
-    assert.strictEqual(integrationMatrixResponse.json.product, 'xoonya', 'integration matrix product missing');
-    assert.strictEqual(integrationMatrixResponse.json.counts.integration_count >= 5, true, 'integration matrix count missing');
-
-    const integrationMatrixSummaryResponse = await getJson(baseUrl, '/v1/integration-matrix/summary');
-    assert.strictEqual(integrationMatrixSummaryResponse.status, 200, 'integration matrix summary route failed');
-    assert.strictEqual(integrationMatrixSummaryResponse.json.lane_count >= 14, true, 'integration matrix lane count missing');
-
-    const telemetryLaneResponse = await getJson(baseUrl, '/v1/telemetry');
-    assert.strictEqual(telemetryLaneResponse.status, 200, 'telemetry lane route failed');
-    assert.strictEqual(telemetryLaneResponse.json.core_signals.length >= 4, true, 'telemetry lane signal count missing');
-
-    const provenanceLaneResponse = await getJson(baseUrl, '/v1/provenance');
-    assert.strictEqual(provenanceLaneResponse.status, 200, 'provenance lane route failed');
-    assert.strictEqual(provenanceLaneResponse.json.standards.includes('slsa'), true, 'provenance lane standard missing');
-
-    const artifactDistributionLaneResponse = await getJson(baseUrl, '/v1/artifact-distribution');
-    assert.strictEqual(artifactDistributionLaneResponse.status, 200, 'artifact distribution lane route failed');
-    assert.strictEqual(artifactDistributionLaneResponse.json.artifact_families.length >= 4, true, 'artifact distribution family count missing');
-
-    const sharedSignalsLaneResponse = await getJson(baseUrl, '/v1/shared-signals');
-    assert.strictEqual(sharedSignalsLaneResponse.status, 200, 'shared signals lane route failed');
-    assert.strictEqual(sharedSignalsLaneResponse.json.standards.includes('caep'), true, 'shared signals standard missing');
-
-    const featureControlLaneResponse = await getJson(baseUrl, '/v1/feature-control');
-    assert.strictEqual(featureControlLaneResponse.status, 200, 'feature control lane route failed');
-    assert.strictEqual(featureControlLaneResponse.json.standards.includes('openfeature'), true, 'feature control standard missing');
-
-    const majorRailsLaneResponse = await getJson(baseUrl, '/v1/major-rails');
-    assert.strictEqual(majorRailsLaneResponse.status, 200, 'major rails lane route failed');
-    assert.strictEqual(majorRailsLaneResponse.json.product, 'xoonya', 'major rails lane product missing');
-    assert.strictEqual(majorRailsLaneResponse.json.lane_state, 'first_party_major_rails_proof_family_present', 'major rails lane state missing');
-
-    const majorRailsLaneSummaryResponse = await getJson(baseUrl, '/v1/major-rails/summary');
-    assert.strictEqual(majorRailsLaneSummaryResponse.status, 200, 'major rails lane summary route failed');
-    assert.strictEqual(majorRailsLaneSummaryResponse.json.featured_lane_count >= 3, true, 'major rails lane summary count missing');
-
-    const treasuryLaneResponse = await getJson(baseUrl, '/v1/treasury');
-    assert.strictEqual(treasuryLaneResponse.status, 200, 'treasury lane route failed');
-    assert.strictEqual(treasuryLaneResponse.json.product, 'xoonya', 'treasury lane product missing');
-    assert.strictEqual(treasuryLaneResponse.json.lane_state, 'first_party_treasury_proof_connectivity_present', 'treasury lane state missing');
-    assert.strictEqual(treasuryLaneResponse.json.reserve_doctrine.optional_hidden_privacy_reserve, 'monero', 'treasury lane privacy reserve missing');
-
-    const treasuryLaneSummaryResponse = await getJson(baseUrl, '/v1/treasury/summary');
-    assert.strictEqual(treasuryLaneSummaryResponse.status, 200, 'treasury lane summary route failed');
-    assert.strictEqual(treasuryLaneSummaryResponse.json.stable_reserve_count >= 2, true, 'treasury lane stable reserve count missing');
-
-    const erc8004LaneResponse = await getJson(baseUrl, '/v1/erc8004');
-    assert.strictEqual(erc8004LaneResponse.status, 200, 'erc8004 lane route failed');
-    assert.strictEqual(erc8004LaneResponse.json.product, 'xoonya', 'erc8004 lane product missing');
-    assert.strictEqual(erc8004LaneResponse.json.lane_state, 'first_party_erc8004_proof_present', 'erc8004 lane state missing');
-
-    const erc8004LaneSummaryResponse = await getJson(baseUrl, '/v1/erc8004/summary');
-    assert.strictEqual(erc8004LaneSummaryResponse.status, 200, 'erc8004 lane summary route failed');
-    assert.strictEqual(erc8004LaneSummaryResponse.json.product, 'xoonya', 'erc8004 lane summary product missing');
-    assert.strictEqual(erc8004LaneSummaryResponse.json.first_run_flow_count >= 1, true, 'erc8004 lane summary flow count missing');
-
-    const proofBridgeLaneResponse = await getJson(baseUrl, '/v1/proof-bridge');
-    assert.strictEqual(proofBridgeLaneResponse.status, 200, 'proof bridge lane route failed');
-    assert.strictEqual(proofBridgeLaneResponse.json.product, 'xoonya', 'proof bridge lane product missing');
-    assert.strictEqual(proofBridgeLaneResponse.json.lane_state, 'first_party_proof_bridge_present', 'proof bridge lane state missing');
-
-    const proofBridgeLaneSummaryResponse = await getJson(baseUrl, '/v1/proof-bridge/summary');
-    assert.strictEqual(proofBridgeLaneSummaryResponse.status, 200, 'proof bridge lane summary route failed');
-    assert.strictEqual(proofBridgeLaneSummaryResponse.json.product, 'xoonya', 'proof bridge lane summary product missing');
-    assert.strictEqual(proofBridgeLaneSummaryResponse.json.first_run_flow_count >= 2, true, 'proof bridge lane summary flow count missing');
-
-    const verificationServicesResponse = await getJson(baseUrl, '/v1/proof-center/verification-services');
-    assert.strictEqual(verificationServicesResponse.status, 200, 'verification services route failed');
-    assert.strictEqual(verificationServicesResponse.json.category, 'xoonya-verification-services-pack', 'verification services category missing');
-    assert.strictEqual(verificationServicesResponse.json.service_count >= 6, true, 'verification services count missing');
-
-    const verificationServicesSummaryResponse = await getJson(baseUrl, '/v1/proof-center/verification-services/summary');
-    assert.strictEqual(verificationServicesSummaryResponse.status, 200, 'verification services summary route failed');
-    assert.strictEqual(verificationServicesSummaryResponse.json.category, 'xoonya-verification-services-summary', 'verification services summary category missing');
-    assert.strictEqual(verificationServicesSummaryResponse.json.service_count >= 6, true, 'verification services summary count missing');
-
-    const externalProofImportResponse = await getJson(baseUrl, '/v1/external-proof-import');
-    assert.strictEqual(externalProofImportResponse.status, 200, 'external proof import lane route failed');
-    assert.strictEqual(externalProofImportResponse.json.product, 'xoonya', 'external proof import lane product missing');
-    assert.strictEqual(externalProofImportResponse.json.lane_state, 'first_party_external_proof_import_family_present', 'external proof import lane state missing');
-
-    const externalProofImportSummaryResponse = await getJson(baseUrl, '/v1/external-proof-import/summary');
-    assert.strictEqual(externalProofImportSummaryResponse.status, 200, 'external proof import lane summary route failed');
-    assert.strictEqual(externalProofImportSummaryResponse.json.first_run_flow_count >= 1, true, 'external proof import lane summary flow count missing');
-
-    const resultPackageTrustResponse = await getJson(baseUrl, '/v1/result-package-trust');
-    assert.strictEqual(resultPackageTrustResponse.status, 200, 'result package trust lane route failed');
-    assert.strictEqual(resultPackageTrustResponse.json.product, 'xoonya', 'result package trust lane product missing');
-    assert.strictEqual(resultPackageTrustResponse.json.lane_state, 'first_party_result_package_trust_continuity_present', 'result package trust lane state missing');
-
-    const resultPackageTrustSummaryResponse = await getJson(baseUrl, '/v1/result-package-trust/summary');
-    assert.strictEqual(resultPackageTrustSummaryResponse.status, 200, 'result package trust lane summary route failed');
-    assert.strictEqual(resultPackageTrustSummaryResponse.json.first_run_flow_count >= 1, true, 'result package trust lane summary flow count missing');
-
-    const eventSystemsLaneResponse = await getJson(baseUrl, '/v1/event-systems');
-    assert.strictEqual(eventSystemsLaneResponse.status, 200, 'event systems lane route failed');
-    assert.strictEqual(eventSystemsLaneResponse.json.product, 'xoonya', 'event systems lane product missing');
-    assert.strictEqual(eventSystemsLaneResponse.json.lane_state, 'first_party_event_system_family_present', 'event systems lane state missing');
-
-    const eventSystemsLaneSummaryResponse = await getJson(baseUrl, '/v1/event-systems/summary');
-    assert.strictEqual(eventSystemsLaneSummaryResponse.status, 200, 'event systems lane summary route failed');
-    assert.strictEqual(eventSystemsLaneSummaryResponse.json.product, 'xoonya', 'event systems lane summary product missing');
-    assert.strictEqual(eventSystemsLaneSummaryResponse.json.first_run_flow_count >= 1, true, 'event systems lane summary flow count missing');
-
-    const releasePackResponse = await getJson(baseUrl, '/v1/release-pack');
-    assert.strictEqual(releasePackResponse.status, 200, 'release pack route failed');
-    assert.strictEqual(releasePackResponse.json.product.name, 'xoonya', 'release pack product missing');
-    assert.strictEqual(
-      releasePackResponse.json.result_package_handoff_summary.supported_source_refs.includes('result.spine.job.commitment'),
-      true,
-      'release pack result package handoff missing'
-    );
-
-    const releasePackSummaryResponse = await getJson(baseUrl, '/v1/release-pack/summary');
-    assert.strictEqual(releasePackSummaryResponse.status, 200, 'release pack summary route failed');
-    assert.strictEqual(releasePackSummaryResponse.json.product, 'xoonya', 'release pack summary product missing');
-    assert.strictEqual(releasePackSummaryResponse.json.proof_bundle_version, 'proof-bundle/v1', 'release pack summary bundle version missing');
-    assert.strictEqual(releasePackSummaryResponse.json.loop_count >= 2, true, 'release pack summary loop count missing');
-    const comparisonPackResponse = await getJson(baseUrl, '/v1/release-pack/comparison');
-    assert.strictEqual(comparisonPackResponse.status, 200, 'comparison pack route failed');
-    assert.strictEqual(comparisonPackResponse.json.product, 'xoonya', 'comparison pack product missing');
-    assert.strictEqual(comparisonPackResponse.json.comparisons.length >= 3, true, 'comparison pack breadth missing');
-    const comparisonPackSummaryResponse = await getJson(baseUrl, '/v1/release-pack/comparison/summary');
-    assert.strictEqual(comparisonPackSummaryResponse.status, 200, 'comparison pack summary route failed');
-    assert.strictEqual(comparisonPackSummaryResponse.json.comparison_count >= 3, true, 'comparison pack summary count missing');
-    const adoptionPackResponse = await getJson(baseUrl, '/v1/release-pack/adoption');
-    assert.strictEqual(adoptionPackResponse.status, 200, 'adoption pack route failed');
-    assert.strictEqual(adoptionPackResponse.json.product, 'xoonya', 'adoption pack product missing');
-    assert.strictEqual(adoptionPackResponse.json.initial_adoption_targets.length >= 4, true, 'adoption pack target breadth missing');
-    const adoptionPackSummaryResponse = await getJson(baseUrl, '/v1/release-pack/adoption/summary');
-    assert.strictEqual(adoptionPackSummaryResponse.status, 200, 'adoption pack summary route failed');
-    assert.strictEqual(adoptionPackSummaryResponse.json.target_count >= 4, true, 'adoption pack summary count missing');
-    const scenarioPackResponse = await getJson(baseUrl, '/v1/release-pack/scenarios');
-    assert.strictEqual(scenarioPackResponse.status, 200, 'scenario pack route failed');
-    assert.strictEqual(scenarioPackResponse.json.product, 'xoonya', 'scenario pack product missing');
-    assert.strictEqual(scenarioPackResponse.json.scenarios.length >= 3, true, 'scenario pack breadth missing');
-    const scenarioPackSummaryResponse = await getJson(baseUrl, '/v1/release-pack/scenarios/summary');
-    assert.strictEqual(scenarioPackSummaryResponse.status, 200, 'scenario pack summary route failed');
-    assert.strictEqual(scenarioPackSummaryResponse.json.scenario_count >= 3, true, 'scenario pack summary count missing');
-    const launchPackResponse = await getJson(baseUrl, '/v1/release-pack/launch');
-    assert.strictEqual(launchPackResponse.status, 200, 'launch pack route failed');
-    assert.strictEqual(launchPackResponse.json.product, 'xoonya', 'launch pack product missing');
-    assert.strictEqual(Array.isArray(launchPackResponse.json.launch_operator_checks), true, 'launch pack operator checks missing');
-    const launchPackSummaryResponse = await getJson(baseUrl, '/v1/release-pack/launch/summary');
-    assert.strictEqual(launchPackSummaryResponse.status, 200, 'launch pack summary route failed');
-    assert.strictEqual(launchPackSummaryResponse.json.category, 'proof-launch-pack', 'launch pack summary category missing');
-    assert.strictEqual(launchPackSummaryResponse.json.operator_check_count >= 7, true, 'launch pack operator check count missing');
-    const releaseManifestResponse = await getJson(baseUrl, '/v1/release-manifest');
-    assert.strictEqual(releaseManifestResponse.status, 200, 'release manifest route failed');
-    assert.strictEqual(releaseManifestResponse.json.product, 'xoonya', 'release manifest product missing');
-    const releaseManifestSummaryResponse = await getJson(baseUrl, '/v1/release-manifest/summary');
-    assert.strictEqual(releaseManifestSummaryResponse.status, 200, 'release manifest summary route failed');
-    assert.strictEqual(releaseManifestSummaryResponse.json.release_track, 'public_release', 'release manifest track missing');
-    const releaseNotesResponse = await getJson(baseUrl, '/v1/release-notes');
-    assert.strictEqual(releaseNotesResponse.status, 200, 'release notes route failed');
-    assert.strictEqual(releaseNotesResponse.json.product, 'xoonya', 'release notes product missing');
-    const releaseNotesSummaryResponse = await getJson(baseUrl, '/v1/release-notes/summary');
-    assert.strictEqual(releaseNotesSummaryResponse.status, 200, 'release notes summary route failed');
-    assert.strictEqual(releaseNotesSummaryResponse.json.operator_check_count >= 5, true, 'release notes summary checks missing');
-    const releaseCenterResponse = await getJson(baseUrl, '/v1/release-center');
-    assert.strictEqual(releaseCenterResponse.status, 200, 'release center route failed');
-    assert.strictEqual(releaseCenterResponse.json.product, 'xoonya', 'release center product missing');
-    assert.strictEqual(releaseCenterResponse.json.quickstart.first_cli_entrypoint, 'xoonya-release --center --summary', 'release center cli missing');
-    const releaseCenterSummaryResponse = await getJson(baseUrl, '/v1/release-center/summary');
-    assert.strictEqual(releaseCenterSummaryResponse.status, 200, 'release center summary route failed');
-    assert.strictEqual(releaseCenterSummaryResponse.json.category, 'proof-release-center', 'release center summary category missing');
-    assert.strictEqual(releaseCenterSummaryResponse.json.verification_surface_count >= 6, true, 'release center summary verification count missing');
-    const releaseHistoryResponse = await getJson(baseUrl, '/v1/release-history');
-    assert.strictEqual(releaseHistoryResponse.status, 200, 'release history route failed');
-    assert.strictEqual(releaseHistoryResponse.json.product, 'xoonya', 'release history product missing');
-    assert.strictEqual(releaseHistoryResponse.json.history.length >= 2, true, 'release history breadth missing');
-    const releaseHistorySummaryResponse = await getJson(baseUrl, '/v1/release-history/summary');
-    assert.strictEqual(releaseHistorySummaryResponse.status, 200, 'release history summary route failed');
-    assert.strictEqual(releaseHistorySummaryResponse.json.category, 'proof-release-history', 'release history summary category missing');
-    assert.strictEqual(releaseHistorySummaryResponse.json.release_count >= 2, true, 'release history summary count missing');
-    const phaseProgramResponse = await getJson(baseUrl, '/v1/phases');
-    assert.strictEqual(phaseProgramResponse.status, 200, 'phase program route failed');
-    assert.strictEqual(phaseProgramResponse.json.product, 'xoonya', 'phase program product missing');
-    assert.strictEqual(phaseProgramResponse.json.phases.length >= 10, true, 'phase program phases missing');
-    const phaseProgramSummaryResponse = await getJson(baseUrl, '/v1/phases/summary');
-    assert.strictEqual(phaseProgramSummaryResponse.status, 200, 'phase program summary route failed');
-    assert.strictEqual(phaseProgramSummaryResponse.json.category, 'proof-phase-program-pack', 'phase program summary category missing');
-    assert.strictEqual(phaseProgramSummaryResponse.json.phase_count >= 10, true, 'phase program summary phase count missing');
-    assert.strictEqual(phaseProgramSummaryResponse.json.current_phase, 'program_closed', 'phase program current phase missing');
-    const phase1Response = await getJson(baseUrl, '/v1/phases/phase-1');
-    assert.strictEqual(phase1Response.status, 200, 'phase 1 route failed');
-    assert.strictEqual(phase1Response.json.product, 'xoonya', 'phase 1 product missing');
-    assert.strictEqual(phase1Response.json.ecosystems.length >= 2, true, 'phase 1 ecosystems missing');
-    const phase1SummaryResponse = await getJson(baseUrl, '/v1/phases/phase-1/summary');
-    assert.strictEqual(phase1SummaryResponse.status, 200, 'phase 1 summary route failed');
-    assert.strictEqual(phase1SummaryResponse.json.category, 'proof-phase-1-ecosystem-pack', 'phase 1 summary category missing');
-    assert.strictEqual(phase1SummaryResponse.json.active_count >= 2, true, 'phase 1 summary active count missing');
-    const phase1OpenaiCodexResponse = await getJson(baseUrl, '/v1/phases/phase-1/openai-codex');
-    assert.strictEqual(phase1OpenaiCodexResponse.status, 200, 'phase 1 openai/codex route failed');
-    assert.strictEqual(phase1OpenaiCodexResponse.json.category, 'proof-phase-1-openai-codex-pack', 'phase 1 openai/codex category missing');
-    assert.strictEqual(phase1OpenaiCodexResponse.json.scope.first_surfaces.length >= 4, true, 'phase 1 openai/codex surfaces missing');
-    const phase1OpenaiCodexSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-1/openai-codex/summary');
-    assert.strictEqual(phase1OpenaiCodexSummaryResponse.status, 200, 'phase 1 openai/codex summary route failed');
-    assert.strictEqual(phase1OpenaiCodexSummaryResponse.json.surface_count >= 4, true, 'phase 1 openai/codex summary count missing');
-    const phase1OpenaiCodexProofResponse = await getJson(baseUrl, '/v1/phases/phase-1/openai-codex/proof');
-    assert.strictEqual(phase1OpenaiCodexProofResponse.status, 200, 'phase 1 openai/codex proof route failed');
-    assert.strictEqual(phase1OpenaiCodexProofResponse.json.category, 'proof-phase-1-openai-codex-proof-pack', 'phase 1 openai/codex proof category missing');
-    assert.strictEqual(phase1OpenaiCodexProofResponse.json.first_path.first_http_sequence.length >= 3, true, 'phase 1 openai/codex proof steps missing');
-    const phase1OpenaiCodexProofSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-1/openai-codex/proof/summary');
-    assert.strictEqual(phase1OpenaiCodexProofSummaryResponse.status, 200, 'phase 1 openai/codex proof summary route failed');
-    assert.strictEqual(phase1OpenaiCodexProofSummaryResponse.json.http_step_count >= 3, true, 'phase 1 openai/codex proof summary count missing');
-    const phase1ClaudeMcpResponse = await getJson(baseUrl, '/v1/phases/phase-1/claude-mcp');
-    assert.strictEqual(phase1ClaudeMcpResponse.status, 200, 'phase 1 claude/mcp route failed');
-    assert.strictEqual(phase1ClaudeMcpResponse.json.category, 'proof-phase-1-claude-mcp-pack', 'phase 1 claude/mcp category missing');
-    assert.strictEqual(phase1ClaudeMcpResponse.json.scope.first_surfaces.length >= 4, true, 'phase 1 claude/mcp surfaces missing');
-    const phase1ClaudeMcpSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-1/claude-mcp/summary');
-    assert.strictEqual(phase1ClaudeMcpSummaryResponse.status, 200, 'phase 1 claude/mcp summary route failed');
-    assert.strictEqual(phase1ClaudeMcpSummaryResponse.json.surface_count >= 4, true, 'phase 1 claude/mcp summary count missing');
-    const phase1ClaudeMcpProofResponse = await getJson(baseUrl, '/v1/phases/phase-1/claude-mcp/proof');
-    assert.strictEqual(phase1ClaudeMcpProofResponse.status, 200, 'phase 1 claude/mcp proof route failed');
-    assert.strictEqual(phase1ClaudeMcpProofResponse.json.category, 'proof-phase-1-claude-mcp-proof-pack', 'phase 1 claude/mcp proof category missing');
-    assert.strictEqual(phase1ClaudeMcpProofResponse.json.first_path.first_http_sequence.length >= 3, true, 'phase 1 claude/mcp proof steps missing');
-    const phase1ClaudeMcpProofSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-1/claude-mcp/proof/summary');
-    assert.strictEqual(phase1ClaudeMcpProofSummaryResponse.status, 200, 'phase 1 claude/mcp proof summary route failed');
-    assert.strictEqual(phase1ClaudeMcpProofSummaryResponse.json.http_step_count >= 3, true, 'phase 1 claude/mcp proof summary count missing');
-    const phase2Response = await getJson(baseUrl, '/v1/phases/phase-2');
-    assert.strictEqual(phase2Response.status, 200, 'phase 2 route failed');
-    assert.strictEqual(phase2Response.json.category, 'proof-phase-2-payment-rails-pack', 'phase 2 category missing');
-    assert.strictEqual(phase2Response.json.ecosystems.length >= 4, true, 'phase 2 ecosystems missing');
-    const phase2SummaryResponse = await getJson(baseUrl, '/v1/phases/phase-2/summary');
-    assert.strictEqual(phase2SummaryResponse.status, 200, 'phase 2 summary route failed');
-    assert.strictEqual(phase2SummaryResponse.json.ecosystem_count >= 4, true, 'phase 2 summary ecosystem count missing');
-    assert.strictEqual(phase2SummaryResponse.json.proof_mode_count >= 1, true, 'phase 2 summary proof mode count missing');
-    const phase2CompletionResponse = await getJson(baseUrl, '/v1/phases/phase-2/completion');
-    assert.strictEqual(phase2CompletionResponse.status, 200, 'phase 2 completion route failed');
-    assert.strictEqual(phase2CompletionResponse.json.category, 'proof-phase-2-completion-pack', 'phase 2 completion category missing');
-    const phase2CompletionSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-2/completion/summary');
-    assert.strictEqual(phase2CompletionSummaryResponse.status, 200, 'phase 2 completion summary route failed');
-    assert.strictEqual(phase2CompletionSummaryResponse.json.completion_check_count >= 5, true, 'phase 2 completion summary check count missing');
-    const phase2FreezeReviewResponse = await getJson(baseUrl, '/v1/phases/phase-2/freeze-review');
-    assert.strictEqual(phase2FreezeReviewResponse.status, 200, 'phase 2 freeze review route failed');
-    assert.strictEqual(phase2FreezeReviewResponse.json.category, 'proof-phase-2-freeze-review-pack', 'phase 2 freeze review category missing');
-    const phase2FreezeReviewSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-2/freeze-review/summary');
-    assert.strictEqual(phase2FreezeReviewSummaryResponse.status, 200, 'phase 2 freeze review summary route failed');
-    assert.strictEqual(phase2FreezeReviewSummaryResponse.json.blocker_count, 0, 'phase 2 freeze review blocker count mismatch');
-    const phase2GateResponse = await getJson(baseUrl, '/v1/phases/phase-2/gate');
-    assert.strictEqual(phase2GateResponse.status, 200, 'phase 2 gate route failed');
-    assert.strictEqual(phase2GateResponse.json.category, 'proof-phase-2-gate-pack', 'phase 2 gate category missing');
-    const phase2GateSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-2/gate/summary');
-    assert.strictEqual(phase2GateSummaryResponse.status, 200, 'phase 2 gate summary route failed');
-    assert.strictEqual(phase2GateSummaryResponse.json.unsatisfied_gate_count, 0, 'phase 2 gate unsatisfied count mismatch');
-    assert.strictEqual(phase2GateSummaryResponse.json.ready_for_next_phase, true, 'phase 2 gate ready state missing');
-    const phase2CloseoutResponse = await getJson(baseUrl, '/v1/phases/phase-2/closeout');
-    assert.strictEqual(phase2CloseoutResponse.status, 200, 'phase 2 closeout route failed');
-    assert.strictEqual(phase2CloseoutResponse.json.category, 'proof-phase-2-closeout-pack', 'phase 2 closeout category missing');
-    const phase2CloseoutSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-2/closeout/summary');
-    assert.strictEqual(phase2CloseoutSummaryResponse.status, 200, 'phase 2 closeout summary route failed');
-    assert.strictEqual(phase2CloseoutSummaryResponse.json.blocking_action_count, 0, 'phase 2 closeout blocking action count mismatch');
-    assert.strictEqual(phase2CloseoutSummaryResponse.json.current_decision, 'ready_for_phase_3', 'phase 2 closeout decision mismatch');
-    const phase2DecisionRecordResponse = await getJson(baseUrl, '/v1/phases/phase-2/decision-record');
-    assert.strictEqual(phase2DecisionRecordResponse.status, 200, 'phase 2 decision-record route failed');
-    assert.strictEqual(phase2DecisionRecordResponse.json.category, 'proof-phase-2-decision-record-pack', 'phase 2 decision-record category missing');
-    const phase2DecisionRecordSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-2/decision-record/summary');
-    assert.strictEqual(phase2DecisionRecordSummaryResponse.status, 200, 'phase 2 decision-record summary route failed');
-    assert.strictEqual(phase2DecisionRecordSummaryResponse.json.pending_record_count, 0, 'phase 2 decision-record pending count mismatch');
-    assert.strictEqual(phase2DecisionRecordSummaryResponse.json.freeze_decision_status, 'recorded', 'phase 2 freeze decision status mismatch');
-    assert.strictEqual(phase2DecisionRecordSummaryResponse.json.gate_review_status, 'recorded', 'phase 2 gate review status mismatch');
-    const phase2DecisionResolutionResponse = await getJson(baseUrl, '/v1/phases/phase-2/decision-resolution');
-    assert.strictEqual(phase2DecisionResolutionResponse.status, 200, 'phase 2 decision-resolution route failed');
-    assert.strictEqual(phase2DecisionResolutionResponse.json.category, 'proof-phase-2-decision-resolution-pack', 'phase 2 decision-resolution category missing');
-    const phase2DecisionResolutionSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-2/decision-resolution/summary');
-    assert.strictEqual(phase2DecisionResolutionSummaryResponse.status, 200, 'phase 2 decision-resolution summary route failed');
-    assert.strictEqual(phase2DecisionResolutionSummaryResponse.json.transition_count >= 2, true, 'phase 2 decision-resolution transition count missing');
-    const phase2FlipPreviewResponse = await getJson(baseUrl, '/v1/phases/phase-2/flip-preview');
-    assert.strictEqual(phase2FlipPreviewResponse.status, 200, 'phase 2 flip-preview route failed');
-    assert.strictEqual(phase2FlipPreviewResponse.json.category, 'proof-phase-2-flip-preview-pack', 'phase 2 flip-preview category missing');
-    const phase2FlipPreviewSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-2/flip-preview/summary');
-    assert.strictEqual(phase2FlipPreviewSummaryResponse.status, 200, 'phase 2 flip-preview summary route failed');
-    assert.strictEqual(phase2FlipPreviewSummaryResponse.json.ready_for_next_phase, true, 'phase 2 flip-preview ready state missing');
-    const phase2EvmBaseProofResponse = await getJson(baseUrl, '/v1/phases/phase-2/evm-base/proof');
-    assert.strictEqual(phase2EvmBaseProofResponse.status, 200, 'phase 2 evm/base proof route failed');
-    assert.strictEqual(phase2EvmBaseProofResponse.json.category, 'proof-phase-2-evm-base-proof-pack', 'phase 2 evm/base proof category missing');
-    assert.strictEqual(phase2EvmBaseProofResponse.json.first_path.first_http_sequence.length >= 3, true, 'phase 2 evm/base proof steps missing');
-    const phase2EvmBaseProofSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-2/evm-base/proof/summary');
-    assert.strictEqual(phase2EvmBaseProofSummaryResponse.status, 200, 'phase 2 evm/base proof summary route failed');
-    assert.strictEqual(phase2EvmBaseProofSummaryResponse.json.http_step_count >= 3, true, 'phase 2 evm/base proof summary count missing');
-    const phase2BaseUsdcProofResponse = await getJson(baseUrl, '/v1/phases/phase-2/base-usdc/proof');
-    assert.strictEqual(phase2BaseUsdcProofResponse.status, 200, 'phase 2 base/usdc proof route failed');
-    assert.strictEqual(phase2BaseUsdcProofResponse.json.category, 'proof-phase-2-base-usdc-proof-pack', 'phase 2 base/usdc proof category missing');
-    assert.strictEqual(phase2BaseUsdcProofResponse.json.first_path.first_http_sequence.length >= 3, true, 'phase 2 base/usdc proof steps missing');
-    const phase2BaseUsdcProofSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-2/base-usdc/proof/summary');
-    assert.strictEqual(phase2BaseUsdcProofSummaryResponse.status, 200, 'phase 2 base/usdc proof summary route failed');
-    assert.strictEqual(phase2BaseUsdcProofSummaryResponse.json.http_step_count >= 3, true, 'phase 2 base/usdc proof summary count missing');
-    assert.strictEqual(phase2BaseUsdcProofSummaryResponse.json.signal_count >= 3, true, 'phase 2 base/usdc proof summary signal count missing');
-    const phase2EthProofResponse = await getJson(baseUrl, '/v1/phases/phase-2/eth/proof');
-    assert.strictEqual(phase2EthProofResponse.status, 200, 'phase 2 eth proof route failed');
-    assert.strictEqual(phase2EthProofResponse.json.category, 'proof-phase-2-eth-proof-pack', 'phase 2 eth proof category missing');
-    assert.strictEqual(phase2EthProofResponse.json.settlement_shape.proof_surfaces.length >= 2, true, 'phase 2 eth proof surfaces missing');
-    const phase2EthProofSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-2/eth/proof/summary');
-    assert.strictEqual(phase2EthProofSummaryResponse.status, 200, 'phase 2 eth proof summary route failed');
-    assert.strictEqual(phase2EthProofSummaryResponse.json.proof_surface_count >= 2, true, 'phase 2 eth proof summary surface count missing');
-    const phase2EvmProofResponse = await getJson(baseUrl, '/v1/phases/phase-2/evm/proof');
-    assert.strictEqual(phase2EvmProofResponse.status, 200, 'phase 2 evm proof route failed');
-    assert.strictEqual(phase2EvmProofResponse.json.category, 'proof-phase-2-evm-proof-pack', 'phase 2 evm proof category missing');
-    assert.strictEqual(phase2EvmProofResponse.json.settlement_shape.proof_modes.length >= 1, true, 'phase 2 evm proof modes missing');
-    const phase2EvmProofSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-2/evm/proof/summary');
-    assert.strictEqual(phase2EvmProofSummaryResponse.status, 200, 'phase 2 evm proof summary route failed');
-    assert.strictEqual(phase2EvmProofSummaryResponse.json.proof_mode_count >= 1, true, 'phase 2 evm proof summary mode count missing');
-    const phase2BaseProofResponse = await getJson(baseUrl, '/v1/phases/phase-2/base/proof');
-    assert.strictEqual(phase2BaseProofResponse.status, 200, 'phase 2 base proof route failed');
-    assert.strictEqual(phase2BaseProofResponse.json.category, 'proof-phase-2-base-proof-pack', 'phase 2 base proof category missing');
-    assert.strictEqual(phase2BaseProofResponse.json.settlement_shape.proof_surfaces.length >= 2, true, 'phase 2 base proof surfaces missing');
-    const phase2BaseProofSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-2/base/proof/summary');
-    assert.strictEqual(phase2BaseProofSummaryResponse.status, 200, 'phase 2 base proof summary route failed');
-    assert.strictEqual(phase2BaseProofSummaryResponse.json.proof_surface_count >= 2, true, 'phase 2 base proof summary surface count missing');
-    const phase2UsdcProofResponse = await getJson(baseUrl, '/v1/phases/phase-2/usdc/proof');
-    assert.strictEqual(phase2UsdcProofResponse.status, 200, 'phase 2 usdc proof route failed');
-    assert.strictEqual(phase2UsdcProofResponse.json.category, 'proof-phase-2-usdc-proof-pack', 'phase 2 usdc proof category missing');
-    assert.strictEqual(phase2UsdcProofResponse.json.settlement_shape.proof_surfaces.length >= 2, true, 'phase 2 usdc proof surfaces missing');
-    const phase2UsdcProofSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-2/usdc/proof/summary');
-    assert.strictEqual(phase2UsdcProofSummaryResponse.status, 200, 'phase 2 usdc proof summary route failed');
-    assert.strictEqual(phase2UsdcProofSummaryResponse.json.proof_surface_count >= 2, true, 'phase 2 usdc proof summary surface count missing');
-    const phase3Response = await getJson(baseUrl, '/v1/phases/phase-3');
-    assert.strictEqual(phase3Response.status, 200, 'phase 3 route failed');
-    assert.strictEqual(phase3Response.json.category, 'proof-phase-3-native-bsv-pack', 'phase 3 category missing');
-    assert.strictEqual(phase3Response.json.ecosystems.length >= 4, true, 'phase 3 ecosystems missing');
-    const phase3SummaryResponse = await getJson(baseUrl, '/v1/phases/phase-3/summary');
-    assert.strictEqual(phase3SummaryResponse.status, 200, 'phase 3 summary route failed');
-    assert.strictEqual(phase3SummaryResponse.json.ecosystem_count >= 4, true, 'phase 3 summary ecosystem count missing');
-    assert.strictEqual(phase3SummaryResponse.json.identity_layer_count >= 2, true, 'phase 3 summary identity layer count missing');
-    const phase3NativeContinuityResponse = await getJson(baseUrl, '/v1/phases/phase-3/native-continuity');
-    assert.strictEqual(phase3NativeContinuityResponse.status, 200, 'phase 3 native continuity route failed');
-    assert.strictEqual(phase3NativeContinuityResponse.json.category, 'proof-phase-3-native-continuity-pack', 'phase 3 native continuity category missing');
-    const phase3NativeContinuitySummaryResponse = await getJson(baseUrl, '/v1/phases/phase-3/native-continuity/summary');
-    assert.strictEqual(phase3NativeContinuitySummaryResponse.status, 200, 'phase 3 native continuity summary route failed');
-    assert.strictEqual(phase3NativeContinuitySummaryResponse.json.signal_count >= 4, true, 'phase 3 native continuity signal count missing');
-    const phase3FreezeBaselineResponse = await getJson(baseUrl, '/v1/phases/phase-3/freeze-baseline');
-    assert.strictEqual(phase3FreezeBaselineResponse.status, 200, 'phase 3 freeze baseline route failed');
-    assert.strictEqual(phase3FreezeBaselineResponse.json.category, 'proof-phase-3-freeze-baseline-pack', 'phase 3 freeze baseline category missing');
-    const phase3FreezeBaselineSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-3/freeze-baseline/summary');
-    assert.strictEqual(phase3FreezeBaselineSummaryResponse.status, 200, 'phase 3 freeze baseline summary route failed');
-    assert.strictEqual(phase3FreezeBaselineSummaryResponse.json.baseline_status, 'recorded', 'phase 3 freeze baseline status mismatch');
-    const phase3CompletionResponse = await getJson(baseUrl, '/v1/phases/phase-3/completion');
-    assert.strictEqual(phase3CompletionResponse.status, 200, 'phase 3 completion route failed');
-    assert.strictEqual(phase3CompletionResponse.json.category, 'proof-phase-3-completion-pack', 'phase 3 completion category missing');
-    const phase3CompletionSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-3/completion/summary');
-    assert.strictEqual(phase3CompletionSummaryResponse.status, 200, 'phase 3 completion summary route failed');
-    assert.strictEqual(phase3CompletionSummaryResponse.json.completion_check_count >= 5, true, 'phase 3 completion summary check count missing');
-    const phase3FreezeReviewResponse = await getJson(baseUrl, '/v1/phases/phase-3/freeze-review');
-    assert.strictEqual(phase3FreezeReviewResponse.status, 200, 'phase 3 freeze review route failed');
-    assert.strictEqual(phase3FreezeReviewResponse.json.category, 'proof-phase-3-freeze-review-pack', 'phase 3 freeze review category missing');
-    const phase3FreezeReviewSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-3/freeze-review/summary');
-    assert.strictEqual(phase3FreezeReviewSummaryResponse.status, 200, 'phase 3 freeze review summary route failed');
-    assert.strictEqual(phase3FreezeReviewSummaryResponse.json.blocker_count, 0, 'phase 3 freeze review blocker count mismatch');
-    const phase3GateResponse = await getJson(baseUrl, '/v1/phases/phase-3/gate');
-    assert.strictEqual(phase3GateResponse.status, 200, 'phase 3 gate route failed');
-    assert.strictEqual(phase3GateResponse.json.category, 'proof-phase-3-gate-pack', 'phase 3 gate category missing');
-    const phase3GateSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-3/gate/summary');
-    assert.strictEqual(phase3GateSummaryResponse.status, 200, 'phase 3 gate summary route failed');
-    assert.strictEqual(phase3GateSummaryResponse.json.unsatisfied_gate_count, 0, 'phase 3 gate unsatisfied count mismatch');
-    const phase3CloseoutResponse = await getJson(baseUrl, '/v1/phases/phase-3/closeout');
-    assert.strictEqual(phase3CloseoutResponse.status, 200, 'phase 3 closeout route failed');
-    assert.strictEqual(phase3CloseoutResponse.json.category, 'proof-phase-3-closeout-pack', 'phase 3 closeout category missing');
-    const phase3CloseoutSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-3/closeout/summary');
-    assert.strictEqual(phase3CloseoutSummaryResponse.status, 200, 'phase 3 closeout summary route failed');
-    assert.strictEqual(phase3CloseoutSummaryResponse.json.blocking_action_count, 0, 'phase 3 closeout blocking action count mismatch');
-    const phase3DecisionRecordResponse = await getJson(baseUrl, '/v1/phases/phase-3/decision-record');
-    assert.strictEqual(phase3DecisionRecordResponse.status, 200, 'phase 3 decision-record route failed');
-    assert.strictEqual(phase3DecisionRecordResponse.json.category, 'proof-phase-3-decision-record-pack', 'phase 3 decision-record category missing');
-    const phase3DecisionRecordSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-3/decision-record/summary');
-    assert.strictEqual(phase3DecisionRecordSummaryResponse.status, 200, 'phase 3 decision-record summary route failed');
-    assert.strictEqual(phase3DecisionRecordSummaryResponse.json.pending_record_count, 0, 'phase 3 decision-record pending count mismatch');
-    const phase3DecisionResolutionResponse = await getJson(baseUrl, '/v1/phases/phase-3/decision-resolution');
-    assert.strictEqual(phase3DecisionResolutionResponse.status, 200, 'phase 3 decision-resolution route failed');
-    assert.strictEqual(phase3DecisionResolutionResponse.json.category, 'proof-phase-3-decision-resolution-pack', 'phase 3 decision-resolution category missing');
-    const phase3DecisionResolutionSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-3/decision-resolution/summary');
-    assert.strictEqual(phase3DecisionResolutionSummaryResponse.status, 200, 'phase 3 decision-resolution summary route failed');
-    assert.strictEqual(phase3DecisionResolutionSummaryResponse.json.transition_count >= 2, true, 'phase 3 decision-resolution transition count missing');
-    const phase3BsvTeranodeProofResponse = await getJson(baseUrl, '/v1/phases/phase-3/bsv-teranode/proof');
-    assert.strictEqual(phase3BsvTeranodeProofResponse.status, 200, 'phase 3 bsv/teranode proof route failed');
-    assert.strictEqual(phase3BsvTeranodeProofResponse.json.category, 'proof-phase-3-bsv-teranode-proof-pack', 'phase 3 bsv/teranode proof category missing');
-    assert.strictEqual(phase3BsvTeranodeProofResponse.json.first_path.first_http_sequence.length >= 3, true, 'phase 3 bsv/teranode proof steps missing');
-    const phase3BsvTeranodeProofSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-3/bsv-teranode/proof/summary');
-    assert.strictEqual(phase3BsvTeranodeProofSummaryResponse.status, 200, 'phase 3 bsv/teranode proof summary route failed');
-    assert.strictEqual(phase3BsvTeranodeProofSummaryResponse.json.http_step_count >= 3, true, 'phase 3 bsv/teranode proof summary count missing');
-    const phase3MetanetProofResponse = await getJson(baseUrl, '/v1/phases/phase-3/metanet/proof');
-    assert.strictEqual(phase3MetanetProofResponse.status, 200, 'phase 3 metanet proof route failed');
-    assert.strictEqual(phase3MetanetProofResponse.json.category, 'proof-phase-3-metanet-proof-pack', 'phase 3 metanet proof category missing');
-    const phase3MetanetProofSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-3/metanet/proof/summary');
-    assert.strictEqual(phase3MetanetProofSummaryResponse.status, 200, 'phase 3 metanet proof summary route failed');
-    assert.strictEqual(phase3MetanetProofSummaryResponse.json.http_step_count >= 3, true, 'phase 3 metanet proof summary count missing');
-    const phase3BrcProofResponse = await getJson(baseUrl, '/v1/phases/phase-3/brc/proof');
-    assert.strictEqual(phase3BrcProofResponse.status, 200, 'phase 3 brc proof route failed');
-    assert.strictEqual(phase3BrcProofResponse.json.category, 'proof-phase-3-brc-proof-pack', 'phase 3 brc proof category missing');
-    const phase3BrcProofSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-3/brc/proof/summary');
-    assert.strictEqual(phase3BrcProofSummaryResponse.status, 200, 'phase 3 brc proof summary route failed');
-    assert.strictEqual(phase3BrcProofSummaryResponse.json.http_step_count >= 3, true, 'phase 3 brc proof summary count missing');
-    const phase4Response = await getJson(baseUrl, '/v1/phases/phase-4');
-    assert.strictEqual(phase4Response.status, 200, 'phase 4 route failed');
-    assert.strictEqual(phase4Response.json.category, 'proof-phase-4-identity-trust-pack', 'phase 4 category missing');
-    const phase4SummaryResponse = await getJson(baseUrl, '/v1/phases/phase-4/summary');
-    assert.strictEqual(phase4SummaryResponse.status, 200, 'phase 4 summary route failed');
-    assert.strictEqual(phase4SummaryResponse.json.ecosystem_count >= 3, true, 'phase 4 ecosystem count missing');
-    assert.strictEqual(phase4SummaryResponse.json.erc8004_mode_count >= 3, true, 'phase 4 erc8004 mode count missing');
-    const phase4Erc8004ProofResponse = await getJson(baseUrl, '/v1/phases/phase-4/erc8004/proof');
-    assert.strictEqual(phase4Erc8004ProofResponse.status, 200, 'phase 4 erc8004 proof route failed');
-    assert.strictEqual(phase4Erc8004ProofResponse.json.category, 'proof-phase-4-erc8004-proof-pack', 'phase 4 erc8004 proof category missing');
-    const phase4Erc8004ProofSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-4/erc8004/proof/summary');
-    assert.strictEqual(phase4Erc8004ProofSummaryResponse.status, 200, 'phase 4 erc8004 proof summary route failed');
-    assert.strictEqual(phase4Erc8004ProofSummaryResponse.json.http_step_count >= 3, true, 'phase 4 erc8004 proof summary count missing');
-    assert.strictEqual(phase4Erc8004ProofSummaryResponse.json.erc8004_mode_count >= 3, true, 'phase 4 erc8004 proof mode detail missing');
-    const phase4IdentityRegistryProofResponse = await getJson(baseUrl, '/v1/phases/phase-4/identity-registry/proof');
-    assert.strictEqual(phase4IdentityRegistryProofResponse.status, 200, 'phase 4 identity registry proof route failed');
-    assert.strictEqual(phase4IdentityRegistryProofResponse.json.category, 'proof-phase-4-identity-registry-proof-pack', 'phase 4 identity registry proof category missing');
-    const phase4IdentityRegistryProofSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-4/identity-registry/proof/summary');
-    assert.strictEqual(phase4IdentityRegistryProofSummaryResponse.status, 200, 'phase 4 identity registry proof summary route failed');
-    assert.strictEqual(phase4IdentityRegistryProofSummaryResponse.json.http_step_count >= 3, true, 'phase 4 identity registry proof summary count missing');
-    assert.strictEqual(phase4IdentityRegistryProofSummaryResponse.json.resolution_mode_count >= 3, true, 'phase 4 identity registry proof resolution detail missing');
-    const phase4AttestationProofResponse = await getJson(baseUrl, '/v1/phases/phase-4/attestation/proof');
-    assert.strictEqual(phase4AttestationProofResponse.status, 200, 'phase 4 attestation proof route failed');
-    assert.strictEqual(phase4AttestationProofResponse.json.category, 'proof-phase-4-attestation-proof-pack', 'phase 4 attestation proof category missing');
-    const phase4AttestationProofSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-4/attestation/proof/summary');
-    assert.strictEqual(phase4AttestationProofSummaryResponse.status, 200, 'phase 4 attestation proof summary route failed');
-    assert.strictEqual(phase4AttestationProofSummaryResponse.json.http_step_count >= 3, true, 'phase 4 attestation proof summary count missing');
-    assert.strictEqual(phase4AttestationProofSummaryResponse.json.review_mode_count >= 3, true, 'phase 4 attestation proof review detail missing');
-    const phase4TrustContinuityResponse = await getJson(baseUrl, '/v1/phases/phase-4/trust-continuity');
-    assert.strictEqual(phase4TrustContinuityResponse.status, 200, 'phase 4 trust continuity route failed');
-    assert.strictEqual(phase4TrustContinuityResponse.json.category, 'proof-phase-4-trust-continuity-pack', 'phase 4 trust continuity category missing');
-    const phase4CompletionResponse = await getJson(baseUrl, '/v1/phases/phase-4/completion/summary');
-    assert.strictEqual(phase4CompletionResponse.status, 200, 'phase 4 completion summary route failed');
-    assert.strictEqual(phase4CompletionResponse.json.readiness_criteria_count >= 6, true, 'phase 4 completion criteria missing');
-    const phase4FreezeBaselineResponse = await getJson(baseUrl, '/v1/phases/phase-4/freeze-baseline/summary');
-    assert.strictEqual(phase4FreezeBaselineResponse.status, 200, 'phase 4 freeze baseline summary route failed');
-    assert.strictEqual(phase4FreezeBaselineResponse.json.baseline_status, 'recorded', 'phase 4 freeze baseline status missing');
-    const phase4GateResponse = await getJson(baseUrl, '/v1/phases/phase-4/gate/summary');
-    assert.strictEqual(phase4GateResponse.status, 200, 'phase 4 gate summary route failed');
-    assert.strictEqual(typeof phase4GateResponse.json.decision, 'string', 'phase 4 gate decision missing');
-    assert.strictEqual(phase4GateResponse.json.decision, 'ready_for_phase_5', 'phase 4 gate decision mismatch');
-    const phase5Response = await getJson(baseUrl, '/v1/phases/phase-5');
-    assert.strictEqual(phase5Response.status, 200, 'phase 5 route failed');
-    assert.strictEqual(phase5Response.json.category, 'proof-phase-5-major-rails-pack', 'phase 5 category missing');
-    const phase5ContinuitySummaryResponse = await getJson(baseUrl, '/v1/phases/phase-5/major-rails-continuity/summary');
-    assert.strictEqual(phase5ContinuitySummaryResponse.status, 200, 'phase 5 continuity summary route failed');
-    assert.strictEqual(phase5ContinuitySummaryResponse.json.signal_count >= 4, true, 'phase 5 continuity signals missing');
-    const phase5CompletionSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-5/completion/summary');
-    assert.strictEqual(phase5CompletionSummaryResponse.status, 200, 'phase 5 completion summary route failed');
-    assert.strictEqual(phase5CompletionSummaryResponse.json.unsatisfied_criteria_count, 0, 'phase 5 completion state mismatch');
-    const phase5FreezeBaselineSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-5/freeze-baseline/summary');
-    assert.strictEqual(phase5FreezeBaselineSummaryResponse.status, 200, 'phase 5 freeze baseline summary route failed');
-    assert.strictEqual(phase5FreezeBaselineSummaryResponse.json.baseline_status, 'recorded', 'phase 5 freeze baseline status missing');
-    const phase5GateSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-5/gate/summary');
-    assert.strictEqual(phase5GateSummaryResponse.status, 200, 'phase 5 gate summary route failed');
-    assert.strictEqual(phase5GateSummaryResponse.json.decision, 'ready_for_phase_6', 'phase 5 gate decision mismatch');
-    const phase6Response = await getJson(baseUrl, '/v1/phases/phase-6');
-    assert.strictEqual(phase6Response.status, 200, 'phase 6 route failed');
-    assert.strictEqual(phase6Response.json.category, 'proof-phase-6-framework-runtime-pack', 'phase 6 category missing');
-    const phase6SummaryResponse = await getJson(baseUrl, '/v1/phases/phase-6/summary');
-    assert.strictEqual(phase6SummaryResponse.status, 200, 'phase 6 summary route failed');
-    assert.strictEqual(phase6SummaryResponse.json.proof_mode_count >= 3, true, 'phase 6 proof mode count missing');
-    const phase6LanggraphProofSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-6/langgraph/proof/summary');
-    assert.strictEqual(phase6LanggraphProofSummaryResponse.status, 200, 'phase 6 langgraph proof summary route failed');
-    assert.strictEqual(phase6LanggraphProofSummaryResponse.json.category, 'proof-phase-6-langgraph-proof-pack', 'phase 6 langgraph proof category missing');
-    assert.strictEqual(phase6LanggraphProofSummaryResponse.json.followthrough_mode_count >= 3, true, 'phase 6 langgraph followthrough mode count missing');
-    const phase6LangchainProofSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-6/langchain/proof/summary');
-    assert.strictEqual(phase6LangchainProofSummaryResponse.status, 200, 'phase 6 langchain proof summary route failed');
-    assert.strictEqual(phase6LangchainProofSummaryResponse.json.category, 'proof-phase-6-langchain-proof-pack', 'phase 6 langchain proof category missing');
-    assert.strictEqual(phase6LangchainProofSummaryResponse.json.followthrough_mode_count >= 3, true, 'phase 6 langchain followthrough mode count missing');
-    const phase6AutogenProofSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-6/autogen/proof/summary');
-    assert.strictEqual(phase6AutogenProofSummaryResponse.status, 200, 'phase 6 autogen proof summary route failed');
-    assert.strictEqual(phase6AutogenProofSummaryResponse.json.category, 'proof-phase-6-autogen-proof-pack', 'phase 6 autogen proof category missing');
-    assert.strictEqual(phase6AutogenProofSummaryResponse.json.followthrough_mode_count >= 3, true, 'phase 6 autogen followthrough mode count missing');
-    const phase6SemanticKernelProofSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-6/semantic-kernel/proof/summary');
-    assert.strictEqual(phase6SemanticKernelProofSummaryResponse.status, 200, 'phase 6 semantic kernel proof summary route failed');
-    assert.strictEqual(phase6SemanticKernelProofSummaryResponse.json.category, 'proof-phase-6-semantic-kernel-proof-pack', 'phase 6 semantic kernel proof category missing');
-    assert.strictEqual(phase6SemanticKernelProofSummaryResponse.json.followthrough_mode_count >= 3, true, 'phase 6 semantic kernel followthrough mode count missing');
-    const phase6ContinuitySummaryResponse = await getJson(baseUrl, '/v1/phases/phase-6/framework-continuity/summary');
-    assert.strictEqual(phase6ContinuitySummaryResponse.status, 200, 'phase 6 continuity summary route failed');
-    assert.strictEqual(phase6ContinuitySummaryResponse.json.category, 'proof-phase-6-framework-continuity-pack', 'phase 6 continuity category missing');
-    assert.strictEqual(phase6ContinuitySummaryResponse.json.signal_count >= 4, true, 'phase 6 continuity signal count missing');
-    const phase6CompletionSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-6/completion/summary');
-    assert.strictEqual(phase6CompletionSummaryResponse.status, 200, 'phase 6 completion summary route failed');
-    assert.strictEqual(phase6CompletionSummaryResponse.json.unsatisfied_criteria_count, 0, 'phase 6 completion state mismatch');
-    const phase6FreezeBaselineSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-6/freeze-baseline/summary');
-    assert.strictEqual(phase6FreezeBaselineSummaryResponse.status, 200, 'phase 6 freeze baseline summary route failed');
-    assert.strictEqual(phase6FreezeBaselineSummaryResponse.json.category, 'proof-phase-6-freeze-baseline-pack', 'phase 6 freeze baseline category mismatch');
-    assert.strictEqual(phase6FreezeBaselineSummaryResponse.json.baseline_status, 'recorded', 'phase 6 freeze baseline state mismatch');
-    const phase6GateSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-6/gate/summary');
-    assert.strictEqual(phase6GateSummaryResponse.status, 200, 'phase 6 gate summary route failed');
-    assert.strictEqual(phase6GateSummaryResponse.json.decision, 'ready_for_phase_7', 'phase 6 gate decision mismatch');
-    const phase7Response = await getJson(baseUrl, '/v1/phases/phase-7');
-    assert.strictEqual(phase7Response.status, 200, 'phase 7 route failed');
-    assert.strictEqual(phase7Response.json.category, 'proof-phase-7-event-system-pack', 'phase 7 category missing');
-    const phase7SummaryResponse = await getJson(baseUrl, '/v1/phases/phase-7/summary');
-    assert.strictEqual(phase7SummaryResponse.status, 200, 'phase 7 summary route failed');
-    assert.strictEqual(phase7SummaryResponse.json.proof_mode_count >= 3, true, 'phase 7 proof mode count missing');
-    assert.strictEqual(phase7SummaryResponse.json.lane_count >= 4, true, 'phase 7 lane count missing');
-    const phase7KafkaProofSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-7/kafka/proof/summary');
-    assert.strictEqual(phase7KafkaProofSummaryResponse.status, 200, 'phase 7 kafka proof summary route failed');
-    assert.strictEqual(phase7KafkaProofSummaryResponse.json.category, 'proof-phase-7-kafka-proof-pack', 'phase 7 kafka proof category missing');
-    assert.strictEqual(phase7KafkaProofSummaryResponse.json.evidence_mode_count >= 3, true, 'phase 7 kafka evidence mode count missing');
-    const phase7NatsProofSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-7/nats/proof/summary');
-    assert.strictEqual(phase7NatsProofSummaryResponse.status, 200, 'phase 7 nats proof summary route failed');
-    assert.strictEqual(phase7NatsProofSummaryResponse.json.category, 'proof-phase-7-nats-proof-pack', 'phase 7 nats proof category missing');
-    assert.strictEqual(phase7NatsProofSummaryResponse.json.evidence_mode_count >= 3, true, 'phase 7 nats evidence mode count missing');
-    const phase7MqttProofSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-7/mqtt/proof/summary');
-    assert.strictEqual(phase7MqttProofSummaryResponse.status, 200, 'phase 7 mqtt proof summary route failed');
-    assert.strictEqual(phase7MqttProofSummaryResponse.json.category, 'proof-phase-7-mqtt-proof-pack', 'phase 7 mqtt proof category missing');
-    assert.strictEqual(phase7MqttProofSummaryResponse.json.evidence_mode_count >= 3, true, 'phase 7 mqtt evidence mode count missing');
-    const phase7WebhookEventBusProofSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-7/webhook-event-bus/proof/summary');
-    assert.strictEqual(phase7WebhookEventBusProofSummaryResponse.status, 200, 'phase 7 webhook event bus proof summary route failed');
-    assert.strictEqual(
-      phase7WebhookEventBusProofSummaryResponse.json.category,
-      'proof-phase-7-webhook-event-bus-proof-pack',
-      'phase 7 webhook event bus proof category missing'
-    );
-    assert.strictEqual(phase7WebhookEventBusProofSummaryResponse.json.evidence_mode_count >= 3, true, 'phase 7 webhook event bus evidence mode count missing');
-    const phase7ContinuitySummaryResponse = await getJson(baseUrl, '/v1/phases/phase-7/event-system-continuity/summary');
-    assert.strictEqual(phase7ContinuitySummaryResponse.status, 200, 'phase 7 continuity summary route failed');
-    assert.strictEqual(phase7ContinuitySummaryResponse.json.category, 'proof-phase-7-event-system-continuity-pack', 'phase 7 continuity category missing');
-    const phase7CompletionSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-7/completion/summary');
-    assert.strictEqual(phase7CompletionSummaryResponse.status, 200, 'phase 7 completion summary route failed');
-    assert.strictEqual(phase7CompletionSummaryResponse.json.category, 'proof-phase-7-completion-pack', 'phase 7 completion category missing');
-    assert.strictEqual(phase7CompletionSummaryResponse.json.unsatisfied_criteria_count, 0, 'phase 7 completion state mismatch');
-    const phase7FreezeBaselineSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-7/freeze-baseline/summary');
-    assert.strictEqual(phase7FreezeBaselineSummaryResponse.status, 200, 'phase 7 freeze baseline summary route failed');
-    assert.strictEqual(phase7FreezeBaselineSummaryResponse.json.category, 'proof-phase-7-freeze-baseline-pack', 'phase 7 freeze baseline category missing');
-    const phase7FreezeReviewSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-7/freeze-review/summary');
-    assert.strictEqual(phase7FreezeReviewSummaryResponse.status, 200, 'phase 7 freeze review summary route failed');
-    assert.strictEqual(phase7FreezeReviewSummaryResponse.json.category, 'proof-phase-7-freeze-review-pack', 'phase 7 freeze review category missing');
-    const phase7GateSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-7/gate/summary');
-    assert.strictEqual(phase7GateSummaryResponse.status, 200, 'phase 7 gate summary route failed');
-    assert.strictEqual(phase7GateSummaryResponse.json.category, 'proof-phase-7-gate-pack', 'phase 7 gate category missing');
-    assert.strictEqual(phase7GateSummaryResponse.json.decision, 'ready_for_phase_8', 'phase 7 gate decision mismatch');
-    assert.strictEqual(phase7GateSummaryResponse.json.unsatisfied_gate_count, 0, 'phase 7 gate state mismatch');
-    const phase7CloseoutSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-7/closeout/summary');
-    assert.strictEqual(phase7CloseoutSummaryResponse.status, 200, 'phase 7 closeout summary route failed');
-    assert.strictEqual(phase7CloseoutSummaryResponse.json.category, 'proof-phase-7-closeout-pack', 'phase 7 closeout category missing');
-    const phase7DecisionRecordSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-7/decision-record/summary');
-    assert.strictEqual(phase7DecisionRecordSummaryResponse.status, 200, 'phase 7 decision-record summary route failed');
-    assert.strictEqual(phase7DecisionRecordSummaryResponse.json.category, 'proof-phase-7-decision-record-pack', 'phase 7 decision-record category missing');
-    assert.strictEqual(phase7DecisionRecordSummaryResponse.json.pending_record_count, 0, 'phase 7 decision-record state mismatch');
-    const phase8SummaryResponse = await getJson(baseUrl, '/v1/phases/phase-8/summary');
-    assert.strictEqual(phase8SummaryResponse.status, 200, 'phase 8 summary route failed');
-    assert.strictEqual(phase8SummaryResponse.json.category, 'proof-phase-8-proof-bridges-pack', 'phase 8 category missing');
-    const phase8ProofBridgeContinuitySummaryResponse = await getJson(baseUrl, '/v1/phases/phase-8/proof-bridge-continuity/summary');
-    assert.strictEqual(phase8ProofBridgeContinuitySummaryResponse.status, 200, 'phase 8 proof-bridge continuity summary route failed');
-    assert.strictEqual(phase8ProofBridgeContinuitySummaryResponse.json.category, 'proof-phase-8-proof-bridge-continuity-pack', 'phase 8 proof-bridge continuity category missing');
-    const phase8CompletionSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-8/completion/summary');
-    assert.strictEqual(phase8CompletionSummaryResponse.status, 200, 'phase 8 completion summary route failed');
-    assert.strictEqual(phase8CompletionSummaryResponse.json.category, 'proof-phase-8-completion-pack', 'phase 8 completion category missing');
-    assert.strictEqual(phase8CompletionSummaryResponse.json.unsatisfied_criteria_count, 0, 'phase 8 completion state mismatch');
-    const phase8FreezeBaselineSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-8/freeze-baseline/summary');
-    assert.strictEqual(phase8FreezeBaselineSummaryResponse.status, 200, 'phase 8 freeze baseline summary route failed');
-    assert.strictEqual(phase8FreezeBaselineSummaryResponse.json.category, 'proof-phase-8-freeze-baseline-pack', 'phase 8 freeze baseline category missing');
-    assert.strictEqual(phase8FreezeBaselineSummaryResponse.json.baseline_status, 'recorded', 'phase 8 freeze baseline status mismatch');
-    const phase8FreezeReviewSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-8/freeze-review/summary');
-    assert.strictEqual(phase8FreezeReviewSummaryResponse.status, 200, 'phase 8 freeze review summary route failed');
-    assert.strictEqual(phase8FreezeReviewSummaryResponse.json.category, 'proof-phase-8-freeze-review-pack', 'phase 8 freeze review category missing');
-    const phase8GateSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-8/gate/summary');
-    assert.strictEqual(phase8GateSummaryResponse.status, 200, 'phase 8 gate summary route failed');
-    assert.strictEqual(phase8GateSummaryResponse.json.category, 'proof-phase-8-gate-pack', 'phase 8 gate category missing');
-    assert.strictEqual(phase8GateSummaryResponse.json.decision, 'ready_for_phase_9', 'phase 8 gate decision mismatch');
-    assert.strictEqual(phase8GateSummaryResponse.json.unsatisfied_gate_count, 0, 'phase 8 gate state mismatch');
-    const phase8CloseoutSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-8/closeout/summary');
-    assert.strictEqual(phase8CloseoutSummaryResponse.status, 200, 'phase 8 closeout summary route failed');
-    assert.strictEqual(phase8CloseoutSummaryResponse.json.category, 'proof-phase-8-closeout-pack', 'phase 8 closeout category missing');
-    const phase8DecisionRecordSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-8/decision-record/summary');
-    assert.strictEqual(phase8DecisionRecordSummaryResponse.status, 200, 'phase 8 decision-record summary route failed');
-    assert.strictEqual(phase8DecisionRecordSummaryResponse.json.category, 'proof-phase-8-decision-record-pack', 'phase 8 decision-record category missing');
-    assert.strictEqual(phase8DecisionRecordSummaryResponse.json.pending_record_count, 0, 'phase 8 decision-record state mismatch');
-    const phase8DecisionResolutionSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-8/decision-resolution/summary');
-    assert.strictEqual(phase8DecisionResolutionSummaryResponse.status, 200, 'phase 8 decision-resolution summary route failed');
-    assert.strictEqual(phase8DecisionResolutionSummaryResponse.json.category, 'proof-phase-8-decision-resolution-pack', 'phase 8 decision-resolution category missing');
-    const phase8ExternalResultImportSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-8/external-result-import/proof/summary');
-    assert.strictEqual(phase8ExternalResultImportSummaryResponse.status, 200, 'phase 8 external-result-import summary route failed');
-    assert.strictEqual(phase8ExternalResultImportSummaryResponse.json.category, 'proof-phase-8-external-result-import-proof-pack', 'phase 8 external-result-import category missing');
-    const phase8ExternalReceiptImportSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-8/external-receipt-import/proof/summary');
-    assert.strictEqual(phase8ExternalReceiptImportSummaryResponse.status, 200, 'phase 8 external-receipt-import summary route failed');
-    assert.strictEqual(phase8ExternalReceiptImportSummaryResponse.json.category, 'proof-phase-8-external-receipt-import-proof-pack', 'phase 8 external-receipt-import category missing');
-    const phase8BundleNormalizationSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-8/proof-bundle-normalization/proof/summary');
-    assert.strictEqual(phase8BundleNormalizationSummaryResponse.status, 200, 'phase 8 proof-bundle-normalization summary route failed');
-    assert.strictEqual(phase8BundleNormalizationSummaryResponse.json.category, 'proof-phase-8-proof-bundle-normalization-proof-pack', 'phase 8 proof-bundle-normalization category missing');
-    const phase9SummaryResponse = await getJson(baseUrl, '/v1/phases/phase-9/summary');
-    assert.strictEqual(phase9SummaryResponse.status, 200, 'phase 9 summary route failed');
-    assert.strictEqual(phase9SummaryResponse.json.category, 'proof-phase-9-treasury-connectivity-pack', 'phase 9 category missing');
-    assert.strictEqual(phase9SummaryResponse.json.destination_mode_count >= 3, true, 'phase 9 destination mode count missing');
-    assert.strictEqual(phase9SummaryResponse.json.custody_mode_count >= 3, true, 'phase 9 custody mode count missing');
-    assert.strictEqual(phase9SummaryResponse.json.accounting_mode_count >= 3, true, 'phase 9 accounting mode count missing');
-    const phase9TreasuryContinuitySummaryResponse = await getJson(baseUrl, '/v1/phases/phase-9/treasury-continuity/summary');
-    assert.strictEqual(phase9TreasuryContinuitySummaryResponse.status, 200, 'phase 9 treasury continuity summary route failed');
-    assert.strictEqual(phase9TreasuryContinuitySummaryResponse.json.category, 'proof-phase-9-treasury-continuity-pack', 'phase 9 treasury continuity category missing');
-    const phase9CompletionSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-9/completion/summary');
-    assert.strictEqual(phase9CompletionSummaryResponse.status, 200, 'phase 9 completion summary route failed');
-    assert.strictEqual(phase9CompletionSummaryResponse.json.category, 'proof-phase-9-completion-pack', 'phase 9 completion category missing');
-    assert.strictEqual(phase9CompletionSummaryResponse.json.unsatisfied_criteria_count, 0, 'phase 9 completion state mismatch');
-    const phase9FreezeBaselineSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-9/freeze-baseline/summary');
-    assert.strictEqual(phase9FreezeBaselineSummaryResponse.status, 200, 'phase 9 freeze baseline summary route failed');
-    assert.strictEqual(phase9FreezeBaselineSummaryResponse.json.category, 'proof-phase-9-freeze-baseline-pack', 'phase 9 freeze baseline category missing');
-    assert.strictEqual(phase9FreezeBaselineSummaryResponse.json.baseline_status, 'recorded', 'phase 9 freeze baseline status mismatch');
-    const phase9FreezeReviewSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-9/freeze-review/summary');
-    assert.strictEqual(phase9FreezeReviewSummaryResponse.status, 200, 'phase 9 freeze review summary route failed');
-    assert.strictEqual(phase9FreezeReviewSummaryResponse.json.category, 'proof-phase-9-freeze-review-pack', 'phase 9 freeze review category missing');
-    const phase9GateSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-9/gate/summary');
-    assert.strictEqual(phase9GateSummaryResponse.status, 200, 'phase 9 gate summary route failed');
-    assert.strictEqual(phase9GateSummaryResponse.json.category, 'proof-phase-9-gate-pack', 'phase 9 gate category missing');
-    assert.strictEqual(phase9GateSummaryResponse.json.decision, 'ready_for_phase_10', 'phase 9 gate decision mismatch');
-    assert.strictEqual(phase9GateSummaryResponse.json.unsatisfied_gate_count, 0, 'phase 9 gate state mismatch');
-    const phase9CloseoutSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-9/closeout/summary');
-    assert.strictEqual(phase9CloseoutSummaryResponse.status, 200, 'phase 9 closeout summary route failed');
-    assert.strictEqual(phase9CloseoutSummaryResponse.json.category, 'proof-phase-9-closeout-pack', 'phase 9 closeout category missing');
-    const phase9DecisionRecordSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-9/decision-record/summary');
-    assert.strictEqual(phase9DecisionRecordSummaryResponse.status, 200, 'phase 9 decision-record summary route failed');
-    assert.strictEqual(phase9DecisionRecordSummaryResponse.json.category, 'proof-phase-9-decision-record-pack', 'phase 9 decision-record category missing');
-    assert.strictEqual(phase9DecisionRecordSummaryResponse.json.pending_record_count, 0, 'phase 9 decision-record state mismatch');
-    const phase9DecisionResolutionSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-9/decision-resolution/summary');
-    assert.strictEqual(phase9DecisionResolutionSummaryResponse.status, 200, 'phase 9 decision-resolution summary route failed');
-    assert.strictEqual(phase9DecisionResolutionSummaryResponse.json.category, 'proof-phase-9-decision-resolution-pack', 'phase 9 decision-resolution category missing');
-    const phase9TreasuryDestinationsSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-9/treasury-destinations/proof/summary');
-    assert.strictEqual(phase9TreasuryDestinationsSummaryResponse.status, 200, 'phase 9 treasury-destinations summary route failed');
-    assert.strictEqual(phase9TreasuryDestinationsSummaryResponse.json.category, 'proof-phase-9-treasury-destinations-proof-pack', 'phase 9 treasury-destinations category missing');
-    assert.strictEqual(phase9TreasuryDestinationsSummaryResponse.json.destination_mode_count >= 3, true, 'phase 9 treasury-destinations destination count missing');
-    const phase9CustodyRefsSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-9/custody-refs/proof/summary');
-    assert.strictEqual(phase9CustodyRefsSummaryResponse.status, 200, 'phase 9 custody-refs summary route failed');
-    assert.strictEqual(phase9CustodyRefsSummaryResponse.json.category, 'proof-phase-9-custody-refs-proof-pack', 'phase 9 custody-refs category missing');
-    assert.strictEqual(phase9CustodyRefsSummaryResponse.json.custody_mode_count >= 3, true, 'phase 9 custody mode count missing');
-    const phase9OperatorAccountingBridgesSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-9/operator-accounting-bridges/proof/summary');
-    assert.strictEqual(phase9OperatorAccountingBridgesSummaryResponse.status, 200, 'phase 9 operator-accounting-bridges summary route failed');
-    assert.strictEqual(phase9OperatorAccountingBridgesSummaryResponse.json.category, 'proof-phase-9-operator-accounting-bridges-proof-pack', 'phase 9 operator-accounting-bridges category missing');
-    assert.strictEqual(phase9OperatorAccountingBridgesSummaryResponse.json.accounting_mode_count >= 3, true, 'phase 9 accounting bridge mode count missing');
-    const phase10SummaryResponse = await getJson(baseUrl, '/v1/phases/phase-10/summary');
-    assert.strictEqual(phase10SummaryResponse.status, 200, 'phase 10 summary route failed');
-    assert.strictEqual(phase10SummaryResponse.json.category, 'proof-phase-10-long-tail-ecosystem-pack', 'phase 10 category missing');
-    assert.strictEqual(phase10SummaryResponse.json.lane_count >= 3, true, 'phase 10 lane count missing');
-    assert.strictEqual(phase10SummaryResponse.json.proof_mode_count >= 3, true, 'phase 10 proof mode count missing');
-    const phase10DemandSignalAdaptersSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-10/demand-signal-adapters/proof/summary');
-    assert.strictEqual(phase10DemandSignalAdaptersSummaryResponse.status, 200, 'phase 10 demand-signal-adapters summary route failed');
-    assert.strictEqual(phase10DemandSignalAdaptersSummaryResponse.json.category, 'proof-phase-10-demand-signal-adapters-proof-pack', 'phase 10 demand-signal-adapters category missing');
-    assert.strictEqual(phase10DemandSignalAdaptersSummaryResponse.json.demand_mode_count >= 3, true, 'phase 10 demand mode count missing');
-    const phase10NicheExtensionRegistrySummaryResponse = await getJson(baseUrl, '/v1/phases/phase-10/niche-extension-registry/proof/summary');
-    assert.strictEqual(phase10NicheExtensionRegistrySummaryResponse.status, 200, 'phase 10 niche-extension-registry summary route failed');
-    assert.strictEqual(phase10NicheExtensionRegistrySummaryResponse.json.category, 'proof-phase-10-niche-extension-registry-proof-pack', 'phase 10 niche-extension-registry category missing');
-    const phase10EcosystemBacklogTriageSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-10/ecosystem-backlog-triage/proof/summary');
-    assert.strictEqual(phase10EcosystemBacklogTriageSummaryResponse.status, 200, 'phase 10 ecosystem-backlog-triage summary route failed');
-    assert.strictEqual(phase10EcosystemBacklogTriageSummaryResponse.json.category, 'proof-phase-10-ecosystem-backlog-triage-proof-pack', 'phase 10 ecosystem-backlog-triage category missing');
-    const phase10LongTailContinuitySummaryResponse = await getJson(baseUrl, '/v1/phases/phase-10/long-tail-continuity/summary');
-    assert.strictEqual(phase10LongTailContinuitySummaryResponse.status, 200, 'phase 10 long-tail continuity summary route failed');
-    assert.strictEqual(phase10LongTailContinuitySummaryResponse.json.category, 'proof-phase-10-long-tail-continuity-pack', 'phase 10 long-tail continuity category missing');
-    const phase10CompletionDisciplineSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-10/completion/summary');
-    assert.strictEqual(phase10CompletionDisciplineSummaryResponse.status, 200, 'phase 10 completion summary route failed');
-    assert.strictEqual(phase10CompletionDisciplineSummaryResponse.json.category, 'proof-phase-10-completion-pack', 'phase 10 completion category missing');
-    assert.strictEqual(phase10CompletionDisciplineSummaryResponse.json.unsatisfied_criteria_count, 0, 'phase 10 completion unsatisfied count mismatch');
-    const phase10FreezeBaselineSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-10/freeze-baseline/summary');
-    assert.strictEqual(phase10FreezeBaselineSummaryResponse.status, 200, 'phase 10 freeze baseline summary route failed');
-    assert.strictEqual(phase10FreezeBaselineSummaryResponse.json.category, 'proof-phase-10-freeze-baseline-pack', 'phase 10 freeze baseline category missing');
-    assert.strictEqual(phase10FreezeBaselineSummaryResponse.json.baseline_status, 'recorded', 'phase 10 freeze baseline status mismatch');
-    const phase10FreezeReviewSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-10/freeze-review/summary');
-    assert.strictEqual(phase10FreezeReviewSummaryResponse.status, 200, 'phase 10 freeze review summary route failed');
-    assert.strictEqual(phase10FreezeReviewSummaryResponse.json.category, 'proof-phase-10-freeze-review-pack', 'phase 10 freeze review category missing');
-    const phase10GateDisciplineSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-10/gate/summary');
-    assert.strictEqual(phase10GateDisciplineSummaryResponse.status, 200, 'phase 10 gate summary route failed');
-    assert.strictEqual(phase10GateDisciplineSummaryResponse.json.category, 'proof-phase-10-gate-pack', 'phase 10 gate category missing');
-    assert.strictEqual(phase10GateDisciplineSummaryResponse.json.decision, 'ready_for_program_closeout', 'phase 10 gate decision mismatch');
-    assert.strictEqual(phase10GateDisciplineSummaryResponse.json.unsatisfied_gate_count, 0, 'phase 10 gate unsatisfied count mismatch');
-    const phase10CloseoutSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-10/closeout/summary');
-    assert.strictEqual(phase10CloseoutSummaryResponse.status, 200, 'phase 10 closeout summary route failed');
-    assert.strictEqual(phase10CloseoutSummaryResponse.json.category, 'proof-phase-10-closeout-pack', 'phase 10 closeout category missing');
-    const phase10DecisionRecordSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-10/decision-record/summary');
-    assert.strictEqual(phase10DecisionRecordSummaryResponse.status, 200, 'phase 10 decision-record summary route failed');
-    assert.strictEqual(phase10DecisionRecordSummaryResponse.json.category, 'proof-phase-10-decision-record-pack', 'phase 10 decision-record category missing');
-    assert.strictEqual(phase10DecisionRecordSummaryResponse.json.pending_record_count, 0, 'phase 10 decision-record pending count mismatch');
-    const phase10DecisionResolutionSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-10/decision-resolution/summary');
-    assert.strictEqual(phase10DecisionResolutionSummaryResponse.status, 200, 'phase 10 decision-resolution summary route failed');
-    assert.strictEqual(phase10DecisionResolutionSummaryResponse.json.category, 'proof-phase-10-decision-resolution-pack', 'phase 10 decision-resolution category missing');
-    const phase5SolanaProofSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-5/solana/proof/summary');
-    assert.strictEqual(phase5SolanaProofSummaryResponse.status, 200, 'phase 5 solana proof summary route failed');
-    assert.strictEqual(phase5SolanaProofSummaryResponse.json.evidence_mode_count >= 3, true, 'phase 5 solana proof evidence count missing');
-    const phase5AntelopeProofSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-5/antelope/proof/summary');
-    assert.strictEqual(phase5AntelopeProofSummaryResponse.status, 200, 'phase 5 antelope proof summary route failed');
-    assert.strictEqual(phase5AntelopeProofSummaryResponse.json.evidence_mode_count >= 3, true, 'phase 5 antelope proof evidence count missing');
-    const phase5ProtonXprProofSummaryResponse = await getJson(baseUrl, '/v1/phases/phase-5/proton-xpr/proof/summary');
-    assert.strictEqual(phase5ProtonXprProofSummaryResponse.status, 200, 'phase 5 proton xpr proof summary route failed');
-    assert.strictEqual(phase5ProtonXprProofSummaryResponse.json.evidence_mode_count >= 3, true, 'phase 5 proton xpr proof evidence count missing');
-    const publishPlanResponse = await getJson(baseUrl, '/v1/publish-plan');
-    assert.strictEqual(publishPlanResponse.status, 200, 'publish plan route failed');
-    assert.strictEqual(publishPlanResponse.json.product, 'xoonya', 'publish plan product missing');
-    assert.strictEqual(publishPlanResponse.json.publish_sequence.length >= 5, true, 'publish plan sequence missing');
-    const publishPlanSummaryResponse = await getJson(baseUrl, '/v1/publish-plan/summary');
-    assert.strictEqual(publishPlanSummaryResponse.status, 200, 'publish plan summary route failed');
-    assert.strictEqual(publishPlanSummaryResponse.json.category, 'proof-publish-plan', 'publish plan summary category missing');
-    assert.strictEqual(publishPlanSummaryResponse.json.publish_step_count >= 5, true, 'publish plan summary count missing');
-    const ecosystemEntryResponse = await getJson(baseUrl, '/v1/ecosystem-entry');
-    assert.strictEqual(ecosystemEntryResponse.status, 200, 'ecosystem entry route failed');
-    assert.strictEqual(ecosystemEntryResponse.json.product, 'xoonya', 'ecosystem entry product missing');
-    assert.strictEqual(ecosystemEntryResponse.json.audiences.length >= 4, true, 'ecosystem entry breadth missing');
-    const ecosystemEntrySummaryResponse = await getJson(baseUrl, '/v1/ecosystem-entry/summary');
-    assert.strictEqual(ecosystemEntrySummaryResponse.status, 200, 'ecosystem entry summary route failed');
-    assert.strictEqual(ecosystemEntrySummaryResponse.json.category, 'proof-ecosystem-entry', 'ecosystem entry summary category missing');
-    assert.strictEqual(ecosystemEntrySummaryResponse.json.audience_count >= 4, true, 'ecosystem entry summary count missing');
-    const launchNarrativeResponse = await getJson(baseUrl, '/v1/launch-narrative');
-    assert.strictEqual(launchNarrativeResponse.status, 200, 'launch narrative route failed');
-    assert.strictEqual(launchNarrativeResponse.json.product, 'xoonya', 'launch narrative product missing');
-    assert.strictEqual(launchNarrativeResponse.json.first_success_looks_like.length >= 4, true, 'launch narrative success signals missing');
-    const launchNarrativeSummaryResponse = await getJson(baseUrl, '/v1/launch-narrative/summary');
-    assert.strictEqual(launchNarrativeSummaryResponse.status, 200, 'launch narrative summary route failed');
-    assert.strictEqual(launchNarrativeSummaryResponse.json.category, 'proof-launch-narrative', 'launch narrative summary category missing');
-    assert.strictEqual(launchNarrativeSummaryResponse.json.immediate_audience_count >= 4, true, 'launch narrative summary audience count missing');
-    const outreachProofResponse = await getJson(baseUrl, '/v1/outreach-proof');
-    assert.strictEqual(outreachProofResponse.status, 200, 'outreach proof route failed');
-    assert.strictEqual(outreachProofResponse.json.product, 'xoonya', 'outreach proof product missing');
-    assert.strictEqual(outreachProofResponse.json.proven_live_today.length >= 4, true, 'outreach proof proven list missing');
-    const outreachProofSummaryResponse = await getJson(baseUrl, '/v1/outreach-proof/summary');
-    assert.strictEqual(outreachProofSummaryResponse.status, 200, 'outreach proof summary route failed');
-    assert.strictEqual(outreachProofSummaryResponse.json.category, 'proof-outreach-proof', 'outreach proof summary category missing');
-    assert.strictEqual(outreachProofSummaryResponse.json.live_rail_count >= 3, true, 'outreach proof summary rail count missing');
-    const announcementPackResponse = await getJson(baseUrl, '/v1/announcement-pack');
-    assert.strictEqual(announcementPackResponse.status, 200, 'announcement pack route failed');
-    assert.strictEqual(announcementPackResponse.json.product, 'xoonya', 'announcement pack product missing');
-    assert.strictEqual(announcementPackResponse.json.release_candidate.checks.length >= 5, true, 'announcement pack checks missing');
-    const announcementSummaryResponse = await getJson(baseUrl, '/v1/announcement-pack/summary');
-    assert.strictEqual(announcementSummaryResponse.status, 200, 'announcement pack summary route failed');
-    assert.strictEqual(announcementSummaryResponse.json.category, 'proof-announcement-pack', 'announcement pack summary category missing');
-    assert.strictEqual(announcementSummaryResponse.json.publish_step_count >= 5, true, 'announcement pack publish step count missing');
-    const releaseCandidateResponse = await getJson(baseUrl, '/v1/release-candidate');
-    assert.strictEqual(releaseCandidateResponse.status, 200, 'release candidate route failed');
-    assert.strictEqual(releaseCandidateResponse.json.product, 'xoonya', 'release candidate product missing');
-    assert.strictEqual(releaseCandidateResponse.json.checklist.length >= 5, true, 'release candidate checklist missing');
-    const releaseCandidateSummaryResponse = await getJson(baseUrl, '/v1/release-candidate/summary');
-    assert.strictEqual(releaseCandidateSummaryResponse.status, 200, 'release candidate summary route failed');
-    assert.strictEqual(releaseCandidateSummaryResponse.json.category, 'proof-release-candidate', 'release candidate summary category missing');
-    assert.strictEqual(releaseCandidateSummaryResponse.json.checklist_count >= 5, true, 'release candidate checklist count missing');
-    const trustIntelligenceResponse = await getJson(baseUrl, '/v1/trust-intelligence');
-    assert.strictEqual(trustIntelligenceResponse.status, 200, 'trust intelligence route failed');
-    assert.strictEqual(trustIntelligenceResponse.json.category, 'proof-trust-intelligence-pack', 'trust intelligence category missing');
-    assert.strictEqual(typeof trustIntelligenceResponse.json.proof_readiness_state, 'string', 'trust intelligence proof readiness missing');
-    assert.strictEqual(typeof trustIntelligenceResponse.json.next_best_action, 'string', 'trust intelligence next best action missing');
-    assert.strictEqual(typeof trustIntelligenceResponse.json.linked_surfaces.bridge_summary_ref, 'string', 'trust intelligence bridge summary ref missing');
-    const trustIntelligenceSummaryResponse = await getJson(baseUrl, '/v1/trust-intelligence/summary');
-    assert.strictEqual(trustIntelligenceSummaryResponse.status, 200, 'trust intelligence summary route failed');
-    assert.strictEqual(trustIntelligenceSummaryResponse.json.category, 'proof-trust-intelligence-pack', 'trust intelligence summary category missing');
-    assert.strictEqual(trustIntelligenceSummaryResponse.json.signal_count >= 5, true, 'trust intelligence summary signal count missing');
-    const reviewIntelligenceResponse = await getJson(baseUrl, '/v1/review-intelligence');
-    assert.strictEqual(reviewIntelligenceResponse.status, 200, 'review intelligence route failed');
-    assert.strictEqual(reviewIntelligenceResponse.json.category, 'proof-review-intelligence-pack', 'review intelligence category missing');
-    assert.strictEqual(typeof reviewIntelligenceResponse.json.review_burden_state, 'string', 'review intelligence burden state missing');
-    assert.strictEqual(typeof reviewIntelligenceResponse.json.next_best_action, 'string', 'review intelligence next best action missing');
-    assert.strictEqual(typeof reviewIntelligenceResponse.json.linked_surfaces.governance_dashboard_ref, 'string', 'review intelligence governance dashboard ref missing');
-    const reviewIntelligenceSummaryResponse = await getJson(baseUrl, '/v1/review-intelligence/summary');
-    assert.strictEqual(reviewIntelligenceSummaryResponse.status, 200, 'review intelligence summary route failed');
-    assert.strictEqual(reviewIntelligenceSummaryResponse.json.category, 'proof-review-intelligence-pack', 'review intelligence summary category missing');
-    assert.strictEqual(reviewIntelligenceSummaryResponse.json.signal_count >= 6, true, 'review intelligence summary signal count missing');
-    const governanceIntelligenceResponse = await getJson(baseUrl, '/v1/governance-intelligence');
-    assert.strictEqual(governanceIntelligenceResponse.status, 200, 'governance intelligence route failed');
-    assert.strictEqual(governanceIntelligenceResponse.json.category, 'proof-governance-intelligence-pack', 'governance intelligence category missing');
-    assert.strictEqual(typeof governanceIntelligenceResponse.json.escalation_readiness_state, 'string', 'governance intelligence escalation state missing');
-    assert.strictEqual(typeof governanceIntelligenceResponse.json.next_best_action, 'string', 'governance intelligence next best action missing');
-    assert.strictEqual(typeof governanceIntelligenceResponse.json.linked_surfaces.governance_console_pack_ref, 'string', 'governance intelligence console ref missing');
-    const governanceIntelligenceSummaryResponse = await getJson(baseUrl, '/v1/governance-intelligence/summary');
-    assert.strictEqual(governanceIntelligenceSummaryResponse.status, 200, 'governance intelligence summary route failed');
-    assert.strictEqual(governanceIntelligenceSummaryResponse.json.category, 'proof-governance-intelligence-pack', 'governance intelligence summary category missing');
-    assert.strictEqual(governanceIntelligenceSummaryResponse.json.signal_count >= 7, true, 'governance intelligence summary signal count missing');
-    const bridgeIntelligenceResponse = await getJson(baseUrl, '/v1/bridge-intelligence');
-    assert.strictEqual(bridgeIntelligenceResponse.status, 200, 'bridge intelligence route failed');
-    assert.strictEqual(bridgeIntelligenceResponse.json.category, 'proof-bridge-intelligence-pack', 'bridge intelligence category missing');
-    assert.strictEqual(typeof bridgeIntelligenceResponse.json.bridge_coverage_state, 'string', 'bridge intelligence coverage state missing');
-    assert.strictEqual(typeof bridgeIntelligenceResponse.json.next_best_action, 'string', 'bridge intelligence next best action missing');
-    assert.strictEqual(typeof bridgeIntelligenceResponse.json.linked_surfaces.bridge_summary_ref, 'string', 'bridge intelligence bridge summary ref missing');
-    const bridgeIntelligenceSummaryResponse = await getJson(baseUrl, '/v1/bridge-intelligence/summary');
-    assert.strictEqual(bridgeIntelligenceSummaryResponse.status, 200, 'bridge intelligence summary route failed');
-    assert.strictEqual(bridgeIntelligenceSummaryResponse.json.category, 'proof-bridge-intelligence-pack', 'bridge intelligence summary category missing');
-    assert.strictEqual(bridgeIntelligenceSummaryResponse.json.signal_count >= 6, true, 'bridge intelligence summary signal count missing');
-
-    const roleFreezeResponse = await getJson(baseUrl, '/v1/role-freeze');
-    assert.strictEqual(roleFreezeResponse.status, 200, 'role freeze route failed');
-    assert.strictEqual(roleFreezeResponse.json.category, 'proof-role-freeze-pack', 'role freeze category missing');
-    assert.strictEqual(roleFreezeResponse.json.frozen_role, 'proof_review_governance_bridge_followthrough', 'role freeze frozen role missing');
-    assert.strictEqual(roleFreezeResponse.json.role_state, 'explicitly_frozen', 'role freeze role state missing');
-    assert.strictEqual(Array.isArray(roleFreezeResponse.json.owns), true, 'role freeze owns missing');
-    assert.strictEqual(Array.isArray(roleFreezeResponse.json.does_not_own), true, 'role freeze does not own missing');
-    assert.strictEqual(typeof roleFreezeResponse.json.linked_surfaces.proof_center_summary_ref, 'string', 'role freeze proof center ref missing');
-
-    const roleFreezeSummaryResponse = await getJson(baseUrl, '/v1/role-freeze/summary');
-    assert.strictEqual(roleFreezeSummaryResponse.status, 200, 'role freeze summary route failed');
-    assert.strictEqual(roleFreezeSummaryResponse.json.category, 'proof-role-freeze-pack', 'role freeze summary category missing');
-    assert.strictEqual(roleFreezeSummaryResponse.json.role_state, 'explicitly_frozen', 'role freeze summary role state missing');
-    assert.strictEqual(roleFreezeSummaryResponse.json.owns_count >= 5, true, 'role freeze summary owns count missing');
-    assert.strictEqual(roleFreezeSummaryResponse.json.does_not_own_count >= 5, true, 'role freeze summary does not own count missing');
-
-    const roleFreezeOperatorBundleResponse = await getJson(baseUrl, '/v1/role-freeze/operator-bundle');
-    assert.strictEqual(roleFreezeOperatorBundleResponse.status, 200, 'role freeze operator bundle route failed');
-    assert.strictEqual(roleFreezeOperatorBundleResponse.json.category, 'proof-role-freeze-operator-bundle', 'role freeze operator bundle category missing');
-    assert.strictEqual(roleFreezeOperatorBundleResponse.json.bundle_version, 'xoonya-proof-role-freeze-operator-bundle-v1', 'role freeze operator bundle version missing');
-    assert.strictEqual(roleFreezeOperatorBundleResponse.json.role_freeze.category, 'proof-role-freeze-pack', 'role freeze operator bundle freeze pack missing');
-    assert.strictEqual(roleFreezeOperatorBundleResponse.json.trust_intelligence.category, 'proof-trust-intelligence-pack', 'role freeze operator bundle trust intelligence missing');
-    assert.strictEqual(roleFreezeOperatorBundleResponse.json.review_intelligence.category, 'proof-review-intelligence-pack', 'role freeze operator bundle review intelligence missing');
-    assert.strictEqual(roleFreezeOperatorBundleResponse.json.governance_intelligence.category, 'proof-governance-intelligence-pack', 'role freeze operator bundle governance intelligence missing');
-    assert.strictEqual(roleFreezeOperatorBundleResponse.json.bridge_intelligence.category, 'proof-bridge-intelligence-pack', 'role freeze operator bundle bridge intelligence missing');
-    assert.strictEqual(typeof roleFreezeOperatorBundleResponse.json.operator_posture.recommended_operator_motion, 'string', 'role freeze operator bundle operator motion missing');
-
-    const roleFreezeOperatorBundleSummaryResponse = await getJson(baseUrl, '/v1/role-freeze/operator-bundle/summary');
-    assert.strictEqual(roleFreezeOperatorBundleSummaryResponse.status, 200, 'role freeze operator bundle summary route failed');
-    assert.strictEqual(roleFreezeOperatorBundleSummaryResponse.json.category, 'proof-role-freeze-operator-bundle', 'role freeze operator bundle summary category missing');
-    assert.strictEqual(roleFreezeOperatorBundleSummaryResponse.json.bundle_version, 'xoonya-proof-role-freeze-operator-bundle-v1', 'role freeze operator bundle summary version missing');
-    assert.strictEqual(roleFreezeOperatorBundleSummaryResponse.json.role_state, 'explicitly_frozen', 'role freeze operator bundle summary role state missing');
-    assert.strictEqual(typeof roleFreezeOperatorBundleSummaryResponse.json.recommended_operator_motion, 'string', 'role freeze operator bundle summary operator motion missing');
-
-    const roleFreezePolicyPackResponse = await getJson(baseUrl, '/v1/role-freeze/policy-pack');
-    assert.strictEqual(roleFreezePolicyPackResponse.status, 200, 'role freeze policy pack route failed');
-    assert.strictEqual(roleFreezePolicyPackResponse.json.category, 'proof-role-freeze-policy-pack', 'role freeze policy pack category missing');
-    assert.strictEqual(roleFreezePolicyPackResponse.json.pack_version, 'xoonya-proof-role-freeze-policy-pack-v1', 'role freeze policy pack version missing');
-    assert.strictEqual(Array.isArray(roleFreezePolicyPackResponse.json.policy_templates), true, 'role freeze policy pack templates missing');
-    assert.strictEqual(roleFreezePolicyPackResponse.json.policy_templates.length >= 4, true, 'role freeze policy pack template count missing');
-
-    const roleFreezePolicyPackSummaryResponse = await getJson(baseUrl, '/v1/role-freeze/policy-pack/summary');
-    assert.strictEqual(roleFreezePolicyPackSummaryResponse.status, 200, 'role freeze policy pack summary route failed');
-    assert.strictEqual(roleFreezePolicyPackSummaryResponse.json.category, 'proof-role-freeze-policy-pack', 'role freeze policy pack summary category missing');
-    assert.strictEqual(roleFreezePolicyPackSummaryResponse.json.pack_version, 'xoonya-proof-role-freeze-policy-pack-v1', 'role freeze policy pack summary version missing');
-    assert.strictEqual(roleFreezePolicyPackSummaryResponse.json.template_count >= 4, true, 'role freeze policy pack summary template count missing');
-    assert.strictEqual(typeof roleFreezePolicyPackSummaryResponse.json.recommended_policy_motion, 'string', 'role freeze policy pack summary motion missing');
-
-    const roleFreezePolicyApplicationSummaryResponse = await getJson(baseUrl, '/v1/role-freeze/policy-application-summary?template_id=bridge_followthrough_lead');
-    assert.strictEqual(roleFreezePolicyApplicationSummaryResponse.status, 200, 'role freeze policy application summary route failed');
-    assert.strictEqual(roleFreezePolicyApplicationSummaryResponse.json.category, 'proof-role-freeze-policy-application-summary', 'role freeze policy application summary category missing');
-    assert.strictEqual(roleFreezePolicyApplicationSummaryResponse.json.summary_version, 'xoonya-proof-role-freeze-policy-application-summary-v1', 'role freeze policy application summary version missing');
-    assert.strictEqual(roleFreezePolicyApplicationSummaryResponse.json.selected_template_id, 'bridge_followthrough_lead', 'role freeze policy application selected template missing');
-    assert.strictEqual(Array.isArray(roleFreezePolicyApplicationSummaryResponse.json.available_template_ids), true, 'role freeze policy application template ids missing');
-
-    const roleFreezePackageResponse = await getJson(baseUrl, '/v1/role-freeze/package');
-    assert.strictEqual(roleFreezePackageResponse.status, 200, 'role freeze package route failed');
-    assert.strictEqual(roleFreezePackageResponse.json.category, 'proof-role-freeze-package', 'role freeze package category missing');
-    assert.strictEqual(roleFreezePackageResponse.json.package_version, 'xoonya-proof-role-freeze-package-v1', 'role freeze package version missing');
-    assert.strictEqual(roleFreezePackageResponse.json.role_freeze.category, 'proof-role-freeze-pack', 'role freeze package freeze pack missing');
-    assert.strictEqual(roleFreezePackageResponse.json.role_freeze_operator_bundle.category, 'proof-role-freeze-operator-bundle', 'role freeze package operator bundle missing');
-    assert.strictEqual(roleFreezePackageResponse.json.role_freeze_policy_pack.category, 'proof-role-freeze-policy-pack', 'role freeze package policy pack missing');
-    assert.strictEqual(roleFreezePackageResponse.json.role_freeze_policy_application_summary.category, 'proof-role-freeze-policy-application-summary', 'role freeze package policy application summary missing');
-    assert.strictEqual(typeof roleFreezePackageResponse.json.package_posture.recommended_operator_motion, 'string', 'role freeze package operator motion missing');
-    assert.strictEqual(typeof roleFreezePackageResponse.json.package_posture.recommended_policy_motion, 'string', 'role freeze package policy motion missing');
-
-    const roleFreezePackageSummaryResponse = await getJson(baseUrl, '/v1/role-freeze/package/summary');
-    assert.strictEqual(roleFreezePackageSummaryResponse.status, 200, 'role freeze package summary route failed');
-    assert.strictEqual(roleFreezePackageSummaryResponse.json.category, 'proof-role-freeze-package', 'role freeze package summary category missing');
-    assert.strictEqual(roleFreezePackageSummaryResponse.json.package_version, 'xoonya-proof-role-freeze-package-v1', 'role freeze package summary version missing');
-    assert.strictEqual(roleFreezePackageSummaryResponse.json.role_state, 'explicitly_frozen', 'role freeze package summary role state missing');
-    assert.strictEqual(typeof roleFreezePackageSummaryResponse.json.recommended_operator_motion, 'string', 'role freeze package summary operator motion missing');
-    assert.strictEqual(typeof roleFreezePackageSummaryResponse.json.recommended_policy_motion, 'string', 'role freeze package summary policy motion missing');
-
-    const roleTransitionResponse = await getJson(baseUrl, '/v1/role-transition');
-    assert.strictEqual(roleTransitionResponse.status, 200, 'role transition route failed');
-    assert.strictEqual(roleTransitionResponse.json.category, 'proof-role-transition-pack', 'role transition category missing');
-    assert.strictEqual(roleTransitionResponse.json.package_version, 'xoonya-proof-role-transition-pack-v1', 'role transition package version missing');
-    assert.strictEqual(roleTransitionResponse.json.current_role.current_primary_posture, 'proof_primary', 'role transition current posture missing');
-    assert.strictEqual(roleTransitionResponse.json.long_term_direction.target_role, 'capability_execution_coordination_shell_with_proof_strength', 'role transition target role missing');
-    assert.strictEqual(typeof roleTransitionResponse.json.recommended_transition_motion, 'string', 'role transition recommended motion missing');
-
-    const roleTransitionSummaryResponse = await getJson(baseUrl, '/v1/role-transition/summary');
-    assert.strictEqual(roleTransitionSummaryResponse.status, 200, 'role transition summary route failed');
-    assert.strictEqual(roleTransitionSummaryResponse.json.category, 'proof-role-transition-pack', 'role transition summary category missing');
-    assert.strictEqual(roleTransitionSummaryResponse.json.package_version, 'xoonya-proof-role-transition-pack-v1', 'role transition summary version missing');
-    assert.strictEqual(roleTransitionSummaryResponse.json.current_transition_state, 'proof_primary_today_coordination_shell_later', 'role transition summary state missing');
-    assert.strictEqual(typeof roleTransitionSummaryResponse.json.recommended_transition_motion, 'string', 'role transition summary motion missing');
-
-    const capabilityRegistryHomeResponse = await getJson(baseUrl, '/v1/capability-registry-home');
-    assert.strictEqual(capabilityRegistryHomeResponse.status, 200, 'capability registry home route failed');
-    assert.strictEqual(capabilityRegistryHomeResponse.json.category, 'proof-capability-registry-home-pack', 'capability registry home category missing');
-    assert.strictEqual(capabilityRegistryHomeResponse.json.package_version, 'xoonya-proof-capability-registry-home-pack-v1', 'capability registry home version missing');
-    assert.strictEqual(capabilityRegistryHomeResponse.json.current_registry_home.current_owner, 'xytara', 'capability registry home current owner missing');
-    assert.strictEqual(capabilityRegistryHomeResponse.json.target_registry_home.target_owner, 'xoonya', 'capability registry home target owner missing');
-    assert.strictEqual(typeof capabilityRegistryHomeResponse.json.recommended_registry_home_motion, 'string', 'capability registry home motion missing');
-
-    const capabilityRegistryHomeSummaryResponse = await getJson(baseUrl, '/v1/capability-registry-home/summary');
-    assert.strictEqual(capabilityRegistryHomeSummaryResponse.status, 200, 'capability registry home summary route failed');
-    assert.strictEqual(capabilityRegistryHomeSummaryResponse.json.category, 'proof-capability-registry-home-pack', 'capability registry home summary category missing');
-    assert.strictEqual(capabilityRegistryHomeSummaryResponse.json.package_version, 'xoonya-proof-capability-registry-home-pack-v1', 'capability registry home summary version missing');
-    assert.strictEqual(capabilityRegistryHomeSummaryResponse.json.current_owner, 'xytara', 'capability registry home summary current owner missing');
-    assert.strictEqual(capabilityRegistryHomeSummaryResponse.json.target_owner, 'xoonya', 'capability registry home summary target owner missing');
-    assert.strictEqual(typeof capabilityRegistryHomeSummaryResponse.json.recommended_registry_home_motion, 'string', 'capability registry home summary motion missing');
-
-    const proofCenterResponse = await getJson(baseUrl, '/v1/proof-center');
-    assert.strictEqual(proofCenterResponse.status, 200, 'proof center route failed');
-    assert.strictEqual(proofCenterResponse.json.proof_model.event_version, 'canonical-event-bundle/v1', 'proof center event version missing');
-    assert.strictEqual(proofCenterResponse.json.proof_model.receipt_version, 'receipt/v1', 'proof center receipt version missing');
-
-    const proofCenterSummaryResponse = await getJson(baseUrl, '/v1/proof-center/summary');
-    assert.strictEqual(proofCenterSummaryResponse.status, 200, 'proof center summary route failed');
-    assert.strictEqual(proofCenterSummaryResponse.json.proof_bundle_version, 'proof-bundle/v1', 'proof center summary bundle version missing');
-    assert.strictEqual(proofCenterSummaryResponse.json.helper_count >= 5, true, 'proof center summary helper count missing');
-    assert.strictEqual(proofCenterSummaryResponse.json.verification_method_count >= 10, true, 'proof center verification method count missing');
-    assert.strictEqual(proofCenterSummaryResponse.json.external_verification_method_count >= 6, true, 'proof center external method count missing');
-    assert.strictEqual(proofCenterSummaryResponse.json.verification_methods.includes('jwt-assertion-v1'), true, 'proof center jwt method missing');
-    assert.strictEqual(proofCenterSummaryResponse.json.verification_methods.includes('did-vc-v1'), true, 'proof center did vc method missing');
-    assert.strictEqual(proofCenterSummaryResponse.json.verification_methods.includes('sd-jwt-vc-v1'), true, 'proof center sd jwt vc method missing');
-    const nativeStandardResponse = await getJson(baseUrl, '/v1/proof-center/native-standard');
-    assert.strictEqual(nativeStandardResponse.status, 200, 'native proof standard route failed');
-    assert.strictEqual(nativeStandardResponse.json.standard_version, 'xoonya-native-proof/v1', 'native proof standard version missing');
-    assert.strictEqual(nativeStandardResponse.json.current_native_methods.some((entry) => entry.method === 'xoonya-native-sha256-v1'), true, 'native proof current method missing');
-    assert.strictEqual(nativeStandardResponse.json.current_native_methods.some((entry) => entry.method === 'xoonya-native-signed-v1'), true, 'native proof signed method missing');
-    assert.strictEqual(nativeStandardResponse.json.current_native_methods.some((entry) => entry.method === 'xoonya-native-anchored-v1'), true, 'native proof anchored method missing');
-    assert.strictEqual(nativeStandardResponse.json.native_signature_suite_policy.implemented_suites.includes('ed25519'), true, 'native proof ed25519 suite missing');
-    assert.strictEqual(nativeStandardResponse.json.native_signature_suite_policy.implemented_suites.includes('secp256k1'), true, 'native proof secp256k1 suite missing');
-    assert.strictEqual(nativeStandardResponse.json.native_signature_suite_policy.implemented_suites.includes('p256'), true, 'native proof p256 suite missing');
-    assert.strictEqual(nativeStandardResponse.json.not_a_replacement_for.includes('JWT'), true, 'native proof interop boundary missing');
-    assert.strictEqual(nativeStandardResponse.json.native_design_carry_in.lineage, 'fixed_atom_plus_proof_envelope', 'native proof design lineage missing');
-    assert.strictEqual(nativeStandardResponse.json.hot_path_atom.magic, 'XNYA', 'native proof atom magic missing');
-    assert.strictEqual(nativeStandardResponse.json.hot_path_atom.fixed_size_bytes, 58, 'native proof hot atom size missing');
-    assert.strictEqual(nativeStandardResponse.json.future_atom_candidates.some((entry) => entry.candidate_version === 'xoonya-native-atom/v2' && entry.fixed_size_bytes === 70), true, 'native proof v2 atom candidate missing');
-    assert.strictEqual(nativeStandardResponse.json.crypto_support_boundary.cleanly_layers_with.includes('webauthn'), true, 'native proof webauthn support boundary missing');
-    assert.strictEqual(nativeStandardResponse.json.competitive_positioning.category, 'deterministic_machine_evidence', 'native proof competitive category missing');
-    const nativeStandardSummaryResponse = await getJson(baseUrl, '/v1/proof-center/native-standard/summary');
-    assert.strictEqual(nativeStandardSummaryResponse.status, 200, 'native proof standard summary route failed');
-    assert.strictEqual(nativeStandardSummaryResponse.json.category, 'xoonya-native-proof-standard-summary', 'native proof standard summary category missing');
-    assert.strictEqual(nativeStandardSummaryResponse.json.current_native_method_count >= 2, true, 'native proof standard summary current methods missing');
-    assert.strictEqual(nativeStandardSummaryResponse.json.next_native_method, 'xoonya-native-hybrid-v1', 'native proof standard next method missing');
-    assert.strictEqual(nativeStandardSummaryResponse.json.native_methods.includes('xoonya-native-anchored-v1'), true, 'native proof standard anchored summary missing');
-    assert.strictEqual(nativeStandardSummaryResponse.json.implemented_signature_suites.includes('ed25519'), true, 'native proof summary ed25519 suite missing');
-    assert.strictEqual(nativeStandardSummaryResponse.json.implemented_signature_suites.includes('secp256k1'), true, 'native proof summary secp256k1 suite missing');
-    assert.strictEqual(nativeStandardSummaryResponse.json.implemented_signature_suites.includes('p256'), true, 'native proof summary p256 suite missing');
-    assert.strictEqual(nativeStandardSummaryResponse.json.native_atom_magic, 'XNYA', 'native proof summary atom magic missing');
-    assert.strictEqual(nativeStandardSummaryResponse.json.native_hot_atom_fixed_size_bytes, 58, 'native proof summary hot atom size missing');
-    assert.strictEqual(nativeStandardSummaryResponse.json.future_atom_candidate_count >= 3, true, 'native proof summary future atom candidates missing');
-    const nativeHybridReadinessResponse = await getJson(baseUrl, '/v1/proof-center/native-hybrid-readiness');
-    assert.strictEqual(nativeHybridReadinessResponse.status, 200, 'native hybrid readiness route failed');
-    assert.strictEqual(nativeHybridReadinessResponse.json.method, 'xoonya-native-hybrid-v1', 'native hybrid readiness method missing');
-    assert.strictEqual(nativeHybridReadinessResponse.json.status, 'implemented', 'native hybrid readiness implementation missing');
-    assert.strictEqual(nativeHybridReadinessResponse.json.implemented_classical_suites.some((entry) => entry.suite === 'secp256k1'), true, 'native hybrid readiness secp256k1 suite missing');
-    assert.strictEqual(nativeHybridReadinessResponse.json.implemented_hybrid_suites.some((entry) => entry.suite === 'ed25519+ml-dsa-65'), true, 'native hybrid readiness implemented suite missing');
-    const nativeHybridReadinessSummaryResponse = await getJson(baseUrl, '/v1/proof-center/native-hybrid-readiness/summary');
-    assert.strictEqual(nativeHybridReadinessSummaryResponse.status, 200, 'native hybrid readiness summary route failed');
-    assert.strictEqual(nativeHybridReadinessSummaryResponse.json.category, 'xoonya-native-hybrid-readiness-summary', 'native hybrid readiness summary category missing');
-    assert.strictEqual(nativeHybridReadinessSummaryResponse.json.current_decision.includes('runtime_supported'), true, 'native hybrid readiness summary boundary missing');
-    const nativeStandardizationResponse = await getJson(baseUrl, '/v1/proof-center/native-standardization');
-    assert.strictEqual(nativeStandardizationResponse.status, 200, 'native standardization route failed');
-    assert.strictEqual(nativeStandardizationResponse.json.canonical_magic, 'XNYA', 'native standardization magic missing');
-    assert.strictEqual(nativeStandardizationResponse.json.conformance_mark_policy.mark, 'XNYA-compatible', 'native standardization mark missing');
-    assert.strictEqual(nativeStandardizationResponse.json.conformance_mark_policy.not_allowed_when.includes('unregistered_or_runtime_unsupported_pqc_or_hybrid_support_is_claimed'), true, 'native standardization pq boundary missing');
-    const nativeStandardizationSummaryResponse = await getJson(baseUrl, '/v1/proof-center/native-standardization/summary');
-    assert.strictEqual(nativeStandardizationSummaryResponse.status, 200, 'native standardization summary route failed');
-    assert.strictEqual(nativeStandardizationSummaryResponse.json.category, 'xoonya-native-standardization-summary', 'native standardization summary category missing');
-    assert.strictEqual(nativeStandardizationSummaryResponse.json.public_claim.includes('deterministic'), true, 'native standardization summary claim missing');
-    const nativeConformanceMarkResponse = await getJson(baseUrl, '/v1/proof-center/native-conformance-mark');
-    assert.strictEqual(nativeConformanceMarkResponse.status, 200, 'native conformance mark route failed');
-    assert.strictEqual(nativeConformanceMarkResponse.json.mark, 'XNYA-compatible', 'native conformance mark missing');
-    assert.strictEqual(nativeConformanceMarkResponse.json.required_artifacts.includes('XNYA_CONFORMANCE_MARK.md'), true, 'native conformance mark doc missing');
-    assert.strictEqual(nativeConformanceMarkResponse.json.forbidden_claims_without_extra_evidence.some((entry) => entry.claim === 'pqc_or_hybrid_verified'), true, 'native conformance mark pq gate missing');
-    const nativeConformanceMarkSummaryResponse = await getJson(baseUrl, '/v1/proof-center/native-conformance-mark/summary');
-    assert.strictEqual(nativeConformanceMarkSummaryResponse.status, 200, 'native conformance mark summary route failed');
-    assert.strictEqual(nativeConformanceMarkSummaryResponse.json.category, 'xoonya-native-conformance-mark-summary', 'native conformance mark summary category missing');
-    assert.strictEqual(nativeConformanceMarkSummaryResponse.json.claim_class_count >= 4, true, 'native conformance mark claim classes missing');
-    const nativeReferenceImplementationResponse = await getJson(baseUrl, '/v1/proof-center/native-reference-implementations');
-    assert.strictEqual(nativeReferenceImplementationResponse.status, 200, 'native reference implementations route failed');
-    assert.strictEqual(nativeReferenceImplementationResponse.json.category, 'xoonya-native-reference-implementation-pack', 'native reference implementations category missing');
-    assert.strictEqual(nativeReferenceImplementationResponse.json.implemented_reference_implementations.some((entry) => entry.language === 'javascript' && entry.status === 'implemented'), true, 'native reference javascript implementation missing');
-    assert.strictEqual(nativeReferenceImplementationResponse.json.planned_reference_candidates.some((entry) => entry.language === 'python'), true, 'native reference python candidate missing');
-    assert.strictEqual(nativeReferenceImplementationResponse.json.planned_reference_candidates.some((entry) => entry.language === 'rust'), true, 'native reference rust candidate missing');
-    const nativeReferenceImplementationSummaryResponse = await getJson(baseUrl, '/v1/proof-center/native-reference-implementations/summary');
-    assert.strictEqual(nativeReferenceImplementationSummaryResponse.status, 200, 'native reference implementations summary route failed');
-    assert.strictEqual(nativeReferenceImplementationSummaryResponse.json.category, 'xoonya-native-reference-implementation-summary', 'native reference implementations summary category missing');
-    assert.strictEqual(nativeReferenceImplementationSummaryResponse.json.implemented_reference_count, 1, 'native reference implementations summary count mismatch');
-    assert.strictEqual(nativeReferenceImplementationSummaryResponse.json.planned_reference_count >= 2, true, 'native planned reference implementations summary count mismatch');
-    assert.strictEqual(nativeReferenceImplementationSummaryResponse.json.verified_candidate_scaffold_count >= 1, true, 'native verified candidate scaffold summary missing');
-    assert.strictEqual(nativeReferenceImplementationSummaryResponse.json.deterministic_rejection_code_count >= 11, true, 'native reference promotion rejection code count missing');
-    const nativePayloadProfileResponse = await getJson(baseUrl, '/v1/proof-center/native-payload-profile');
-    assert.strictEqual(nativePayloadProfileResponse.status, 200, 'native payload profile route failed');
-    assert.strictEqual(nativePayloadProfileResponse.json.category, 'xoonya-native-payload-profile-pack', 'native payload profile category missing');
-    assert.strictEqual(nativePayloadProfileResponse.json.binary_magic, 'XNYP', 'native payload profile magic missing');
-    assert.strictEqual(nativePayloadProfileResponse.json.canonical_rules.includes('binary_not_json'), true, 'native payload profile binary rule missing');
-    assert.strictEqual(nativePayloadProfileResponse.json.canonical_rules.includes('unknown_field_ids_can_be_rejected_by_verifier_policy'), true, 'native payload profile unknown field rule missing');
-    assert.strictEqual(nativePayloadProfileResponse.json.example_profile.profile, 'xoonya-native-payload-profile/v1', 'native payload profile example missing');
-    const nativePayloadProfileSummaryResponse = await getJson(baseUrl, '/v1/proof-center/native-payload-profile/summary');
-    assert.strictEqual(nativePayloadProfileSummaryResponse.status, 200, 'native payload profile summary route failed');
-    assert.strictEqual(nativePayloadProfileSummaryResponse.json.category, 'xoonya-native-payload-profile-summary', 'native payload profile summary category missing');
-    assert.strictEqual(nativePayloadProfileSummaryResponse.json.field_type_count >= 5, true, 'native payload profile field type count missing');
-    const nativeLineRateFrameResponse = await getJson(baseUrl, '/v1/proof-center/native-line-rate-frame');
-    assert.strictEqual(nativeLineRateFrameResponse.status, 200, 'native line-rate frame route failed');
-    assert.strictEqual(nativeLineRateFrameResponse.json.category, 'xoonya-native-line-rate-frame-pack', 'native line-rate frame category missing');
-    assert.strictEqual(nativeLineRateFrameResponse.json.status, 'implemented_optional_transport_profile', 'native line-rate frame status missing');
-    assert.strictEqual(nativeLineRateFrameResponse.json.supported_frame_sizes_bytes.includes(60), true, 'native line-rate frame v1 size missing');
-    assert.strictEqual(nativeLineRateFrameResponse.json.supported_frame_sizes_bytes.includes(72), true, 'native line-rate frame v2 size missing');
-    assert.strictEqual(nativeLineRateFrameResponse.json.boundary.includes('transport_fast_reject'), true, 'native line-rate frame boundary missing');
-    const nativeLineRateFrameSummaryResponse = await getJson(baseUrl, '/v1/proof-center/native-line-rate-frame/summary');
-    assert.strictEqual(nativeLineRateFrameSummaryResponse.status, 200, 'native line-rate frame summary route failed');
-    assert.strictEqual(nativeLineRateFrameSummaryResponse.json.category, 'xoonya-native-line-rate-frame-summary', 'native line-rate frame summary category missing');
-    assert.strictEqual(nativeLineRateFrameSummaryResponse.json.wrapped_atom_sizes_bytes.includes(58), true, 'native line-rate frame wrapped atom size missing');
-    const nativeAtomSpecResponse = await getJson(baseUrl, '/v1/proof-center/native-atom-spec');
-    assert.strictEqual(nativeAtomSpecResponse.status, 200, 'native atom spec route failed');
-    assert.strictEqual(nativeAtomSpecResponse.json.canonical_magic, 'XNYA', 'native atom spec magic missing');
-    assert.strictEqual(nativeAtomSpecResponse.json.versions.some((entry) => entry.atom_version === 'xoonya-native-atom/v1' && entry.fixed_size_bytes === 58), true, 'native atom spec v1 missing');
-    assert.strictEqual(nativeAtomSpecResponse.json.versions.some((entry) => entry.atom_version === 'xoonya-native-atom/v2' && entry.fixed_size_bytes === 70), true, 'native atom spec v2 missing');
-    assert.strictEqual(nativeAtomSpecResponse.json.deterministic_error_codes.includes('atom_bad_magic'), true, 'native atom spec error codes missing');
-    const nativeAtomSpecSummaryResponse = await getJson(baseUrl, '/v1/proof-center/native-atom-spec/summary');
-    assert.strictEqual(nativeAtomSpecSummaryResponse.status, 200, 'native atom spec summary route failed');
-    assert.strictEqual(nativeAtomSpecSummaryResponse.json.canonical_magic, 'XNYA', 'native atom spec summary magic missing');
-    assert.strictEqual(nativeAtomSpecSummaryResponse.json.fixed_size_bytes.includes(58), true, 'native atom spec summary v1 size missing');
-    assert.strictEqual(nativeAtomSpecSummaryResponse.json.fixed_size_bytes.includes(70), true, 'native atom spec summary v2 size missing');
-    assert.strictEqual(nativeAtomSpecSummaryResponse.json.deterministic_error_code_count >= 9, true, 'native atom spec summary error code count missing');
-    const nativeAtomConformanceResponse = await getJson(baseUrl, '/v1/proof-center/native-atom-conformance');
-    assert.strictEqual(nativeAtomConformanceResponse.status, 200, 'native atom conformance route failed');
-    assert.strictEqual(nativeAtomConformanceResponse.json.category, 'xoonya-native-atom-conformance-pack', 'native atom conformance category missing');
-    assert.strictEqual(nativeAtomConformanceResponse.json.deterministic_error_codes.includes('payload_hash_mismatch'), true, 'native atom conformance error code missing');
-    assert.strictEqual(nativeAtomConformanceResponse.json.conformance_requirements.includes('return_stable_error_code_for_each_reject'), true, 'native atom conformance stable reject requirement missing');
-    const nativeAtomConformanceSummaryResponse = await getJson(baseUrl, '/v1/proof-center/native-atom-conformance/summary');
-    assert.strictEqual(nativeAtomConformanceSummaryResponse.status, 200, 'native atom conformance summary route failed');
-    assert.strictEqual(nativeAtomConformanceSummaryResponse.json.category, 'xoonya-native-atom-conformance-summary', 'native atom conformance summary category missing');
-    assert.strictEqual(nativeAtomConformanceSummaryResponse.json.deterministic_error_code_count >= 9, true, 'native atom conformance summary error code count missing');
-
-    const nativeAnchorProfileResponse = await getJson(baseUrl, '/v1/proof-center/native-anchor-profile');
-    assert.strictEqual(nativeAnchorProfileResponse.status, 200, 'native anchor profile route failed');
-    assert.strictEqual(nativeAnchorProfileResponse.json.method, 'xoonya-native-anchored-v1', 'native anchor profile method missing');
-    assert.strictEqual(nativeAnchorProfileResponse.json.validation_semantics.includes('verify_binding_material_sha256'), true, 'native anchor profile validation semantics missing');
-    const nativeAnchorProfileSummaryResponse = await getJson(baseUrl, '/v1/proof-center/native-anchor-profile/summary');
-    assert.strictEqual(nativeAnchorProfileSummaryResponse.status, 200, 'native anchor profile summary route failed');
-    assert.strictEqual(nativeAnchorProfileSummaryResponse.json.category, 'xoonya-native-anchor-profile-summary', 'native anchor profile summary category missing');
-    assert.strictEqual(nativeAnchorProfileSummaryResponse.json.supported_anchor_kind_count >= 5, true, 'native anchor profile summary kind count missing');
-    const importAdapterResponse = await getJson(baseUrl, '/v1/proof-center/import-adapter');
-    assert.strictEqual(importAdapterResponse.status, 200, 'external proof import adapter route failed');
-    assert.strictEqual(importAdapterResponse.json.category, 'xoonya-external-proof-import-adapter', 'external proof import category missing');
-    assert.strictEqual(importAdapterResponse.json.supported_methods.some((entry) => entry.method === 'jwt-assertion-v1'), true, 'external proof import jwt method missing');
-    assert.strictEqual(importAdapterResponse.json.verification_boundary.external_verifier_retains.includes('issuer_cryptographic_truth'), true, 'external proof import boundary missing');
-    assert.strictEqual(importAdapterResponse.json.deterministic_rejection_codes.includes('external_issuer_truth_claim_requires_external_verifier'), true, 'external proof import truth rejection code missing');
-    const importAdapterSummaryResponse = await getJson(baseUrl, '/v1/proof-center/import-adapter/summary');
-    assert.strictEqual(importAdapterSummaryResponse.status, 200, 'external proof import adapter summary route failed');
-    assert.strictEqual(importAdapterSummaryResponse.json.category, 'xoonya-external-proof-import-adapter-summary', 'external proof import summary category missing');
-    assert.strictEqual(importAdapterSummaryResponse.json.supported_methods.includes('did-vc-v1'), true, 'external proof import did-vc summary missing');
-    assert.strictEqual(importAdapterSummaryResponse.json.deterministic_rejection_code_count >= 11, true, 'external proof import rejection code summary missing');
-    const proofLoopsResponse = await getJson(baseUrl, '/v1/proof-center/default-loops');
-    assert.strictEqual(proofLoopsResponse.status, 200, 'proof loop catalog route failed');
-    assert.strictEqual(proofLoopsResponse.json.loop_count >= 2, true, 'proof loop catalog count missing');
-    const proofLoopsSummaryResponse = await getJson(baseUrl, '/v1/proof-center/default-loops/summary');
-    assert.strictEqual(proofLoopsSummaryResponse.status, 200, 'proof loop summary route failed');
-    assert.strictEqual(proofLoopsSummaryResponse.json.loop_refs.includes('default.proof.bundle.loop'), true, 'proof loop summary missing');
-    const proofLoopDetailResponse = await getJson(baseUrl, '/v1/proof-center/default-loop?ref=default.proof.bundle.loop');
-    assert.strictEqual(proofLoopDetailResponse.status, 200, 'proof loop detail route failed');
-    assert.strictEqual(proofLoopDetailResponse.json.loop.stage_count, 5, 'proof loop detail stage count missing');
-    const transactionProofHandoffCenterResponse = await getJson(baseUrl, '/v1/proof-center/transaction-handoff');
-    assert.strictEqual(transactionProofHandoffCenterResponse.status, 200, 'transaction proof handoff center route failed');
-    assert.strictEqual(
-      transactionProofHandoffCenterResponse.json.recommended_loop,
-      'default.proof.bundle.loop',
-      'transaction proof handoff center recommended loop missing'
-    );
-    const transactionProofHandoffSummaryResponse = await getJson(baseUrl, '/v1/proof-center/transaction-handoff/summary');
-    assert.strictEqual(transactionProofHandoffSummaryResponse.status, 200, 'transaction proof handoff summary route failed');
-    assert.strictEqual(
-      transactionProofHandoffSummaryResponse.json.supported_source_refs.includes('transaction.registry.anchor'),
-      true,
-      'transaction proof handoff summary missing'
-    );
-    const interactionSpineHandoffCenterResponse = await getJson(baseUrl, '/v1/proof-center/interaction-spine-handoff');
-    assert.strictEqual(interactionSpineHandoffCenterResponse.status, 200, 'interaction spine handoff center route failed');
-    assert.strictEqual(
-      interactionSpineHandoffCenterResponse.json.recommended_loop,
-      'default.proof.bundle.loop',
-      'interaction spine handoff center recommended loop missing'
-    );
-    const interactionSpineHandoffSummaryResponse = await getJson(baseUrl, '/v1/proof-center/interaction-spine-handoff/summary');
-    assert.strictEqual(interactionSpineHandoffSummaryResponse.status, 200, 'interaction spine handoff summary route failed');
-    assert.strictEqual(
-      interactionSpineHandoffSummaryResponse.json.supported_source_refs.includes('spine.job.commitment'),
-      true,
-      'interaction spine handoff summary missing'
-    );
-    const resultPackageHandoffCenterResponse = await getJson(baseUrl, '/v1/proof-center/result-package-handoff');
-    assert.strictEqual(resultPackageHandoffCenterResponse.status, 200, 'result package handoff center route failed');
-    assert.strictEqual(
-      resultPackageHandoffCenterResponse.json.recommended_loop,
-      'default.proof.bundle.loop',
-      'result package handoff center recommended loop missing'
-    );
-    const resultPackageHandoffSummaryResponse = await getJson(baseUrl, '/v1/proof-center/result-package-handoff/summary');
-    assert.strictEqual(resultPackageHandoffSummaryResponse.status, 200, 'result package handoff summary route failed');
-    assert.strictEqual(
-      resultPackageHandoffSummaryResponse.json.supported_source_refs.includes('result.spine.job.commitment'),
-      true,
-      'result package handoff summary missing'
-    );
-    const governanceCenterResponse = await getJson(baseUrl, '/v1/proof-center/governance');
-    assert.strictEqual(governanceCenterResponse.status, 200, 'governance center route failed');
-    assert.strictEqual(governanceCenterResponse.json.supported_capabilities.includes('dispute_review'), true, 'governance center capability missing');
-    const governanceSummaryResponse = await getJson(baseUrl, '/v1/proof-center/governance/summary');
-    assert.strictEqual(governanceSummaryResponse.status, 200, 'governance summary route failed');
-    assert.strictEqual(governanceSummaryResponse.json.handoff_bundle_surface, '/v1/proof-center/governance/handoff-bundle', 'governance summary handoff bundle surface missing');
-    const bridgeCenterResponse = await getJson(baseUrl, '/v1/proof-center/bridge');
-    assert.strictEqual(bridgeCenterResponse.status, 200, 'bridge center route failed');
-    assert.strictEqual(bridgeCenterResponse.json.supported_capabilities.includes('receipt_ledger_handoff'), true, 'bridge center capability missing');
-    const bridgeSummaryResponse = await getJson(baseUrl, '/v1/proof-center/bridge/summary');
-    assert.strictEqual(bridgeSummaryResponse.status, 200, 'bridge summary route failed');
-    assert.strictEqual(bridgeSummaryResponse.json.receipt_ledger_handoff_surface, '/v1/proof-center/bridge/receipt-ledger-handoff', 'bridge summary handoff surface missing');
-    const bridgeProfileSupportResponse = await getJson(baseUrl, '/v1/proof-center/bridge/profile-support');
-    assert.strictEqual(bridgeProfileSupportResponse.status, 200, 'bridge profile support route failed');
-    assert.strictEqual(bridgeProfileSupportResponse.json.proof_profile_versions.includes('proof-envelope-v1'), true, 'bridge profile support versions missing');
-
-    const identityMaterialHex = sdk.makeIdentityMaterial('01', 'abcd');
-    const payloadUtf8 = 'proof service smoke';
-    const payloadBuffer = Buffer.from(payloadUtf8, 'utf8');
-    const receipt = sdk.createReceipt(identityMaterialHex, payloadBuffer);
-    const bridgeReceiptWrap = await postJson(baseUrl, '/v1/proof-center/bridge/receipt-wrap', {
-      identity_material_hex: identityMaterialHex,
-      payload_utf8: payloadUtf8
-    });
-    assert.strictEqual(bridgeReceiptWrap.status, 200, 'bridge receipt wrap route failed');
-    assert.strictEqual(bridgeReceiptWrap.json.verification.valid, true, 'bridge receipt wrap verification missing');
-    const bridgeValidatorVerify = await postJson(baseUrl, '/v1/proof-center/bridge/validator-verify', {
-      opreturn_hex: receipt.opreturn_hex,
-      payload_utf8: payloadUtf8
-    });
-    assert.strictEqual(bridgeValidatorVerify.status, 200, 'bridge validator verify route failed');
-    assert.strictEqual(bridgeValidatorVerify.json.valid, true, 'bridge validator verify payload invalid');
-
-    const receiptVerify = await postJson(baseUrl, '/v1/receipts/verify', {
-      opreturn_hex: receipt.opreturn_hex,
-      payload_utf8: payloadUtf8,
-    });
-    assert.strictEqual(receiptVerify.status, 200, 'receipt verify route failed');
-    assert.strictEqual(receiptVerify.json.valid, true, 'receipt verify payload invalid');
-
-    const validatorCompat = await postJson(baseUrl, '/validate', {
-      opreturn_hex: receipt.opreturn_hex,
-      payload_bytes_ascii: payloadUtf8,
-    });
-    assert.strictEqual(validatorCompat.status, 200, 'validator compatibility route failed');
-    assert.strictEqual(validatorCompat.json.valid, true, 'validator compatibility payload invalid');
-
-    const canonicalEvent = {
-      version: 'canonical-event-bundle/v1',
-      domain_id: 'service.verify',
-      sequence: '9',
-      actor_id: receipt.agent_id,
-      adapter_source: 'verify_service',
-      event_type: 'proof.service.smoke',
-      event_hash: '77'.repeat(32),
-      semantic_slots: {
-        payload_utf8: payloadUtf8,
-      },
-    };
-
-    const canonicalizeResponse = await postJson(baseUrl, '/v1/events/canonicalize', {
-      event: {
-        semantic_slots: canonicalEvent.semantic_slots,
-        event_hash: canonicalEvent.event_hash,
-        event_type: canonicalEvent.event_type,
-        adapter_source: canonicalEvent.adapter_source,
-        actor_id: canonicalEvent.actor_id,
-        sequence: canonicalEvent.sequence,
-        domain_id: canonicalEvent.domain_id,
-        version: canonicalEvent.version,
-      },
-    });
-    assert.strictEqual(canonicalizeResponse.status, 200, 'event canonicalize route failed');
-    assert.strictEqual(canonicalizeResponse.json.domain_id, canonicalEvent.domain_id, 'event canonicalize payload invalid');
-
-    const hashResponse = await postJson(baseUrl, '/v1/events/hash', {
-      event: canonicalEvent,
-    });
-    assert.strictEqual(hashResponse.status, 200, 'event hash route failed');
-    assert.strictEqual(hashResponse.json.event_commitment, sdk.hashEvent(canonicalEvent), 'event hash payload invalid');
-
-    const integrationsResponse = await getJson(baseUrl, '/v1/integrations');
-    const integrationsJson = integrationsResponse.json;
-    assert.strictEqual(integrationsResponse.status, 200, 'integrations route failed');
-    assert.strictEqual(Array.isArray(integrationsJson.integrations), true, 'integrations payload missing');
-    assert.strictEqual(integrationsJson.integrations.some((entry) => entry.integration_id === 'builtin.identity.legacy_material'), true, 'legacy identity integration missing');
-    assert.strictEqual(integrationsJson.integrations.some((entry) => entry.integration_id === 'builtin.verifier.registry_profile'), true, 'builtin verifier integration missing');
-
-    const integrationSummaryResponse = await getJson(baseUrl, '/v1/integrations/summary');
-    const integrationSummaryJson = integrationSummaryResponse.json;
-    assert.strictEqual(integrationSummaryResponse.status, 200, 'integration summary route failed');
-    assert.strictEqual(integrationSummaryJson.integration_count >= 6, true, 'integration summary breadth missing');
-    assert.strictEqual(integrationSummaryJson.staged_registration_count >= 1, true, 'integration summary staged registration missing');
-
-    const integrationSnapshotResponse = await getJson(baseUrl, '/v1/integrations/snapshot?registration_state=staging_registered');
-    const integrationSnapshotJson = integrationSnapshotResponse.json;
-    assert.strictEqual(integrationSnapshotResponse.status, 200, 'integration snapshot route failed');
-    assert.strictEqual(integrationSnapshotJson.integration_count >= 1, true, 'integration snapshot staged breadth missing');
-
-    const integrationDetailResponse = await getJson(baseUrl, '/v1/integrations/builtin.verifier.registry_profile');
-    const integrationDetailJson = integrationDetailResponse.json;
-    assert.strictEqual(integrationDetailResponse.status, 200, 'integration detail route failed');
-    assert.strictEqual(integrationDetailJson.integration.integration_id, 'builtin.verifier.registry_profile', 'integration detail payload invalid');
-
-    const stagedIntegrationDetailResponse = await getJson(baseUrl, '/v1/integrations/partner.verifier.lattice_notary');
-    const stagedIntegrationDetailJson = stagedIntegrationDetailResponse.json;
-    assert.strictEqual(stagedIntegrationDetailResponse.status, 200, 'staged integration detail route failed');
-    assert.strictEqual(stagedIntegrationDetailJson.integration.registration.registration_state, 'staging_registered', 'staged integration detail payload invalid');
-
-    const promotionReadinessListResponse = await getJson(baseUrl, '/v1/integrations/promotion-readiness?source=third_party_example');
-    const promotionReadinessListJson = promotionReadinessListResponse.json;
-    assert.strictEqual(promotionReadinessListResponse.status, 200, 'promotion readiness list route failed');
-    assert.strictEqual(Array.isArray(promotionReadinessListJson.integrations), true, 'promotion readiness list payload invalid');
-    assert.strictEqual(
-      promotionReadinessListJson.integrations.every((entry) => entry.promotion_readiness.review_ready === true),
-      true,
-      'promotion readiness list review-ready mismatch'
-    );
-
-    const builtinPromotionReadinessResponse = await getJson(baseUrl, '/v1/integrations/builtin.verifier.registry_profile/promotion-readiness');
-    const builtinPromotionReadinessJson = builtinPromotionReadinessResponse.json;
-    assert.strictEqual(builtinPromotionReadinessResponse.status, 200, 'builtin promotion readiness route failed');
-    assert.strictEqual(
-      builtinPromotionReadinessJson.promotion_readiness.production_default_ready,
-      true,
-      'builtin promotion readiness production-default mismatch'
-    );
-
-    const stagedPromotionReadinessResponse = await getJson(baseUrl, '/v1/integrations/partner.verifier.lattice_notary/promotion-readiness');
-    const stagedPromotionReadinessJson = stagedPromotionReadinessResponse.json;
-    assert.strictEqual(stagedPromotionReadinessResponse.status, 200, 'staged promotion readiness route failed');
-    assert.strictEqual(
-      stagedPromotionReadinessJson.promotion_readiness.production_default_ready,
-      false,
-      'staged promotion readiness production-default mismatch'
-    );
-    assert.strictEqual(
-      stagedPromotionReadinessJson.promotion_readiness.blockers.includes('not_certified'),
-      true,
-      'staged promotion readiness certification blocker missing'
-    );
-
-    const promotionWorkflowListResponse = await getJson(
-      baseUrl,
-      '/v1/integrations/promotion-workflow?source=third_party_example&registration_state=staging_registered&bundled=false'
-    );
-    const promotionWorkflowListJson = promotionWorkflowListResponse.json;
-    assert.strictEqual(promotionWorkflowListResponse.status, 200, 'promotion workflow list route failed');
-    assert.strictEqual(Array.isArray(promotionWorkflowListJson.integrations), true, 'promotion workflow list payload invalid');
-    assert.strictEqual(promotionWorkflowListJson.integration_count >= 1, true, 'promotion workflow list breadth missing');
-    assert.strictEqual(
-      promotionWorkflowListJson.next_actions.some((entry) => entry.action === 'complete_certification'),
-      true,
-      'promotion workflow list next-action mismatch'
-    );
-    assert.strictEqual(
-      promotionWorkflowListJson.recommendations.some((entry) => entry.recommendation === 'keep_staged_until_requirements_clear'),
-      true,
-      'promotion workflow list recommendation mismatch'
-    );
-    assert.strictEqual(
-      promotionWorkflowListJson.blocker_categories.some((entry) => entry.category === 'certification'),
-      true,
-      'promotion workflow list blocker-category mismatch'
-    );
-
-    const builtinPromotionWorkflowResponse = await getJson(baseUrl, '/v1/integrations/builtin.verifier.registry_profile/promotion-workflow');
-    const builtinPromotionWorkflowJson = builtinPromotionWorkflowResponse.json;
-    assert.strictEqual(builtinPromotionWorkflowResponse.status, 200, 'builtin promotion workflow route failed');
-    assert.strictEqual(
-      builtinPromotionWorkflowJson.next_transition.action,
-      'maintain_production_default',
-      'builtin promotion workflow next-transition mismatch'
-    );
-
-    const stagedPromotionWorkflowResponse = await getJson(baseUrl, '/v1/integrations/partner.verifier.lattice_notary/promotion-workflow');
-    const stagedPromotionWorkflowJson = stagedPromotionWorkflowResponse.json;
-    assert.strictEqual(stagedPromotionWorkflowResponse.status, 200, 'staged promotion workflow route failed');
-    assert.strictEqual(
-      stagedPromotionWorkflowJson.next_transition.action,
-      'complete_certification',
-      'staged promotion workflow next-transition mismatch'
-    );
-    assert.strictEqual(
-      stagedPromotionWorkflowJson.next_transition.later_actions.includes('promote_maturity'),
-      true,
-      'staged promotion workflow later-actions mismatch'
-    );
-    assert.strictEqual(
-      stagedPromotionWorkflowJson.promotion_recommendation.recommendation,
-      'keep_staged_until_requirements_clear',
-      'staged promotion workflow recommendation mismatch'
-    );
-    assert.strictEqual(
-      stagedPromotionWorkflowJson.certification_gaps.missing_requirements.includes('certification_state'),
-      true,
-      'staged promotion workflow certification gap mismatch'
-    );
-
-    const receiptEmitResponse = await postJson(baseUrl, '/v1/receipts/emit', {
-      event: canonicalEvent,
-      options: {
-        legacy_identity_material_hex: identityMaterialHex,
-      },
-    });
-    assert.strictEqual(receiptEmitResponse.status, 200, 'receipt emit route failed');
-    assert.strictEqual(receiptEmitResponse.json.version, 'receipt/v1', 'receipt emit payload invalid');
-
-    const proofBundleBuild = await postJson(baseUrl, '/v1/proof-bundles/build', {
-      ceb: canonicalEvent,
-      receipt: receiptEmitResponse.json,
-      evidence_refs: ['memory://proof/service'],
-    });
-    assert.strictEqual(proofBundleBuild.status, 200, 'proof bundle build route failed');
-    assert.strictEqual(proofBundleBuild.json.version, 'proof-bundle/v1', 'proof bundle build payload invalid');
-
-    const proofBundleVerify = await postJson(baseUrl, '/v1/proof-bundles/verify', {
-      bundle: proofBundleBuild.json,
-    });
-    assert.strictEqual(proofBundleVerify.status, 200, 'proof bundle verify route failed');
-    assert.strictEqual(proofBundleVerify.json.valid, true, 'proof bundle verify payload invalid');
-    assert.strictEqual(proofBundleVerify.json.verification_class, 'digest', 'legacy proof bundle verify class mismatch');
-    assert.strictEqual(proofBundleVerify.json.cryptographically_verified, false, 'legacy proof bundle must not claim cryptographic verification');
-    assert.strictEqual(proofBundleVerify.json.strict, false, 'proof bundle verify strict flag default mismatch');
-    assert.strictEqual(proofBundleVerify.json.trust_root_applied, false, 'proof bundle verify trust root flag default mismatch');
-
-    const digestReceipt = sdk.emitReceipt(canonicalEvent, { agent_identity: 'service-digest-agent' });
-    const digestBundle = sdk.buildProofBundle({ ceb: canonicalEvent, receipt: digestReceipt });
-    const digestVerifyDefault = await postJson(baseUrl, '/v1/proof-bundles/verify', { bundle: digestBundle });
-    assert.strictEqual(digestVerifyDefault.status, 200, 'digest proof bundle verify route failed');
-    assert.strictEqual(digestVerifyDefault.json.valid, true, 'digest proof bundle must verify in default mode');
-    assert.strictEqual(digestVerifyDefault.json.verification_class, 'digest', 'digest proof bundle class mismatch');
-    const digestVerifyStrict = await postJson(baseUrl, '/v1/proof-bundles/verify', {
-      bundle: digestBundle,
-      options: { strict: true },
-    });
-    assert.strictEqual(digestVerifyStrict.status, 200, 'strict digest proof bundle verify route failed');
-    assert.strictEqual(digestVerifyStrict.json.valid, false, 'digest proof bundle must fail under strict verification');
-    assert.strictEqual(digestVerifyStrict.json.reason, 'digest_only_not_cryptographically_verified', 'strict digest rejection reason mismatch');
-    assert.strictEqual(digestVerifyStrict.json.strict, true, 'strict flag must echo in verify result');
-    assert.strictEqual(digestVerifyStrict.json.cryptographically_verified, false, 'strict digest result must not claim cryptographic verification');
-
-    const optionsResponse = await fetch(`${baseUrl}/v1/proof-bundles/verify`, { method: 'OPTIONS' });
-    assert.strictEqual(optionsResponse.status, 204, 'OPTIONS must return 204');
-    assert.strictEqual(/POST/.test(optionsResponse.headers.get('allow') || ''), true, 'OPTIONS must advertise POST in allow header');
-    const headResponse = await fetch(`${baseUrl}/health`, { method: 'HEAD' });
-    assert.strictEqual(headResponse.status, 200, 'HEAD on a known GET route must return 200');
-    assert.strictEqual((await headResponse.text()).length, 0, 'HEAD response must not carry a body');
-    assert.strictEqual(headResponse.headers.get('x-content-type-options'), 'nosniff', 'nosniff header missing');
-    assert.strictEqual(digestVerifyStrict.status, 200, 'post response status mismatch');
-    const postHeadersResponse = await fetch(`${baseUrl}/v1/proof-bundles/verify`, {
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ bundle: digestBundle }),
-    });
-    assert.strictEqual(postHeadersResponse.headers.get('cache-control'), 'no-store', 'POST responses must be no-store');
-    await postHeadersResponse.text();
-    const badEncodingResponse = await fetch(`${baseUrl}/v1/integrations/%E0%A4%A`);
-    assert.strictEqual(badEncodingResponse.status, 400, 'invalid percent-encoding must return 400');
-    assert.strictEqual((await badEncodingResponse.json()).reason, 'invalid_path_encoding', 'invalid path encoding reason mismatch');
-    const oversizedResponse = await new Promise((resolve, reject) => {
-      const request = http.request(
-        {
-          host: '127.0.0.1',
-          port: address.port,
-          method: 'POST',
-          path: '/v1/proof-bundles/verify',
-          headers: { 'content-type': 'application/json', 'content-length': String(2 * 1024 * 1024) },
-        },
-        (response) => {
-          let raw = '';
-          response.setEncoding('utf8');
-          response.on('data', (chunk) => { raw += chunk; });
-          response.on('end', () => {
-            request.destroy();
-            resolve({ status: response.statusCode, json: JSON.parse(raw) });
-          });
-        }
-      );
-      request.on('error', reject);
-      request.flushHeaders();
-    });
-    assert.strictEqual(oversizedResponse.status, 400, 'oversized declared content-length must be rejected before the body is read');
-    assert.strictEqual(oversizedResponse.json.reason, 'request body too large', 'oversized body reason mismatch');
-
-    const previousPrivateKeyPolicy = process.env.XOONYA_ACCEPT_PRIVATE_KEY_MATERIAL;
-    process.env.XOONYA_ACCEPT_PRIVATE_KEY_MATERIAL = 'false';
-    try {
-      const privateKeyEmit = await postJson(baseUrl, '/v1/receipts/emit', {
-        event: canonicalEvent,
-        options: {
-          algorithm: 'xoonya-native-signed-v1',
-          signature_suite: 'ed25519',
-          private_key_pem: '-----BEGIN PRIVATE KEY-----\nMC4CAQAwBQYDK2VwBCIEIOPZUHPWLt9QpTQ3ub3+RyJXNZrJYHxfDJEcUZhrXIz7\n-----END PRIVATE KEY-----\n',
-          public_key_pem: '-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEArnC5ARNJQFbPtc6pMrFUz2p043Nbds48Dz66+i1R5gk=\n-----END PUBLIC KEY-----\n',
-        },
-      });
-      assert.strictEqual(privateKeyEmit.status, 400, 'private key material must be rejected when policy disallows it');
-      assert.strictEqual(privateKeyEmit.json.reason, 'private_key_material_not_accepted', 'private key rejection reason mismatch');
-      assert.strictEqual(privateKeyEmit.json.field, 'options.private_key_pem', 'private key rejection field mismatch');
-      const privateKeyBuild = await postJson(baseUrl, '/v1/proof-bundles/build', {
-        ceb: canonicalEvent,
-        receipt_options: { classical_private_key_pem: 'x', pq_private_key_pem: 'y' },
-      });
-      assert.strictEqual(privateKeyBuild.status, 400, 'build route must reject private key material when policy disallows it');
-      assert.strictEqual(privateKeyBuild.json.reason, 'private_key_material_not_accepted', 'build private key rejection reason mismatch');
-      const noKeyEmit = await postJson(baseUrl, '/v1/receipts/emit', {
-        event: canonicalEvent,
-        options: { legacy_identity_material_hex: identityMaterialHex },
-      });
-      assert.strictEqual(noKeyEmit.status, 200, 'emit without private key material must still succeed under restrictive policy');
-    } finally {
-      if (previousPrivateKeyPolicy === undefined) {
-        delete process.env.XOONYA_ACCEPT_PRIVATE_KEY_MATERIAL;
-      } else {
-        process.env.XOONYA_ACCEPT_PRIVATE_KEY_MATERIAL = previousPrivateKeyPolicy;
-      }
-    }
-    const defaultProofLoopRun = await postJson(baseUrl, '/v1/proof-center/default-loops/run', {
-      loop_ref: 'default.proof.bundle.loop',
-      event: canonicalEvent,
-      options: {
-        legacy_identity_material_hex: identityMaterialHex
-      },
-      evidence_refs: ['memory://proof/service/default-loop']
-    });
-    assert.strictEqual(defaultProofLoopRun.status, 200, 'default proof loop run route failed');
-    assert.strictEqual(defaultProofLoopRun.json.loop.loop_ref, 'default.proof.bundle.loop', 'default proof loop ref missing');
-    assert.strictEqual(defaultProofLoopRun.json.bundle_verification.valid, true, 'default proof loop bundle verification missing');
-    assert.strictEqual(defaultProofLoopRun.json.receipt_verification.valid, true, 'default proof loop receipt verification missing');
-    const externalImportReview = await postJson(baseUrl, '/v1/proof-center/import-adapter/review', {
-      method: 'jwt-assertion-v1',
-      import_ref: 'service-jwt-import',
-      issuer_ref: 'did:example:issuer',
-      subject_ref: 'txn:xytara:service-demo',
-      external_proof: 'eyJhbGciOiJFZERTQSJ9.eyJzdWIiOiJ0eG4teHl0YXJhLXNlcnZpY2UtZGVtbyJ9.signature',
-      evidence_refs: ['memory://external/service-jwt-import']
-    });
-    assert.strictEqual(externalImportReview.status, 200, 'external proof import review route failed');
-    assert.strictEqual(externalImportReview.json.accepted, true, 'external proof import review acceptance missing');
-    assert.strictEqual(externalImportReview.json.method, 'jwt-assertion-v1', 'external proof import review method mismatch');
-    const externalImportReviewSummary = await postJson(baseUrl, '/v1/proof-center/import-adapter/review/summary', {
-      method: 'did-vc-v1',
-      external_proof: {
-        type: ['VerifiableCredential'],
-        issuer: 'did:example:issuer',
-        credentialSubject: { id: 'did:example:agent' }
-      }
-    });
-    assert.strictEqual(externalImportReviewSummary.status, 200, 'external proof import review summary route failed');
-    assert.strictEqual(externalImportReviewSummary.json.accepted, true, 'external proof import review summary acceptance missing');
-    assert.strictEqual(externalImportReviewSummary.json.method, 'did-vc-v1', 'external proof import review summary method mismatch');
-    const externalImportRun = await postJson(baseUrl, '/v1/proof-center/import-adapter/run', {
-      method: 'partner-proof-envelope-v1',
-      import_ref: 'service-partner-proof-import',
-      issuer_ref: 'partner:verifier-demo',
-      subject_ref: 'txn:xytara:service-demo',
-      external_proof: {
-        envelope_version: 'partner-proof-envelope/v1',
-        proof_ref: 'partner-proof-demo',
-        subject_ref: 'txn:xytara:service-demo'
-      },
-      evidence_refs: ['memory://external/partner-proof-demo']
-    });
-    assert.strictEqual(externalImportRun.status, 200, 'external proof import run route failed');
-    assert.strictEqual(externalImportRun.json.ok, true, 'external proof import run ok missing');
-    assert.strictEqual(externalImportRun.json.bundle_verification.valid, true, 'external proof import bundle verification missing');
-    assert.strictEqual(externalImportRun.json.bundle_verification.verification_method, 'partner-proof-envelope-v1', 'external proof import bundle method mismatch');
-    const transactionProofHandoffRun = await postJson(baseUrl, '/v1/proof-center/transaction-handoff/run', {
-      handoff_bundle: {
-        source_ref: 'transaction.registry.anchor',
-        transaction_id: 'txn-service-1',
-        receipt_id: 'txn-receipt-service-1',
-        proof_ref: 'memory://proof/service/transaction-proof',
-        task_refs: ['registry.pack.bundle', 'anchoring.pack.preview'],
-        delivery_count: 1,
-        payment_ledger_count: 1
-      },
-      options: {
-        legacy_identity_material_hex: identityMaterialHex
-      }
-    });
-    assert.strictEqual(transactionProofHandoffRun.status, 200, 'transaction proof handoff run route failed');
-    assert.strictEqual(
-      transactionProofHandoffRun.json.bundle_verification.valid,
-      true,
-      'transaction proof handoff run bundle verification missing'
-    );
-    assert.strictEqual(
-      transactionProofHandoffRun.json.recommended_loop,
-      'default.proof.bundle.loop',
-      'transaction proof handoff run recommended loop missing'
-    );
-    const interactionSpineHandoffRun = await postJson(baseUrl, '/v1/proof-center/interaction-spine-handoff/run', {
-      handoff_bundle: {
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-spine-service-1',
-        receipt_id: 'txn-spine-receipt-service-1',
-        proof_ref: 'memory://proof/service/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: identityMaterialHex
-      }
-    });
-    assert.strictEqual(interactionSpineHandoffRun.status, 200, 'interaction spine handoff run route failed');
-    assert.strictEqual(
-      interactionSpineHandoffRun.json.bundle_verification.valid,
-      true,
-      'interaction spine handoff run bundle verification missing'
-    );
-    assert.strictEqual(
-      interactionSpineHandoffRun.json.handoff.committed_ref,
-      'transaction.job.commitment',
-      'interaction spine handoff committed ref missing'
-    );
-    const resultPackageHandoffRun = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/run', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-service-1',
-        receipt_id: 'txn-result-package-receipt-service-1',
-        proof_ref: 'memory://proof/service/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'],
-        economic_consequence_handoff_bundle: {
-          contract_version: 'naxytra-economic-consequence-handoff-v1',
-          source_system: 'xytara',
-          account_ref: 'acct_demo',
-          usage_meter_ref: 'usage_meter_demo_1',
-          meter_profile_ref: 'meter_profile.trust.verify',
-          credit_spend_ref: 'credit_spend_demo_1',
-          usage_meter: {
-            usage_meter_id: 'usage_meter_demo_1',
-            account_id: 'acct_demo',
-            credit_spend_id: 'credit_spend_demo_1',
-            units: 2,
-            pricing_band: 'task_standard'
-          },
-          credit_spend: {
-            credit_spend_id: 'credit_spend_demo_1',
-            account_id: 'acct_demo',
-            units: 2
-          }
-        }
-      },
-      options: {
-        legacy_identity_material_hex: identityMaterialHex
-      }
-    });
-    assert.strictEqual(resultPackageHandoffRun.status, 200, 'result package handoff run route failed');
-    assert.strictEqual(
-      resultPackageHandoffRun.json.bundle_verification.valid,
-      true,
-      'result package handoff run bundle verification missing'
-    );
-    assert.strictEqual(
-      resultPackageHandoffRun.json.handoff.result_package_ref,
-      'result.spine.job.commitment',
-      'result package handoff package ref missing'
-    );
-    assert.strictEqual(resultPackageHandoffRun.json.economic_consequence_review.usage_meter_ref, 'usage_meter_demo_1', 'result package handoff run economic usage meter missing');
-    const resultPackageHandoffReview = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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'],
-        economic_consequence_handoff_bundle: {
-          contract_version: 'naxytra-economic-consequence-handoff-v1',
-          source_system: 'xytara',
-          account_ref: 'acct_demo',
-          usage_meter_ref: 'usage_meter_demo_2',
-          meter_profile_ref: 'meter_profile.trust.verify',
-          credit_spend_ref: 'credit_spend_demo_2',
-          payment_ref: 'pay_demo_2',
-          settlement_ref: 'settlement_demo_2',
-          settlement_txid: 'txid_demo_2',
-          settlement_status: 'finalized',
-          settlement_finality_status: 'finalized',
-          treasury_receipt_ref: 'treasury_rcpt_demo_2',
-          proof_ref: 'memory://proof/service/result-package-review-proof',
-          usage_meter: {
-            usage_meter_id: 'usage_meter_demo_2',
-            account_id: 'acct_demo',
-            credit_spend_id: 'credit_spend_demo_2',
-            units: 3,
-            pricing_band: 'task_standard'
-          },
-          credit_spend: {
-            credit_spend_id: 'credit_spend_demo_2',
-            account_id: 'acct_demo',
-            units: 3
-          }
-        }
-      }
-    });
-    assert.strictEqual(resultPackageHandoffReview.status, 200, 'result package handoff review route failed');
-    assert.strictEqual(resultPackageHandoffReview.json.accepted, true, 'result package handoff review acceptance missing');
-    assert.strictEqual(resultPackageHandoffReview.json.next_surface, '/v1/proof-center/result-package-handoff/run', 'result package handoff review next surface missing');
-    assert.strictEqual(resultPackageHandoffReview.json.durability_summary.review_ref, 'review.result.spine.job.commitment', 'result package handoff review ref missing');
-    assert.strictEqual(resultPackageHandoffReview.json.durability_summary.run_ready, true, 'result package handoff review run readiness missing');
-    assert.strictEqual(resultPackageHandoffReview.json.economic_consequence_review.credit_spend_ref, 'credit_spend_demo_2', 'result package handoff review economic credit spend missing');
-    assert.strictEqual(resultPackageHandoffReview.json.economic_consequence_review.economic_audit_summary.usage_meter_ref, 'usage_meter_demo_2', 'result package handoff review economic audit usage meter missing');
-    assert.strictEqual(resultPackageHandoffReview.json.economic_consequence_review.economic_audit_summary.settlement_ref, 'settlement_demo_2', 'result package handoff review economic audit settlement ref missing');
-    assert.strictEqual(resultPackageHandoffReview.json.economic_consequence_review.economic_audit_summary.treasury_receipt_ref, 'treasury_rcpt_demo_2', 'result package handoff review economic audit treasury receipt missing');
-    const resultPackageHandoffReviewSummaryCompact = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/summary', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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'],
-        economic_consequence_handoff_bundle: {
-          contract_version: 'naxytra-economic-consequence-handoff-v1',
-          source_system: 'xytara',
-          account_ref: 'acct_demo',
-          usage_meter_ref: 'usage_meter_demo_2',
-          meter_profile_ref: 'meter_profile.trust.verify',
-          credit_spend_ref: 'credit_spend_demo_2',
-          payment_ref: 'pay_demo_2',
-          settlement_ref: 'settlement_demo_2',
-          settlement_txid: 'txid_demo_2',
-          settlement_status: 'finalized',
-          settlement_finality_status: 'finalized',
-          treasury_receipt_ref: 'treasury_rcpt_demo_2',
-          proof_ref: 'memory://proof/service/result-package-review-proof',
-          usage_meter: {
-            usage_meter_id: 'usage_meter_demo_2',
-            account_id: 'acct_demo',
-            credit_spend_id: 'credit_spend_demo_2',
-            units: 3,
-            pricing_band: 'task_standard'
-          },
-          credit_spend: {
-            credit_spend_id: 'credit_spend_demo_2',
-            account_id: 'acct_demo',
-            units: 3
-          }
-        }
-      }
-    });
-    assert.strictEqual(resultPackageHandoffReviewSummaryCompact.status, 200, 'result package handoff review summary route failed');
-    assert.strictEqual(resultPackageHandoffReviewSummaryCompact.json.economic_audit_summary.credit_spend_ref, 'credit_spend_demo_2', 'result package handoff review summary audit credit spend missing');
-    assert.strictEqual(resultPackageHandoffReviewSummaryCompact.json.economic_audit_summary.settlement_finality_status, 'finalized', 'result package handoff review summary audit settlement finality missing');
-    const resultPackageHandoffReviewSummary = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/summary', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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'],
-        economic_consequence_handoff_bundle: {
-          contract_version: 'naxytra-economic-consequence-handoff-v1',
-          source_system: 'xytara',
-          account_ref: 'acct_demo',
-          usage_meter_ref: 'usage_meter_demo_3',
-          meter_profile_ref: 'meter_profile.trust.verify',
-          credit_spend_ref: 'credit_spend_demo_3',
-          usage_meter: {
-            usage_meter_id: 'usage_meter_demo_3',
-            account_id: 'acct_demo',
-            credit_spend_id: 'credit_spend_demo_3',
-            units: 4,
-            pricing_band: 'task_standard'
-          },
-          credit_spend: {
-            credit_spend_id: 'credit_spend_demo_3',
-            account_id: 'acct_demo',
-            units: 4
-          }
-        }
-      }
-    });
-    assert.strictEqual(resultPackageHandoffReviewSummary.status, 200, 'result package handoff review summary route failed');
-    assert.strictEqual(resultPackageHandoffReviewSummary.json.review_ref, 'review.result.spine.job.commitment', 'result package handoff review summary ref missing');
-    assert.strictEqual(resultPackageHandoffReviewSummary.json.run_ready, true, 'result package handoff review summary run readiness missing');
-    assert.strictEqual(resultPackageHandoffReviewSummary.json.economic_consequence_ready, true, 'result package handoff review summary economic readiness missing');
-    assert.strictEqual(resultPackageHandoffReviewSummary.json.usage_meter_ref, 'usage_meter_demo_3', 'result package handoff review summary usage meter missing');
-    const resultPackageHandoffExtensionReadiness = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/extension-readiness', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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(resultPackageHandoffExtensionReadiness.status, 200, 'result package handoff extension readiness route failed');
-    assert.strictEqual(resultPackageHandoffExtensionReadiness.json.extension_ready_ref, 'extension.review.result.spine.job.commitment', 'result package handoff extension readiness ref missing');
-    assert.strictEqual(resultPackageHandoffExtensionReadiness.json.proof_extension_ready, true, 'result package handoff extension readiness proof readiness missing');
-    const resultPackageHandoffExtensionBoundary = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/extension-boundary', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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(resultPackageHandoffExtensionBoundary.status, 200, 'result package handoff extension boundary route failed');
-    assert.strictEqual(resultPackageHandoffExtensionBoundary.json.extension_ready_ref, 'extension.review.result.spine.job.commitment', 'result package handoff extension boundary ref missing');
-    assert.strictEqual(resultPackageHandoffExtensionBoundary.json.stable_boundary_ids.includes('proof_run'), true, 'result package handoff extension boundary ids missing');
-    const resultPackageHandoffDefaultContinuation = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/default-continuation', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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(resultPackageHandoffDefaultContinuation.status, 200, 'result package handoff default continuation route failed');
-    assert.strictEqual(resultPackageHandoffDefaultContinuation.json.reusable_default_ref, 'default.review.result.spine.job.commitment', 'result package handoff default continuation ref missing');
-    assert.strictEqual(resultPackageHandoffDefaultContinuation.json.default_followthrough.review_summary_surface, '/v1/proof-center/result-package-handoff/review/summary', 'result package handoff default continuation review summary surface missing');
-    assert.strictEqual(resultPackageHandoffDefaultContinuation.json.default_followthrough.reusable_by_default, true, 'result package handoff default continuation reusable-by-default missing');
-    const resultPackageHandoffDefaultBoundary = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/default-boundary', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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(resultPackageHandoffDefaultBoundary.status, 200, 'result package handoff default boundary route failed');
-    assert.strictEqual(resultPackageHandoffDefaultBoundary.json.reusable_default_ref, 'default.review.result.spine.job.commitment', 'result package handoff default boundary ref missing');
-    assert.strictEqual(resultPackageHandoffDefaultBoundary.json.stable_boundary_ids.includes('proof_run'), true, 'result package handoff default boundary ids missing');
-    const resultPackageHandoffContractSummary = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/contract-summary', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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(resultPackageHandoffContractSummary.status, 200, 'result package handoff contract summary route failed');
-    assert.strictEqual(resultPackageHandoffContractSummary.json.composition_contract_ref, 'contract.default.review.result.spine.job.commitment', 'result package handoff contract summary ref missing');
-    assert.strictEqual(resultPackageHandoffContractSummary.json.contract_ready, true, 'result package handoff contract summary contract-ready missing');
-    const resultPackageHandoffContractBoundary = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/contract-boundary', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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(resultPackageHandoffContractBoundary.status, 200, 'result package handoff contract boundary route failed');
-    assert.strictEqual(resultPackageHandoffContractBoundary.json.composition_contract_ref, 'contract.default.review.result.spine.job.commitment', 'result package handoff contract boundary ref missing');
-    assert.strictEqual(resultPackageHandoffContractBoundary.json.stable_boundary_ids.includes('proof_run'), true, 'result package handoff contract boundary ids missing');
-    const resultPackageHandoffContractCarry = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/contract-carry', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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(resultPackageHandoffContractCarry.status, 200, 'result package handoff contract carry route failed');
-    assert.strictEqual(resultPackageHandoffContractCarry.json.composition_contract_ref, 'contract.default.review.result.spine.job.commitment', 'result package handoff contract carry ref missing');
-    assert.strictEqual(resultPackageHandoffContractCarry.json.public_contract_ids.includes('proof_run'), true, 'result package handoff contract carry ids missing');
-    assert.strictEqual(resultPackageHandoffContractCarry.json.contract_ready, true, 'result package handoff contract carry contract-ready missing');
-    const resultPackageHandoffBridgeSummary = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/bridge-summary', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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(resultPackageHandoffBridgeSummary.status, 200, 'result package handoff bridge summary route failed');
-    assert.strictEqual(resultPackageHandoffBridgeSummary.json.adapter_bridge_ref, 'bridge.contract.default.review.result.spine.job.commitment', 'result package handoff bridge summary ref missing');
-    assert.strictEqual(resultPackageHandoffBridgeSummary.json.bridge_ready, true, 'result package handoff bridge summary bridge-ready missing');
-    const resultPackageHandoffBridgeBoundary = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/bridge-boundary', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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(resultPackageHandoffBridgeBoundary.status, 200, 'result package handoff bridge boundary route failed');
-    assert.strictEqual(resultPackageHandoffBridgeBoundary.json.adapter_bridge_ref, 'bridge.contract.default.review.result.spine.job.commitment', 'result package handoff bridge boundary ref missing');
-    assert.strictEqual(resultPackageHandoffBridgeBoundary.json.stable_boundary_ids.includes('proof_run'), true, 'result package handoff bridge boundary ids missing');
-    const resultPackageHandoffBridgeCarry = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/bridge-carry', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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(resultPackageHandoffBridgeCarry.status, 200, 'result package handoff bridge carry route failed');
-    assert.strictEqual(resultPackageHandoffBridgeCarry.json.adapter_bridge_ref, 'bridge.contract.default.review.result.spine.job.commitment', 'result package handoff bridge carry ref missing');
-    assert.strictEqual(resultPackageHandoffBridgeCarry.json.stable_bridge_ids.includes('proof_run'), true, 'result package handoff bridge carry ids missing');
-    assert.strictEqual(resultPackageHandoffBridgeCarry.json.bridge_ready, true, 'result package handoff bridge carry bridge-ready missing');
-    const resultPackageHandoffBridgeRun = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/bridge-run', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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(resultPackageHandoffBridgeRun.status, 200, 'result package handoff bridge run route failed');
-    assert.strictEqual(resultPackageHandoffBridgeRun.json.adapter_bridge_ref, 'bridge.contract.default.review.result.spine.job.commitment', 'result package handoff bridge run ref missing');
-    assert.strictEqual(resultPackageHandoffBridgeRun.json.accepted_bridge_ids.includes('proof_run'), true, 'result package handoff bridge run accepted ids missing');
-    assert.strictEqual(resultPackageHandoffBridgeRun.json.run_surface, '/v1/proof-center/result-package-handoff/run', 'result package handoff bridge run surface missing');
-    const resultPackageHandoffContinuity = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/handoff-continuity', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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.status, 200, 'result package handoff continuity route failed');
-    assert.strictEqual(resultPackageHandoffContinuity.json.handoff_contract_ref, 'handoff.bridge.contract.default.review.result.spine.job.commitment', 'result package handoff continuity ref missing');
-    assert.strictEqual(resultPackageHandoffContinuity.json.stable_handoff_ids.includes('proof_run'), true, 'result package handoff continuity ids missing');
-    assert.strictEqual(resultPackageHandoffContinuity.json.run_surface, '/v1/proof-center/result-package-handoff/run', 'result package handoff continuity surface missing');
-    const resultPackageHandoffIntake = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/handoff-intake', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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.status, 200, 'result package handoff intake route failed');
-    assert.strictEqual(resultPackageHandoffIntake.json.handoff_surface_ref, 'surface.handoff.bridge.contract.default.review.result.spine.job.commitment', 'result package handoff intake ref missing');
-    assert.strictEqual(resultPackageHandoffIntake.json.adapter_consumable, true, 'result package handoff intake consumable missing');
-    const resultPackageHandoffIntakeBoundary = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/handoff-intake-boundary', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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.status, 200, 'result package handoff intake boundary route failed');
-    assert.strictEqual(resultPackageHandoffIntakeBoundary.json.handoff_surface_ref, 'surface.handoff.bridge.contract.default.review.result.spine.job.commitment', 'result package handoff intake boundary ref missing');
-    assert.strictEqual(resultPackageHandoffIntakeBoundary.json.stable_boundary_ids.includes('proof_run'), true, 'result package handoff intake boundary ids missing');
-    const resultPackageHandoffIntakeCarry = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/handoff-intake-carry', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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.status, 200, 'result package handoff intake carry route failed');
-    assert.strictEqual(resultPackageHandoffIntakeCarry.json.handoff_surface_ref, 'surface.handoff.bridge.contract.default.review.result.spine.job.commitment', 'result package handoff intake carry ref missing');
-    assert.strictEqual(resultPackageHandoffIntakeCarry.json.stable_handoff_surface_ids.includes('proof_run'), true, 'result package handoff intake carry ids missing');
-    assert.strictEqual(resultPackageHandoffIntakeCarry.json.adapter_consumable, true, 'result package handoff intake carry consumable missing');
-    const resultPackageHandoffPackageIntake = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/handoff-package-intake', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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.status, 200, 'result package handoff package intake route failed');
-    assert.strictEqual(resultPackageHandoffPackageIntake.json.handoff_package_ref, 'package.surface.handoff.bridge.contract.default.review.result.spine.job.commitment', 'result package handoff package intake ref missing');
-    assert.strictEqual(resultPackageHandoffPackageIntake.json.adapter_usable, true, 'result package handoff package intake usable missing');
-    const resultPackageHandoffPackageCarry = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/handoff-package-carry', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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.status, 200, 'result package handoff package carry route failed');
-    assert.strictEqual(resultPackageHandoffPackageCarry.json.handoff_package_ref, 'package.surface.handoff.bridge.contract.default.review.result.spine.job.commitment', 'result package handoff package carry ref missing');
-    assert.strictEqual(resultPackageHandoffPackageCarry.json.stable_handoff_package_ids.includes('proof_run'), true, 'result package handoff package carry ids missing');
-    assert.strictEqual(resultPackageHandoffPackageCarry.json.adapter_usable, true, 'result package handoff package carry usable missing');
-    const resultPackageHandoffPackageRun = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/handoff-package-run', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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.status, 200, 'result package handoff package run route failed');
-    assert.strictEqual(resultPackageHandoffPackageRun.json.handoff_package_ref, 'package.surface.handoff.bridge.contract.default.review.result.spine.job.commitment', 'result package handoff package run ref missing');
-    assert.strictEqual(resultPackageHandoffPackageRun.json.accepted_handoff_package_ids.includes('proof_run'), true, 'result package handoff package run accepted ids missing');
-    assert.strictEqual(resultPackageHandoffPackageRun.json.run_surface, '/v1/proof-center/result-package-handoff/run', 'result package handoff package run surface missing');
-    const resultPackageExecutionPackage = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/execution-package', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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.status, 200, 'result package execution package route failed');
-    assert.strictEqual(resultPackageExecutionPackage.json.execution_package_ref, 'execution.package.surface.handoff.bridge.contract.default.review.result.spine.job.commitment', 'result package execution package ref missing');
-    assert.strictEqual(resultPackageExecutionPackage.json.accepted_execution_package_ids.includes('proof_run'), true, 'result package execution package accepted ids missing');
-    assert.strictEqual(resultPackageExecutionPackage.json.run_surface, '/v1/proof-center/result-package-handoff/run', 'result package execution package surface missing');
-    const resultPackageExecutionPackageCarry = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/execution-package-carry', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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.status, 200, 'result package execution package carry route failed');
-    assert.strictEqual(resultPackageExecutionPackageCarry.json.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.json.accepted_execution_package_ids.includes('proof_run'), true, 'result package execution package carry ids missing');
-    assert.strictEqual(resultPackageExecutionPackageCarry.json.adapter_ready, true, 'result package execution package carry ready missing');
-    const resultPackageExecutionPackageRun = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/execution-package-run', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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.status, 200, 'result package execution package run route failed');
-    assert.strictEqual(resultPackageExecutionPackageRun.json.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.json.accepted_execution_package_ids.includes('proof_run'), true, 'result package execution package run ids missing');
-    assert.strictEqual(resultPackageExecutionPackageRun.json.execution_ready_by_default, true, 'result package execution package run ready missing');
-    assert.strictEqual(resultPackageExecutionPackageRun.json.run_surface, '/v1/proof-center/result-package-handoff/run', 'result package execution package run surface missing');
-    const resultPackageExecutionContract = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/execution-contract', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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.status, 200, 'result package execution contract route failed');
-    assert.strictEqual(resultPackageExecutionContract.json.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.json.accepted_execution_contract_ids.includes('proof_run'), true, 'result package execution contract ids missing');
-    assert.strictEqual(resultPackageExecutionContract.json.adapter_operable, true, 'result package execution contract operable missing');
-    assert.strictEqual(resultPackageExecutionContract.json.run_surface, '/v1/proof-center/result-package-handoff/run', 'result package execution contract surface missing');
-    const resultPackageExecutionContractCarry = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/execution-contract-carry', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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.status, 200, 'result package execution contract carry route failed');
-    assert.strictEqual(resultPackageExecutionContractCarry.json.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.json.accepted_execution_contract_ids.includes('proof_run'), true, 'result package execution contract carry ids missing');
-    assert.strictEqual(resultPackageExecutionContractCarry.json.adapter_operable, true, 'result package execution contract carry operable missing');
-    const resultPackageExecutionContractRun = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/execution-contract-run', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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.status, 200, 'result package execution contract run route failed');
-    assert.strictEqual(resultPackageExecutionContractRun.json.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.json.accepted_execution_contract_ids.includes('proof_run'), true, 'result package execution contract run ids missing');
-    assert.strictEqual(resultPackageExecutionContractRun.json.execution_operable_by_default, true, 'result package execution contract run operable missing');
-    assert.strictEqual(resultPackageExecutionContractRun.json.run_surface, '/v1/proof-center/result-package-handoff/run', 'result package execution contract run surface missing');
-    const resultPackageOperatingContract = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/operating-contract', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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.status, 200, 'result package operating contract route failed');
-    assert.strictEqual(resultPackageOperatingContract.json.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.json.accepted_operating_contract_ids.includes('proof_run'), true, 'result package operating contract ids missing');
-    assert.strictEqual(resultPackageOperatingContract.json.adapter_stable, true, 'result package operating contract stable missing');
-    assert.strictEqual(resultPackageOperatingContract.json.run_surface, '/v1/proof-center/result-package-handoff/run', 'result package operating contract surface missing');
-    const resultPackageOperatingContractCarry = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/operating-contract-carry', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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.status, 200, 'result package operating contract carry route failed');
-    assert.strictEqual(resultPackageOperatingContractCarry.json.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.json.accepted_operating_contract_ids.includes('proof_run'), true, 'result package operating contract carry ids missing');
-    assert.strictEqual(resultPackageOperatingContractCarry.json.adapter_stable, true, 'result package operating contract carry stable missing');
-    const resultPackageOperatingContractRun = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/operating-contract-run', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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.status, 200, 'result package operating contract run route failed');
-    assert.strictEqual(resultPackageOperatingContractRun.json.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.json.accepted_operating_contract_ids.includes('proof_run'), true, 'result package operating contract run ids missing');
-    assert.strictEqual(resultPackageOperatingContractRun.json.operating_stable_by_default, true, 'result package operating contract run stable missing');
-    assert.strictEqual(resultPackageOperatingContractRun.json.run_surface, '/v1/proof-center/result-package-handoff/run', 'result package operating contract run surface missing');
-    const resultPackageOperatingInterface = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/operating-interface', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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.status, 200, 'result package operating interface route failed');
-    assert.strictEqual(resultPackageOperatingInterface.json.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.json.accepted_operating_interface_ids.includes('proof_run'), true, 'result package operating interface ids missing');
-    assert.strictEqual(resultPackageOperatingInterface.json.adapter_reliable, true, 'result package operating interface reliable missing');
-    assert.strictEqual(resultPackageOperatingInterface.json.run_surface, '/v1/proof-center/result-package-handoff/run', 'result package operating interface surface missing');
-    const resultPackageOperatingInterfaceCarry = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/operating-interface-carry', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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.status, 200, 'result package operating interface carry route failed');
-    assert.strictEqual(resultPackageOperatingInterfaceCarry.json.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.json.accepted_operating_interface_ids.includes('proof_run'), true, 'result package operating interface carry ids missing');
-    assert.strictEqual(resultPackageOperatingInterfaceCarry.json.adapter_reliable, true, 'result package operating interface carry reliable missing');
-    const resultPackageOperatingInterfaceRun = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/operating-interface-run', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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.status, 200, 'result package operating interface run route failed');
-    assert.strictEqual(resultPackageOperatingInterfaceRun.json.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.json.accepted_operating_interface_ids.includes('proof_run'), true, 'result package operating interface run ids missing');
-    assert.strictEqual(resultPackageOperatingInterfaceRun.json.operating_interface_reliable_by_default, true, 'result package operating interface run reliable missing');
-    assert.strictEqual(resultPackageOperatingInterfaceRun.json.run_surface, '/v1/proof-center/result-package-handoff/run', 'result package operating interface run surface missing');
-    const resultPackageOperatingIntegration = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/operating-integration', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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.status, 200, 'result package operating integration route failed');
-    assert.strictEqual(resultPackageOperatingIntegration.json.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.json.accepted_operating_integration_ids.includes('proof_run'), true, 'result package operating integration ids missing');
-    assert.strictEqual(resultPackageOperatingIntegration.json.adapter_integrable, true, 'result package operating integration integrable missing');
-    assert.strictEqual(resultPackageOperatingIntegration.json.run_surface, '/v1/proof-center/result-package-handoff/run', 'result package operating integration surface missing');
-    const resultPackageOperatingIntegrationCarry = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/operating-integration-carry', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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.status, 200, 'result package operating integration carry route failed');
-    assert.strictEqual(resultPackageOperatingIntegrationCarry.json.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.json.accepted_operating_integration_ids.includes('proof_run'), true, 'result package operating integration carry ids missing');
-    assert.strictEqual(resultPackageOperatingIntegrationCarry.json.adapter_integrable, true, 'result package operating integration carry integrable missing');
-    const resultPackageOperatingIntegrationRun = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/operating-integration-run', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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.status, 200, 'result package operating integration run route failed');
-    assert.strictEqual(resultPackageOperatingIntegrationRun.json.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.json.accepted_operating_integration_ids.includes('proof_run'), true, 'result package operating integration run ids missing');
-    assert.strictEqual(resultPackageOperatingIntegrationRun.json.operating_integration_integrable_by_default, true, 'result package operating integration run integrable missing');
-    assert.strictEqual(resultPackageOperatingIntegrationRun.json.run_surface, '/v1/proof-center/result-package-handoff/run', 'result package operating integration run surface missing');
-    const resultPackageOperatingPath = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/operating-path', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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.status, 200, 'result package operating path route failed');
-    assert.strictEqual(resultPackageOperatingPath.json.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.json.accepted_operating_path_ids.includes('proof_run'), true, 'result package operating path ids missing');
-    assert.strictEqual(resultPackageOperatingPath.json.adapter_ready_by_default, true, 'result package operating path default readiness missing');
-    assert.strictEqual(resultPackageOperatingPath.json.run_surface, '/v1/proof-center/result-package-handoff/run', 'result package operating path surface missing');
-    const resultPackageOperatingPathCarry = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/operating-path-carry', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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.status, 200, 'result package operating path carry route failed');
-    assert.strictEqual(resultPackageOperatingPathCarry.json.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.json.accepted_operating_path_ids.includes('proof_run'), true, 'result package operating path carry ids missing');
-    assert.strictEqual(resultPackageOperatingPathCarry.json.adapter_ready_by_default, true, 'result package operating path carry default readiness missing');
-    const resultPackageOperatingPathRun = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/operating-path-run', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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.status, 200, 'result package operating path run route failed');
-    assert.strictEqual(resultPackageOperatingPathRun.json.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.json.accepted_operating_path_ids.includes('proof_run'), true, 'result package operating path run ids missing');
-    assert.strictEqual(resultPackageOperatingPathRun.json.operating_path_ready_by_default, true, 'result package operating path run ready missing');
-    assert.strictEqual(resultPackageOperatingPathRun.json.run_surface, '/v1/proof-center/result-package-handoff/run', 'result package operating path run surface missing');
-    const resultPackageCompleteDefaultPath = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/complete-default-path', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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.status, 200, 'result package complete default path route failed');
-    assert.strictEqual(resultPackageCompleteDefaultPath.json.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.json.accepted_complete_default_path_ids.includes('proof_run'), true, 'result package complete default path ids missing');
-    assert.strictEqual(resultPackageCompleteDefaultPath.json.adapter_complete_by_default, true, 'result package complete default path complete missing');
-    assert.strictEqual(resultPackageCompleteDefaultPath.json.run_surface, '/v1/proof-center/result-package-handoff/run', 'result package complete default path surface missing');
-    const resultPackageCompleteDefaultPathCarry = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/complete-default-path-carry', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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.status, 200, 'result package complete default path carry route failed');
-    assert.strictEqual(resultPackageCompleteDefaultPathCarry.json.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.json.accepted_complete_default_path_ids.includes('proof_run'), true, 'result package complete default path carry ids missing');
-    assert.strictEqual(resultPackageCompleteDefaultPathCarry.json.adapter_complete_by_default, true, 'result package complete default path carry complete missing');
-    const resultPackageCompleteDefaultPathRun = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/complete-default-path-run', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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.status, 200, 'result package complete default path run route failed');
-    assert.strictEqual(resultPackageCompleteDefaultPathRun.json.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.json.accepted_complete_default_path_ids.includes('proof_run'), true, 'result package complete default path run ids missing');
-    assert.strictEqual(resultPackageCompleteDefaultPathRun.json.complete_default_path_ready, true, 'result package complete default path run ready missing');
-    assert.strictEqual(resultPackageCompleteDefaultPathRun.json.run_surface, '/v1/proof-center/result-package-handoff/run', 'result package complete default path run surface missing');
-    const resultPackageHandoffRunReview = await postJson(baseUrl, '/v1/proof-center/result-package-handoff/review/handoff-run', {
-      handoff_bundle: {
-        result_package_ref: 'result.spine.job.commitment',
-        source_ref: 'spine.job.commitment',
-        transaction_id: 'txn-result-package-review-service-1',
-        receipt_id: 'txn-result-package-review-receipt-service-1',
-        proof_ref: 'memory://proof/service/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(resultPackageHandoffRunReview.status, 200, 'result package handoff run route failed');
-    assert.strictEqual(resultPackageHandoffRunReview.json.handoff_contract_ref, 'handoff.bridge.contract.default.review.result.spine.job.commitment', 'result package handoff run ref missing');
-    assert.strictEqual(resultPackageHandoffRunReview.json.accepted_handoff_ids.includes('proof_run'), true, 'result package handoff run accepted ids missing');
-    assert.strictEqual(resultPackageHandoffRunReview.json.run_surface, '/v1/proof-center/result-package-handoff/run', 'result package handoff run surface missing');
-    const governanceInterpretation = await postJson(baseUrl, '/v1/proof-center/governance/interpretation-validate', {
-      result_package_ref: 'result.spine.job.commitment',
-      case_ref: 'case-demo',
-      interpretation_context: {
-        policy_ref: 'policy-demo',
-      }
-    });
-    assert.strictEqual(governanceInterpretation.status, 200, 'governance interpretation route failed');
-    assert.strictEqual(governanceInterpretation.json.interpretation_status, 'validated', 'governance interpretation status missing');
-    const governanceCoordination = await postJson(baseUrl, '/v1/proof-center/governance/coordination', {
-      result_package_ref: 'result.spine.job.commitment',
-      case_ref: 'case-demo'
-    });
-    assert.strictEqual(governanceCoordination.status, 200, 'governance coordination route failed');
-    assert.strictEqual(governanceCoordination.json.next_surface, '/v1/proof-center/result-package-handoff/run', 'governance coordination next surface missing');
-    const governanceDashboard = await postJson(baseUrl, '/v1/proof-center/governance/dashboard', {
-      account_ref: 'account-demo',
-      review_count: 4,
-      dispute_count: 2
-    });
-    assert.strictEqual(governanceDashboard.status, 200, 'governance dashboard route failed');
-    assert.strictEqual(governanceDashboard.json.queue_summary.review_count, 4, 'governance dashboard review count missing');
-    const governanceOperatorView = await postJson(baseUrl, '/v1/proof-center/governance/operator-view', {
-      account_ref: 'account-demo'
-    });
-    assert.strictEqual(governanceOperatorView.status, 200, 'governance operator view route failed');
-    assert.strictEqual(governanceOperatorView.json.attention_refs.includes('governance.dispute.queue'), true, 'governance operator attention refs missing');
-    const governanceAdminView = await postJson(baseUrl, '/v1/proof-center/governance/admin-view', {
-      account_ref: 'account-demo'
-    });
-    assert.strictEqual(governanceAdminView.status, 200, 'governance admin view route failed');
-    assert.strictEqual(governanceAdminView.json.oversight_summary.escalation_ready_count >= 1, true, 'governance admin oversight summary missing');
-    const governanceDashboardPack = await postJson(baseUrl, '/v1/proof-center/governance/dashboard-pack', {
-      account_ref: 'account-demo'
-    });
-    assert.strictEqual(governanceDashboardPack.status, 200, 'governance dashboard pack route failed');
-    assert.strictEqual(Array.isArray(governanceDashboardPack.json.included_sections), true, 'governance dashboard pack sections missing');
-    const governanceWorkflowPack = await postJson(baseUrl, '/v1/proof-center/governance/workflow-pack', {
-      result_package_ref: 'result.spine.job.commitment'
-    });
-    assert.strictEqual(governanceWorkflowPack.status, 200, 'governance workflow pack route failed');
-    assert.strictEqual(governanceWorkflowPack.json.workflow_pack_ref.startsWith('governance.workflow-pack.'), true, 'governance workflow pack ref missing');
-    const governanceSignoffPack = await postJson(baseUrl, '/v1/proof-center/governance/signoff-pack', {
-      account_ref: 'account-demo'
-    });
-    assert.strictEqual(governanceSignoffPack.status, 200, 'governance signoff pack route failed');
-    assert.strictEqual(governanceSignoffPack.json.signoff_status, 'review_ready', 'governance signoff status missing');
-    const governanceDisputes = await postJson(baseUrl, '/v1/proof-center/governance/disputes/summary', {
-      account_ref: 'account-demo',
-      case_count: 3
-    });
-    assert.strictEqual(governanceDisputes.status, 200, 'governance disputes summary route failed');
-    assert.strictEqual(governanceDisputes.json.case_count, 3, 'governance disputes case count missing');
-    const governanceCaseReview = await postJson(baseUrl, '/v1/proof-center/governance/disputes/case-review', {
-      case_ref: 'case-demo',
-      source_ref: 'result.spine.job.commitment'
-    });
-    assert.strictEqual(governanceCaseReview.status, 200, 'governance case review route failed');
-    assert.strictEqual(governanceCaseReview.json.available_actions.includes('resolve'), true, 'governance case review actions missing');
-    const governanceDisputeAction = await postJson(baseUrl, '/v1/proof-center/governance/disputes/action', {
-      case_ref: 'case-demo',
-      action: 'resolve'
-    });
-    assert.strictEqual(governanceDisputeAction.status, 200, 'governance dispute action route failed');
-    assert.strictEqual(governanceDisputeAction.json.action_status, 'recorded', 'governance dispute action status missing');
-    const governanceCaseBundle = await postJson(baseUrl, '/v1/proof-center/governance/disputes/case-bundle', {
-      case_ref: 'case-demo'
-    });
-    assert.strictEqual(governanceCaseBundle.status, 200, 'governance case bundle route failed');
-    assert.strictEqual(governanceCaseBundle.json.case_bundle_ref.startsWith('governance.case-bundle.'), true, 'governance case bundle ref missing');
-    const governanceResolutionPack = await postJson(baseUrl, '/v1/proof-center/governance/disputes/resolution-pack', {
-      case_ref: 'case-demo',
-      action: 'resolve'
-    });
-    assert.strictEqual(governanceResolutionPack.status, 200, 'governance resolution pack route failed');
-    assert.strictEqual(governanceResolutionPack.json.resolution_pack_ref.startsWith('governance.resolution-pack.'), true, 'governance resolution pack ref missing');
-    const reviewIntelligence = await postJson(baseUrl, '/v1/review-intelligence', {
-      account_ref: 'account-demo',
-      review_count: 4,
-      dispute_count: 2,
-      case_count: 3
-    });
-    assert.strictEqual(reviewIntelligence.status, 200, 'review intelligence route failed');
-    assert.strictEqual(reviewIntelligence.json.review_burden_state, 'moderate', 'review intelligence burden state missing');
-    assert.strictEqual(reviewIntelligence.json.dispute_risk_state, 'watch', 'review intelligence dispute risk state missing');
-    assert.strictEqual(reviewIntelligence.json.bridge_dependency_state, 'strong', 'review intelligence bridge dependency state missing');
-    assert.strictEqual(typeof reviewIntelligence.json.linked_surfaces.governance_disputes_summary_ref, 'string', 'review intelligence disputes summary ref missing');
-    const reviewIntelligenceSummary = await postJson(baseUrl, '/v1/review-intelligence/summary', {
-      account_ref: 'account-demo',
-      review_count: 4,
-      dispute_count: 2,
-      case_count: 3
-    });
-    assert.strictEqual(reviewIntelligenceSummary.status, 200, 'review intelligence summary route failed');
-    assert.strictEqual(reviewIntelligenceSummary.json.category, 'proof-review-intelligence-pack', 'review intelligence summary category missing');
-    assert.strictEqual(reviewIntelligenceSummary.json.signal_count >= 6, true, 'review intelligence summary signal count missing');
-    const governanceIntelligence = await postJson(baseUrl, '/v1/governance-intelligence', {
-      account_ref: 'account-demo',
-      review_count: 4,
-      dispute_count: 2,
-      case_count: 3
-    });
-    assert.strictEqual(governanceIntelligence.status, 200, 'governance intelligence route failed');
-    assert.strictEqual(governanceIntelligence.json.escalation_readiness_state, 'active', 'governance intelligence escalation state missing');
-    assert.strictEqual(governanceIntelligence.json.signoff_motion_state, 'review_ready', 'governance intelligence signoff state missing');
-    assert.strictEqual(governanceIntelligence.json.handoff_continuity_state, 'strong', 'governance intelligence handoff continuity state missing');
-    assert.strictEqual(typeof governanceIntelligence.json.linked_surfaces.governance_handoff_bundle_ref, 'string', 'governance intelligence handoff ref missing');
-    const governanceIntelligenceSummary = await postJson(baseUrl, '/v1/governance-intelligence/summary', {
-      account_ref: 'account-demo',
-      review_count: 4,
-      dispute_count: 2,
-      case_count: 3
-    });
-    assert.strictEqual(governanceIntelligenceSummary.status, 200, 'governance intelligence summary route failed');
-    assert.strictEqual(governanceIntelligenceSummary.json.category, 'proof-governance-intelligence-pack', 'governance intelligence summary category missing');
-    assert.strictEqual(governanceIntelligenceSummary.json.signal_count >= 7, true, 'governance intelligence summary signal count missing');
-    const bridgeIntelligence = await postJson(baseUrl, '/v1/bridge-intelligence', {
-      account_ref: 'account-demo',
-      source_ref: 'result.spine.job.commitment'
-    });
-    assert.strictEqual(bridgeIntelligence.status, 200, 'bridge intelligence route failed');
-    assert.strictEqual(bridgeIntelligence.json.bridge_coverage_state, 'broad', 'bridge intelligence coverage state missing');
-    assert.strictEqual(bridgeIntelligence.json.compatibility_strength_state, 'strong', 'bridge intelligence compatibility state missing');
-    assert.strictEqual(bridgeIntelligence.json.handoff_dependency_state, 'strong', 'bridge intelligence handoff dependency state missing');
-    assert.strictEqual(typeof bridgeIntelligence.json.linked_surfaces.result_package_handoff_summary_ref, 'string', 'bridge intelligence handoff summary ref missing');
-    const bridgeIntelligenceSummary = await postJson(baseUrl, '/v1/bridge-intelligence/summary', {
-      account_ref: 'account-demo',
-      source_ref: 'result.spine.job.commitment'
-    });
-    assert.strictEqual(bridgeIntelligenceSummary.status, 200, 'bridge intelligence summary route failed');
-    assert.strictEqual(bridgeIntelligenceSummary.json.category, 'proof-bridge-intelligence-pack', 'bridge intelligence summary category missing');
-    assert.strictEqual(bridgeIntelligenceSummary.json.signal_count >= 6, true, 'bridge intelligence summary signal count missing');
-    const governanceConsolePack = await postJson(baseUrl, '/v1/proof-center/governance/console-pack', {
-      account_ref: 'account-demo'
-    });
-    assert.strictEqual(governanceConsolePack.status, 200, 'governance console pack route failed');
-    assert.strictEqual(governanceConsolePack.json.console_pack_ref.startsWith('governance.console-pack.'), true, 'governance console pack ref missing');
-    const governanceHandoffBundle = await postJson(baseUrl, '/v1/proof-center/governance/handoff-bundle', {
-      result_package_ref: 'result.spine.job.commitment',
-      account_ref: 'account-demo'
-    });
-    assert.strictEqual(governanceHandoffBundle.status, 200, 'governance handoff bundle route failed');
-    assert.strictEqual(governanceHandoffBundle.json.next_surface, '/v1/proof-center/result-package-handoff/run', 'governance handoff bundle next surface missing');
-    assert.strictEqual(governanceHandoffBundle.json.review_summary_surface, '/v1/proof-center/result-package-handoff/review/summary', 'governance handoff bundle review summary surface missing');
-    const governanceReviewLink = await postJson(baseUrl, '/v1/proof-center/governance/review-link', {
-      result_package_ref: 'result.spine.job.commitment'
-    });
-    assert.strictEqual(governanceReviewLink.status, 200, 'governance review link route failed');
-    assert.strictEqual(governanceReviewLink.json.handoff_run_surface, '/v1/proof-center/result-package-handoff/review/handoff-run', 'governance review link handoff run surface missing');
-    const bridgeReceiptLedgerHandoff = await postJson(baseUrl, '/v1/proof-center/bridge/receipt-ledger-handoff', {
-      receipt_ref: 'receipt-demo',
-      opreturn_hex: receipt.opreturn_hex,
-      payload_utf8: payloadUtf8,
-      account_ref: 'account-demo',
-      usage_report_ref: 'usage-report-demo',
-      meter_profile_ref: 'meter-profile-demo',
-      ledger_entry_ref: 'ledger-entry-demo',
-      ledger_operation: 'commit',
-      units_actual: 2,
-      usage_report: {
-        account_ref: 'account-demo',
-        units_actual: 2,
-        task_ref: 'jobs.commit'
-      },
-      ledger_entry: {
-        account_ref: 'account-demo',
-        operation: 'COMMIT',
-        receipt_ref: 'receipt-demo',
-        units: -2
-      }
-    });
-    assert.strictEqual(bridgeReceiptLedgerHandoff.status, 200, 'bridge receipt-ledger handoff route failed');
-    assert.strictEqual(bridgeReceiptLedgerHandoff.json.handoff.mode, 'xoonya-receipt-ledger-handoff-v1', 'bridge receipt-ledger handoff mode missing');
-    assert.strictEqual(bridgeReceiptLedgerHandoff.json.next_surface, '/v1/proof-center/governance/interpretation-validate', 'bridge receipt-ledger next surface missing');
-    const bridgeEconomicHandoff = await postJson(baseUrl, '/v1/proof-center/bridge/economic-handoff', {
-      handoff_bundle: {
-        contract_version: 'naxytra-economic-consequence-handoff-v1',
-        source_system: 'xytara',
-        account_ref: 'account-demo',
-        usage_meter_ref: 'usage-meter-demo',
-        meter_profile_ref: 'meter-profile-demo',
-        credit_spend_ref: 'credit-spend-demo',
-        usage_meter: {
-          usage_meter_id: 'usage-meter-demo',
-          account_id: 'account-demo',
-          task_ref: 'trust.verify',
-          pricing_band: 'trust_critical',
-          units: 8,
-          credit_spend_id: 'credit-spend-demo'
-        },
-        credit_spend: {
-          credit_spend_id: 'credit-spend-demo',
-          account_id: 'account-demo',
-          task_ref: 'trust.verify',
-          units: 8,
-          pack_id: 'credits.agent'
-        }
-      }
-    });
-    assert.strictEqual(bridgeEconomicHandoff.status, 200, 'bridge economic handoff route failed');
-    assert.strictEqual(bridgeEconomicHandoff.json.handoff.mode, 'xoonya-economic-consequence-handoff-v1', 'bridge economic handoff mode missing');
-    assert.strictEqual(bridgeEconomicHandoff.json.review_summary_surface, '/v1/proof-center/result-package-handoff/review/summary', 'bridge economic handoff review summary surface missing');
-    const bridgeEconomicConformancePack = await postJson(baseUrl, '/v1/proof-center/bridge/economic-conformance-pack', {
-      handoff_bundle: {
-        contract_version: 'naxytra-economic-consequence-handoff-v1',
-        source_system: 'xytara',
-        account_ref: 'account-demo',
-        usage_meter_ref: 'usage-meter-demo',
-        meter_profile_ref: 'meter-profile-demo',
-        credit_spend_ref: 'credit-spend-demo',
-        usage_meter: {
-          usage_meter_id: 'usage-meter-demo',
-          account_id: 'account-demo',
-          task_ref: 'trust.verify',
-          pricing_band: 'trust_critical',
-          units: 8,
-          credit_spend_id: 'credit-spend-demo'
-        },
-        credit_spend: {
-          credit_spend_id: 'credit-spend-demo',
-          account_id: 'account-demo',
-          task_ref: 'trust.verify',
-          units: 8,
-          pack_id: 'credits.agent'
-        }
-      }
-    });
-    assert.strictEqual(bridgeEconomicConformancePack.status, 200, 'bridge economic conformance pack route failed');
-    assert.strictEqual(bridgeEconomicConformancePack.json.deterministic_consequence.usage_units, 8, 'bridge economic conformance usage units missing');
-    assert.strictEqual(bridgeEconomicConformancePack.json.preserved_routes.includes('/v1/proof-center/bridge/economic-handoff'), true, 'bridge economic conformance preserved routes missing');
-    const bridgeOperatorReviewPack = await postJson(baseUrl, '/v1/proof-center/bridge/operator-review-pack', {
-      source_ref: 'receipt-demo',
-      account_ref: 'account-demo'
-    });
-    assert.strictEqual(bridgeOperatorReviewPack.status, 200, 'bridge operator review pack route failed');
-    assert.strictEqual(bridgeOperatorReviewPack.json.compatibility_pack_surface, '/v1/proof-center/bridge/compatibility-pack', 'bridge operator review compatibility pack surface missing');
-    const bridgeCompatibilityPack = await postJson(baseUrl, '/v1/proof-center/bridge/compatibility-pack', {
-      source_ref: 'receipt-demo'
-    });
-    assert.strictEqual(bridgeCompatibilityPack.status, 200, 'bridge compatibility pack route failed');
-    assert.strictEqual(bridgeCompatibilityPack.json.preserved_routes.includes('/v1/profiles/economic/verify'), true, 'bridge compatibility pack preserved routes missing');
-    const bridgeWorkflowPack = await postJson(baseUrl, '/v1/proof-center/bridge/workflow-pack', {
-      source_ref: 'receipt-demo',
-      account_ref: 'account-demo'
-    });
-    assert.strictEqual(bridgeWorkflowPack.status, 200, 'bridge workflow pack route failed');
-    assert.strictEqual(bridgeWorkflowPack.json.workflow_steps.includes('validator_verify'), true, 'bridge workflow pack steps missing');
-    const bridgeAdminPack = await postJson(baseUrl, '/v1/proof-center/bridge/admin-pack', {
-      source_ref: 'receipt-demo',
-      account_ref: 'account-demo'
-    });
-    assert.strictEqual(bridgeAdminPack.status, 200, 'bridge admin pack route failed');
-    assert.strictEqual(bridgeAdminPack.json.governance_refs.governance_review_link_surface, '/v1/proof-center/governance/review-link', 'bridge admin pack governance review link missing');
-
-    const envelope = sdk.createProofEnvelopeV1(receipt.opreturn_hex, [
-      {
-        proof_id: 'proof-1',
-        proof_type: 'artifact',
-        role: 'primary',
-        media_type: 'application/json',
-        proof_hash_sha256: '33'.repeat(32),
-        locator: 'memory://proof-1',
-      },
-    ]);
-    const proofVerify = await postJson(baseUrl, '/v1/proofs/verify', {
-      envelope,
-    });
-    assert.strictEqual(proofVerify.status, 200, 'proof verify route failed');
-    assert.strictEqual(proofVerify.json.valid, true, 'proof verify payload invalid');
-
-    const economicPayload = {
-      agent_id: receipt.agent_id,
-      counterparty_id: 'counterparty-1',
-      event_class: 'usage',
-      event_id: 'event-1',
-      meter_profile_id: 'meter-1',
-      quantity: '1',
-      unit: 'call',
-      usage_hash_sha256: '44'.repeat(32),
-      window_end_unix_ns: '20',
-      window_start_unix_ns: '10',
-    };
-    const economicReceipt = sdk.createReceipt(
-      identityMaterialHex,
-      Buffer.from(canonicalize(economicPayload), 'utf8')
-    );
-    const economicProfile = sdk.createEconomicReceiptProfileV1(
-      economicReceipt.opreturn_hex,
-      economicPayload,
-      {
-        binding_hash_sha256: envelope.binding_hash_sha256,
-        envelope_version: envelope.envelope_version,
-      }
-    );
-    const economicVerify = await postJson(baseUrl, '/v1/profiles/economic/verify', {
-      profile: economicProfile,
-    });
-    assert.strictEqual(economicVerify.status, 200, 'economic profile verify route failed');
-    assert.strictEqual(economicVerify.json.valid, true, 'economic profile verify payload invalid');
-
-    const registryReceipt = sdk.createReceipt(identityMaterialHex, payloadBuffer, '02');
-    const registryEnvelope = sdk.createProofEnvelopeV1(registryReceipt.opreturn_hex, [
-      {
-        proof_id: 'proof-2',
-        proof_type: 'artifact',
-        role: 'rotation',
-        media_type: 'application/json',
-        proof_hash_sha256: '55'.repeat(32),
-        locator: 'memory://proof-2',
-      },
-    ]);
-    const registryProfile = sdk.createRegistryProfileV1(registryReceipt.opreturn_hex, 'update', {
-      sequence: '2',
-      previous_receipt_hash_sha256: '66'.repeat(32),
-      rotation_from_agent_id: receipt.agent_id,
-      rotation_proof_binding: {
-        binding_hash_sha256: registryEnvelope.binding_hash_sha256,
-        envelope_version: registryEnvelope.envelope_version,
-      },
-    });
-    const registryVerify = await postJson(baseUrl, '/v1/profiles/registry/verify', {
-      profile: registryProfile,
-    });
-    assert.strictEqual(registryVerify.status, 200, 'registry profile verify route failed');
-    assert.strictEqual(registryVerify.json.valid, true, 'registry profile verify payload invalid');
-
-    const inspectResponse = await postJson(baseUrl, '/v1/receipts/inspect', {
-      opreturn_hex: receipt.opreturn_hex,
-    });
-    assert.strictEqual(inspectResponse.status, 200, 'receipt inspect route failed');
-    assert.strictEqual(inspectResponse.json.spec_version, 'v1', 'receipt inspect payload invalid');
-
-    console.log('xoonya verify:service passed');
-  } finally {
-    await new Promise((resolve, reject) => {
-      server.close((error) => (error ? reject(error) : resolve()));
-    });
-  }
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exitCode = 1;
-});