xoonya 2.3.0 → 2.5.0

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/shared_signals_lane_contract.js

@@ -0,0 +1,54 @@
+"use strict";
+
+function buildSharedSignalsLanePack() {
+  return {
+    product: "xoonya",
+    category: "proof-shared-signals-lane-pack",
+    pack_version: "xoonya-shared-signals-lane-pack-v1",
+    lane_state: "first_party_shared_signals_lane_present",
+    posture: "real_time_review_and_risk_signal_exchange_lane",
+    standards: ["openid_shared_signals", "caep"],
+    signal_families: ["review_events", "governance_events", "bridge_attention_events", "external_import_attention_events"],
+    supported_surfaces: {
+      auth_profiles_ref: "/v1/auth-profiles",
+      identity_interop_ref: "/v1/identity-interop",
+      proof_bridge_ref: "/v1/proof-bridge",
+      result_package_trust_ref: "/v1/result-package-trust",
+      external_proof_import_ref: "/v1/external-proof-import"
+    },
+    first_run_flows: [
+      {
+        flow_ref: "proof_risk_signal_alignment",
+        recommended_reason: "best path when partner systems need near-real-time signals about review, bridge, or imported-proof trust changes",
+        sequence: [
+          "inspect_shared_signals_lane_summary",
+          "map native proof review and bridge states to shared signal posture",
+          "connect trust attention and import attention states to external signal exchange",
+          "keep proof acceptance and governance decisions canonical inside xoonya"
+        ]
+      }
+    ],
+    guardrails: [
+      "shared signals should export proof-side state changes, not replace review or governance logic",
+      "signal exchange must remain bounded and reviewable"
+    ]
+  };
+}
+
+function summarizeSharedSignalsLanePack() {
+  const pack = buildSharedSignalsLanePack();
+  return {
+    product: "xoonya",
+    category: "proof-shared-signals-lane-pack-summary",
+    summary_version: "xoonya-shared-signals-lane-pack-summary-v1",
+    lane_state: pack.lane_state,
+    standard_count: pack.standards.length,
+    signal_family_count: pack.signal_families.length,
+    linked_surfaces: pack.supported_surfaces
+  };
+}
+
+module.exports = {
+  buildSharedSignalsLanePack,
+  summarizeSharedSignalsLanePack
+};

package/lib/telemetry_lane_contract.js

@@ -0,0 +1,54 @@
+"use strict";
+
+function buildTelemetryLanePack() {
+  return {
+    product: "xoonya",
+    category: "proof-telemetry-lane-pack",
+    pack_version: "xoonya-telemetry-lane-pack-v1",
+    lane_state: "first_party_observability_lane_present",
+    posture: "proof_followthrough_observability_and_scale_signal_lane",
+    standards: ["opentelemetry"],
+    core_signals: ["review_traces", "verification_metrics", "bridge_logs", "proof_events"],
+    supported_surfaces: {
+      cloudevents_ref: "/cloudevents.json",
+      asyncapi_ref: "/asyncapi.json",
+      proof_bridge_ref: "/v1/proof-bridge",
+      result_package_trust_ref: "/v1/result-package-trust",
+      integration_matrix_ref: "/v1/integration-matrix"
+    },
+    first_run_flows: [
+      {
+        flow_ref: "proof_observability_alignment",
+        recommended_reason: "best path for operators who need review, verification, and bridge visibility at production scale",
+        sequence: [
+          "inspect_telemetry_lane_summary",
+          "align proof events to cloudevents and asyncapi",
+          "map review and verification signals to observability tooling",
+          "keep proof validation canonical while exporting useful operational signals"
+        ]
+      }
+    ],
+    guardrails: [
+      "telemetry should improve proof-side observability without redefining proof validity",
+      "review and verification diagnostics should remain subordinate to canonical proof semantics"
+    ]
+  };
+}
+
+function summarizeTelemetryLanePack() {
+  const pack = buildTelemetryLanePack();
+  return {
+    product: "xoonya",
+    category: "proof-telemetry-lane-pack-summary",
+    summary_version: "xoonya-telemetry-lane-pack-summary-v1",
+    lane_state: pack.lane_state,
+    standard_count: pack.standards.length,
+    signal_count: pack.core_signals.length,
+    linked_surfaces: pack.supported_surfaces
+  };
+}
+
+module.exports = {
+  buildTelemetryLanePack,
+  summarizeTelemetryLanePack
+};

package/lib/treasury_proof_lane_contract.js

@@ -0,0 +1,83 @@
+"use strict";
+
+const {
+  buildPhase9TreasuryConnectivityPack,
+  summarizePhase9TreasuryConnectivityPack
+} = require("./phase_9_treasury_connectivity_pack");
+const {
+  buildProofBridgeLanePack,
+  summarizeProofBridgeLanePack
+} = require("./proof_bridge_lane_contract");
+
+function buildTreasuryProofLanePack() {
+  return {
+    product: "xoonya",
+    category: "proof-treasury-lane-pack",
+    pack_version: "xoonya-treasury-lane-pack-v1",
+    lane_state: "first_party_treasury_proof_connectivity_present",
+    posture: "treasury_destination_and_accounting_evidence_followthrough_lane",
+    phase_alignment: {
+      connectivity: {
+        pack: buildPhase9TreasuryConnectivityPack(),
+        summary: summarizePhase9TreasuryConnectivityPack()
+      },
+      proof_bridge: {
+        pack: buildProofBridgeLanePack(),
+        summary: summarizeProofBridgeLanePack()
+      }
+    },
+    reserve_doctrine: {
+      strategic_native_treasury: "bsv_teranode",
+      stable_operating_reserves: ["dai", "usdc"],
+      optional_hidden_privacy_reserve: "monero",
+      privacy_guardrails: [
+        "monero_never_becomes_public_treasury_identity",
+        "monero_never_replaces_compliant_accounting_evidence",
+        "monero_only_exists_as_internal_optional_reserve_technique_where_operator_policy_explicitly_allows_it"
+      ]
+    },
+    supported_surfaces: {
+      phase_summary_ref: "/v1/phases/phase-9/summary",
+      treasury_destinations_proof_summary_ref: "/v1/phases/phase-9/treasury-destinations/proof/summary",
+      custody_refs_proof_summary_ref: "/v1/phases/phase-9/custody-refs/proof/summary",
+      operator_accounting_bridges_proof_summary_ref: "/v1/phases/phase-9/operator-accounting-bridges/proof/summary",
+      treasury_continuity_summary_ref: "/v1/phases/phase-9/treasury-continuity/summary",
+      proof_bridge_ref: "/v1/proof-bridge/summary"
+    },
+    first_run_flows: [
+      {
+        flow_ref: "treasury_proof_continuity",
+        recommended_reason: "best first path for understanding how treasury destinations, custody refs, and accounting bridges stay provable and reviewable",
+        sequence: [
+          "inspect_treasury_proof_lane_summary",
+          "inspect_phase_9_connectivity_summary",
+          "inspect_treasury_destination_and_accounting_bridge_proof_summaries",
+          "inspect_proof_bridge_followthrough_for_bounded_review_posture"
+        ]
+      }
+    ],
+    guardrails: [
+      "treasury proof lanes should strengthen operator trust without turning xoonya into treasury logic",
+      "reserve doctrine remains internal while proof continuity remains externally reviewable"
+    ]
+  };
+}
+
+function summarizeTreasuryProofLanePack() {
+  const pack = buildTreasuryProofLanePack();
+  return {
+    product: "xoonya",
+    category: "proof-treasury-lane-pack-summary",
+    summary_version: "xoonya-treasury-lane-pack-summary-v1",
+    lane_state: pack.lane_state,
+    strategic_native_treasury: pack.reserve_doctrine.strategic_native_treasury,
+    stable_reserve_count: pack.reserve_doctrine.stable_operating_reserves.length,
+    first_run_flow_count: pack.first_run_flows.length,
+    linked_surfaces: pack.supported_surfaces
+  };
+}
+
+module.exports = {
+  buildTreasuryProofLanePack,
+  summarizeTreasuryProofLanePack
+};

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "xoonya",
-  "version": "2.3.0",
+  "version": "2.5.0",
   "description": "Deterministic proof SDK for canonical events, receipts, proof bundles, and verification.",
   "main": "index.js",
   "bin": {
-    "xoonya-review": "./bin/xoonya-review.js",
-    "xoonya-release": "./bin/xoonya-release.js"
+    "xoonya": "bin/xoonya.js",
+    "xoonya-review": "bin/xoonya-review.js",
+    "xoonya-release": "bin/xoonya-release.js"
   },
   "type": "commonjs",
   "license": "Apache-2.0",