xoonya 1.26.0 → 2.0.0

package/proof_sdk.js

@@ -1048,6 +1048,7 @@ function canonicalizeInteractionResultPackageHandoff(input) {
   const seamLayers = normalizeStringArray(handoff.seam_layers, "handoff_bundle.seam_layers") || [];
   const deliveryCount = Number.isFinite(Number(handoff.delivery_count)) ? Number(handoff.delivery_count) : 0;
   const paymentLedgerCount = Number.isFinite(Number(handoff.payment_ledger_count)) ? Number(handoff.payment_ledger_count) : 0;
+  const economicCarry = extractEconomicConsequenceCarry(handoff);
   return {
     result_package_ref: resultPackageRef,
     source_ref: sourceRef,
@@ -1062,7 +1063,39 @@ function canonicalizeInteractionResultPackageHandoff(input) {
     task_refs: taskRefs,
     delivery_count: deliveryCount,
     payment_ledger_count: paymentLedgerCount,
-    seam_layers: seamLayers
+    seam_layers: seamLayers,
+    economic_consequence_handoff_bundle: economicCarry.handoff_bundle,
+    economic_consequence_review: economicCarry.review
+  };
+}
+
+function extractEconomicConsequenceCarry(handoff) {
+  const bundle = handoff && handoff.economic_consequence_handoff_bundle && typeof handoff.economic_consequence_handoff_bundle === "object" && !Array.isArray(handoff.economic_consequence_handoff_bundle)
+    ? handoff.economic_consequence_handoff_bundle
+    : null;
+  if (!bundle) {
+    return {
+      handoff_bundle: null,
+      review: null
+    };
+  }
+  const conformance = buildEconomicConsequenceConformancePack({
+    handoff_bundle: bundle
+  });
+  return {
+    handoff_bundle: bundle,
+    review: {
+      detected: true,
+      conformance_pack_ref: conformance.conformance_pack_ref,
+      account_ref: conformance.deterministic_consequence.account_ref,
+      usage_meter_ref: conformance.deterministic_consequence.usage_meter_ref,
+      credit_spend_ref: conformance.deterministic_consequence.credit_spend_ref,
+      usage_units: conformance.deterministic_consequence.usage_units,
+      pricing_band: conformance.deterministic_consequence.pricing_band,
+      meter_profile_ref: conformance.deterministic_consequence.meter_profile_ref,
+      next_surface: conformance.next_surface,
+      review_summary_surface: conformance.review_summary_surface
+    }
   };
 }
 
@@ -1130,7 +1163,10 @@ function buildInteractionResultPackageHandoffEvent(input) {
     task_refs: handoff.task_refs,
     delivery_count: handoff.delivery_count,
     payment_ledger_count: handoff.payment_ledger_count,
-    seam_layers: handoff.seam_layers
+    seam_layers: handoff.seam_layers,
+    economic_consequence_ref: handoff.economic_consequence_review
+      ? handoff.economic_consequence_review.conformance_pack_ref
+      : null
   });
   return canonicalizeEvent({
     version: CANONICAL_EVENT_BUNDLE_VERSION,
@@ -1187,7 +1223,10 @@ function runInteractionSpineProofHandoff(input) {
       handoff_kind: "interaction_spine_proof_handoff",
       source_ref: handoff.source_ref,
       committed_ref: handoff.committed_ref || null,
-      precommit_pack_ref: handoff.precommit_pack_ref || null
+      precommit_pack_ref: handoff.precommit_pack_ref || null,
+      economic_consequence_ref: handoff.economic_consequence_review
+        ? handoff.economic_consequence_review.conformance_pack_ref
+        : null
     }
   });
   return {
@@ -1198,6 +1237,7 @@ function runInteractionSpineProofHandoff(input) {
     receipt,
     proof_bundle: proofBundle,
     bundle_verification: verifyProofBundle(proofBundle),
+    economic_consequence_review: handoff.economic_consequence_review || null,
     recommended_loop: "default.proof.bundle.loop"
   };
 }
@@ -1218,7 +1258,10 @@ function runInteractionResultPackageHandoff(input) {
       result_package_ref: handoff.result_package_ref,
       source_ref: handoff.source_ref,
       committed_ref: handoff.committed_ref || null,
-      precommit_pack_ref: handoff.precommit_pack_ref || null
+      precommit_pack_ref: handoff.precommit_pack_ref || null,
+      economic_consequence_ref: handoff.economic_consequence_review
+        ? handoff.economic_consequence_review.conformance_pack_ref
+        : null
     }
   });
   return {
@@ -1229,6 +1272,7 @@ function runInteractionResultPackageHandoff(input) {
     receipt,
     proof_bundle: proofBundle,
     bundle_verification: verifyProofBundle(proofBundle),
+    economic_consequence_review: handoff.economic_consequence_review || null,
     recommended_loop: "default.proof.bundle.loop"
   };
 }
@@ -1292,6 +1336,9 @@ function summarizeInteractionResultPackageHandoff(bundle) {
     precommit_pack_ref: handoff.precommit_pack_ref || null,
     seam_layer_count: Array.isArray(handoff.seam_layers) ? handoff.seam_layers.length : 0,
     task_ref_count: Array.isArray(handoff.task_refs) ? handoff.task_refs.length : 0,
+    economic_consequence_ready: Boolean(handoff.economic_consequence_review),
+    usage_meter_ref: handoff.economic_consequence_review ? handoff.economic_consequence_review.usage_meter_ref : null,
+    credit_spend_ref: handoff.economic_consequence_review ? handoff.economic_consequence_review.credit_spend_ref : null,
     proof_bundle_version: proofBundle.version || null,
     emitted_receipt_id: receipt.receipt_id || null,
     bundle_valid: verification.valid === true,
@@ -1328,7 +1375,8 @@ function reviewInteractionResultPackageHandoff(input) {
         economic_state: {
           payment_protocol: handoff.payment_protocol || null,
           settlement_mode: handoff.settlement_mode || null,
-          treasury_destination_id: handoff.treasury_destination_id || null
+          treasury_destination_id: handoff.treasury_destination_id || null,
+          economic_consequence_review: handoff.economic_consequence_review || null
         },
         proof_handoff: {
           source_ref: handoff.source_ref || null,
@@ -1339,6 +1387,7 @@ function reviewInteractionResultPackageHandoff(input) {
       run_ready: Boolean(handoff.transaction_id && handoff.receipt_id && handoff.proof_ref),
       next_surface: "/v1/proof-center/result-package-handoff/run"
     },
+    economic_consequence_review: handoff.economic_consequence_review || null,
     recommended_loop: "default.proof.bundle.loop",
     next_surface: "/v1/proof-center/result-package-handoff/run"
   };
@@ -1359,7 +1408,11 @@ function summarizeReviewedInteractionResultPackageHandoff(input) {
     review_ref: durability.review_ref || null,
     run_ready: durability.run_ready === true,
     next_surface: durability.next_surface || review.next_surface || null,
-    preserved_seam_layer_count: Number(proofHandoff.seam_layer_count || 0)
+    preserved_seam_layer_count: Number(proofHandoff.seam_layer_count || 0),
+    economic_consequence_ready: Boolean(review.economic_consequence_review),
+    usage_meter_ref: review.economic_consequence_review ? review.economic_consequence_review.usage_meter_ref : null,
+    credit_spend_ref: review.economic_consequence_review ? review.economic_consequence_review.credit_spend_ref : null,
+    economic_consequence_review: review.economic_consequence_review || null
   };
 }
 
@@ -1948,6 +2001,788 @@ function summarizeReviewCompleteDefaultPathRun(input) {
   };
 }
 
+function normalizeBridgeInput(input) {
+  return input && typeof input === "object" && !Array.isArray(input) ? input : {};
+}
+
+function buildBridgeRef(prefix, seed) {
+  const stableSeed = canonicalize(seed);
+  return `${prefix}.${sha256Hex(Buffer.from(stableSeed, "utf8")).slice(0, 16)}`;
+}
+
+function payloadBufferFromBridgeInput(input) {
+  const body = normalizeBridgeInput(input);
+  if (typeof body.payload_bytes_hex === "string" && body.payload_bytes_hex.trim()) {
+    const hex = body.payload_bytes_hex.trim().toLowerCase();
+    if (!/^[a-f0-9]+$/.test(hex) || hex.length % 2 !== 0) {
+      throw new Error("payload_bytes_hex_invalid");
+    }
+    return Buffer.from(hex, "hex");
+  }
+  if (typeof body.payload_base64 === "string" && body.payload_base64.trim()) {
+    return Buffer.from(body.payload_base64, "base64");
+  }
+  if (typeof body.payload_utf8 === "string") {
+    return Buffer.from(body.payload_utf8, "utf8");
+  }
+  if (typeof body.payload_ascii === "string") {
+    return Buffer.from(body.payload_ascii, "ascii");
+  }
+  throw new Error("payload_required");
+}
+
+function verifyAnyCompatibilityReceipt(opreturnHex, payloadBytes) {
+  const parsed = parseReceipt(opreturnHex);
+  return parsed.spec_version === "v2"
+    ? verifyReceiptV2(opreturnHex, payloadBytes)
+    : verifyReceipt(opreturnHex, payloadBytes);
+}
+
+function buildBridgeCenter() {
+  return {
+    center_ref: "proof-center.bridge",
+    receipt_wrap_surface: "/v1/proof-center/bridge/receipt-wrap",
+    validator_verify_surface: "/v1/proof-center/bridge/validator-verify",
+    receipt_ledger_handoff_surface: "/v1/proof-center/bridge/receipt-ledger-handoff",
+    economic_handoff_surface: "/v1/proof-center/bridge/economic-handoff",
+    economic_conformance_pack_surface: "/v1/proof-center/bridge/economic-conformance-pack",
+    operator_review_pack_surface: "/v1/proof-center/bridge/operator-review-pack",
+    compatibility_pack_surface: "/v1/proof-center/bridge/compatibility-pack",
+    supported_profiles: [
+      "economic-receipt-profile-v1",
+      "registry-profile-v1",
+      "proof-envelope-v1"
+    ],
+    supported_capabilities: [
+      "receipt_wrap",
+      "validator_compatible_verification",
+      "receipt_ledger_handoff",
+      "economic_consequence_handoff",
+      "economic_consequence_conformance",
+      "operator_review_packaging",
+      "compatibility_packaging",
+      "profile_carry"
+    ]
+  };
+}
+
+function summarizeBridgeCenter() {
+  const center = buildBridgeCenter();
+  return {
+    center_ref: center.center_ref,
+    capability_count: center.supported_capabilities.length,
+    profile_count: center.supported_profiles.length,
+    receipt_ledger_handoff_surface: center.receipt_ledger_handoff_surface,
+    economic_handoff_surface: center.economic_handoff_surface,
+    operator_review_pack_surface: center.operator_review_pack_surface
+  };
+}
+
+function buildBridgeReceiptWrap(input) {
+  const body = normalizeBridgeInput(input);
+  const payloadBytes = payloadBufferFromBridgeInput(body);
+  const identityMaterialHex = normalizeString(body.identity_material_hex);
+  if (!identityMaterialHex) {
+    throw new Error("identity_material_hex_required");
+  }
+  const typeHex = normalizeString(body.type_hex || TYPE_REGISTER) || TYPE_REGISTER;
+  const contextHash12Hex = normalizeString(body.context_hash12_hex);
+  const receipt = contextHash12Hex
+    ? createReceiptV2(identityMaterialHex, payloadBytes, contextHash12Hex, typeHex)
+    : createReceipt(identityMaterialHex, payloadBytes, typeHex);
+  const verification = verifyAnyCompatibilityReceipt(receipt.opreturn_hex, payloadBytes);
+  return {
+    ok: verification.valid === true,
+    wrap_ref: buildBridgeRef("bridge.receipt-wrap", {
+      receipt_ref: receipt.opreturn_hex,
+      type_hex: typeHex,
+      payload_hash: receipt.payload_hash
+    }),
+    receipt,
+    verification,
+    validator_verify_surface: "/v1/proof-center/bridge/validator-verify",
+    receipt_inspect_surface: "/v1/receipts/inspect"
+  };
+}
+
+function summarizeBridgeValidatorVerify(input) {
+  const body = normalizeBridgeInput(input);
+  const opreturnHex = normalizeString(body.opreturn_hex).toLowerCase();
+  if (!opreturnHex) {
+    throw new Error("opreturn_hex_required");
+  }
+  const payloadBytes = payloadBufferFromBridgeInput(body);
+  const verification = verifyAnyCompatibilityReceipt(opreturnHex, payloadBytes);
+  return {
+    ...verification,
+    validator_ref: buildBridgeRef("bridge.validator", {
+      opreturn_hex: opreturnHex,
+      payload_hash: sha256Hex(payloadBytes)
+    }),
+    verification_surface: "/validate",
+    receipt_inspect_surface: "/v1/receipts/inspect"
+  };
+}
+
+function unwrapEconomicBridgeInput(input) {
+  const body = normalizeBridgeInput(input);
+  if (body.handoff_bundle && typeof body.handoff_bundle === "object" && !Array.isArray(body.handoff_bundle)) {
+    return body.handoff_bundle;
+  }
+  return body;
+}
+
+function buildReceiptLedgerBridgeHandoff(input) {
+  const body = normalizeBridgeInput(input);
+  const receiptRef = normalizeString(body.receipt_ref);
+  const opreturnHex = normalizeString(body.opreturn_hex).toLowerCase();
+  if (!receiptRef) throw new Error("receipt_ref_required");
+  if (!opreturnHex) throw new Error("opreturn_hex_required");
+  const payloadBytes = payloadBufferFromBridgeInput(body);
+  const accountRef = normalizeString(body.account_ref);
+  const usageReportRef = normalizeString(body.usage_report_ref);
+  const meterProfileRef = normalizeString(body.meter_profile_ref);
+  const ledgerEntryRef = normalizeString(body.ledger_entry_ref);
+  const ledgerOperation = normalizeString(body.ledger_operation).toUpperCase();
+  const unitsActual = Number(body.units_actual);
+  const usageReport = body.usage_report && typeof body.usage_report === "object" && !Array.isArray(body.usage_report)
+    ? body.usage_report
+    : null;
+  const ledgerEntry = body.ledger_entry && typeof body.ledger_entry === "object" && !Array.isArray(body.ledger_entry)
+    ? body.ledger_entry
+    : null;
+
+  if (!accountRef) throw new Error("account_ref_required");
+  if (!usageReportRef) throw new Error("usage_report_ref_required");
+  if (!meterProfileRef) throw new Error("meter_profile_ref_required");
+  if (!ledgerEntryRef) throw new Error("ledger_entry_ref_required");
+  if (!new Set(["RESERVE", "COMMIT", "RELEASE", "REVERSE"]).has(ledgerOperation)) {
+    throw new Error("ledger_operation_invalid");
+  }
+  if (!Number.isInteger(unitsActual) || unitsActual <= 0) throw new Error("units_actual_invalid");
+  if (!usageReport) throw new Error("usage_report_required");
+  if (!ledgerEntry) throw new Error("ledger_entry_required");
+
+  const verification = verifyAnyCompatibilityReceipt(opreturnHex, payloadBytes);
+  if (!verification.valid) {
+    throw new Error(`invalid_receipt:${verification.reason || "invalid"}`);
+  }
+
+  if (usageReport.account_ref && normalizeString(usageReport.account_ref) !== accountRef) throw new Error("usage_report_account_mismatch");
+  if (usageReport.units_actual != null && Number(usageReport.units_actual) !== unitsActual) throw new Error("usage_report_units_mismatch");
+  if (ledgerEntry.account_ref && normalizeString(ledgerEntry.account_ref) !== accountRef) throw new Error("ledger_entry_account_mismatch");
+  if (ledgerEntry.operation && normalizeString(ledgerEntry.operation).toUpperCase() !== ledgerOperation) throw new Error("ledger_entry_operation_mismatch");
+  if (ledgerEntry.receipt_ref && normalizeString(ledgerEntry.receipt_ref) !== receiptRef) throw new Error("ledger_entry_receipt_mismatch");
+  if (ledgerEntry.units != null && Math.abs(Number(ledgerEntry.units)) !== unitsActual) throw new Error("ledger_entry_units_mismatch");
+
+  const handoff = {
+    mode: "xoonya-receipt-ledger-handoff-v1",
+    generated_at_iso: new Date().toISOString(),
+    proof_receipt: {
+      receipt_ref: receiptRef,
+      receipt_hash_sha256: sha256Hex(Buffer.from(opreturnHex, "hex")),
+      receipt_version: verification.spec_version || "v1",
+      opreturn_hex: opreturnHex,
+      validation_result: {
+        valid: verification.valid === true,
+        reason: verification.reason || null
+      },
+      compliance_hash: verification.compliance_hash || null,
+      agent_id: verification.agent_id || null
+    },
+    economics_context: {
+      target_system: "xytara",
+      account_ref: accountRef,
+      usage_report_ref: usageReportRef,
+      usage_report_hash: canonicalJsonSha256Hex(usageReport),
+      usage_report: usageReport,
+      meter_profile_ref: meterProfileRef,
+      units_actual: unitsActual,
+      ledger_operation: ledgerOperation,
+      ledger_entry_ref: ledgerEntryRef,
+      ledger_entry_hash: canonicalJsonSha256Hex(ledgerEntry),
+      ledger_entry: ledgerEntry
+    }
+  };
+  return {
+    ok: true,
+    handoff_ref: buildBridgeRef("bridge.receipt-ledger-handoff", handoff),
+    handoff,
+    next_surface: "/v1/proof-center/governance/interpretation-validate"
+  };
+}
+
+function buildEconomicConsequenceBridgeHandoff(input) {
+  const body = unwrapEconomicBridgeInput(input);
+  const accountRef = normalizeString(body.account_ref);
+  const usageMeterRef = normalizeString(body.usage_meter_ref);
+  const meterProfileRef = normalizeString(body.meter_profile_ref);
+  const creditSpendRef = normalizeString(body.credit_spend_ref);
+  const usageMeter = body.usage_meter && typeof body.usage_meter === "object" && !Array.isArray(body.usage_meter)
+    ? body.usage_meter
+    : null;
+  const creditSpend = body.credit_spend && typeof body.credit_spend === "object" && !Array.isArray(body.credit_spend)
+    ? body.credit_spend
+    : null;
+  if (!accountRef) throw new Error("account_ref_required");
+  if (!usageMeterRef) throw new Error("usage_meter_ref_required");
+  if (!meterProfileRef) throw new Error("meter_profile_ref_required");
+  if (!creditSpendRef) throw new Error("credit_spend_ref_required");
+  if (!usageMeter) throw new Error("usage_meter_required");
+  if (!creditSpend) throw new Error("credit_spend_required");
+  if (usageMeter.account_id && normalizeString(usageMeter.account_id) !== accountRef) throw new Error("usage_meter_account_mismatch");
+  if (creditSpend.account_id && normalizeString(creditSpend.account_id) !== accountRef) throw new Error("credit_spend_account_mismatch");
+  if (usageMeter.credit_spend_id && normalizeString(usageMeter.credit_spend_id) !== creditSpendRef) throw new Error("usage_meter_credit_spend_mismatch");
+  if (creditSpend.credit_spend_id && normalizeString(creditSpend.credit_spend_id) !== creditSpendRef) throw new Error("credit_spend_ref_mismatch");
+  if (usageMeter.units != null && creditSpend.units != null && Number(usageMeter.units) !== Number(creditSpend.units)) {
+    throw new Error("usage_meter_units_mismatch");
+  }
+  const handoff = {
+    mode: "xoonya-economic-consequence-handoff-v1",
+    generated_at_iso: new Date().toISOString(),
+    economics_context: {
+      target_system: "xytara",
+      account_ref: accountRef,
+      usage_meter_ref: usageMeterRef,
+      usage_meter_hash: canonicalJsonSha256Hex(usageMeter),
+      usage_meter: usageMeter,
+      meter_profile_ref: meterProfileRef,
+      credit_spend_ref: creditSpendRef,
+      credit_spend_hash: canonicalJsonSha256Hex(creditSpend),
+      credit_spend: creditSpend
+    }
+  };
+  return {
+    ok: true,
+    handoff_ref: buildBridgeRef("bridge.economic-consequence-handoff", handoff),
+    handoff,
+    next_surface: "/v1/proof-center/governance/interpretation-validate",
+    review_summary_surface: "/v1/proof-center/result-package-handoff/review/summary"
+  };
+}
+
+function buildEconomicConsequenceConformancePack(input) {
+  const handoffBundle = buildEconomicConsequenceBridgeHandoff(input);
+  const economicsContext = handoffBundle.handoff.economics_context;
+  return {
+    ok: true,
+    conformance_pack_ref: buildBridgeRef("bridge.economic-conformance-pack", {
+      usage_meter_ref: economicsContext.usage_meter_ref,
+      credit_spend_ref: economicsContext.credit_spend_ref,
+      account_ref: economicsContext.account_ref
+    }),
+    deterministic_consequence: {
+      account_ref: economicsContext.account_ref,
+      usage_meter_ref: economicsContext.usage_meter_ref,
+      credit_spend_ref: economicsContext.credit_spend_ref,
+      usage_units: Number(economicsContext.usage_meter.units || 0),
+      pricing_band: normalizeString(economicsContext.usage_meter.pricing_band || null) || null,
+      meter_profile_ref: economicsContext.meter_profile_ref
+    },
+    preserved_routes: [
+      "/v1/proof-center/bridge/economic-handoff",
+      "/v1/proof-center/bridge/economic-conformance-pack",
+      "/v1/proof-center/governance/interpretation-validate",
+      "/v1/proof-center/result-package-handoff/review/summary"
+    ],
+    next_surface: "/v1/proof-center/governance/interpretation-validate",
+    review_summary_surface: "/v1/proof-center/result-package-handoff/review/summary"
+  };
+}
+
+function buildBridgeOperatorReviewPack(input) {
+  const body = normalizeBridgeInput(input);
+  const sourceRef = normalizeString(body.source_ref || body.receipt_ref || "proof-bridge.source");
+  const operatorPackRef = buildBridgeRef("bridge.operator-review-pack", {
+    source_ref: sourceRef,
+    account_ref: normalizeString(body.account_ref || "")
+  });
+  return {
+    ok: true,
+    operator_review_pack_ref: operatorPackRef,
+    source_ref: sourceRef,
+    included_sections: [
+      "bridge_summary",
+      "validator_verification",
+      "economic_consequence_review",
+      "profile_carry",
+      "governance_review_link",
+      "proof_run_link"
+    ],
+    bridge_summary_surface: "/v1/proof-center/bridge/summary",
+    validator_verify_surface: "/v1/proof-center/bridge/validator-verify",
+    economic_handoff_surface: "/v1/proof-center/bridge/economic-handoff",
+    economic_conformance_pack_surface: "/v1/proof-center/bridge/economic-conformance-pack",
+    compatibility_pack_surface: "/v1/proof-center/bridge/compatibility-pack",
+    governance_review_link_surface: "/v1/proof-center/governance/review-link",
+    proof_run_surface: "/v1/proof-center/result-package-handoff/run"
+  };
+}
+
+function buildBridgeCompatibilityPack(input) {
+  const body = normalizeBridgeInput(input);
+  return {
+    ok: true,
+    compatibility_pack_ref: buildBridgeRef("bridge.compatibility-pack", {
+      source_ref: normalizeString(body.source_ref || body.receipt_ref || "proof-bridge.compatibility")
+    }),
+    preserved_routes: [
+      "/validate",
+      "/v1/receipts/inspect",
+      "/v1/proofs/verify",
+      "/v1/profiles/economic/verify",
+      "/v1/profiles/registry/verify"
+    ],
+    preserved_helpers: [
+      "createReceipt",
+      "verifyReceipt",
+      "createReceiptV2",
+      "verifyReceiptV2",
+      "createProofEnvelopeV1",
+      "verifyProofEnvelopeV1",
+      "createEconomicReceiptProfileV1",
+      "verifyEconomicReceiptProfileV1",
+      "createRegistryProfileV1",
+      "verifyRegistryProfileV1"
+    ],
+    profile_versions: [
+      "proof-envelope-v1",
+      "economic-receipt-profile-v1",
+      "registry-profile-v1"
+    ],
+    posture: "compatibility_support_preserved_for_bridge_and_validator_alignment"
+  };
+}
+
+function buildBridgeProfileSupport() {
+  return {
+    support_ref: "bridge.profile-support",
+    proof_profile_versions: [
+      "proof-envelope-v1",
+      "economic-receipt-profile-v1",
+      "registry-profile-v1"
+    ],
+    payload_profile_examples: [
+      "AgentProfile-v1",
+      "CapabilitiesProfile-v1",
+      "SessionProfile-v1",
+      "AttestationProfile-v1"
+    ],
+    interoperability_notes: [
+      "profiles_extend_proof_context_without_mutating_core_receipt_shape",
+      "resolver_behavior_remains_part_of_interoperability_posture",
+      "bridge_support_packages_are_operator_exports_not_new_protocol_layers"
+    ],
+    verification_surfaces: [
+      "/v1/proofs/verify",
+      "/v1/profiles/economic/verify",
+      "/v1/profiles/registry/verify"
+    ]
+  };
+}
+
+function buildBridgeWorkflowPack(input) {
+  const operatorReviewPack = buildBridgeOperatorReviewPack(input);
+  const compatibilityPack = buildBridgeCompatibilityPack(input);
+  return {
+    ok: true,
+    workflow_pack_ref: buildBridgeRef("bridge.workflow-pack", {
+      operator_review_pack_ref: operatorReviewPack.operator_review_pack_ref,
+      compatibility_pack_ref: compatibilityPack.compatibility_pack_ref
+    }),
+    refs: {
+      operator_review_pack_ref: operatorReviewPack.operator_review_pack_ref,
+      compatibility_pack_ref: compatibilityPack.compatibility_pack_ref
+    },
+    workflow_steps: [
+      "receipt_wrap_or_receive",
+      "validator_verify",
+      "economic_consequence_handoff",
+      "inspect_profile_support",
+      "review_operator_pack",
+      "handoff_or_run"
+    ],
+    guidance: [
+      "use_bridge_support_packs_for_portable_review_and_export",
+      "keep_public_proof_center_as_the_canonical_runtime_surface"
+    ]
+  };
+}
+
+function buildBridgeAdminPack(input) {
+  const workflowPack = buildBridgeWorkflowPack(input);
+  const profileSupport = buildBridgeProfileSupport();
+  return {
+    ok: true,
+    admin_pack_ref: buildBridgeRef("bridge.admin-pack", {
+      workflow_pack_ref: workflowPack.workflow_pack_ref,
+      support_ref: profileSupport.support_ref
+    }),
+    operator_refs: {
+      workflow_pack_ref: workflowPack.workflow_pack_ref,
+      operator_review_pack_ref: workflowPack.refs.operator_review_pack_ref,
+      compatibility_pack_ref: workflowPack.refs.compatibility_pack_ref,
+      economic_handoff_surface: "/v1/proof-center/bridge/economic-handoff",
+      economic_conformance_pack_surface: "/v1/proof-center/bridge/economic-conformance-pack"
+    },
+    governance_refs: {
+      governance_dashboard_surface: "/v1/proof-center/governance/dashboard",
+      governance_review_link_surface: "/v1/proof-center/governance/review-link"
+    },
+    proof_refs: {
+      profile_support_ref: profileSupport.support_ref,
+      proof_run_surface: "/v1/proof-center/result-package-handoff/run"
+    },
+    notes: [
+      "admin_pack_is_a_portable_operator_export",
+      "admin_pack_does_not_mutate_proof_or_profile_semantics"
+    ]
+  };
+}
+
+function buildGovernanceCenter() {
+  return {
+    center_ref: "proof-center.governance",
+    interpretation_surface: "/v1/proof-center/governance/interpretation-validate",
+    coordination_surface: "/v1/proof-center/governance/coordination",
+    dashboard_surface: "/v1/proof-center/governance/dashboard",
+    operator_view_surface: "/v1/proof-center/governance/operator-view",
+    admin_view_surface: "/v1/proof-center/governance/admin-view",
+    dispute_summary_surface: "/v1/proof-center/governance/disputes/summary",
+    dispute_action_surface: "/v1/proof-center/governance/disputes/action",
+    dispute_resolution_pack_surface: "/v1/proof-center/governance/disputes/resolution-pack",
+    review_link_surface: "/v1/proof-center/governance/review-link",
+    handoff_bundle_surface: "/v1/proof-center/governance/handoff-bundle",
+    supported_capabilities: [
+      "interpretation_validation",
+      "governance_coordination",
+      "dashboard_summary",
+      "operator_view",
+      "admin_view",
+      "workflow_packaging",
+      "signoff_packaging",
+      "dispute_review",
+      "dispute_resolution_packaging",
+      "review_linkage",
+      "operator_handoff_bundle"
+    ]
+  };
+}
+
+function summarizeGovernanceCenter() {
+  const center = buildGovernanceCenter();
+  return {
+    center_ref: center.center_ref,
+    capability_count: center.supported_capabilities.length,
+    dashboard_surface: center.dashboard_surface,
+    dispute_summary_surface: center.dispute_summary_surface,
+    review_link_surface: center.review_link_surface,
+    handoff_bundle_surface: center.handoff_bundle_surface
+  };
+}
+
+function normalizeGovernanceInput(input) {
+  return input && typeof input === "object" && !Array.isArray(input) ? input : {};
+}
+
+function buildGovernanceRef(prefix, seed) {
+  const stableSeed = canonicalize(seed);
+  return `${prefix}.${sha256Hex(Buffer.from(stableSeed, "utf8")).slice(0, 16)}`;
+}
+
+function validateGovernanceInterpretation(input) {
+  const body = normalizeGovernanceInput(input);
+  const sourceRef = normalizeString(body.source_ref || body.result_package_ref || body.receipt_ref || "governance.source");
+  const interpretationRef = buildGovernanceRef("governance.interpretation", {
+    source_ref: sourceRef,
+    case_ref: normalizeString(body.case_ref || ""),
+    interpretation_context: body.interpretation_context || null
+  });
+  return {
+    ok: true,
+    interpretation_ref: interpretationRef,
+    source_ref: sourceRef,
+    interpretation_status: "validated",
+    accepted_inputs: [
+      "result_package_ref",
+      "receipt_ref",
+      "case_ref"
+    ],
+    next_surface: "/v1/proof-center/governance/coordination"
+  };
+}
+
+function emitGovernanceCoordination(input) {
+  const interpretation = validateGovernanceInterpretation(input);
+  return {
+    ok: interpretation.ok,
+    interpretation_ref: interpretation.interpretation_ref,
+    coordination_ref: buildGovernanceRef("governance.coordination", {
+      interpretation_ref: interpretation.interpretation_ref,
+      source_ref: interpretation.source_ref
+    }),
+    coordination_status: "ready",
+    coordination_surfaces: [
+      "/v1/proof-center/governance/workflow-pack",
+      "/v1/proof-center/governance/signoff-pack",
+      "/v1/proof-center/governance/handoff-bundle"
+    ],
+    next_surface: "/v1/proof-center/result-package-handoff/run"
+  };
+}
+
+function summarizeGovernanceDashboard(input) {
+  const body = normalizeGovernanceInput(input);
+  const accountRef = normalizeString(body.account_ref || body.operator_ref || "governance.account");
+  const dashboardRef = buildGovernanceRef("governance.dashboard", {
+    account_ref: accountRef,
+    queue_scope: normalizeString(body.queue_scope || "default")
+  });
+  const reviewCount = Number.isFinite(body.review_count) ? body.review_count : 3;
+  const disputeCount = Number.isFinite(body.dispute_count) ? body.dispute_count : 1;
+  return {
+    ok: true,
+    dashboard_ref: dashboardRef,
+    account_ref: accountRef,
+    queue_summary: {
+      review_count: reviewCount,
+      dispute_count: disputeCount,
+      signoff_ready_count: Number.isFinite(body.signoff_ready_count) ? body.signoff_ready_count : 1
+    },
+    proof_linkage: {
+      review_summary_surface: "/v1/proof-center/result-package-handoff/review/summary",
+      handoff_run_surface: "/v1/proof-center/result-package-handoff/review/handoff-run"
+    },
+    dashboard_pack_surface: "/v1/proof-center/governance/dashboard-pack",
+    workflow_pack_surface: "/v1/proof-center/governance/workflow-pack",
+    signoff_pack_surface: "/v1/proof-center/governance/signoff-pack"
+  };
+}
+
+function summarizeGovernanceOperatorView(input) {
+  const dashboard = summarizeGovernanceDashboard(input);
+  return {
+    ok: dashboard.ok,
+    operator_view_ref: buildGovernanceRef("governance.operator-view", dashboard),
+    dashboard_ref: dashboard.dashboard_ref,
+    queue_summary: dashboard.queue_summary,
+    attention_refs: [
+      "governance.review.queue",
+      "governance.dispute.queue",
+      "governance.signoff.queue"
+    ],
+    dashboard_pack_surface: dashboard.dashboard_pack_surface,
+    review_link_surface: "/v1/proof-center/governance/review-link"
+  };
+}
+
+function summarizeGovernanceAdminView(input) {
+  const operatorView = summarizeGovernanceOperatorView(input);
+  return {
+    ok: operatorView.ok,
+    admin_view_ref: buildGovernanceRef("governance.admin-view", operatorView),
+    operator_view_ref: operatorView.operator_view_ref,
+    oversight_summary: {
+      queue_count: 3,
+      escalation_ready_count: 1,
+      signoff_ready_count: operatorView.queue_summary.signoff_ready_count
+    },
+    workflow_pack_surface: "/v1/proof-center/governance/workflow-pack",
+    signoff_pack_surface: "/v1/proof-center/governance/signoff-pack"
+  };
+}
+
+function buildGovernanceDashboardPack(input) {
+  const dashboard = summarizeGovernanceDashboard(input);
+  return {
+    ok: dashboard.ok,
+    dashboard_ref: dashboard.dashboard_ref,
+    pack_ref: buildGovernanceRef("governance.dashboard-pack", dashboard),
+    included_sections: [
+      "queue_summary",
+      "workflow_refs",
+      "signoff_refs"
+    ]
+  };
+}
+
+function buildGovernanceWorkflowPack(input) {
+  const coordination = emitGovernanceCoordination(input);
+  return {
+    ok: coordination.ok,
+    coordination_ref: coordination.coordination_ref,
+    workflow_pack_ref: buildGovernanceRef("governance.workflow-pack", coordination),
+    included_sections: [
+      "interpretation_status",
+      "coordination_status",
+      "next_surfaces",
+      "review_linkage"
+    ],
+    review_summary_surface: "/v1/proof-center/result-package-handoff/review/summary",
+    handoff_run_surface: "/v1/proof-center/result-package-handoff/review/handoff-run"
+  };
+}
+
+function buildGovernanceSignoffPack(input) {
+  const dashboard = summarizeGovernanceDashboard(input);
+  return {
+    ok: dashboard.ok,
+    dashboard_ref: dashboard.dashboard_ref,
+    signoff_pack_ref: buildGovernanceRef("governance.signoff-pack", dashboard),
+    signoff_status: "review_ready",
+    included_sections: [
+      "queue_summary",
+      "signoff_ready_refs",
+      "review_linkage"
+    ],
+    review_link_surface: "/v1/proof-center/governance/review-link"
+  };
+}
+
+function summarizeGovernanceDisputes(input) {
+  const body = normalizeGovernanceInput(input);
+  const queueRef = buildGovernanceRef("governance.disputes", {
+    account_ref: normalizeString(body.account_ref || ""),
+    dispute_scope: normalizeString(body.dispute_scope || "default")
+  });
+  const caseCount = Number.isFinite(body.case_count) ? body.case_count : 2;
+  return {
+    ok: true,
+    dispute_queue_ref: queueRef,
+    case_count: caseCount,
+    open_case_count: Number.isFinite(body.open_case_count) ? body.open_case_count : Math.max(caseCount - 1, 1),
+    case_review_surface: "/v1/proof-center/governance/disputes/case-review",
+    case_bundle_surface: "/v1/proof-center/governance/disputes/case-bundle"
+  };
+}
+
+function reviewGovernanceCase(input) {
+  const body = normalizeGovernanceInput(input);
+  const caseRef = normalizeString(body.case_ref || body.dispute_id || "governance.case");
+  return {
+    ok: true,
+    case_ref: caseRef,
+    review_ref: buildGovernanceRef("governance.case-review", {
+      case_ref: caseRef,
+      source_ref: normalizeString(body.source_ref || "")
+    }),
+    review_status: "triaged",
+    available_actions: [
+      "handoff",
+      "resolve",
+      "dismiss"
+    ],
+    resolution_pack_surface: "/v1/proof-center/governance/disputes/resolution-pack",
+    case_bundle_surface: "/v1/proof-center/governance/disputes/case-bundle"
+  };
+}
+
+function summarizeGovernanceDisputeAction(input) {
+  const review = reviewGovernanceCase(input);
+  const body = normalizeGovernanceInput(input);
+  const requestedAction = normalizeString(body.action || "handoff");
+  const allowedActions = new Set(review.available_actions);
+  const action = allowedActions.has(requestedAction) ? requestedAction : "handoff";
+  return {
+    ok: true,
+    case_ref: review.case_ref,
+    action_ref: buildGovernanceRef("governance.dispute-action", {
+      case_ref: review.case_ref,
+      action
+    }),
+    action,
+    action_status: "recorded",
+    next_surface: action === "handoff"
+      ? "/v1/proof-center/governance/handoff-bundle"
+      : "/v1/proof-center/governance/disputes/resolution-pack"
+  };
+}
+
+function buildGovernanceCaseBundle(input) {
+  const review = reviewGovernanceCase(input);
+  return {
+    ok: review.ok,
+    case_ref: review.case_ref,
+    case_bundle_ref: buildGovernanceRef("governance.case-bundle", review),
+    included_sections: [
+      "review_status",
+      "available_actions",
+      "handoff_refs"
+    ],
+    resolution_pack_surface: review.resolution_pack_surface
+  };
+}
+
+function buildGovernanceResolutionPack(input) {
+  const action = summarizeGovernanceDisputeAction(input);
+  return {
+    ok: action.ok,
+    case_ref: action.case_ref,
+    resolution_pack_ref: buildGovernanceRef("governance.resolution-pack", action),
+    action_ref: action.action_ref,
+    resolution_status: action.action === "dismiss" ? "dismissed" : "resolved_or_handoff_ready",
+    included_sections: [
+      "action_status",
+      "case_resolution_refs",
+      "next_surface"
+    ]
+  };
+}
+
+function buildGovernanceConsolePack(input) {
+  const dashboard = summarizeGovernanceDashboard(input);
+  const disputes = summarizeGovernanceDisputes(input);
+  return {
+    ok: true,
+    console_pack_ref: buildGovernanceRef("governance.console-pack", {
+      dashboard_ref: dashboard.dashboard_ref,
+      dispute_queue_ref: disputes.dispute_queue_ref
+    }),
+    dashboard_ref: dashboard.dashboard_ref,
+    dispute_queue_ref: disputes.dispute_queue_ref,
+    included_sections: [
+      "dashboard",
+      "workflow",
+      "disputes"
+    ]
+  };
+}
+
+function buildGovernanceHandoffBundle(input) {
+  const coordination = emitGovernanceCoordination(input);
+  const disputes = summarizeGovernanceDisputes(input);
+  return {
+    ok: true,
+    handoff_bundle_ref: buildGovernanceRef("governance.handoff-bundle", {
+      coordination_ref: coordination.coordination_ref,
+      dispute_queue_ref: disputes.dispute_queue_ref
+    }),
+    coordination_ref: coordination.coordination_ref,
+    dispute_queue_ref: disputes.dispute_queue_ref,
+    review_summary_surface: "/v1/proof-center/result-package-handoff/review/summary",
+    handoff_run_surface: "/v1/proof-center/result-package-handoff/review/handoff-run",
+    next_surface: "/v1/proof-center/result-package-handoff/run",
+    included_sections: [
+      "coordination",
+      "dispute_summary",
+      "operator_handoff_refs",
+      "review_linkage"
+    ]
+  };
+}
+
+function summarizeGovernanceReviewLink(input) {
+  const coordination = emitGovernanceCoordination(input);
+  return {
+    ok: coordination.ok,
+    coordination_ref: coordination.coordination_ref,
+    review_link_ref: buildGovernanceRef("governance.review-link", coordination),
+    review_summary_surface: "/v1/proof-center/result-package-handoff/review/summary",
+    handoff_run_surface: "/v1/proof-center/result-package-handoff/review/handoff-run",
+    run_surface: "/v1/proof-center/result-package-handoff/run"
+  };
+}
+
 function runDefaultProofLoop(loopRef, input) {
   const loop = getDefaultProofLoop(loopRef);
   if (!loop) {
@@ -1988,6 +2823,36 @@ function runDefaultProofLoop(loopRef, input) {
 }
 
 module.exports = {
+  buildBridgeCenter,
+  summarizeBridgeCenter,
+  buildBridgeReceiptWrap,
+  summarizeBridgeValidatorVerify,
+  buildReceiptLedgerBridgeHandoff,
+  buildEconomicConsequenceBridgeHandoff,
+  buildEconomicConsequenceConformancePack,
+  buildBridgeOperatorReviewPack,
+  buildBridgeCompatibilityPack,
+  buildBridgeProfileSupport,
+  buildBridgeWorkflowPack,
+  buildBridgeAdminPack,
+  buildGovernanceCenter,
+  summarizeGovernanceCenter,
+  validateGovernanceInterpretation,
+  emitGovernanceCoordination,
+  summarizeGovernanceDashboard,
+  summarizeGovernanceOperatorView,
+  summarizeGovernanceAdminView,
+  buildGovernanceDashboardPack,
+  buildGovernanceWorkflowPack,
+  buildGovernanceSignoffPack,
+  summarizeGovernanceDisputes,
+  reviewGovernanceCase,
+  summarizeGovernanceDisputeAction,
+  buildGovernanceCaseBundle,
+  buildGovernanceResolutionPack,
+  buildGovernanceConsolePack,
+  buildGovernanceHandoffBundle,
+  summarizeGovernanceReviewLink,
   buildDefaultProofCenter,
   buildDefaultProofLoopCatalog,
   buildDefaultProofLoops,