xoonya 2.2.0 → 2.4.0

package/RELEASE_NOTES.md

@@ -1,17 +1,19 @@
-# xoonya 2.2.0 Release Notes
+# xoonya 2.4.0 Release Notes
 
-`xoonya` 2.2.0 is the public proof-spine program-complete line.
+`xoonya` 2.4.0 is the proof-role freeze and transition-clarity line.
 
 Highlights:
 
 - direct one-line proof-side review with `xoonya-review`
-- release, comparison, adoption, scenario, and launch packs over HTTP and CLI
-- release-center, announcement-pack, and release-candidate surfaces for public launch readiness
-- canonical event, receipt, and proof-bundle model
-- bridge and governance surfaces for reviewable proof posture
-- stable runtime-to-proof followthrough
-- partner-ready onboarding and launch docs
-- clearer stack-positioning docs for why proof stays separate from runtime commerce
+- trust intelligence for proof readiness, bridge confidence, and recommended review motion
+- review intelligence for governance burden, dispute risk, and dependency posture
+- governance intelligence for escalation, signoff, and handoff continuity
+- bridge intelligence for compatibility strength and bridge coverage posture
+- explicit proof-role freeze, operator bundle, policy pack, and package surfaces
+- explicit role-transition package recording long-term coordination-shell direction
+- explicit capability-registry-home package recording `xytara` as current home and `xoonya` as the later canonical target
+- canonical event, receipt, and proof-bundle model with stable runtime-to-proof followthrough
+- partner-ready onboarding, launch docs, and public example paths remain in place
 
 Recommended first checks:
 
@@ -19,10 +21,15 @@ Recommended first checks:
 2. `xoonya-release --candidate --summary`
 3. `npm run verify:release-candidate`
 4. `node examples/partner_proof_walkthrough.js`
-5. inspect `/v1/release-candidate/summary` and `/v1/proof-center/summary` on the deployed service
+5. inspect `/v1/role-freeze/package`
+6. inspect `/v1/role-transition`
+7. inspect `/v1/capability-registry-home`
+8. inspect `/v1/trust-intelligence` and `/v1/review-intelligence`
+9. inspect `/v1/proof-center/summary` on the deployed service
 
 Recommended first docs:
 
 - `PROGRAM_COMPLETE_RELEASE.md`
+- `FINAL_CONTRACT.md`
 - `WHY_XYTARA_XOONYA.md`
 - `PARTNER_READY_PATH.md`

package/lib/bridge_intelligence.js

@@ -0,0 +1,102 @@
+"use strict";
+
+const packageJson = require("../package.json");
+const proofSdk = require("../proof_sdk");
+
+function classifyBridgeCoverageState(bridgeSummary) {
+  if (bridgeSummary.capability_count >= 8 && bridgeSummary.profile_count >= 3) return "broad";
+  if (bridgeSummary.capability_count >= 4 && bridgeSummary.profile_count >= 2) return "working";
+  return "thin";
+}
+
+function classifyCompatibilityStrengthState(compatibilityPack) {
+  const preservedRouteCount = Array.isArray(compatibilityPack.preserved_routes)
+    ? compatibilityPack.preserved_routes.length
+    : 0;
+  const preservedHelperCount = Array.isArray(compatibilityPack.preserved_helpers)
+    ? compatibilityPack.preserved_helpers.length
+    : 0;
+  if (preservedRouteCount >= 5 && preservedHelperCount >= 8) return "strong";
+  if (preservedRouteCount >= 3 && preservedHelperCount >= 5) return "working";
+  return "thin";
+}
+
+function classifyHandoffDependencyState(operatorReviewPack, handoffCenterSummary) {
+  const includedSectionCount = Array.isArray(operatorReviewPack.included_sections)
+    ? operatorReviewPack.included_sections.length
+    : 0;
+  if (includedSectionCount >= 6 && handoffCenterSummary.source_ref_count >= 3) return "strong";
+  if (includedSectionCount >= 4 && handoffCenterSummary.source_ref_count >= 2) return "working";
+  return "thin";
+}
+
+function buildBridgeIntelligencePack(input) {
+  const payload = input && typeof input === "object" && !Array.isArray(input) ? input : {};
+  const bridgeSummary = proofSdk.summarizeBridgeCenter();
+  const compatibilityPack = proofSdk.buildBridgeCompatibilityPack(payload);
+  const operatorReviewPack = proofSdk.buildBridgeOperatorReviewPack(payload);
+  const handoffCenterSummary = proofSdk.summarizeInteractionResultPackageHandoffCenter();
+
+  const bridgeCoverageState = classifyBridgeCoverageState(bridgeSummary);
+  const compatibilityStrengthState = classifyCompatibilityStrengthState(compatibilityPack);
+  const handoffDependencyState = classifyHandoffDependencyState(operatorReviewPack, handoffCenterSummary);
+
+  let nextBestAction = "continue_bridge_review_motion";
+  if (bridgeCoverageState === "thin") {
+    nextBestAction = "strengthen_bridge_coverage";
+  } else if (compatibilityStrengthState === "thin") {
+    nextBestAction = "strengthen_compatibility_posture";
+  } else if (handoffDependencyState !== "strong") {
+    nextBestAction = "strengthen_bridge_handoff_continuity";
+  } else if (compatibilityStrengthState === "working" || handoffDependencyState === "working") {
+    nextBestAction = "inspect_bridge_operator_pack";
+  }
+
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "proof-bridge-intelligence-pack",
+    bridge_coverage_state: bridgeCoverageState,
+    compatibility_strength_state: compatibilityStrengthState,
+    handoff_dependency_state: handoffDependencyState,
+    recommended_bridge_motion: "bridge_operator_review_and_handoff_followthrough",
+    next_best_action: nextBestAction,
+    explanation_signals: {
+      bridge_capability_count: bridgeSummary.capability_count,
+      bridge_profile_count: bridgeSummary.profile_count,
+      compatibility_route_count: Array.isArray(compatibilityPack.preserved_routes) ? compatibilityPack.preserved_routes.length : 0,
+      compatibility_helper_count: Array.isArray(compatibilityPack.preserved_helpers) ? compatibilityPack.preserved_helpers.length : 0,
+      compatibility_profile_version_count: Array.isArray(compatibilityPack.profile_versions) ? compatibilityPack.profile_versions.length : 0,
+      operator_pack_section_count: Array.isArray(operatorReviewPack.included_sections) ? operatorReviewPack.included_sections.length : 0,
+      handoff_source_ref_count: handoffCenterSummary.source_ref_count,
+      handoff_mode_count: handoffCenterSummary.handoff_mode_count
+    },
+    linked_surfaces: {
+      bridge_summary_ref: "/v1/proof-center/bridge/summary",
+      bridge_operator_review_pack_ref: "/v1/proof-center/bridge/operator-review-pack",
+      bridge_compatibility_pack_ref: "/v1/proof-center/bridge/compatibility-pack",
+      bridge_workflow_pack_ref: "/v1/proof-center/bridge/workflow-pack",
+      result_package_handoff_summary_ref: "/v1/proof-center/result-package-handoff/summary",
+      result_package_handoff_run_ref: "/v1/proof-center/result-package-handoff/run"
+    }
+  };
+}
+
+function summarizeBridgeIntelligencePack(input) {
+  const pack = buildBridgeIntelligencePack(input);
+  return {
+    ok: true,
+    product: pack.product,
+    category: pack.category,
+    bridge_coverage_state: pack.bridge_coverage_state,
+    compatibility_strength_state: pack.compatibility_strength_state,
+    handoff_dependency_state: pack.handoff_dependency_state,
+    next_best_action: pack.next_best_action,
+    signal_count: Object.keys(pack.explanation_signals).length
+  };
+}
+
+module.exports = {
+  buildBridgeIntelligencePack,
+  summarizeBridgeIntelligencePack
+};

package/lib/governance_intelligence.js

@@ -0,0 +1,108 @@
+"use strict";
+
+const packageJson = require("../package.json");
+const proofSdk = require("../proof_sdk");
+
+function classifyEscalationReadinessState(adminView, disputesSummary) {
+  const escalationReadyCount = Number(adminView.oversight_summary?.escalation_ready_count || 0);
+  const openCaseCount = Number(disputesSummary.open_case_count || 0);
+  if (escalationReadyCount >= 1 && openCaseCount >= 2) return "active";
+  if (escalationReadyCount >= 1 || openCaseCount >= 1) return "watch";
+  return "quiet";
+}
+
+function classifySignoffMotionState(dashboard, signoffPack) {
+  const signoffReadyCount = Number(dashboard.queue_summary?.signoff_ready_count || 0);
+  if (signoffPack.signoff_status === "review_ready" && signoffReadyCount >= 1) return "review_ready";
+  if (signoffReadyCount >= 1) return "forming";
+  return "early";
+}
+
+function classifyHandoffContinuityState(handoffBundle) {
+  const includedSectionCount = Array.isArray(handoffBundle.included_sections)
+    ? handoffBundle.included_sections.length
+    : 0;
+  if (
+    includedSectionCount >= 4
+    && handoffBundle.review_summary_surface
+    && handoffBundle.handoff_run_surface
+  ) {
+    return "strong";
+  }
+  if (includedSectionCount >= 2) return "working";
+  return "thin";
+}
+
+function buildGovernanceIntelligencePack(input) {
+  const payload = input && typeof input === "object" && !Array.isArray(input) ? input : {};
+  const dashboard = proofSdk.summarizeGovernanceDashboard(payload);
+  const adminView = proofSdk.summarizeGovernanceAdminView(payload);
+  const disputesSummary = proofSdk.summarizeGovernanceDisputes(payload);
+  const signoffPack = proofSdk.buildGovernanceSignoffPack(payload);
+  const consolePack = proofSdk.buildGovernanceConsolePack(payload);
+  const handoffBundle = proofSdk.buildGovernanceHandoffBundle(payload);
+
+  const escalationReadinessState = classifyEscalationReadinessState(adminView, disputesSummary);
+  const signoffMotionState = classifySignoffMotionState(dashboard, signoffPack);
+  const handoffContinuityState = classifyHandoffContinuityState(handoffBundle);
+
+  let nextBestAction = "continue_governance_flow";
+  if (escalationReadinessState === "active") {
+    nextBestAction = "escalate_governance_attention";
+  } else if (signoffMotionState === "review_ready") {
+    nextBestAction = "advance_signoff_motion";
+  } else if (handoffContinuityState !== "strong") {
+    nextBestAction = "strengthen_handoff_continuity";
+  } else if (escalationReadinessState === "watch") {
+    nextBestAction = "inspect_governance_console";
+  }
+
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "proof-governance-intelligence-pack",
+    escalation_readiness_state: escalationReadinessState,
+    signoff_motion_state: signoffMotionState,
+    handoff_continuity_state: handoffContinuityState,
+    recommended_governance_motion: "governance_console_and_signoff_followthrough",
+    next_best_action: nextBestAction,
+    explanation_signals: {
+      review_count: Number(dashboard.queue_summary?.review_count || 0),
+      dispute_count: Number(dashboard.queue_summary?.dispute_count || 0),
+      signoff_ready_count: Number(dashboard.queue_summary?.signoff_ready_count || 0),
+      escalation_ready_count: Number(adminView.oversight_summary?.escalation_ready_count || 0),
+      oversight_queue_count: Number(adminView.oversight_summary?.queue_count || 0),
+      open_case_count: Number(disputesSummary.open_case_count || 0),
+      case_count: Number(disputesSummary.case_count || 0),
+      console_section_count: Array.isArray(consolePack.included_sections) ? consolePack.included_sections.length : 0,
+      handoff_section_count: Array.isArray(handoffBundle.included_sections) ? handoffBundle.included_sections.length : 0
+    },
+    linked_surfaces: {
+      governance_dashboard_ref: "/v1/proof-center/governance/dashboard",
+      governance_admin_view_ref: "/v1/proof-center/governance/admin-view",
+      governance_signoff_pack_ref: "/v1/proof-center/governance/signoff-pack",
+      governance_console_pack_ref: "/v1/proof-center/governance/console-pack",
+      governance_handoff_bundle_ref: "/v1/proof-center/governance/handoff-bundle",
+      governance_disputes_summary_ref: "/v1/proof-center/governance/disputes/summary"
+    }
+  };
+}
+
+function summarizeGovernanceIntelligencePack(input) {
+  const pack = buildGovernanceIntelligencePack(input);
+  return {
+    ok: true,
+    product: pack.product,
+    category: pack.category,
+    escalation_readiness_state: pack.escalation_readiness_state,
+    signoff_motion_state: pack.signoff_motion_state,
+    handoff_continuity_state: pack.handoff_continuity_state,
+    next_best_action: pack.next_best_action,
+    signal_count: Object.keys(pack.explanation_signals).length
+  };
+}
+
+module.exports = {
+  buildGovernanceIntelligencePack,
+  summarizeGovernanceIntelligencePack
+};

package/lib/review_intelligence.js

@@ -0,0 +1,100 @@
+"use strict";
+
+const packageJson = require("../package.json");
+const proofSdk = require("../proof_sdk");
+
+function classifyReviewBurdenState(queueSummary, openCaseCount) {
+  const reviewCount = Number(queueSummary.review_count || 0);
+  const disputeCount = Number(queueSummary.dispute_count || 0);
+  if (reviewCount >= 5 || disputeCount >= 3 || openCaseCount >= 3) return "high";
+  if (reviewCount >= 3 || disputeCount >= 2 || openCaseCount >= 2) return "moderate";
+  return "light";
+}
+
+function classifyDisputeRiskState(disputeCount, openCaseCount) {
+  if (disputeCount >= 3 || openCaseCount >= 3) return "high";
+  if (disputeCount >= 1 || openCaseCount >= 1) return "watch";
+  return "low";
+}
+
+function classifyBridgeDependencyState(bridgeSummary) {
+  if (bridgeSummary.capability_count >= 8 && bridgeSummary.profile_count >= 3) return "strong";
+  if (bridgeSummary.capability_count >= 4 && bridgeSummary.profile_count >= 2) return "working";
+  return "thin";
+}
+
+function buildReviewIntelligencePack(input) {
+  const payload = input && typeof input === "object" && !Array.isArray(input) ? input : {};
+  const governanceDashboard = proofSdk.summarizeGovernanceDashboard(payload);
+  const governanceDisputes = proofSdk.summarizeGovernanceDisputes(payload);
+  const governanceOperatorView = proofSdk.summarizeGovernanceOperatorView(payload);
+  const bridgeSummary = proofSdk.summarizeBridgeCenter();
+
+  const reviewBurdenState = classifyReviewBurdenState(
+    governanceDashboard.queue_summary,
+    governanceDisputes.open_case_count
+  );
+  const disputeRiskState = classifyDisputeRiskState(
+    governanceDashboard.queue_summary.dispute_count,
+    governanceDisputes.open_case_count
+  );
+  const bridgeDependencyState = classifyBridgeDependencyState(bridgeSummary);
+
+  let nextBestAction = "continue_review_path";
+  if (disputeRiskState === "high") {
+    nextBestAction = "escalate_dispute_review";
+  } else if (reviewBurdenState === "high") {
+    nextBestAction = "prioritize_governance_queue";
+  } else if (bridgeDependencyState === "thin") {
+    nextBestAction = "strengthen_bridge_review_posture";
+  } else if (disputeRiskState === "watch" || reviewBurdenState === "moderate") {
+    nextBestAction = "inspect_governance_dashboard";
+  }
+
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "proof-review-intelligence-pack",
+    review_burden_state: reviewBurdenState,
+    dispute_risk_state: disputeRiskState,
+    bridge_dependency_state: bridgeDependencyState,
+    recommended_review_lane: "governance_and_result_package_review",
+    next_best_action: nextBestAction,
+    explanation_signals: {
+      review_count: Number(governanceDashboard.queue_summary.review_count || 0),
+      dispute_count: Number(governanceDashboard.queue_summary.dispute_count || 0),
+      signoff_ready_count: Number(governanceDashboard.queue_summary.signoff_ready_count || 0),
+      open_case_count: Number(governanceDisputes.open_case_count || 0),
+      case_count: Number(governanceDisputes.case_count || 0),
+      attention_ref_count: Array.isArray(governanceOperatorView.attention_refs) ? governanceOperatorView.attention_refs.length : 0,
+      bridge_capability_count: bridgeSummary.capability_count,
+      bridge_profile_count: bridgeSummary.profile_count
+    },
+    linked_surfaces: {
+      governance_dashboard_ref: "/v1/proof-center/governance/dashboard",
+      governance_operator_view_ref: "/v1/proof-center/governance/operator-view",
+      governance_disputes_summary_ref: "/v1/proof-center/governance/disputes/summary",
+      governance_review_link_ref: "/v1/proof-center/governance/review-link",
+      bridge_summary_ref: "/v1/proof-center/bridge/summary"
+    }
+  };
+}
+
+function summarizeReviewIntelligencePack(input) {
+  const pack = buildReviewIntelligencePack(input);
+  return {
+    ok: true,
+    product: pack.product,
+    category: pack.category,
+    review_burden_state: pack.review_burden_state,
+    dispute_risk_state: pack.dispute_risk_state,
+    bridge_dependency_state: pack.bridge_dependency_state,
+    next_best_action: pack.next_best_action,
+    signal_count: Object.keys(pack.explanation_signals).length
+  };
+}
+
+module.exports = {
+  buildReviewIntelligencePack,
+  summarizeReviewIntelligencePack
+};

package/lib/role_freeze.js

@@ -0,0 +1,436 @@
+"use strict";
+
+const packageJson = require("../package.json");
+const proofSdk = require("../proof_sdk");
+const {
+  buildTrustIntelligencePack
+} = require("./trust_intelligence");
+const {
+  buildReviewIntelligencePack
+} = require("./review_intelligence");
+const {
+  buildGovernanceIntelligencePack
+} = require("./governance_intelligence");
+const {
+  buildBridgeIntelligencePack
+} = require("./bridge_intelligence");
+
+function buildRoleFreezePack() {
+  const proofCenterSummary = proofSdk.summarizeDefaultProofCenter();
+  const resultPackageHandoffSummary = proofSdk.summarizeInteractionResultPackageHandoffCenter();
+  const governanceSummary = proofSdk.summarizeGovernanceCenter();
+  const bridgeSummary = proofSdk.summarizeBridgeCenter();
+  const trustIntelligence = buildTrustIntelligencePack();
+  const reviewIntelligence = buildReviewIntelligencePack();
+  const governanceIntelligence = buildGovernanceIntelligencePack();
+  const bridgeIntelligence = buildBridgeIntelligencePack();
+
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "proof-role-freeze-pack",
+    frozen_role: "proof_review_governance_bridge_followthrough",
+    role_state: "explicitly_frozen",
+    owns: [
+      "canonical_proof_bundle_model",
+      "result_package_review_and_followthrough",
+      "governance_review_and_signoff",
+      "bridge_and_compatibility_followthrough",
+      "proof_side_operator_and_review_intelligence"
+    ],
+    does_not_own: [
+      "runtime_execution_ownership",
+      "wallet_or_ledger_truth",
+      "machine_economics_or_pricing_truth",
+      "fiat_ingress_ownership",
+      "settlement_authority_ownership"
+    ],
+    role_doctrine: {
+      lead_entry_surface: "/v1/proof-center/result-package-handoff/review/summary",
+      primary_center_surface: "/v1/proof-center/summary",
+      runtime_boundary: "xytara_owns_runtime_wallet_authority_identity_and_economics_truth",
+      bridge_boundary: "xoonya_carries_reviewable_proof_followthrough_without_becoming_runtime_core"
+    },
+    role_strength_signals: {
+      proof_helper_count: proofCenterSummary.helper_count,
+      result_package_source_ref_count: resultPackageHandoffSummary.source_ref_count,
+      governance_capability_count: governanceSummary.capability_count,
+      bridge_capability_count: bridgeSummary.capability_count
+    },
+    intelligence_posture: {
+      proof_readiness_state: trustIntelligence.proof_readiness_state,
+      review_burden_state: reviewIntelligence.review_burden_state,
+      escalation_readiness_state: governanceIntelligence.escalation_readiness_state,
+      bridge_coverage_state: bridgeIntelligence.bridge_coverage_state
+    },
+    linked_surfaces: {
+      proof_center_summary_ref: "/v1/proof-center/summary",
+      result_package_handoff_summary_ref: "/v1/proof-center/result-package-handoff/summary",
+      governance_summary_ref: "/v1/proof-center/governance/summary",
+      bridge_summary_ref: "/v1/proof-center/bridge/summary",
+      trust_intelligence_summary_ref: "/v1/trust-intelligence/summary",
+      review_intelligence_summary_ref: "/v1/review-intelligence/summary",
+      governance_intelligence_summary_ref: "/v1/governance-intelligence/summary",
+      bridge_intelligence_summary_ref: "/v1/bridge-intelligence/summary"
+    },
+    generated_from: {
+      proof_bundle_version: proofCenterSummary.proof_bundle_version,
+      center_ref: proofCenterSummary.center_ref || "/v1/proof-center",
+      governance_center_ref: governanceSummary.center_ref,
+      bridge_center_ref: bridgeSummary.center_ref
+    }
+  };
+}
+
+function summarizeRoleFreezePack() {
+  const pack = buildRoleFreezePack();
+  return {
+    ok: true,
+    product: pack.product,
+    category: pack.category,
+    frozen_role: pack.frozen_role,
+    role_state: pack.role_state,
+    lead_entry_surface: pack.role_doctrine.lead_entry_surface,
+    owns_count: pack.owns.length,
+    does_not_own_count: pack.does_not_own.length
+  };
+}
+
+function buildRoleFreezeOperatorBundle() {
+  const roleFreeze = buildRoleFreezePack();
+  const trustIntelligence = buildTrustIntelligencePack();
+  const reviewIntelligence = buildReviewIntelligencePack();
+  const governanceIntelligence = buildGovernanceIntelligencePack();
+  const bridgeIntelligence = buildBridgeIntelligencePack();
+
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "proof-role-freeze-operator-bundle",
+    bundle_version: "xoonya-proof-role-freeze-operator-bundle-v1",
+    operator_posture: {
+      frozen_role: roleFreeze.frozen_role,
+      role_state: roleFreeze.role_state,
+      proof_readiness_state: trustIntelligence.proof_readiness_state,
+      review_burden_state: reviewIntelligence.review_burden_state,
+      escalation_readiness_state: governanceIntelligence.escalation_readiness_state,
+      bridge_coverage_state: bridgeIntelligence.bridge_coverage_state,
+      recommended_operator_motion: bridgeIntelligence.bridge_coverage_state === "thin"
+        ? "strengthen_bridge_followthrough"
+        : governanceIntelligence.escalation_readiness_state === "active"
+          ? "advance_governance_followthrough"
+          : trustIntelligence.proof_readiness_state !== "strong"
+            ? "strengthen_result_package_review_entry"
+            : "maintain_frozen_proof_role"
+    },
+    role_freeze: roleFreeze,
+    trust_intelligence: trustIntelligence,
+    review_intelligence: reviewIntelligence,
+    governance_intelligence: governanceIntelligence,
+    bridge_intelligence: bridgeIntelligence,
+    linked_surfaces: {
+      role_freeze_ref: "/v1/role-freeze",
+      role_freeze_summary_ref: "/v1/role-freeze/summary",
+      trust_intelligence_ref: "/v1/trust-intelligence",
+      review_intelligence_ref: "/v1/review-intelligence",
+      governance_intelligence_ref: "/v1/governance-intelligence",
+      bridge_intelligence_ref: "/v1/bridge-intelligence"
+    }
+  };
+}
+
+function summarizeRoleFreezeOperatorBundle() {
+  const bundle = buildRoleFreezeOperatorBundle();
+  return {
+    ok: true,
+    product: bundle.product,
+    category: bundle.category,
+    bundle_version: bundle.bundle_version,
+    frozen_role: bundle.operator_posture.frozen_role,
+    role_state: bundle.operator_posture.role_state,
+    recommended_operator_motion: bundle.operator_posture.recommended_operator_motion
+  };
+}
+
+function buildRoleFreezePolicyPack() {
+  const roleFreeze = buildRoleFreezePack();
+  const operatorBundle = buildRoleFreezeOperatorBundle();
+  const policyTemplates = [
+    {
+      template_id: "result_package_review_lead",
+      recommended_for: "runtime-to-proof followthrough as the main entry path",
+      target_motion: "strengthen_result_package_review_entry",
+      reinforces: [
+        "canonical_proof_bundle_model",
+        "result_package_review_and_followthrough"
+      ]
+    },
+    {
+      template_id: "governance_followthrough_lead",
+      recommended_for: "active signoff and escalation pressure",
+      target_motion: "advance_governance_followthrough",
+      reinforces: [
+        "governance_review_and_signoff",
+        "proof_side_operator_and_review_intelligence"
+      ]
+    },
+    {
+      template_id: "bridge_followthrough_lead",
+      recommended_for: "thin bridge coverage or compatibility reinforcement",
+      target_motion: "strengthen_bridge_followthrough",
+      reinforces: [
+        "bridge_and_compatibility_followthrough",
+        "proof_side_operator_and_review_intelligence"
+      ]
+    },
+    {
+      template_id: "frozen_role_maintenance",
+      recommended_for: "strong balanced proof-side posture",
+      target_motion: "maintain_frozen_proof_role",
+      reinforces: roleFreeze.owns.slice()
+    }
+  ];
+
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "proof-role-freeze-policy-pack",
+    pack_version: "xoonya-proof-role-freeze-policy-pack-v1",
+    role_freeze: roleFreeze,
+    operator_bundle: operatorBundle,
+    recommended_policy_motion: operatorBundle.operator_posture.recommended_operator_motion,
+    policy_templates: policyTemplates,
+    linked_surfaces: {
+      role_freeze_ref: "/v1/role-freeze",
+      role_freeze_operator_bundle_ref: "/v1/role-freeze/operator-bundle",
+      role_freeze_policy_application_summary_ref: "/v1/role-freeze/policy-application-summary"
+    }
+  };
+}
+
+function summarizeRoleFreezePolicyPack() {
+  const pack = buildRoleFreezePolicyPack();
+  return {
+    ok: true,
+    product: pack.product,
+    category: pack.category,
+    pack_version: pack.pack_version,
+    recommended_policy_motion: pack.recommended_policy_motion,
+    template_count: pack.policy_templates.length
+  };
+}
+
+function buildRoleFreezePolicyApplicationSummary(templateId) {
+  const pack = buildRoleFreezePolicyPack();
+  const selectedTemplate = pack.policy_templates.find((entry) => entry.template_id === templateId)
+    || pack.policy_templates.find((entry) => entry.target_motion === pack.recommended_policy_motion)
+    || pack.policy_templates[0];
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "proof-role-freeze-policy-application-summary",
+    summary_version: "xoonya-proof-role-freeze-policy-application-summary-v1",
+    recommended_policy_motion: pack.recommended_policy_motion,
+    selected_template_id: selectedTemplate ? selectedTemplate.template_id : null,
+    selected_template: selectedTemplate || null,
+    available_template_ids: pack.policy_templates.map((entry) => entry.template_id),
+    linked_surfaces: {
+      role_freeze_policy_pack_ref: "/v1/role-freeze/policy-pack",
+      role_freeze_operator_bundle_ref: "/v1/role-freeze/operator-bundle"
+    }
+  };
+}
+
+function buildRoleFreezePackage() {
+  const roleFreeze = buildRoleFreezePack();
+  const operatorBundle = buildRoleFreezeOperatorBundle();
+  const policyPack = buildRoleFreezePolicyPack();
+  const policyApplicationSummary = buildRoleFreezePolicyApplicationSummary(null);
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "proof-role-freeze-package",
+    package_version: "xoonya-proof-role-freeze-package-v1",
+    package_posture: {
+      frozen_role: roleFreeze.frozen_role,
+      role_state: roleFreeze.role_state,
+      recommended_operator_motion: operatorBundle.operator_posture.recommended_operator_motion,
+      recommended_policy_motion: policyPack.recommended_policy_motion
+    },
+    role_freeze: roleFreeze,
+    role_freeze_operator_bundle: operatorBundle,
+    role_freeze_policy_pack: policyPack,
+    role_freeze_policy_application_summary: policyApplicationSummary,
+    linked_surfaces: {
+      role_freeze_ref: "/v1/role-freeze",
+      role_freeze_operator_bundle_ref: "/v1/role-freeze/operator-bundle",
+      role_freeze_policy_pack_ref: "/v1/role-freeze/policy-pack",
+      role_freeze_policy_application_summary_ref: "/v1/role-freeze/policy-application-summary"
+    }
+  };
+}
+
+function summarizeRoleFreezePackage() {
+  const pack = buildRoleFreezePackage();
+  return {
+    ok: true,
+    product: pack.product,
+    category: pack.category,
+    package_version: pack.package_version,
+    frozen_role: pack.package_posture.frozen_role,
+    role_state: pack.package_posture.role_state,
+    recommended_operator_motion: pack.package_posture.recommended_operator_motion,
+    recommended_policy_motion: pack.package_posture.recommended_policy_motion
+  };
+}
+
+function buildRoleTransitionPack() {
+  const roleFreeze = buildRoleFreezePack();
+  const roleFreezePackage = buildRoleFreezePackage();
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "proof-role-transition-pack",
+    package_version: "xoonya-proof-role-transition-pack-v1",
+    current_role: {
+      frozen_role: roleFreeze.frozen_role,
+      role_state: roleFreeze.role_state,
+      current_primary_posture: "proof_primary"
+    },
+    long_term_direction: {
+      target_role: "capability_execution_coordination_shell_with_proof_strength",
+      direction_state: "explicit_direction_recorded",
+      current_transition_state: "proof_primary_today_coordination_shell_later",
+      rationale: [
+        "xytara remains canonical wallet_ledger_authority_identity_and_pricing_truth",
+        "xoonya remains the strongest home for proof review governance bridge and execution-adjacent followthrough",
+        "future canonical capability ownership may move toward xoonya if coordination-shell direction is affirmed"
+      ]
+    },
+    boundary_guardrails: {
+      xytara_must_continue_to_own: [
+        "wallet_truth",
+        "ledger_truth",
+        "authority_truth",
+        "machine_economics_truth",
+        "fiat_ingress_and_settlement_truth"
+      ],
+      xoonya_may_expand_to_own: [
+        "capability_identity",
+        "capability_execution_coordination",
+        "capability_registry_source_of_truth"
+      ],
+      xoonya_must_not_absorb: [
+        "wallet_balances",
+        "economic_capacity_truth",
+        "pricing_settlement_authority",
+        "adapter_or_fiat_business_logic"
+      ]
+    },
+    transition_readiness_signals: {
+      proof_readiness_state: roleFreeze.intelligence_posture.proof_readiness_state,
+      review_burden_state: roleFreezePackage.role_freeze_operator_bundle.review_intelligence.review_burden_state,
+      bridge_coverage_state: roleFreezePackage.role_freeze_operator_bundle.bridge_intelligence.bridge_coverage_state,
+      governance_posture_state: roleFreezePackage.role_freeze_operator_bundle.governance_intelligence.signoff_motion_state
+    },
+    recommended_transition_motion: roleFreezePackage.role_freeze_operator_bundle.operator_posture.recommended_operator_motion === "maintain_frozen_proof_role"
+      ? "record_transition_guardrails_and_prepare_registry_home_decision"
+      : "strengthen_proof_followthrough_before_coordination_expansion",
+    linked_surfaces: {
+      role_freeze_ref: "/v1/role-freeze",
+      role_freeze_package_ref: "/v1/role-freeze/package",
+      role_transition_summary_ref: "/v1/role-transition/summary"
+    }
+  };
+}
+
+function summarizeRoleTransitionPack() {
+  const pack = buildRoleTransitionPack();
+  return {
+    ok: true,
+    product: pack.product,
+    category: pack.category,
+    package_version: pack.package_version,
+    current_primary_posture: pack.current_role.current_primary_posture,
+    target_role: pack.long_term_direction.target_role,
+    current_transition_state: pack.long_term_direction.current_transition_state,
+    recommended_transition_motion: pack.recommended_transition_motion
+  };
+}
+
+function buildCapabilityRegistryHomePack() {
+  const roleTransition = buildRoleTransitionPack();
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "proof-capability-registry-home-pack",
+    package_version: "xoonya-proof-capability-registry-home-pack-v1",
+    current_registry_home: {
+      current_owner: "xytara",
+      current_state: "explicit_runtime_registry_active",
+      current_primary_surface: "xytara:/v1/capability-registry"
+    },
+    target_registry_home: {
+      target_owner: "xoonya",
+      target_state: "direction_recorded_not_yet_migrated",
+      target_role_dependency: "xoonya_as_capability_execution_coordination_shell"
+    },
+    migration_guardrails: {
+      xytara_keeps: [
+        "capability_refs_needed_for_wallet_authority_pricing_and_consequence",
+        "runtime_settlement_and_economics_binding_truth"
+      ],
+      xoonya_may_become_source_of_truth_for: [
+        "capability_identity",
+        "capability_owner_identity",
+        "capability_execution_coordination_semantics",
+        "capability_registry_publication_and_discovery"
+      ],
+      migration_preconditions: [
+        "role_transition_direction_is_explicit",
+        "registry_home_split_is_machine_readable",
+        "xytara_can_continue_to_resolve_stable_capability_refs_after_transition"
+      ]
+    },
+    current_transition_alignment: {
+      role_transition_state: roleTransition.long_term_direction.current_transition_state,
+      target_role: roleTransition.long_term_direction.target_role,
+      alignment_state: "registry_direction_matches_role_transition"
+    },
+    recommended_registry_home_motion: "keep_runtime_registry_in_xytara_while_recording_xoonya_as_target_canonical_home",
+    linked_surfaces: {
+      role_transition_ref: "/v1/role-transition",
+      role_transition_summary_ref: "/v1/role-transition/summary"
+    }
+  };
+}
+
+function summarizeCapabilityRegistryHomePack() {
+  const pack = buildCapabilityRegistryHomePack();
+  return {
+    ok: true,
+    product: pack.product,
+    category: pack.category,
+    package_version: pack.package_version,
+    current_owner: pack.current_registry_home.current_owner,
+    target_owner: pack.target_registry_home.target_owner,
+    target_state: pack.target_registry_home.target_state,
+    recommended_registry_home_motion: pack.recommended_registry_home_motion
+  };
+}
+
+module.exports = {
+  buildRoleFreezePack,
+  summarizeRoleFreezePack,
+  buildRoleFreezeOperatorBundle,
+  summarizeRoleFreezeOperatorBundle,
+  buildRoleFreezePolicyPack,
+  summarizeRoleFreezePolicyPack,
+  buildRoleFreezePolicyApplicationSummary,
+  buildRoleFreezePackage,
+  summarizeRoleFreezePackage,
+  buildRoleTransitionPack,
+  summarizeRoleTransitionPack,
+  buildCapabilityRegistryHomePack,
+  summarizeCapabilityRegistryHomePack
+};

package/lib/trust_intelligence.js

@@ -0,0 +1,106 @@
+"use strict";
+
+const packageJson = require("../package.json");
+const proofSdk = require("../proof_sdk");
+
+function classifyProofReadinessState(proofCenterSummary, proofLoopSummary, resultPackageHandoffSummary) {
+  if (
+    proofCenterSummary.helper_count >= 5
+    && proofLoopSummary.loop_count >= 2
+    && resultPackageHandoffSummary.source_ref_count >= 3
+  ) {
+    return "strong";
+  }
+  if (proofCenterSummary.helper_count >= 3 && proofLoopSummary.loop_count >= 1) {
+    return "working";
+  }
+  return "early";
+}
+
+function classifyBridgeConfidenceState(bridgeSummary) {
+  if (bridgeSummary.capability_count >= 8 && bridgeSummary.profile_count >= 3) return "strong";
+  if (bridgeSummary.capability_count >= 4 && bridgeSummary.profile_count >= 2) return "working";
+  return "early";
+}
+
+function classifyGovernanceBurdenState(governanceSummary) {
+  if (governanceSummary.capability_count >= 10) return "active_review_ready";
+  if (governanceSummary.capability_count >= 6) return "moderate";
+  return "light";
+}
+
+function buildTrustIntelligencePack() {
+  const proofCenterSummary = proofSdk.summarizeDefaultProofCenter();
+  const proofLoopSummary = proofSdk.summarizeDefaultProofLoops();
+  const resultPackageHandoffSummary = proofSdk.summarizeInteractionResultPackageHandoffCenter();
+  const bridgeSummary = proofSdk.summarizeBridgeCenter();
+  const governanceSummary = proofSdk.summarizeGovernanceCenter();
+
+  const proofReadinessState = classifyProofReadinessState(
+    proofCenterSummary,
+    proofLoopSummary,
+    resultPackageHandoffSummary
+  );
+  const bridgeConfidenceState = classifyBridgeConfidenceState(bridgeSummary);
+  const governanceBurdenState = classifyGovernanceBurdenState(governanceSummary);
+
+  let nextBestAction = "continue_reviewable_proof_posture";
+  if (proofReadinessState !== "strong") {
+    nextBestAction = "strengthen_proof_loop_entry";
+  } else if (bridgeConfidenceState !== "strong") {
+    nextBestAction = "strengthen_bridge_profile_posture";
+  } else if (governanceBurdenState === "active_review_ready") {
+    nextBestAction = "promote_governance_review_path";
+  }
+
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "proof-trust-intelligence-pack",
+    proof_readiness_state: proofReadinessState,
+    bridge_confidence_state: bridgeConfidenceState,
+    governance_burden_state: governanceBurdenState,
+    recommended_review_motion: "lead_with_result_package_handoff_review",
+    next_best_action: nextBestAction,
+    explanation_signals: {
+      proof_helper_count: proofCenterSummary.helper_count,
+      proof_route_count: proofCenterSummary.route_count,
+      proof_loop_count: proofLoopSummary.loop_count,
+      result_package_source_ref_count: resultPackageHandoffSummary.source_ref_count,
+      bridge_capability_count: bridgeSummary.capability_count,
+      bridge_profile_count: bridgeSummary.profile_count,
+      governance_capability_count: governanceSummary.capability_count
+    },
+    linked_surfaces: {
+      proof_center_summary_ref: "/v1/proof-center/summary",
+      proof_loops_summary_ref: "/v1/proof-center/default-loops/summary",
+      result_package_handoff_summary_ref: "/v1/proof-center/result-package-handoff/summary",
+      bridge_summary_ref: "/v1/proof-center/bridge/summary",
+      governance_summary_ref: "/v1/proof-center/governance/summary"
+    },
+    generated_from: {
+      proof_bundle_version: proofCenterSummary.proof_bundle_version,
+      bridge_center_ref: bridgeSummary.center_ref,
+      governance_center_ref: governanceSummary.center_ref
+    }
+  };
+}
+
+function summarizeTrustIntelligencePack() {
+  const pack = buildTrustIntelligencePack();
+  return {
+    ok: true,
+    product: pack.product,
+    category: pack.category,
+    proof_readiness_state: pack.proof_readiness_state,
+    bridge_confidence_state: pack.bridge_confidence_state,
+    governance_burden_state: pack.governance_burden_state,
+    next_best_action: pack.next_best_action,
+    signal_count: Object.keys(pack.explanation_signals).length
+  };
+}
+
+module.exports = {
+  buildTrustIntelligencePack,
+  summarizeTrustIntelligencePack
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xoonya",
-  "version": "2.2.0",
+  "version": "2.4.0",
   "description": "Deterministic proof SDK for canonical events, receipts, proof bundles, and verification.",
   "main": "index.js",
   "bin": {

package/server.js

@@ -59,6 +59,37 @@ const {
   buildAnnouncementPack,
   summarizeAnnouncementPack
 } = require('./lib/announcement_pack');
+const {
+  buildTrustIntelligencePack,
+  summarizeTrustIntelligencePack
+} = require('./lib/trust_intelligence');
+const {
+  buildReviewIntelligencePack,
+  summarizeReviewIntelligencePack
+} = require('./lib/review_intelligence');
+const {
+  buildGovernanceIntelligencePack,
+  summarizeGovernanceIntelligencePack
+} = require('./lib/governance_intelligence');
+const {
+  buildBridgeIntelligencePack,
+  summarizeBridgeIntelligencePack
+} = require('./lib/bridge_intelligence');
+const {
+  buildRoleFreezePack,
+  summarizeRoleFreezePack,
+  buildRoleFreezeOperatorBundle,
+  summarizeRoleFreezeOperatorBundle,
+  buildRoleFreezePolicyPack,
+  summarizeRoleFreezePolicyPack,
+  buildRoleFreezePolicyApplicationSummary,
+  buildRoleFreezePackage,
+  summarizeRoleFreezePackage,
+  buildRoleTransitionPack,
+  summarizeRoleTransitionPack,
+  buildCapabilityRegistryHomePack,
+  summarizeCapabilityRegistryHomePack
+} = require('./lib/role_freeze');
 const {
   buildReleaseCandidatePack,
   summarizeReleaseCandidatePack
@@ -1929,6 +1960,111 @@ async function routeRequest(req, res) {
     return;
   }
 
+  if (req.method === 'GET' && url.pathname === '/v1/trust-intelligence') {
+    sendJson(res, 200, buildTrustIntelligencePack());
+    return;
+  }
+
+  if (req.method === 'GET' && url.pathname === '/v1/trust-intelligence/summary') {
+    sendJson(res, 200, summarizeTrustIntelligencePack());
+    return;
+  }
+
+  if (req.method === 'GET' && url.pathname === '/v1/review-intelligence') {
+    sendJson(res, 200, buildReviewIntelligencePack());
+    return;
+  }
+
+  if (req.method === 'GET' && url.pathname === '/v1/review-intelligence/summary') {
+    sendJson(res, 200, summarizeReviewIntelligencePack());
+    return;
+  }
+
+  if (req.method === 'GET' && url.pathname === '/v1/governance-intelligence') {
+    sendJson(res, 200, buildGovernanceIntelligencePack());
+    return;
+  }
+
+  if (req.method === 'GET' && url.pathname === '/v1/governance-intelligence/summary') {
+    sendJson(res, 200, summarizeGovernanceIntelligencePack());
+    return;
+  }
+
+  if (req.method === 'GET' && url.pathname === '/v1/bridge-intelligence') {
+    sendJson(res, 200, buildBridgeIntelligencePack());
+    return;
+  }
+
+  if (req.method === 'GET' && url.pathname === '/v1/bridge-intelligence/summary') {
+    sendJson(res, 200, summarizeBridgeIntelligencePack());
+    return;
+  }
+
+  if (req.method === 'GET' && url.pathname === '/v1/role-freeze') {
+    sendJson(res, 200, buildRoleFreezePack());
+    return;
+  }
+
+  if (req.method === 'GET' && url.pathname === '/v1/role-freeze/summary') {
+    sendJson(res, 200, summarizeRoleFreezePack());
+    return;
+  }
+
+  if (req.method === 'GET' && url.pathname === '/v1/role-freeze/operator-bundle') {
+    sendJson(res, 200, buildRoleFreezeOperatorBundle());
+    return;
+  }
+
+  if (req.method === 'GET' && url.pathname === '/v1/role-freeze/operator-bundle/summary') {
+    sendJson(res, 200, summarizeRoleFreezeOperatorBundle());
+    return;
+  }
+
+  if (req.method === 'GET' && url.pathname === '/v1/role-freeze/policy-pack') {
+    sendJson(res, 200, buildRoleFreezePolicyPack());
+    return;
+  }
+
+  if (req.method === 'GET' && url.pathname === '/v1/role-freeze/policy-pack/summary') {
+    sendJson(res, 200, summarizeRoleFreezePolicyPack());
+    return;
+  }
+
+  if (req.method === 'GET' && url.pathname === '/v1/role-freeze/policy-application-summary') {
+    sendJson(res, 200, buildRoleFreezePolicyApplicationSummary(url.searchParams.get('template_id')));
+    return;
+  }
+
+  if (req.method === 'GET' && url.pathname === '/v1/role-freeze/package') {
+    sendJson(res, 200, buildRoleFreezePackage());
+    return;
+  }
+
+  if (req.method === 'GET' && url.pathname === '/v1/role-freeze/package/summary') {
+    sendJson(res, 200, summarizeRoleFreezePackage());
+    return;
+  }
+
+  if (req.method === 'GET' && url.pathname === '/v1/role-transition') {
+    sendJson(res, 200, buildRoleTransitionPack());
+    return;
+  }
+
+  if (req.method === 'GET' && url.pathname === '/v1/role-transition/summary') {
+    sendJson(res, 200, summarizeRoleTransitionPack());
+    return;
+  }
+
+  if (req.method === 'GET' && url.pathname === '/v1/capability-registry-home') {
+    sendJson(res, 200, buildCapabilityRegistryHomePack());
+    return;
+  }
+
+  if (req.method === 'GET' && url.pathname === '/v1/capability-registry-home/summary') {
+    sendJson(res, 200, summarizeCapabilityRegistryHomePack());
+    return;
+  }
+
   if (req.method === 'GET' && url.pathname === '/v1/proof-center') {
     sendJson(res, 200, proofSdk.buildDefaultProofCenter());
     return;
@@ -2570,6 +2706,215 @@ async function routeRequest(req, res) {
     return;
   }
 
+  if (req.method === 'POST' && url.pathname === '/v1/review-intelligence') {
+    try {
+      const body = await readJsonBody(req);
+      const result = buildReviewIntelligencePack(body);
+      sendJson(res, 200, result);
+    } catch (error) {
+      sendJson(res, 400, { ok: false, reason: error.message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && url.pathname === '/v1/review-intelligence/summary') {
+    try {
+      const body = await readJsonBody(req);
+      const result = summarizeReviewIntelligencePack(body);
+      sendJson(res, 200, result);
+    } catch (error) {
+      sendJson(res, 400, { ok: false, reason: error.message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && url.pathname === '/v1/governance-intelligence') {
+    try {
+      const body = await readJsonBody(req);
+      const result = buildGovernanceIntelligencePack(body);
+      sendJson(res, 200, result);
+    } catch (error) {
+      sendJson(res, 400, { ok: false, reason: error.message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && url.pathname === '/v1/governance-intelligence/summary') {
+    try {
+      const body = await readJsonBody(req);
+      const result = summarizeGovernanceIntelligencePack(body);
+      sendJson(res, 200, result);
+    } catch (error) {
+      sendJson(res, 400, { ok: false, reason: error.message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && url.pathname === '/v1/bridge-intelligence') {
+    try {
+      const body = await readJsonBody(req);
+      const result = buildBridgeIntelligencePack(body);
+      sendJson(res, 200, result);
+    } catch (error) {
+      sendJson(res, 400, { ok: false, reason: error.message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && url.pathname === '/v1/bridge-intelligence/summary') {
+    try {
+      const body = await readJsonBody(req);
+      const result = summarizeBridgeIntelligencePack(body);
+      sendJson(res, 200, result);
+    } catch (error) {
+      sendJson(res, 400, { ok: false, reason: error.message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && url.pathname === '/v1/role-freeze') {
+    try {
+      await readJsonBody(req);
+      const result = buildRoleFreezePack();
+      sendJson(res, 200, result);
+    } catch (error) {
+      sendJson(res, 400, { ok: false, reason: error.message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && url.pathname === '/v1/role-freeze/summary') {
+    try {
+      await readJsonBody(req);
+      const result = summarizeRoleFreezePack();
+      sendJson(res, 200, result);
+    } catch (error) {
+      sendJson(res, 400, { ok: false, reason: error.message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && url.pathname === '/v1/role-freeze/operator-bundle') {
+    try {
+      await readJsonBody(req);
+      const result = buildRoleFreezeOperatorBundle();
+      sendJson(res, 200, result);
+    } catch (error) {
+      sendJson(res, 400, { ok: false, reason: error.message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && url.pathname === '/v1/role-freeze/operator-bundle/summary') {
+    try {
+      await readJsonBody(req);
+      const result = summarizeRoleFreezeOperatorBundle();
+      sendJson(res, 200, result);
+    } catch (error) {
+      sendJson(res, 400, { ok: false, reason: error.message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && url.pathname === '/v1/role-freeze/policy-pack') {
+    try {
+      await readJsonBody(req);
+      const result = buildRoleFreezePolicyPack();
+      sendJson(res, 200, result);
+    } catch (error) {
+      sendJson(res, 400, { ok: false, reason: error.message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && url.pathname === '/v1/role-freeze/policy-pack/summary') {
+    try {
+      await readJsonBody(req);
+      const result = summarizeRoleFreezePolicyPack();
+      sendJson(res, 200, result);
+    } catch (error) {
+      sendJson(res, 400, { ok: false, reason: error.message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && url.pathname === '/v1/role-freeze/policy-application-summary') {
+    try {
+      const body = await readJsonBody(req);
+      const result = buildRoleFreezePolicyApplicationSummary(body && body.template_id ? body.template_id : null);
+      sendJson(res, 200, result);
+    } catch (error) {
+      sendJson(res, 400, { ok: false, reason: error.message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && url.pathname === '/v1/role-freeze/package') {
+    try {
+      await readJsonBody(req);
+      const result = buildRoleFreezePackage();
+      sendJson(res, 200, result);
+    } catch (error) {
+      sendJson(res, 400, { ok: false, reason: error.message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && url.pathname === '/v1/role-freeze/package/summary') {
+    try {
+      await readJsonBody(req);
+      const result = summarizeRoleFreezePackage();
+      sendJson(res, 200, result);
+    } catch (error) {
+      sendJson(res, 400, { ok: false, reason: error.message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && url.pathname === '/v1/role-transition') {
+    try {
+      await readJsonBody(req);
+      const result = buildRoleTransitionPack();
+      sendJson(res, 200, result);
+    } catch (error) {
+      sendJson(res, 400, { ok: false, reason: error.message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && url.pathname === '/v1/role-transition/summary') {
+    try {
+      await readJsonBody(req);
+      const result = summarizeRoleTransitionPack();
+      sendJson(res, 200, result);
+    } catch (error) {
+      sendJson(res, 400, { ok: false, reason: error.message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && url.pathname === '/v1/capability-registry-home') {
+    try {
+      await readJsonBody(req);
+      const result = buildCapabilityRegistryHomePack();
+      sendJson(res, 200, result);
+    } catch (error) {
+      sendJson(res, 400, { ok: false, reason: error.message });
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && url.pathname === '/v1/capability-registry-home/summary') {
+    try {
+      await readJsonBody(req);
+      const result = summarizeCapabilityRegistryHomePack();
+      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);