xytara 2.7.0 → 2.9.0

package/lib/pricing_optimization_contract.js

@@ -11,6 +11,27 @@ const PRICING_BAND_UNITS = {
   trust_critical: 8
 };
 
+const PRICING_EXPERIMENT_REJECTION_CODES = [
+  "pricing_sample_too_sparse",
+  "experiment_not_registered",
+  "experiment_not_allowed_now",
+  "operator_approval_missing",
+  "baseline_metrics_missing",
+  "rollback_trigger_thresholds_missing",
+  "public_checkout_copy_review_missing",
+  "post_experiment_review_window_missing",
+  "target_surface_mismatch"
+];
+
+const PRICING_EXPERIMENT_LAUNCH_REQUIREMENTS = [
+  "operator_approval_recorded",
+  "sample_maturity_is_mature_live_signals",
+  "baseline_metrics_recorded_before_change",
+  "rollback_trigger_thresholds_recorded",
+  "public_checkout_copy_reviewed_for_accuracy",
+  "post_experiment_review_window_defined"
+];
+
 function normalizeAmount(value) {
   const amount = Number(value || 0);
   return Number.isFinite(amount) ? amount : 0;
@@ -466,6 +487,195 @@ function buildOptimizationRecommendations(state) {
   };
 }
 
+function buildPricingExperimentPlan(state) {
+  const revenueSignals = buildRevenueSignalSummary(state);
+  const decisionGuardrail = buildPricingDecisionGuardrail(state);
+  const quoteCohorts = buildQuoteCohorts(state);
+  const sampleMaturity = revenueSignals.sample_maturity;
+  const experimentReady = decisionGuardrail.allow_price_change;
+  const candidateExperiments = [
+    {
+      experiment_id: "starter_api_pack_entry_price_test",
+      target_surface: "hosted_checkout_starter_api_pack",
+      hypothesis: "starter_entry_conversion_can_improve_without_degrading_refund_or_grant_success_rates",
+      required_segments: [
+        "first_purchase",
+        "hosted_checkout",
+        "starter_api_pack"
+      ],
+      primary_metrics: [
+        "checkout_paid_rate",
+        "external_credit_grant_success_rate",
+        "execution_completion_rate"
+      ],
+      rollback_triggers: [
+        "refund_or_chargeback_rate_increases",
+        "grant_failure_rate_increases",
+        "execution_completion_rate_decreases"
+      ],
+      allowed_now: experimentReady
+    },
+    {
+      experiment_id: "utility_minimum_floor_test",
+      target_surface: "utility_pricing_band_minimum_charge_floor",
+      hypothesis: "utility_quote_abandonment_can_be_reduced_without_training_users_to_expect_free_execution",
+      required_segments: [
+        "pricing_band.utility",
+        "quote_created",
+        "quote_accepted_or_expired"
+      ],
+      primary_metrics: [
+        "quote_conversion_rate",
+        "quote_abandonment_rate",
+        "revenue_capture_rate"
+      ],
+      rollback_triggers: [
+        "revenue_capture_rate_decreases",
+        "support_or_refund_signal_increases",
+        "paid_execution_quality_decreases"
+      ],
+      allowed_now: experimentReady
+    },
+    {
+      experiment_id: "trust_critical_premium_review",
+      target_surface: "trust_critical_premium_multiplier",
+      hypothesis: "high_consequence_work_may_support_higher_margin_when_conversion_is_already_strong",
+      required_segments: [
+        "pricing_band.trust_critical",
+        "converted_quotes",
+        "completed_transactions"
+      ],
+      primary_metrics: [
+        "trust_critical_conversion_rate",
+        "completed_paid_execution_count",
+        "refund_or_dispute_rate"
+      ],
+      rollback_triggers: [
+        "trust_critical_conversion_rate_decreases",
+        "refund_or_dispute_rate_increases",
+        "operator_quality_review_fails"
+      ],
+      allowed_now: experimentReady
+    }
+  ];
+  return {
+    experiment_plan_version: "xytara-pricing-experiment-plan-v1",
+    sample_maturity: sampleMaturity,
+    experiment_state: experimentReady ? "operator_reviewed_experiments_allowed" : "blocked_collect_more_live_data",
+    allow_experiment_launch: experimentReady,
+    required_minimum_live_sample: {
+      quote_count: 100,
+      payment_ledger_count: 20,
+      execution_transaction_count: 20,
+      refund_monitoring_required: true
+    },
+    current_evidence: {
+      counts: revenueSignals.counts,
+      rates: revenueSignals.rates,
+      pricing_band_cohorts: quoteCohorts.by_pricing_band
+    },
+    candidate_experiments: candidateExperiments,
+    launch_requirements: PRICING_EXPERIMENT_LAUNCH_REQUIREMENTS.slice(),
+    deterministic_rejection_codes: PRICING_EXPERIMENT_REJECTION_CODES.slice(),
+    launch_request_template: {
+      experiment_id: "starter_api_pack_entry_price_test",
+      target_surface: "hosted_checkout_starter_api_pack",
+      operator_approval_ref: "ops.pricing.approval.<date>",
+      baseline_metrics_ref: "ops.pricing.baseline.<date>",
+      rollback_trigger_thresholds: {
+        refund_or_chargeback_rate_increases: "operator_defined_threshold",
+        grant_failure_rate_increases: "operator_defined_threshold",
+        execution_completion_rate_decreases: "operator_defined_threshold"
+      },
+      public_checkout_copy_review_ref: "ops.pricing.copy_review.<date>",
+      post_experiment_review_window_days: 14
+    },
+    blocked_actions: experimentReady
+      ? []
+      : [
+          "start_price_ab_test_from_sparse_signals",
+          "change_public_package_prices_without_operator_approval",
+          "change_minimum_floors_without_baseline_metrics",
+          "change_auto_topup_thresholds_without_repeat_usage_data"
+        ],
+    allowed_actions: experimentReady
+      ? [
+          "prepare_small_operator_reviewed_price_experiment",
+          "record_baseline_and_rollback_thresholds",
+          "run_one_surface_at_a_time"
+        ]
+      : [
+          "collect_more_live_quote_payment_execution_and_refund_data",
+          "review_cohort_instrumentation",
+          "keep_current_public_prices_and_thresholds"
+        ],
+    boundary: "pricing_experiments_are_operator_reviewed_and_data_gated_not_automatic_price_changes"
+  };
+}
+
+function validatePricingExperimentLaunchRequest(plan, request) {
+  const pricingPlan = plan || {};
+  const launchRequest = request || {};
+  const candidates = Array.isArray(pricingPlan.candidate_experiments)
+    ? pricingPlan.candidate_experiments
+    : [];
+  const experimentId = launchRequest.experiment_id ? String(launchRequest.experiment_id) : "";
+  const candidate = candidates.find((entry) => entry && entry.experiment_id === experimentId) || null;
+  const rollbackThresholds = launchRequest.rollback_trigger_thresholds || {};
+  const missingRollbackThreshold = candidate
+    ? (Array.isArray(candidate.rollback_triggers) ? candidate.rollback_triggers : [])
+        .some((trigger) => !rollbackThresholds || !rollbackThresholds[trigger])
+    : true;
+  const reviewWindowDays = Number(launchRequest.post_experiment_review_window_days || 0);
+  const rejectionCodes = [];
+
+  if (pricingPlan.allow_experiment_launch !== true || pricingPlan.sample_maturity !== "mature_live_signals") {
+    rejectionCodes.push("pricing_sample_too_sparse");
+  }
+  if (!candidate) {
+    rejectionCodes.push("experiment_not_registered");
+  } else {
+    if (candidate.allowed_now !== true) rejectionCodes.push("experiment_not_allowed_now");
+    if (launchRequest.target_surface && launchRequest.target_surface !== candidate.target_surface) {
+      rejectionCodes.push("target_surface_mismatch");
+    }
+  }
+  if (!launchRequest.operator_approval_ref) rejectionCodes.push("operator_approval_missing");
+  if (!launchRequest.baseline_metrics_ref) rejectionCodes.push("baseline_metrics_missing");
+  if (missingRollbackThreshold) rejectionCodes.push("rollback_trigger_thresholds_missing");
+  if (!launchRequest.public_checkout_copy_review_ref) rejectionCodes.push("public_checkout_copy_review_missing");
+  if (!Number.isFinite(reviewWindowDays) || reviewWindowDays < 1) {
+    rejectionCodes.push("post_experiment_review_window_missing");
+  }
+
+  return {
+    validation_version: "xytara-pricing-experiment-launch-validation-v1",
+    launch_allowed: rejectionCodes.length === 0,
+    experiment_id: experimentId || null,
+    sample_maturity: pricingPlan.sample_maturity || null,
+    rejection_codes: Array.from(new Set(rejectionCodes)),
+    required_requirements: PRICING_EXPERIMENT_LAUNCH_REQUIREMENTS.slice(),
+    boundary: "pricing_launch_validation_requires_mature_samples_operator_approval_baseline_metrics_and_rollback_thresholds"
+  };
+}
+
+function summarizePricingExperimentPlan(state) {
+  const plan = buildPricingExperimentPlan(state);
+  return {
+    product: "xytara",
+    category: "machine-commerce-pricing-experiment-plan-summary",
+    summary_version: "xytara-pricing-experiment-plan-summary-v1",
+    sample_maturity: plan.sample_maturity,
+    experiment_state: plan.experiment_state,
+    allow_experiment_launch: plan.allow_experiment_launch,
+    candidate_experiment_count: plan.candidate_experiments.length,
+    blocked_action_count: plan.blocked_actions.length,
+    launch_requirement_count: plan.launch_requirements.length,
+    deterministic_rejection_code_count: plan.deterministic_rejection_codes.length,
+    boundary: plan.boundary
+  };
+}
+
 function buildPricingOptimizationPack(state) {
   const minimumChargeFloors = buildMinimumChargeFloors();
   const starterPricing = buildStarterPricing();
@@ -476,6 +686,7 @@ function buildPricingOptimizationPack(state) {
   const revenueSignalSummary = buildRevenueSignalSummary(state);
   const pricingDecisionGuardrail = buildPricingDecisionGuardrail(state);
   const packageThresholdRationale = buildPackageThresholdRationale(state);
+  const pricingExperimentPlan = buildPricingExperimentPlan(state);
   return {
     product: "xytara",
     category: "machine-commerce-pricing-optimization-pack",
@@ -501,6 +712,7 @@ function buildPricingOptimizationPack(state) {
     revenue_signal_summary: revenueSignalSummary,
     pricing_decision_guardrail: pricingDecisionGuardrail,
     package_threshold_rationale: packageThresholdRationale,
+    pricing_experiment_plan: pricingExperimentPlan,
     optimization_recommendations: recommendations,
     data_dependent_tuning: [
       "conversion_test_starter_pack_pricing",
@@ -516,7 +728,9 @@ function buildPricingOptimizationPack(state) {
       quote_cohorts_ref: "/v1/pricing-optimization/quote-cohorts",
       recommendations_ref: "/v1/pricing-optimization/recommendations",
       revenue_signal_summary_ref: "/v1/pricing-optimization/revenue-signal-summary",
-      decision_guardrail_ref: "/v1/pricing-optimization/decision-guardrail"
+      decision_guardrail_ref: "/v1/pricing-optimization/decision-guardrail",
+      experiment_plan_ref: "/v1/pricing-optimization/experiment-plan",
+      experiment_plan_summary_ref: "/v1/pricing-optimization/experiment-plan/summary"
     }
   };
 }
@@ -541,6 +755,8 @@ function summarizePricingOptimizationPack(state) {
     refund_count: pack.revenue_signal_summary.counts.refund_count,
     execution_transaction_count: pack.revenue_signal_summary.counts.execution_transaction_count,
     recommendation_count: pack.optimization_recommendations.recommendations.length,
+    candidate_experiment_count: pack.pricing_experiment_plan.candidate_experiments.length,
+    allow_experiment_launch: pack.pricing_experiment_plan.allow_experiment_launch,
     linked_surfaces: pack.supported_surfaces
   };
 }
@@ -552,5 +768,8 @@ module.exports = {
   buildQuoteCohorts,
   buildRevenueSignalSummary,
   buildPricingDecisionGuardrail,
-  buildOptimizationRecommendations
+  buildOptimizationRecommendations,
+  buildPricingExperimentPlan,
+  summarizePricingExperimentPlan,
+  validatePricingExperimentLaunchRequest
 };

package/lib/release_history.js

@@ -10,6 +10,31 @@ function buildReleaseHistory() {
     current_version: packageJson.version,
     release_track: "public_release",
     history: [
+      {
+        version: "2.9.0",
+        channel: "public_release",
+        maturity_posture: "public_polish",
+        headline: "public-polish release with canonical Naxytra product URLs and safer quote-first runtime first contact",
+        milestone_refs: [
+          "canonical_naxytra_product_url",
+          "standalone_product_domain_guard",
+          "quote_first_public_first_contact",
+          "release_summary_secretless_first_contact"
+        ]
+      },
+      {
+        version: "2.8.0",
+        channel: "public_release",
+        maturity_posture: "release_boundary_hardened",
+        headline: "release-boundary hardening with provider promotion evidence gates, pricing experiment guardrails, treasury public-claim safety, and read-only operator observability boundaries",
+        milestone_refs: [
+          "framework_provider_promotion_evidence_gate",
+          "pricing_experiment_plan_gate",
+          "pricing_experiment_launch_gate",
+          "treasury_public_claim_boundary",
+          "operator_observability_read_only_boundary"
+        ]
+      },
       {
         version: "2.7.0",
         channel: "public_release",

package/lib/release_pack.js

@@ -172,7 +172,7 @@ function buildScenarioPack() {
           "run xytara-run for trust.verify",
           "inspect transaction, payment, and settlement records"
         ],
-        entrypoint: "xytara-run --url https://xytara.onrender.com --account acct_demo --command \"cli-run\" --task trust.verify --body-json '{\"subject_id\":\"subject-1\"}' --wallet-id merchant_wallet_main --wallet-secret YOUR_LOCAL_SIGNED_SECRET --txid YOUR_BSV_TXID",
+        entrypoint: "xytara first-run --run-quote --account ACCOUNT_REF --pretty",
         surfaces: [
           "/v1/catalog/summary",
           "/x402/commands/execute",
@@ -349,7 +349,7 @@ function buildReleasePack() {
     },
     first_contact: {
       install: "npm install xytara",
-      direct_run_cli: "xytara-run --url https://xytara.onrender.com --account acct_demo --command \"cli-run\" --task trust.verify --body-json '{\"subject_id\":\"subject-1\"}' --wallet-id merchant_wallet_main --wallet-secret YOUR_LOCAL_SIGNED_SECRET --txid YOUR_BSV_TXID",
+      direct_run_cli: "xytara first-run --run-quote --account ACCOUNT_REF --pretty",
       discovery_surface: "/v1/catalog/summary",
       transaction_center_surface: "/v1/transaction-center/summary",
       economics_surface: "/v1/transaction-center/economics/summary",

package/lib/soft_launch_pack.js

@@ -39,7 +39,7 @@ function buildSoftLaunchPack() {
       outreach_proof: "/v1/outreach-proof/summary",
       adapter_partners: "/v1/adapter-partners/summary",
       first_cli: "xytara-release --center --summary",
-      first_run_cli: "xytara-run --url https://xytara.onrender.com --account acct_demo --command \"cli-run\" --task trust.verify --body-json '{\"subject_id\":\"subject-1\"}' --wallet-id merchant_wallet_main --wallet-secret YOUR_LOCAL_SIGNED_SECRET --txid YOUR_BSV_TXID"
+      first_run_cli: "xytara first-run --run-quote --account ACCOUNT_REF --pretty"
     },
     outreach_sequence: [
       "send the short pitch and first proof path to a small builder set",

package/lib/treasury_destinations_contract.js

@@ -177,6 +177,30 @@ const RAIL_PROFILES = [
   }
 ];
 
+const TREASURY_PUBLIC_BOUNDARY_REJECTION_CODES = [
+  "public_custody_destination_leak",
+  "public_external_ref_leak",
+  "public_custody_ref_leak",
+  "public_reporting_ref_leak",
+  "public_wallet_ref_leak",
+  "public_provider_ref_leak",
+  "internal_rail_public_claimed",
+  "readiness_only_rail_public_claimed",
+  "claim_boundary_mismatch",
+  "unsupported_live_claim_rail",
+  "operator_visibility_rule_missing"
+];
+
+const SENSITIVE_PUBLIC_DESTINATION_FIELDS = [
+  "external_ref",
+  "custody_ref",
+  "reporting_ref",
+  "wallet_ref",
+  "provider_ref",
+  "merchant_address",
+  "merchant_paymail"
+];
+
 function classifyDestinationSource(profile, paymentConfig) {
   const settlementMode = profile.settlement_mode;
   const mapEntry = paymentConfig.treasury_destinations_by_settlement_mode[settlementMode];
@@ -432,6 +456,7 @@ function buildOperatorTreasuryDestinationsPack() {
       ? "claim_only_the_rails_with_real_configured_destinations_as_live_landing_paths"
       : "no_multi-rail_operational_claims_until_real_destinations_exist",
     custody_visibility_rule: "do_not_expose_real_external_refs_or_custody_refs_on_public_surfaces",
+    deterministic_rejection_codes: TREASURY_PUBLIC_BOUNDARY_REJECTION_CODES.slice(),
     config_examples: Object.fromEntries(RAIL_PROFILES.map((profile) => [profile.settlement_mode, profile.config_template]))
   };
 }
@@ -458,6 +483,7 @@ function buildTreasuryDestinationsPack() {
     operator_rule: operatorPack.operator_rule,
     claim_discipline_rule: "unsupported_or_unconfigured_rails_may_be_listed_as_architecture_but_not_as_live_landing_paths",
     privacy_rule: "public_surfaces_must_not_expose_real_treasury_landing_refs_or_custody_provider_refs",
+    deterministic_rejection_codes: TREASURY_PUBLIC_BOUNDARY_REJECTION_CODES.slice(),
     config_examples: operatorPack.config_examples
   };
 }
@@ -475,6 +501,7 @@ function summarizeTreasuryDestinationsPack() {
     readiness_only_profile_count: pack.readiness_summary.readiness_only_profile_count,
     reporting_gap_count: pack.readiness_summary.reporting_gap_count,
     internal_only_profile_count: pack.profiles.filter((entry) => entry.compliance_posture === "internal_only_policy_gated").length,
+    deterministic_rejection_code_count: pack.deterministic_rejection_codes.length,
     public_claim_boundary: pack.public_claim_boundary,
     linked_surfaces: pack.supported_surfaces
   };
@@ -493,6 +520,7 @@ function summarizeOperatorTreasuryDestinationsPack() {
     readiness_only_profile_count: pack.readiness_summary.readiness_only_profile_count,
     reporting_gap_count: pack.readiness_summary.reporting_gap_count,
     internal_only_profile_count: pack.profiles.filter((entry) => entry.compliance_posture === "internal_only_policy_gated").length,
+    deterministic_rejection_code_count: pack.deterministic_rejection_codes.length,
     public_claim_boundary: pack.public_claim_boundary,
     linked_surfaces: pack.supported_surfaces
   };
@@ -534,10 +562,80 @@ function buildTreasuryDestinationValidationPreview(input) {
   }
 }
 
+function arraysEqual(left, right) {
+  const leftSorted = (Array.isArray(left) ? left : []).slice().sort();
+  const rightSorted = (Array.isArray(right) ? right : []).slice().sort();
+  return leftSorted.length === rightSorted.length && leftSorted.every((entry, index) => entry === rightSorted[index]);
+}
+
+function validateTreasuryDestinationPublicBoundary(packInput) {
+  const pack = packInput || buildTreasuryDestinationsPack();
+  const profiles = Array.isArray(pack.profiles) ? pack.profiles : [];
+  const boundary = pack.public_claim_boundary || {};
+  const rejectionCodes = [];
+  const liveClaimableRails = profiles.filter((entry) => entry && entry.public_claim_allowed).map((entry) => entry.rail_id);
+  const internalOnlyRails = profiles
+    .filter((entry) => entry && entry.compliance_posture === "internal_only_policy_gated")
+    .map((entry) => entry.rail_id);
+  const readinessOnlyRails = profiles
+    .filter((entry) => entry && !entry.public_claim_allowed && entry.compliance_posture !== "internal_only_policy_gated")
+    .map((entry) => entry.rail_id);
+
+  for (const profile of profiles) {
+    if (!profile) continue;
+    if (profile.custody_destination != null) {
+      rejectionCodes.push("public_custody_destination_leak");
+    }
+    const visibility = profile.destination_visibility || {};
+    for (const fieldName of SENSITIVE_PUBLIC_DESTINATION_FIELDS) {
+      if (visibility[fieldName] != null) {
+        rejectionCodes.push(`public_${fieldName}_leak`);
+      }
+      if (profile[fieldName] != null) {
+        rejectionCodes.push(`public_${fieldName}_leak`);
+      }
+    }
+    if (profile.compliance_posture === "internal_only_policy_gated" && profile.public_claim_allowed === true) {
+      rejectionCodes.push("internal_rail_public_claimed");
+    }
+    if (boundary.readiness_only_rails && boundary.readiness_only_rails.includes(profile.rail_id) && profile.public_claim_allowed === true) {
+      rejectionCodes.push("readiness_only_rail_public_claimed");
+    }
+  }
+
+  const boundaryLiveRails = Array.isArray(boundary.live_claimable_rails) ? boundary.live_claimable_rails : [];
+  const boundaryReadinessRails = Array.isArray(boundary.readiness_only_rails) ? boundary.readiness_only_rails : [];
+  const boundaryInternalRails = Array.isArray(boundary.internal_only_rails) ? boundary.internal_only_rails : [];
+  if (
+    !arraysEqual(liveClaimableRails, boundaryLiveRails)
+    || !arraysEqual(readinessOnlyRails, boundaryReadinessRails)
+    || !arraysEqual(internalOnlyRails, boundaryInternalRails)
+  ) {
+    rejectionCodes.push("claim_boundary_mismatch");
+  }
+  if (boundaryLiveRails.some((railId) => !profiles.some((entry) => entry && entry.rail_id === railId && entry.public_claim_allowed === true))) {
+    rejectionCodes.push("unsupported_live_claim_rail");
+  }
+  if (pack.category === "machine-commerce-operator-treasury-destinations-pack"
+    && pack.custody_visibility_rule !== "do_not_expose_real_external_refs_or_custody_refs_on_public_surfaces") {
+    rejectionCodes.push("operator_visibility_rule_missing");
+  }
+
+  return {
+    validation_version: "xytara-treasury-public-boundary-validation-v1",
+    public_boundary_valid: rejectionCodes.length === 0,
+    rejection_codes: Array.from(new Set(rejectionCodes)),
+    deterministic_rejection_codes: TREASURY_PUBLIC_BOUNDARY_REJECTION_CODES.slice(),
+    public_claim_boundary: boundary,
+    boundary: "public_treasury_surfaces_must_not_expose_landing_or_custody_refs_and_must_match_claim_allowed_state"
+  };
+}
+
 module.exports = {
   buildOperatorTreasuryDestinationsPack,
   summarizeOperatorTreasuryDestinationsPack,
   buildTreasuryDestinationsPack,
   summarizeTreasuryDestinationsPack,
-  buildTreasuryDestinationValidationPreview
+  buildTreasuryDestinationValidationPreview,
+  validateTreasuryDestinationPublicBoundary
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xytara",
-  "version": "2.7.0",
+  "version": "2.9.0",
   "description": "Agent-commerce runtime for quote, pay, execute, deliver, meter, and integrate.",
   "main": "index.js",
   "bin": {
@@ -10,10 +10,10 @@
   },
   "type": "commonjs",
   "license": "Apache-2.0",
-  "homepage": "https://xytara.com",
+  "homepage": "https://naxytra.com/xytara",
   "funding": {
     "type": "individual",
-    "url": "https://xytara.com"
+    "url": "https://naxytra.com/xytara"
   },
   "keywords": [
     "agent-commerce",
@@ -72,12 +72,16 @@
     "verify:package": "node scripts/verify_all.js",
     "verify:integrations": "node scripts/verify_integrations.js",
     "verify:adapters": "node scripts/verify_adapters.js",
+    "verify:framework-provider-promotion": "node scripts/verify_framework_provider_promotion.js",
+    "verify:operator-observability-boundary": "node scripts/verify_operator_observability_boundary.js",
+    "verify:pricing-experiment-plan": "node scripts/verify_pricing_experiment_plan.js",
+    "verify:treasury-public-boundary": "node scripts/verify_treasury_public_boundary.js",
     "verify:tooling": "node scripts/verify_tooling.js",
     "verify:examples": "node scripts/verify_examples.js",
     "verify:service": "node scripts/verify_service.js",
     "verify:release-candidate": "node scripts/verify_release_candidate.js",
     "verify:production-readiness": "node scripts/verify_production_readiness.js",
-    "verify:all": "node scripts/verify_all.js && node scripts/verify_integrations.js && node scripts/verify_adapters.js && node scripts/verify_tooling.js && node scripts/verify_examples.js && node scripts/verify_service.js",
+    "verify:all": "node scripts/verify_all.js && node scripts/verify_integrations.js && node scripts/verify_adapters.js && node scripts/verify_framework_provider_promotion.js && node scripts/verify_operator_observability_boundary.js && node scripts/verify_pricing_experiment_plan.js && node scripts/verify_treasury_public_boundary.js && node scripts/verify_tooling.js && node scripts/verify_examples.js && node scripts/verify_service.js",
     "prepublishOnly": "npm run verify:release-candidate"
   }
 }

package/scripts/verify_framework_provider_promotion.js

@@ -0,0 +1,152 @@
+"use strict";
+
+const assert = require("assert");
+const {
+  FRAMEWORK_PROVIDER_CANDIDATES,
+  buildFrameworkProviderPromotionPack,
+  summarizeFrameworkProviderPromotionPack,
+  validateFrameworkProviderPromotionEvidence
+} = require("../lib/framework_provider_promotion");
+
+function normalizeUrl(baseUrl, healthPath) {
+  const url = new URL(baseUrl);
+  const normalizedPath = String(healthPath || "/health").startsWith("/")
+    ? String(healthPath || "/health")
+    : `/${healthPath}`;
+  url.pathname = normalizedPath;
+  return url.toString();
+}
+
+async function checkHealth(candidate, env) {
+  const endpoint = env[candidate.endpoint_env];
+  const token = env[candidate.auth_env];
+  const healthPath = env[candidate.health_path_env] || "/health";
+  const started = Date.now();
+  const response = await fetch(normalizeUrl(endpoint, healthPath), {
+    method: "GET",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/json"
+    }
+  });
+  const latencyMs = Date.now() - started;
+  let body = null;
+  try {
+    body = await response.json();
+  } catch (_error) {
+    body = null;
+  }
+  return {
+    framework_id: candidate.framework_id,
+    adapter_id: candidate.adapter_id,
+    status_code: response.status,
+    latency_ms: latencyMs,
+    health_ok: response.ok && (!body || ["ok", "ready", "auth_required"].includes(String(body.status || body.readiness || "ok"))),
+    body_status: body && (body.status || body.readiness || null)
+  };
+}
+
+function buildValidPromotionEvidence(candidateSummary) {
+  return {
+    framework_id: candidateSummary.framework_id,
+    adapter_id: candidateSummary.adapter_id,
+    task_ref: candidateSummary.task_ref,
+    operator_evidence_ref: `ops.framework_provider.${candidateSummary.framework_id}.2026-04-22`,
+    auth_boundary_ref: `ops.framework_provider.auth_boundary.${candidateSummary.framework_id}.2026-04-22`,
+    health_check: {
+      status_code: 200,
+      health_ok: true
+    },
+    latency_ms: 250,
+    latency_budget_ms: 2000,
+    failure_behavior_ref: `ops.framework_provider.failure_behavior.${candidateSummary.framework_id}.2026-04-22`,
+    proof_fact_shape_ref: `ops.framework_provider.proof_facts.${candidateSummary.framework_id}.2026-04-22`
+  };
+}
+
+function assertRejected(pack, evidence, expectedCode) {
+  const validation = validateFrameworkProviderPromotionEvidence(pack, evidence);
+  assert.strictEqual(validation.promotion_allowed, false, `expected ${expectedCode} to block framework provider promotion`);
+  assert.strictEqual(
+    validation.rejection_codes.includes(expectedCode),
+    true,
+    `missing deterministic rejection code ${expectedCode}`
+  );
+  return validation;
+}
+
+async function main() {
+  const pack = buildFrameworkProviderPromotionPack();
+  const summary = summarizeFrameworkProviderPromotionPack();
+  assert.strictEqual(pack.ok, true, "framework provider promotion pack failed");
+  assert.strictEqual(summary.framework_candidate_count, FRAMEWORK_PROVIDER_CANDIDATES.length, "framework candidate count mismatch");
+  assert.strictEqual(pack.promoted_provider_count, 0, "promotion pack must not auto-promote providers");
+  assert.strictEqual(pack.deterministic_rejection_codes.length >= 13, true, "framework promotion rejection codes missing");
+  assert.strictEqual(summary.deterministic_rejection_code_count, pack.deterministic_rejection_codes.length, "framework promotion summary rejection code count mismatch");
+  assert.strictEqual(
+    pack.strict_boundaries.includes("reference_framework_adapters_do_not_equal_live_provider_integrations"),
+    true,
+    "framework reference boundary missing"
+  );
+
+  assertRejected(pack, buildValidPromotionEvidence(pack.candidates[0]), "candidate_not_live_check_ready");
+  assertRejected(pack, { framework_id: "unknown_framework" }, "framework_not_registered");
+
+  const syntheticEnv = {
+    XYTARA_LANGGRAPH_PROVIDER_URL: "https://provider.example.test",
+    XYTARA_LANGGRAPH_PROVIDER_TOKEN: "configured-token-placeholder",
+    XYTARA_LANGGRAPH_PROVIDER_HEALTH_PATH: "/health"
+  };
+  const promotablePack = buildFrameworkProviderPromotionPack({ env: syntheticEnv });
+  const promotableCandidate = promotablePack.candidates.find((candidate) => candidate.framework_id === "langgraph");
+  const validEvidence = buildValidPromotionEvidence(promotableCandidate);
+  const validValidation = validateFrameworkProviderPromotionEvidence(promotablePack, validEvidence);
+  assert.strictEqual(promotableCandidate.state, "live_check_ready", "synthetic provider should be live-check ready");
+  assert.strictEqual(validValidation.promotion_allowed, true, "complete synthetic evidence should validate");
+  assert.deepStrictEqual(validValidation.rejection_codes, [], "complete synthetic evidence should not carry rejections");
+
+  assertRejected(promotablePack, { ...validEvidence, adapter_id: "wrong.adapter" }, "adapter_id_mismatch");
+  assertRejected(promotablePack, { ...validEvidence, task_ref: "wrong.task" }, "task_ref_mismatch");
+  assertRejected(promotablePack, { ...validEvidence, operator_evidence_ref: null }, "operator_evidence_missing");
+  assertRejected(promotablePack, { ...validEvidence, auth_boundary_ref: null }, "auth_boundary_evidence_missing");
+  assertRejected(promotablePack, { ...validEvidence, health_check: null }, "health_check_missing");
+  assertRejected(promotablePack, { ...validEvidence, health_check: { status_code: 503, health_ok: false } }, "health_check_failed");
+  assertRejected(promotablePack, { ...validEvidence, latency_ms: null }, "latency_measurement_missing");
+  assertRejected(promotablePack, { ...validEvidence, latency_ms: 3000, latency_budget_ms: 1000 }, "latency_budget_exceeded");
+  assertRejected(promotablePack, { ...validEvidence, failure_behavior_ref: null }, "failure_behavior_evidence_missing");
+  assertRejected(promotablePack, { ...validEvidence, proof_fact_shape_ref: null }, "proof_fact_shape_evidence_missing");
+  assertRejected(promotablePack, { ...validEvidence, provider_token: "sk_live_accidental_secret" }, "secret_material_forbidden");
+
+  const readyCandidates = pack.candidates.filter((candidate) => candidate.state === "live_check_ready");
+  if (pack.require_live) {
+    assert.strictEqual(readyCandidates.length > 0, true, "live provider promotion required but no endpoint/auth pair is configured");
+  }
+
+  const live_checks = [];
+  for (const candidate of FRAMEWORK_PROVIDER_CANDIDATES) {
+    const candidateSummary = pack.candidates.find((entry) => entry.framework_id === candidate.framework_id);
+    if (!candidateSummary || candidateSummary.state !== "live_check_ready") continue;
+    const result = await checkHealth(candidate, process.env);
+    assert.strictEqual(result.health_ok, true, `${candidate.framework_id} live health check failed`);
+    live_checks.push(result);
+  }
+
+  const result = {
+    ok: true,
+    product: "xytara",
+    category: "xytara-framework-provider-promotion-verification",
+    status: live_checks.length > 0 ? "live_provider_health_checks_passed" : "no_live_provider_evidence_configured",
+    live_check_count: live_checks.length,
+    promotion_allowed: false,
+    deterministic_rejection_code_count: pack.deterministic_rejection_codes.length,
+    adversarial_case_count: 13,
+    live_checks,
+    boundary: "this_verifier_checks_promotion_evidence_but_does_not_promote_reference_adapters_to_live_provider_claims"
+  };
+  process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+}
+
+main().catch((error) => {
+  console.error(error && error.stack ? error.stack : error);
+  process.exit(1);
+});