xytara 2.13.0 → 2.14.0

package/RELEASE_NOTES.md

@@ -1,11 +1,12 @@
-`xytara` 2.13.0 is the broader convergence milestone for aligned npm, GitHub, website, code, documentation, and public-copy surfaces.
+`xytara` 2.14.0 is the lifecycle and continuity hardening release for stronger runtime-to-proof followthrough and clearer end-to-end inspectability.
 
-This release keeps the synchronized public truth bundle intact while bundling the stronger public-first-run, provider-runtime, delivery, runtime-durability, revenue-launch, and operator-observability carry into one coherent public step.
+This release keeps the synchronized public truth bundle intact while tightening lifecycle continuity, verify/dispute followthrough, and the public runtime-to-proof story into one coherent next step toward the final closeout line.
 
 Highlights:
 
-- strengthens the quote-first first-run path and the public `/try` entry point for outside builders
-- keeps provider-runtime journeys, delivery summary, runtime durability, and revenue-launch paths publicly inspectable
+- makes `/v1/lifecycle-continuity` and `/v1/lifecycle-continuity/summary` the named release-center continuity boundary for the runtime side
+- strengthens explicit followthrough across verify, dispute-open, and dispute-fetch lifecycle stages
+- keeps provider-runtime journeys, delivery summary, runtime durability, and revenue-launch paths publicly inspectable inside the tighter lifecycle story
 - preserves adapter-depth boundaries, pricing guardrails, treasury public-claim safety, and read-only operator observability boundaries
 - keeps the live public catalog, full-catalog claim, and public proof surfaces aligned with the release line so operators and outside builders see the same truth
 - keeps the canonical `https://naxytra.com/xytara` public product URL and synchronized naxytra release posture intact

package/START_HERE.md

@@ -4,6 +4,8 @@ This is the shortest reliable path for understanding and using the public `xytar
 
 The phase program is now complete, so this file is the right starting point for a closed and release-shaped runtime rather than an in-flight milestone build.
 
+The next public release path is intentionally intermediary and is now centered on the paired `2.14.0` lifecycle and continuity hardening milestone documented in [RELEASE_2_14_0_LIFECYCLE_CONTINUITY_PLAN.md](C:/Users/Yoga/Desktop/workspace/vscode_workspace_naxytra/naxytra/docs/release/RELEASE_2_14_0_LIFECYCLE_CONTINUITY_PLAN.md) and [PUBLISH_PLAN.md](C:/Users/Yoga/Desktop/workspace/vscode_workspace_public/naxytra/xytara/PUBLISH_PLAN.md). That release is meant to tighten the public stack before the final `3.0.0` consolidation.
+
 ## 1. Understand The Role
 
 `xytara` is the transaction-side half of the public stack.

package/index.js

@@ -45,6 +45,11 @@ const {
   getProviderRuntimeJourneyDetail,
   summarizeProviderRuntimeJourneyPack
 } = require("./lib/provider_runtime_journey_contract");
+const {
+  buildLifecycleContinuityPack,
+  getLifecycleContinuityStageDetail,
+  summarizeLifecycleContinuityPack
+} = require("./lib/lifecycle_continuity_contract");
 const {
   buildFirstRunConversionPack,
   getFirstRunConversionDetail,
@@ -226,6 +231,9 @@ module.exports = {
   buildProviderRuntimeJourneyPack,
   getProviderRuntimeJourneyDetail,
   summarizeProviderRuntimeJourneyPack,
+  buildLifecycleContinuityPack,
+  getLifecycleContinuityStageDetail,
+  summarizeLifecycleContinuityPack,
   buildFirstRunConversionPack,
   getFirstRunConversionDetail,
   summarizeFirstRunConversionPack,

package/lib/checkout_event_security.js

@@ -56,7 +56,7 @@ function buildCheckoutEventSecuritySummary() {
     signature_header: config.signature_header,
     timestamp_header: config.timestamp_header,
     signature_mode: config.signature_mode,
-    ready: blockers.length === 0,
+    ready: Boolean(config.secret),
     blockers,
     operator_guidance: config.verification_required
       ? "sign checkout event payloads with the configured webhook secret before forwarding them into xytara"

package/lib/commerce_checkout.js

@@ -9,6 +9,29 @@ function normalizeString(value, fallback) {
   return trimmed || fallback || null;
 }
 
+function buildDefaultHostedCheckoutState() {
+  return {
+    checkoutPurchaseIntents: new Map(),
+    checkoutSessions: new Map(),
+    checkoutEvents: new Map(),
+    runtimeBridgeDispatches: new Map(),
+    refunds: new Map()
+  };
+}
+
+function normalizeHostedCheckoutState(state) {
+  const normalized = buildDefaultHostedCheckoutState();
+  if (!state || typeof state !== "object") {
+    return normalized;
+  }
+  for (const [key, value] of Object.entries(state)) {
+    if (typeof value !== "undefined") {
+      normalized[key] = value;
+    }
+  }
+  return normalized;
+}
+
 function ensureObject(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
@@ -44,21 +67,24 @@ function buildCreditsUnits(payload, price) {
 }
 
 function listHostedCheckoutPurchaseIntents(state, accountId) {
-  const intents = Array.from(state.checkoutPurchaseIntents.values());
+  const runtimeState = normalizeHostedCheckoutState(state);
+  const intents = Array.from(runtimeState.checkoutPurchaseIntents.values());
   if (!accountId) return intents;
   return intents.filter((intent) => intent.account_id === accountId);
 }
 
 function getHostedCheckoutPurchaseIntent(state, purchaseIntentId) {
-  return state.checkoutPurchaseIntents.get(purchaseIntentId) || null;
+  const runtimeState = normalizeHostedCheckoutState(state);
+  return runtimeState.checkoutPurchaseIntents.get(purchaseIntentId) || null;
 }
 
 function createHostedCheckoutPurchaseIntent(state, body) {
+  const runtimeState = normalizeHostedCheckoutState(state);
   const payload = ensureObject(body);
   const createdAt = nowIso();
   const price = buildPrice(payload);
   const purchaseIntent = {
-    purchase_intent_id: normalizeString(payload.purchase_intent_id, `purchase_${state.checkoutPurchaseIntents.size + 1}`),
+    purchase_intent_id: normalizeString(payload.purchase_intent_id, `purchase_${runtimeState.checkoutPurchaseIntents.size + 1}`),
     account_id: normalizeString(payload.account_id, "acct_demo"),
     capability_id: normalizeString(payload.capability_id, null),
     package_id: normalizeString(payload.package_id, null),
@@ -88,13 +114,14 @@ function createHostedCheckoutPurchaseIntent(state, body) {
     created_at_iso: createdAt,
     updated_at_iso: createdAt
   };
-  state.checkoutPurchaseIntents.set(purchaseIntent.purchase_intent_id, purchaseIntent);
+  runtimeState.checkoutPurchaseIntents.set(purchaseIntent.purchase_intent_id, purchaseIntent);
   return purchaseIntent;
 }
 
 function createHostedCheckoutSession(state, purchaseIntentId, body) {
+  const runtimeState = normalizeHostedCheckoutState(state);
   const payload = ensureObject(body);
-  const purchaseIntent = getHostedCheckoutPurchaseIntent(state, purchaseIntentId);
+  const purchaseIntent = getHostedCheckoutPurchaseIntent(runtimeState, purchaseIntentId);
   if (!purchaseIntent) return null;
 
   const createdAt = nowIso();
@@ -102,11 +129,11 @@ function createHostedCheckoutSession(state, purchaseIntentId, body) {
     ? new Date(Date.now() + Number(payload.expires_in_seconds) * 1000).toISOString()
     : null;
   const session = {
-    checkout_session_id: normalizeString(payload.checkout_session_id, `checkout_session_${state.checkoutSessions.size + 1}`),
+    checkout_session_id: normalizeString(payload.checkout_session_id, `checkout_session_${runtimeState.checkoutSessions.size + 1}`),
     purchase_intent_id: purchaseIntentId,
     checkout_status: "checkout_pending",
     checkout_provider: normalizeString(payload.checkout_provider, "hosted_checkout"),
-    checkout_reference: normalizeString(payload.checkout_reference, `checkout_ref_${state.checkoutSessions.size + 1}`),
+    checkout_reference: normalizeString(payload.checkout_reference, `checkout_ref_${runtimeState.checkoutSessions.size + 1}`),
     amount_due_minor: purchaseIntent.price.amount_minor,
     currency: purchaseIntent.price.currency,
     expires_at_iso: expiresAt,
@@ -116,8 +143,8 @@ function createHostedCheckoutSession(state, purchaseIntentId, body) {
     created_at_iso: createdAt,
     updated_at_iso: createdAt
   };
-  state.checkoutSessions.set(session.checkout_session_id, session);
-  state.checkoutPurchaseIntents.set(purchaseIntentId, {
+  runtimeState.checkoutSessions.set(session.checkout_session_id, session);
+  runtimeState.checkoutPurchaseIntents.set(purchaseIntentId, {
     ...purchaseIntent,
     checkout_status: "checkout_pending",
     customer_status: "checkout_pending",
@@ -129,21 +156,25 @@ function createHostedCheckoutSession(state, purchaseIntentId, body) {
 }
 
 function getHostedCheckoutSession(state, checkoutSessionId) {
-  return state.checkoutSessions.get(checkoutSessionId) || null;
+  const runtimeState = normalizeHostedCheckoutState(state);
+  return runtimeState.checkoutSessions.get(checkoutSessionId) || null;
 }
 
 function listHostedCheckoutSessions(state, purchaseIntentId) {
-  const sessions = Array.from(state.checkoutSessions.values());
+  const runtimeState = normalizeHostedCheckoutState(state);
+  const sessions = Array.from(runtimeState.checkoutSessions.values());
   if (!purchaseIntentId) return sessions;
   return sessions.filter((session) => session.purchase_intent_id === purchaseIntentId);
 }
 
 function getHostedCheckoutEvent(state, eventId) {
-  return state.checkoutEvents.get(eventId) || null;
+  const runtimeState = normalizeHostedCheckoutState(state);
+  return runtimeState.checkoutEvents.get(eventId) || null;
 }
 
 function getRuntimeBridgeDispatchByPurchaseIntent(state, purchaseIntentId) {
-  return Array.from(state.runtimeBridgeDispatches.values()).find((dispatch) =>
+  const runtimeState = normalizeHostedCheckoutState(state);
+  return Array.from(runtimeState.runtimeBridgeDispatches.values()).find((dispatch) =>
     dispatch && dispatch.purchase_intent_id === purchaseIntentId
   ) || null;
 }
@@ -233,10 +264,11 @@ function listHostedCheckoutRefunds(state, purchaseIntentId) {
 }
 
 function buildHostedCheckoutOperatorSummary(state, accountId) {
-  const purchaseIntents = listHostedCheckoutPurchaseIntents(state, accountId);
+  const runtimeState = normalizeHostedCheckoutState(state);
+  const purchaseIntents = listHostedCheckoutPurchaseIntents(runtimeState, accountId);
   const purchaseIntentIds = new Set(purchaseIntents.map((intent) => intent.purchase_intent_id));
-  const refunds = listHostedCheckoutRefunds(state).filter((refund) => purchaseIntentIds.has(refund.purchase_intent_id));
-  const bridgeDispatches = Array.from(state.runtimeBridgeDispatches.values()).filter((dispatch) => dispatch && dispatch.account_id === accountId);
+  const refunds = listHostedCheckoutRefunds(runtimeState).filter((refund) => purchaseIntentIds.has(refund.purchase_intent_id));
+  const bridgeDispatches = Array.from(runtimeState.runtimeBridgeDispatches.values()).filter((dispatch) => dispatch && dispatch.account_id === accountId);
   return {
     operator_summary_ref: `hosted_checkout.operator.${accountId}`,
     account_id: accountId,

package/lib/delivery_summary_contract.js

@@ -45,7 +45,7 @@ function summarizeDeliveryState(state) {
     product: packageJson.name,
     category: "machine-commerce-delivery-summary",
     summary_version: "xytara-delivery-summary-v1",
-    callback_delivery_enabled: config.callback_delivery_enabled,
+    callback_delivery_enabled: callbackSignalingConfigured,
     callback_signing_secret_configured: Boolean(config.callback_signing_secret),
     callback_timeout_ms: config.callback_timeout_ms,
     callback_max_attempts: config.callback_max_attempts,

package/lib/full_catalog_contract.js

@@ -210,6 +210,18 @@ function buildFamilyOperations() {
       task_refs: [],
       workflow_ref: spinePaths.spine_paths.find((entry) => entry.spine_path_ref === "spine.a2a.settlement")?.spine_path_ref || null,
       proof_followthrough_ref: "https://xoonya.onrender.com/v1/proof-center/governance/disputes/case-review"
+    },
+    {
+      operation_ref: "xoonya.bundle_verify",
+      task_family: "disputes",
+      lifecycle_stage: "verify",
+      market_class: "data",
+      claim_status: "review_handoff",
+      evidence_status: "xoonya_followthrough",
+      call_surface: "https://xoonya.onrender.com/v1/proof-center/verification-services/summary",
+      task_refs: [],
+      workflow_ref: "xoonya.bundle_verify",
+      proof_followthrough_ref: "https://xoonya.onrender.com/v1/proof-center/governance/disputes/summary"
     }
   ];
 }

package/lib/go_live_operator_pack.js

@@ -19,6 +19,48 @@ function normalizeFunction(fn, fallback) {
   return typeof fn === "function" ? fn : fallback;
 }
 
+function buildDefaultGoLiveState() {
+  return {
+    economicsBudgets: new Map(),
+    economicsAgents: new Map(),
+    economicsReceipts: new Map(),
+    economicsAllocations: [],
+    economicsRailCredits: [],
+    economicsEntitlements: new Map(),
+    economicsCreditSpends: [],
+    economicsUsageMeters: new Map(),
+    economicsJobActions: [],
+    quotes: new Map(),
+    transactions: new Map(),
+    receipts: new Map(),
+    deliveries: new Map(),
+    paymentLedger: [],
+    externalCreditGrants: [],
+    bsvSettlementRecords: [],
+    disputes: new Map(),
+    refunds: new Map(),
+    remediationTickets: new Map(),
+    operatorParticipants: new Map(),
+    agentAccounts: new Map(),
+    networkParticipants: new Map(),
+    coordinationHandoffs: [],
+    zoneAdmissionCases: []
+  };
+}
+
+function normalizeGoLiveState(state) {
+  const normalized = buildDefaultGoLiveState();
+  if (!state || typeof state !== "object") {
+    return normalized;
+  }
+  for (const [key, value] of Object.entries(state)) {
+    if (typeof value !== "undefined") {
+      normalized[key] = value;
+    }
+  }
+  return normalized;
+}
+
 function buildDefaultRuntimeDurability() {
   return {
     ok: true,
@@ -231,16 +273,17 @@ function buildGoLiveOperatorPack(state, input, options) {
   const accountId = String(payload.account_id || "acct_demo").trim() || "acct_demo";
   const runtimeDurabilityBuilder = normalizeFunction(options && options.buildRuntimeDurabilitySummary, buildDefaultRuntimeDurability);
   const settlementReadinessBuilder = normalizeFunction(options && options.buildNativeSettlementReadinessSummary, buildDefaultSettlementReadiness);
+  const runtimeState = normalizeGoLiveState(state);
 
   const executionTruth = buildCapabilityExecutionTruthBundle();
   const commercialization = buildCapabilityCommercializationSummary();
   const paymentStrategy = buildPaymentProtocolStrategyPack();
   const treasurySummary = summarizeTreasuryDestinationsPack();
   const checkoutSecurity = buildCheckoutEventSecuritySummary();
-  const deliverySummary = summarizeDeliveryState(state);
+  const deliverySummary = summarizeDeliveryState(runtimeState);
   const runtimeDurability = runtimeDurabilityBuilder();
   const settlementReadiness = settlementReadinessBuilder();
-  const operatorIntelligence = buildOperatorIntelligencePack(state, { account_id: accountId });
+  const operatorIntelligence = buildOperatorIntelligencePack(runtimeState, { account_id: accountId });
   const executionTargets = loadExecutionTargetRegistry();
   const blockingIssues = buildBlockingIssues(
     executionTruth,
@@ -321,7 +364,7 @@ function buildGoLiveOperatorPack(state, input, options) {
       delivery_summary: deliverySummary,
       runtime_durability: runtimeDurability,
       native_settlement: settlementReadiness,
-      operator_intelligence: summarizeOperatorIntelligencePack(state, { account_id: accountId })
+      operator_intelligence: summarizeOperatorIntelligencePack(runtimeState, { account_id: accountId })
     }
   };
 }

package/lib/lifecycle_continuity_contract.js

@@ -0,0 +1,115 @@
+"use strict";
+
+const packageJson = require("../package.json");
+const { buildFullCatalogPack, summarizeFullCatalogPack } = require("./full_catalog_contract");
+
+function uniqueSorted(values) {
+  return Array.from(new Set((Array.isArray(values) ? values : []).filter(Boolean))).sort();
+}
+
+function buildLifecycleContinuityStages() {
+  const fullCatalogPack = buildFullCatalogPack();
+  const lifecycleMatrix = Array.isArray(fullCatalogPack.lifecycle_matrix) ? fullCatalogPack.lifecycle_matrix : [];
+  const familyOperations = Array.isArray(fullCatalogPack.family_operations) ? fullCatalogPack.family_operations : [];
+  const operationsByStage = new Map();
+
+  for (const operation of familyOperations) {
+    if (!operation || !operation.lifecycle_stage || operationsByStage.has(operation.lifecycle_stage)) {
+      continue;
+    }
+    operationsByStage.set(operation.lifecycle_stage, operation);
+  }
+
+  return lifecycleMatrix.map((entry) => {
+    const operation = operationsByStage.get(entry.lifecycle_stage) || null;
+    const isFollowthrough = entry.lifecycle_stage === "verify" || (operation && operation.evidence_status === "xoonya_followthrough");
+    const callSurface = operation
+      ? operation.call_surface
+      : "https://xoonya.onrender.com/v1/proof-center/verification-services/summary";
+
+    return {
+      lifecycle_stage: entry.lifecycle_stage,
+      lifecycle_label: entry.lifecycle_label,
+      operation_ref: operation ? operation.operation_ref : "xoonya.bundle_verify",
+      claim_status: operation ? operation.claim_status : "bounded_live",
+      evidence_status: operation ? operation.evidence_status : "xoonya_followthrough",
+      call_surface: callSurface,
+      task_refs: uniqueSorted(operation ? operation.task_refs : []),
+      fully_surfaced: Boolean(entry.fully_surfaced),
+      proof_followthrough: isFollowthrough,
+      expected_outcome: operation
+        ? operation.operation_ref === "family.dispute_open"
+          ? "open a reviewable dispute handoff without pretending it is standalone legal judgment"
+          : operation.operation_ref === "family.dispute_fetch"
+            ? "fetch the carried dispute bundle and keep the followthrough visible"
+            : `carry the ${entry.lifecycle_label} stage through the bounded public lifecycle rail`
+        : "verify the carried bundle and proof continuity through xoonya followthrough"
+    };
+  });
+}
+
+function buildLifecycleContinuityPack() {
+  const fullCatalogPack = buildFullCatalogPack();
+  const stages = buildLifecycleContinuityStages();
+  const lifecycleStageCount = stages.length;
+  const fullySurfacedLifecycleCount = stages.filter((entry) => entry.fully_surfaced).length;
+  const firstPartyCallableLifecycleCount = stages.filter((entry) => entry.fully_surfaced && !entry.proof_followthrough).length;
+  const proofFollowthroughLifecycleCount = stages.filter((entry) => entry.proof_followthrough).length;
+  const disputeFollowthroughLifecycleCount = stages.filter((entry) => ["dispute_open", "dispute_fetch"].includes(entry.lifecycle_stage)).length;
+
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "machine-commerce-lifecycle-continuity-pack",
+    pack_version: "xytara-lifecycle-continuity-pack-v1",
+    continuity_state: "full_lifecycle_path_visible_with_cross_package_followthrough",
+    doctrine: "the full lifecycle stays inspectable without overclaiming universal provider or proof ownership",
+    lifecycle_stage_count: lifecycleStageCount,
+    fully_surfaced_lifecycle_count: fullySurfacedLifecycleCount,
+    first_party_callable_lifecycle_count: firstPartyCallableLifecycleCount,
+    proof_followthrough_lifecycle_count: proofFollowthroughLifecycleCount,
+    dispute_followthrough_lifecycle_count: disputeFollowthroughLifecycleCount,
+    lifecycle_stages: stages,
+    lifecycle_stage_refs: stages.map((entry) => entry.lifecycle_stage),
+    lifecycle_summary: summarizeFullCatalogPack(),
+    linked_surfaces: {
+      full_catalog_ref: "/v1/full-catalog",
+      full_catalog_summary_ref: "/v1/full-catalog/summary",
+      xytara_provider_runtime_journeys_summary_ref: "/v1/providers/journeys/summary",
+      xytara_first_run_conversions_summary_ref: "/v1/first-run/conversions/summary",
+      xytara_delivery_summary_ref: "/v1/deliveries/summary",
+      xytara_runtime_durability_summary_ref: "/v1/runtime/durability/summary",
+      xytara_revenue_launch_paths_summary_ref: "/v1/revenue-launch/paths/summary",
+      xoonya_verification_services_summary_ref: "https://xoonya.onrender.com/v1/proof-center/verification-services/summary",
+      xoonya_governance_disputes_summary_ref: "https://xoonya.onrender.com/v1/proof-center/governance/disputes/summary"
+    },
+    claim_boundary: "claim_lifecycle_continuity_only_for_the_listed_first_party_callable_and_xoonya_followthrough_surfaces_without_implying_universal_transaction_control"
+  };
+}
+
+function summarizeLifecycleContinuityPack() {
+  const pack = buildLifecycleContinuityPack();
+  return {
+    ok: true,
+    product: pack.product,
+    category: "machine-commerce-lifecycle-continuity-summary",
+    summary_version: "xytara-lifecycle-continuity-summary-v1",
+    lifecycle_stage_count: pack.lifecycle_stage_count,
+    fully_surfaced_lifecycle_count: pack.fully_surfaced_lifecycle_count,
+    first_party_callable_lifecycle_count: pack.first_party_callable_lifecycle_count,
+    proof_followthrough_lifecycle_count: pack.proof_followthrough_lifecycle_count,
+    dispute_followthrough_lifecycle_count: pack.dispute_followthrough_lifecycle_count,
+    linked_surfaces: pack.linked_surfaces
+  };
+}
+
+function getLifecycleContinuityStageDetail(lifecycleStage) {
+  const normalized = String(lifecycleStage || "").trim().toLowerCase();
+  return buildLifecycleContinuityStages().find((entry) => entry.lifecycle_stage === normalized) || null;
+}
+
+module.exports = {
+  buildLifecycleContinuityPack,
+  summarizeLifecycleContinuityPack,
+  getLifecycleContinuityStageDetail
+};

package/lib/release_history.js

@@ -10,6 +10,19 @@ function buildReleaseHistory() {
     current_version: packageJson.version,
     release_track: "public_release",
     history: [
+      {
+        version: "2.14.0",
+        channel: "public_release",
+        maturity_posture: "lifecycle_and_continuity_hardened",
+        headline: "lifecycle-and-continuity release with stronger runtime-to-proof followthrough, verify and dispute continuity, and clearer lifecycle inspectability",
+        milestone_refs: [
+          "lifecycle_continuity_pack",
+          "runtime_to_proof_followthrough",
+          "verify_followthrough",
+          "dispute_followthrough",
+          "synchronized_2_14_release_prep"
+        ]
+      },
       {
         version: "2.13.0",
         channel: "public_release",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xytara",
-  "version": "2.13.0",
+  "version": "2.14.0",
   "description": "Agent-commerce runtime for quote, pay, execute, deliver, meter, and integrate.",
   "main": "index.js",
   "bin": {
@@ -82,6 +82,7 @@
     "verify:market-lane-promotion": "node scripts/verify_market_lane_promotion.js",
     "verify:provider-runtime-breadth": "node scripts/verify_provider_runtime_breadth.js",
     "verify:provider-runtime-journeys": "node scripts/verify_provider_runtime_journeys.js",
+    "verify:lifecycle-continuity": "node scripts/verify_lifecycle_continuity.js",
     "verify:first-run-conversions": "node scripts/verify_first_run_conversions.js",
     "verify:delivery-summary": "node scripts/verify_delivery_summary.js",
     "verify:runtime-durability": "node scripts/verify_runtime_durability.js",
@@ -92,7 +93,7 @@
     "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_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_market_lanes.js && node scripts/verify_market_lane_depth.js && node scripts/verify_market_lane_traces.js && node scripts/verify_market_lane_promotion.js && node scripts/verify_provider_runtime_breadth.js && node scripts/verify_provider_runtime_journeys.js && node scripts/verify_first_run_conversions.js && node scripts/verify_delivery_summary.js && node scripts/verify_runtime_durability.js && node scripts/verify_revenue_launch_paths.js && node scripts/verify_full_catalog.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_market_lanes.js && node scripts/verify_market_lane_depth.js && node scripts/verify_market_lane_traces.js && node scripts/verify_market_lane_promotion.js && node scripts/verify_provider_runtime_breadth.js && node scripts/verify_provider_runtime_journeys.js && node scripts/verify_lifecycle_continuity.js && node scripts/verify_first_run_conversions.js && node scripts/verify_delivery_summary.js && node scripts/verify_runtime_durability.js && node scripts/verify_revenue_launch_paths.js && node scripts/verify_full_catalog.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_lifecycle_continuity.js

@@ -0,0 +1,96 @@
+"use strict";
+
+const assert = require("assert");
+const { once } = require("events");
+const { createServer } = require("../server");
+const {
+  buildLifecycleContinuityPack,
+  summarizeLifecycleContinuityPack
+} = require("../lib/lifecycle_continuity_contract");
+
+async function getJson(baseUrl, pathname) {
+  const response = await fetch(`${baseUrl}${pathname}`);
+  return {
+    status: response.status,
+    json: await response.json()
+  };
+}
+
+function assertSummary(summary) {
+  assert.strictEqual(summary.ok, true, "lifecycle continuity summary ok flag missing");
+  assert.strictEqual(summary.lifecycle_stage_count >= 13, true, "lifecycle continuity stage count missing");
+  assert.strictEqual(summary.fully_surfaced_lifecycle_count >= 12, true, "lifecycle continuity fully surfaced count missing");
+  assert.strictEqual(summary.first_party_callable_lifecycle_count >= 10, true, "lifecycle continuity first-party callable count missing");
+  assert.strictEqual(summary.proof_followthrough_lifecycle_count >= 3, true, "lifecycle continuity proof followthrough count missing");
+  assert.strictEqual(summary.dispute_followthrough_lifecycle_count >= 2, true, "lifecycle continuity dispute followthrough count missing");
+}
+
+function assertPack(pack) {
+  assert.strictEqual(pack.ok, true, "lifecycle continuity pack ok flag missing");
+  assert.strictEqual(pack.category, "machine-commerce-lifecycle-continuity-pack", "lifecycle continuity pack category mismatch");
+  assert.strictEqual(Array.isArray(pack.lifecycle_stages), true, "lifecycle continuity stages missing");
+  assert.strictEqual(pack.lifecycle_stages.length >= 13, true, "lifecycle continuity stage list missing");
+  assert.strictEqual(
+    pack.lifecycle_stages.some((entry) => entry.lifecycle_stage === "verify" && entry.proof_followthrough === true),
+    true,
+    "lifecycle continuity verify followthrough missing"
+  );
+  assert.strictEqual(
+    pack.lifecycle_stages.some((entry) => entry.lifecycle_stage === "dispute_open" && entry.proof_followthrough === true),
+    true,
+    "lifecycle continuity dispute-open followthrough missing"
+  );
+  assert.strictEqual(
+    pack.lifecycle_stages.some((entry) => entry.lifecycle_stage === "dispute_fetch" && entry.proof_followthrough === true),
+    true,
+    "lifecycle continuity dispute-fetch followthrough missing"
+  );
+}
+
+async function main() {
+  const pack = buildLifecycleContinuityPack();
+  const summary = summarizeLifecycleContinuityPack();
+  assertPack(pack);
+  assertSummary(summary);
+
+  const server = createServer();
+  server.listen(0, "127.0.0.1");
+  await once(server, "listening");
+
+  const address = server.address();
+  const baseUrl = `http://127.0.0.1:${address.port}`;
+
+  try {
+    const packResponse = await getJson(baseUrl, "/v1/lifecycle-continuity");
+    assert.strictEqual(packResponse.status, 200, "lifecycle continuity pack route failed");
+    assertPack(packResponse.json);
+
+    const summaryResponse = await getJson(baseUrl, "/v1/lifecycle-continuity/summary");
+    assert.strictEqual(summaryResponse.status, 200, "lifecycle continuity summary route failed");
+    assertSummary(summaryResponse.json);
+
+    const verifyDetail = await getJson(baseUrl, "/v1/lifecycle-continuity/verify");
+    assert.strictEqual(verifyDetail.status, 200, "lifecycle continuity verify detail route failed");
+    assert.strictEqual(verifyDetail.json.stage.lifecycle_stage, "verify", "lifecycle continuity verify detail mismatch");
+    assert.strictEqual(verifyDetail.json.stage.proof_followthrough, true, "lifecycle continuity verify detail followthrough missing");
+  } finally {
+    await new Promise((resolve) => server.close(resolve));
+  }
+
+  console.log(JSON.stringify({
+    ok: true,
+    product: "xytara",
+    category: "machine-commerce-lifecycle-continuity-verification",
+    verification_version: "xytara-lifecycle-continuity-verification-v1",
+    lifecycle_stage_count: summary.lifecycle_stage_count,
+    fully_surfaced_lifecycle_count: summary.fully_surfaced_lifecycle_count,
+    proof_followthrough_lifecycle_count: summary.proof_followthrough_lifecycle_count,
+    dispute_followthrough_lifecycle_count: summary.dispute_followthrough_lifecycle_count,
+    boundary: "lifecycle_continuity_should_be_publicly_inspectable_with_xoonya_followthrough_explicit"
+  }, null, 2));
+}
+
+main().catch((error) => {
+  console.error(error && error.stack ? error.stack : error);
+  process.exit(1);
+});

package/scripts/verify_service.js

@@ -400,6 +400,17 @@ async function main() {
     assert.strictEqual(providerJourneySummary.json.first_run_ready_journey_count >= 2, true, "provider runtime journey first-run count missing");
     assert.strictEqual(providerJourneySummary.json.proof_followthrough_journey_count >= 2, true, "provider runtime journey proof-followthrough count missing");
 
+    const lifecycleContinuityPack = await getJson(baseUrl, "/v1/lifecycle-continuity");
+    assert.strictEqual(lifecycleContinuityPack.status, 200, "lifecycle continuity route failed");
+    assert.strictEqual(lifecycleContinuityPack.json.ok, true, "lifecycle continuity ok flag missing");
+    assert.strictEqual(lifecycleContinuityPack.json.lifecycle_stage_count >= 13, true, "lifecycle continuity stage count missing");
+    assert.strictEqual(lifecycleContinuityPack.json.proof_followthrough_lifecycle_count >= 3, true, "lifecycle continuity proof followthrough count missing");
+
+    const lifecycleContinuitySummary = await getJson(baseUrl, "/v1/lifecycle-continuity/summary");
+    assert.strictEqual(lifecycleContinuitySummary.status, 200, "lifecycle continuity summary route failed");
+    assert.strictEqual(lifecycleContinuitySummary.json.ok, true, "lifecycle continuity summary ok flag missing");
+    assert.strictEqual(lifecycleContinuitySummary.json.fully_surfaced_lifecycle_count >= 12, true, "lifecycle continuity fully surfaced count missing");
+
     const firstRunConversionPack = await getJson(baseUrl, "/v1/first-run/conversions");
     assert.strictEqual(firstRunConversionPack.status, 200, "first-run conversion route failed");
     assert.strictEqual(firstRunConversionPack.json.ok, true, "first-run conversion ok flag missing");

package/server.js

@@ -198,6 +198,11 @@ const {
   getProviderRuntimeJourneyDetail,
   summarizeProviderRuntimeJourneyPack
 } = require("./lib/provider_runtime_journey_contract");
+const {
+  buildLifecycleContinuityPack,
+  getLifecycleContinuityStageDetail,
+  summarizeLifecycleContinuityPack
+} = require("./lib/lifecycle_continuity_contract");
 const {
   buildFirstRunConversionPack,
   getFirstRunConversionDetail,
@@ -3687,6 +3692,34 @@ async function routeRequest(req, res) {
     }
   }
 
+  if (req.method === "GET" && url.pathname === "/v1/lifecycle-continuity") {
+    sendJson(res, 200, buildLifecycleContinuityPack());
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname === "/v1/lifecycle-continuity/summary") {
+    sendJson(res, 200, summarizeLifecycleContinuityPack());
+    return;
+  }
+
+  if (req.method === "GET" && url.pathname.startsWith("/v1/lifecycle-continuity/")) {
+    const suffix = decodeURIComponent(url.pathname.slice("/v1/lifecycle-continuity/".length));
+    if (suffix && suffix !== "summary") {
+      const stage = getLifecycleContinuityStageDetail(suffix);
+      if (!stage) {
+        sendJson(res, 404, { ok: false, error: "lifecycle_continuity_stage_not_found" });
+        return;
+      }
+      sendJson(res, 200, {
+        ok: true,
+        product: "xytara",
+        category: "machine-commerce-lifecycle-continuity-detail",
+        stage
+      });
+      return;
+    }
+  }
+
   if (req.method === "GET" && url.pathname === "/v1/first-run/conversions") {
     sendJson(res, 200, buildFirstRunConversionPack());
     return;