xoonya 1.26.0 → 1.27.0

package/FINAL_CONTRACT.md

@@ -409,7 +409,7 @@ The public API of `xoonya` should center on:
 
 Optional profile helpers may be added separately.
 
-## What Should Be Carried Forward From Older Shoonya Lineage
+## What Should Be Carried Forward From Older Proof Lineage
 
 Keep:
 

package/README.md

@@ -155,6 +155,34 @@ Primary proof-model routes:
 - `POST /v1/proof-center/transaction-handoff/run`
 - `GET /v1/proof-center/result-package-handoff`
 - `GET /v1/proof-center/result-package-handoff/summary`
+- `GET /v1/proof-center/governance`
+- `GET /v1/proof-center/governance/summary`
+- `GET /v1/proof-center/bridge`
+- `GET /v1/proof-center/bridge/summary`
+- `GET /v1/proof-center/bridge/profile-support`
+- `POST /v1/proof-center/governance/interpretation-validate`
+- `POST /v1/proof-center/governance/coordination`
+- `POST /v1/proof-center/governance/dashboard`
+- `POST /v1/proof-center/governance/operator-view`
+- `POST /v1/proof-center/governance/admin-view`
+- `POST /v1/proof-center/governance/dashboard-pack`
+- `POST /v1/proof-center/governance/workflow-pack`
+- `POST /v1/proof-center/governance/signoff-pack`
+- `POST /v1/proof-center/governance/disputes/summary`
+- `POST /v1/proof-center/governance/disputes/case-review`
+- `POST /v1/proof-center/governance/disputes/action`
+- `POST /v1/proof-center/governance/disputes/case-bundle`
+- `POST /v1/proof-center/governance/disputes/resolution-pack`
+- `POST /v1/proof-center/governance/console-pack`
+- `POST /v1/proof-center/governance/handoff-bundle`
+- `POST /v1/proof-center/governance/review-link`
+- `POST /v1/proof-center/bridge/receipt-wrap`
+- `POST /v1/proof-center/bridge/validator-verify`
+- `POST /v1/proof-center/bridge/receipt-ledger-handoff`
+- `POST /v1/proof-center/bridge/operator-review-pack`
+- `POST /v1/proof-center/bridge/compatibility-pack`
+- `POST /v1/proof-center/bridge/workflow-pack`
+- `POST /v1/proof-center/bridge/admin-pack`
 - `POST /v1/proof-center/result-package-handoff/review`
 - `POST /v1/proof-center/result-package-handoff/review/summary`
 - `POST /v1/proof-center/result-package-handoff/review/extension-readiness`
@@ -212,6 +240,25 @@ It now also exposes a handoff-intake summary and handoff-intake-boundary summary
 It now also exposes a handoff-intake-carry summary so the same proof-side intake surface can be reused more directly as compact consumable carry instead of only summary or boundary posture.
 It now also exposes a handoff-run summary so that same handoff contract can be read directly as the final proof-native run posture instead of only as continuity guidance.
 
+The Wave B governance carry-over line adds a bounded governance center on the proof side:
+
+- governance interpretation validation for receipt-ledger and result-package follow-through
+- governance coordination emission for the next proof-side/operator handoff step
+- governance dashboard, operator-view, admin-view, dashboard-pack, workflow-pack, and signoff-pack packaging
+- dispute summary, case review, metadata-only dispute action, case-bundle export, and resolution-pack export
+- console-pack, handoff-bundle, and explicit review-link surfaces for compact operator carry into the proof-side review/run ladder
+
+This keeps governance review attached to the proof-side operating shape without widening `xoonya` into a runtime or economics system.
+
+The Wave E bridge carry-over line adds a bounded bridge center on the proof side:
+
+- receipt-wrap support for compact compatibility receipts when an outside bridge still needs that bounded surface
+- validator-compatible verification and receipt inspection posture for bridge-side review
+- receipt-ledger handoff packaging for compact proof-to-economics carry
+- operator review packs, workflow packs, admin packs, and compatibility packs so bridge-facing support breadth is easy to inspect without changing the public proof center
+
+This keeps the public story centered on `xoonya` while preserving the useful bridge, validator, and profile lineage as support surfaces instead of separate product identities.
+
 The current `1.18.0` line starts turning that adapter-consumable handoff surface into a clearer adapter-usable handoff package:
 
 - proof-side handoff-package intake summaries on top of the intake surface

package/SERVICE_CONTRACT.md

@@ -7,6 +7,36 @@ This file freezes the public service contract for `xoonya`.
 Primary proof-model routes:
 
 - `GET /health`
+- `GET /v1/proof-center`
+- `GET /v1/proof-center/summary`
+- `GET /v1/proof-center/governance`
+- `GET /v1/proof-center/governance/summary`
+- `GET /v1/proof-center/bridge`
+- `GET /v1/proof-center/bridge/summary`
+- `GET /v1/proof-center/bridge/profile-support`
+- `POST /v1/proof-center/governance/interpretation-validate`
+- `POST /v1/proof-center/governance/coordination`
+- `POST /v1/proof-center/governance/dashboard`
+- `POST /v1/proof-center/governance/operator-view`
+- `POST /v1/proof-center/governance/admin-view`
+- `POST /v1/proof-center/governance/dashboard-pack`
+- `POST /v1/proof-center/governance/workflow-pack`
+- `POST /v1/proof-center/governance/signoff-pack`
+- `POST /v1/proof-center/governance/disputes/summary`
+- `POST /v1/proof-center/governance/disputes/case-review`
+- `POST /v1/proof-center/governance/disputes/action`
+- `POST /v1/proof-center/governance/disputes/case-bundle`
+- `POST /v1/proof-center/governance/disputes/resolution-pack`
+- `POST /v1/proof-center/governance/console-pack`
+- `POST /v1/proof-center/governance/handoff-bundle`
+- `POST /v1/proof-center/governance/review-link`
+- `POST /v1/proof-center/bridge/receipt-wrap`
+- `POST /v1/proof-center/bridge/validator-verify`
+- `POST /v1/proof-center/bridge/receipt-ledger-handoff`
+- `POST /v1/proof-center/bridge/operator-review-pack`
+- `POST /v1/proof-center/bridge/compatibility-pack`
+- `POST /v1/proof-center/bridge/workflow-pack`
+- `POST /v1/proof-center/bridge/admin-pack`
 - `POST /v1/events/canonicalize`
 - `POST /v1/events/hash`
 - `POST /v1/receipts/emit`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xoonya",
-  "version": "1.26.0",
+  "version": "1.27.0",
   "description": "Deterministic proof SDK for canonical events, receipts, proof bundles, and verification.",
   "main": "index.js",
   "type": "commonjs",

package/proof_sdk.js

@@ -1948,6 +1948,691 @@ 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",
+    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",
+      "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,
+    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 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 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",
+      "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",
+    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",
+      "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
+    },
+    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 +2673,34 @@ function runDefaultProofLoop(loopRef, input) {
 }
 
 module.exports = {
+  buildBridgeCenter,
+  summarizeBridgeCenter,
+  buildBridgeReceiptWrap,
+  summarizeBridgeValidatorVerify,
+  buildReceiptLedgerBridgeHandoff,
+  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,

package/server.js

@@ -127,6 +127,31 @@ async function routeRequest(req, res) {
     return;
   }
 
+  if (req.method === 'GET' && url.pathname === '/v1/proof-center/governance') {
+    sendJson(res, 200, proofSdk.buildGovernanceCenter());
+    return;
+  }
+
+  if (req.method === 'GET' && url.pathname === '/v1/proof-center/governance/summary') {
+    sendJson(res, 200, proofSdk.summarizeGovernanceCenter());
+    return;
+  }
+
+  if (req.method === 'GET' && url.pathname === '/v1/proof-center/bridge') {
+    sendJson(res, 200, proofSdk.buildBridgeCenter());
+    return;
+  }
+
+  if (req.method === 'GET' && url.pathname === '/v1/proof-center/bridge/summary') {
+    sendJson(res, 200, proofSdk.summarizeBridgeCenter());
+    return;
+  }
+
+  if (req.method === 'GET' && url.pathname === '/v1/proof-center/bridge/profile-support') {
+    sendJson(res, 200, proofSdk.buildBridgeProfileSupport());
+    return;
+  }
+
   if (req.method === 'GET' && url.pathname === '/v1/proof-center/default-loop') {
     const loop = proofSdk.getDefaultProofLoop(url.searchParams.get('ref'));
     if (!loop) {
@@ -660,6 +685,259 @@ async function routeRequest(req, res) {
     return;
   }
 
+  if (req.method === 'POST' && url.pathname === '/v1/proof-center/governance/interpretation-validate') {
+    try {
+      const body = await readJsonBody(req);
+      const result = proofSdk.validateGovernanceInterpretation(body);
+      sendJson(res, 200, result);
+    } catch (error) {
+      sendJson(res, 400, { ok: false, reason: error.message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && url.pathname === '/v1/proof-center/governance/coordination') {
+    try {
+      const body = await readJsonBody(req);
+      const result = proofSdk.emitGovernanceCoordination(body);
+      sendJson(res, 200, result);
+    } catch (error) {
+      sendJson(res, 400, { ok: false, reason: error.message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && url.pathname === '/v1/proof-center/governance/dashboard') {
+    try {
+      const body = await readJsonBody(req);
+      const result = proofSdk.summarizeGovernanceDashboard(body);
+      sendJson(res, 200, result);
+    } catch (error) {
+      sendJson(res, 400, { ok: false, reason: error.message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && url.pathname === '/v1/proof-center/governance/operator-view') {
+    try {
+      const body = await readJsonBody(req);
+      const result = proofSdk.summarizeGovernanceOperatorView(body);
+      sendJson(res, 200, result);
+    } catch (error) {
+      sendJson(res, 400, { ok: false, reason: error.message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && url.pathname === '/v1/proof-center/governance/admin-view') {
+    try {
+      const body = await readJsonBody(req);
+      const result = proofSdk.summarizeGovernanceAdminView(body);
+      sendJson(res, 200, result);
+    } catch (error) {
+      sendJson(res, 400, { ok: false, reason: error.message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && url.pathname === '/v1/proof-center/governance/dashboard-pack') {
+    try {
+      const body = await readJsonBody(req);
+      const result = proofSdk.buildGovernanceDashboardPack(body);
+      sendJson(res, 200, result);
+    } catch (error) {
+      sendJson(res, 400, { ok: false, reason: error.message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && url.pathname === '/v1/proof-center/governance/workflow-pack') {
+    try {
+      const body = await readJsonBody(req);
+      const result = proofSdk.buildGovernanceWorkflowPack(body);
+      sendJson(res, 200, result);
+    } catch (error) {
+      sendJson(res, 400, { ok: false, reason: error.message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && url.pathname === '/v1/proof-center/governance/signoff-pack') {
+    try {
+      const body = await readJsonBody(req);
+      const result = proofSdk.buildGovernanceSignoffPack(body);
+      sendJson(res, 200, result);
+    } catch (error) {
+      sendJson(res, 400, { ok: false, reason: error.message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && url.pathname === '/v1/proof-center/governance/disputes/summary') {
+    try {
+      const body = await readJsonBody(req);
+      const result = proofSdk.summarizeGovernanceDisputes(body);
+      sendJson(res, 200, result);
+    } catch (error) {
+      sendJson(res, 400, { ok: false, reason: error.message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && url.pathname === '/v1/proof-center/governance/disputes/case-review') {
+    try {
+      const body = await readJsonBody(req);
+      const result = proofSdk.reviewGovernanceCase(body);
+      sendJson(res, 200, result);
+    } catch (error) {
+      sendJson(res, 400, { ok: false, reason: error.message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && url.pathname === '/v1/proof-center/governance/disputes/action') {
+    try {
+      const body = await readJsonBody(req);
+      const result = proofSdk.summarizeGovernanceDisputeAction(body);
+      sendJson(res, 200, result);
+    } catch (error) {
+      sendJson(res, 400, { ok: false, reason: error.message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && url.pathname === '/v1/proof-center/governance/disputes/case-bundle') {
+    try {
+      const body = await readJsonBody(req);
+      const result = proofSdk.buildGovernanceCaseBundle(body);
+      sendJson(res, 200, result);
+    } catch (error) {
+      sendJson(res, 400, { ok: false, reason: error.message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && url.pathname === '/v1/proof-center/governance/disputes/resolution-pack') {
+    try {
+      const body = await readJsonBody(req);
+      const result = proofSdk.buildGovernanceResolutionPack(body);
+      sendJson(res, 200, result);
+    } catch (error) {
+      sendJson(res, 400, { ok: false, reason: error.message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && url.pathname === '/v1/proof-center/governance/console-pack') {
+    try {
+      const body = await readJsonBody(req);
+      const result = proofSdk.buildGovernanceConsolePack(body);
+      sendJson(res, 200, result);
+    } catch (error) {
+      sendJson(res, 400, { ok: false, reason: error.message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && url.pathname === '/v1/proof-center/governance/handoff-bundle') {
+    try {
+      const body = await readJsonBody(req);
+      const result = proofSdk.buildGovernanceHandoffBundle(body);
+      sendJson(res, 200, result);
+    } catch (error) {
+      sendJson(res, 400, { ok: false, reason: error.message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && url.pathname === '/v1/proof-center/governance/review-link') {
+    try {
+      const body = await readJsonBody(req);
+      const result = proofSdk.summarizeGovernanceReviewLink(body);
+      sendJson(res, 200, result);
+    } catch (error) {
+      sendJson(res, 400, { ok: false, reason: error.message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && url.pathname === '/v1/proof-center/bridge/receipt-wrap') {
+    try {
+      const body = await readJsonBody(req);
+      const result = proofSdk.buildBridgeReceiptWrap(body);
+      sendJson(res, 200, result);
+    } catch (error) {
+      sendJson(res, 400, { ok: false, reason: error.message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && url.pathname === '/v1/proof-center/bridge/validator-verify') {
+    try {
+      const body = await readJsonBody(req);
+      const result = proofSdk.summarizeBridgeValidatorVerify(body);
+      sendJson(res, 200, result);
+    } catch (error) {
+      sendJson(res, 400, { valid: false, reason: error.message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && url.pathname === '/v1/proof-center/bridge/receipt-ledger-handoff') {
+    try {
+      const body = await readJsonBody(req);
+      const result = proofSdk.buildReceiptLedgerBridgeHandoff(body);
+      sendJson(res, 200, result);
+    } catch (error) {
+      sendJson(res, 400, { ok: false, reason: error.message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && url.pathname === '/v1/proof-center/bridge/operator-review-pack') {
+    try {
+      const body = await readJsonBody(req);
+      const result = proofSdk.buildBridgeOperatorReviewPack(body);
+      sendJson(res, 200, result);
+    } catch (error) {
+      sendJson(res, 400, { ok: false, reason: error.message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && url.pathname === '/v1/proof-center/bridge/compatibility-pack') {
+    try {
+      const body = await readJsonBody(req);
+      const result = proofSdk.buildBridgeCompatibilityPack(body);
+      sendJson(res, 200, result);
+    } catch (error) {
+      sendJson(res, 400, { ok: false, reason: error.message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && url.pathname === '/v1/proof-center/bridge/workflow-pack') {
+    try {
+      const body = await readJsonBody(req);
+      const result = proofSdk.buildBridgeWorkflowPack(body);
+      sendJson(res, 200, result);
+    } catch (error) {
+      sendJson(res, 400, { ok: false, reason: error.message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && url.pathname === '/v1/proof-center/bridge/admin-pack') {
+    try {
+      const body = await readJsonBody(req);
+      const result = proofSdk.buildBridgeAdminPack(body);
+      sendJson(res, 200, result);
+    } catch (error) {
+      sendJson(res, 400, { ok: false, reason: error.message });
+    }
+    return;
+  }
+
   if (req.method === 'GET' && url.pathname === '/v1/integrations') {
     const response = buildIntegrationListResponse({
       ok: true,