xytara 3.1.16 → 3.2.0

package/lib/commerce_runtime.js

@@ -1,322 +0,0 @@
-"use strict";
-
-const { createCommandArtifacts } = require("./commerce_artifacts");
-const { createQuote, hydrateQuoteStates, markQuoteExecuted } = require("./commerce_quotes");
-const { listRecords } = require("./record_queries");
-const { createBsvSettlementRecord } = require("./settlement_bsv_live");
-const {
-  actOnDispute,
-  actOnRefund,
-  actOnRemediationTicket,
-  createDispute,
-  createRefund,
-  createRemediationTicket,
-  settleRefundAsCredit
-} = require("./commerce_cases");
-
-function createRuntimeState() {
-  return {
-    quotes: new Map(),
-    checkoutPurchaseIntents: new Map(),
-    checkoutSessions: new Map(),
-    checkoutEvents: new Map(),
-    externalCreditGrants: new Map(),
-    accountAuthorityBindings: new Map(),
-    accountSpendCredentials: new Map(),
-    accountSpendCredentialsByToken: new Map(),
-    machineIdentityBindings: new Map(),
-    operatorParticipants: new Map(),
-    networkParticipants: new Map(),
-    runtimeBridgeDispatches: new Map(),
-    agentAccounts: new Map(),
-    transactions: new Map(),
-    receipts: new Map(),
-    paymentLedger: [],
-    bsvSettlementRecords: new Map(),
-    providerRegistry: new Map(),
-    providerSettlementLedger: [],
-    providerPayouts: [],
-    acceptedPaymentNonces: new Set(),
-    acceptedAgentSignatures: new Map(),
-    inFlightPaymentAuthorizations: new Map(),
-    economicsBudgets: new Map(),
-    economicsAgents: new Map(),
-    economicsReceipts: new Map(),
-    economicsAllocations: [],
-    economicsRailCredits: [],
-    economicsEntitlements: new Map(),
-    economicsCreditSpends: [],
-    economicsUsageMeters: new Map(),
-    economicsInterpretationHandoffs: [],
-    economicsJobActions: [],
-    coordinationHandoffs: [],
-    zoneAdmissionCases: [],
-    deliveries: new Map(),
-    pendingExecutions: new Map(),
-    disputes: new Map(),
-    refunds: new Map(),
-    remediationTickets: new Map()
-  };
-}
-
-function buildDeliveryEvent(event, delivery, atIso, extra) {
-  return {
-    event,
-    at_iso: atIso,
-    status: delivery.status,
-    callback_url: delivery.callback_url || null,
-    output_ref: delivery.output_ref || null,
-    proof_ref: delivery.proof_ref || null,
-    ...(extra || {})
-  };
-}
-
-function buildCallbackDeliveryState(callbackUrl, deliveredAtIso, options = {}) {
-  if (!callbackUrl) return null;
-  const opts = options || {};
-  const initialStatus = opts.initial_status || (deliveredAtIso ? "queued" : "pending_execution");
-  return {
-    status: initialStatus,
-    attempt_count: 0,
-    max_attempts: null,
-    last_attempt_at_iso: null,
-    next_attempt_at_iso: deliveredAtIso || null,
-    delivered_at_iso: null,
-    failed_at_iso: null,
-    last_error: null,
-    last_response_status: null,
-    signature_mode: "hmac_sha256"
-  };
-}
-
-function completePendingExecution(state, transactionId) {
-  if (!transactionId || !state.pendingExecutions.has(transactionId) || !state.transactions.has(transactionId)) {
-    return state.transactions.get(transactionId) || null;
-  }
-  const pending = state.pendingExecutions.get(transactionId);
-  const current = state.transactions.get(transactionId);
-  if (!pending || !current || Date.now() < pending.readyAtMs) {
-    return current;
-  }
-
-  const completedAtIso = new Date(pending.readyAtMs).toISOString();
-  const next = {
-    transaction: {
-      ...current.transaction,
-      status: "completed",
-      completed_at_iso: completedAtIso,
-      timing: {
-        ...current.transaction.timing,
-        completed_at_iso: completedAtIso,
-        duration_ms: pending.durationMs,
-        observed_latency_class: pending.observedLatencyClass,
-        assessment: pending.assessment
-      },
-      execution: {
-        ...current.transaction.execution,
-        status: "completed"
-      },
-      remediation: {
-        ...current.transaction.remediation,
-        updated_at_iso: completedAtIso
-      }
-    },
-    receipt: {
-      ...current.receipt,
-      status: "completed",
-      created_at_iso: completedAtIso,
-      timing: {
-        ...current.receipt.timing,
-        completed_at_iso: completedAtIso,
-        duration_ms: pending.durationMs,
-        observed_latency_class: pending.observedLatencyClass,
-        assessment: pending.assessment
-      },
-      remediation: {
-        ...current.receipt.remediation,
-        updated_at_iso: completedAtIso
-      }
-    },
-    command: current.command
-  };
-
-  state.transactions.set(transactionId, next);
-  state.receipts.set(next.receipt.receipt_id, next);
-  if (pending.quoteId && state.quotes.has(pending.quoteId)) {
-    const quote = state.quotes.get(pending.quoteId);
-    state.quotes.set(pending.quoteId, {
-      ...quote,
-      status: "executed",
-      payment_recorded_at_iso: completedAtIso,
-      executed_at_iso: completedAtIso
-    });
-  }
-  if (pending.deliveryId && state.deliveries.has(pending.deliveryId)) {
-    const delivery = state.deliveries.get(pending.deliveryId);
-    const nextDelivery = {
-      ...delivery,
-      status: "delivered",
-      delivered_at_iso: completedAtIso,
-      receipt_id: next.receipt.receipt_id,
-      proof_ref: next.receipt.proof_ref,
-      attempt_count: (delivery.attempt_count || 0) + 1,
-      last_attempt_at_iso: completedAtIso,
-      history: [
-        ...(Array.isArray(delivery.history) ? delivery.history : []),
-        buildDeliveryEvent("delivered", { ...delivery, status: "delivered", proof_ref: next.receipt.proof_ref }, completedAtIso, {
-          attempt_number: (delivery.attempt_count || 0) + 1
-        })
-      ],
-      callback_delivery: delivery.callback_url
-        ? {
-            ...(delivery.callback_delivery || buildCallbackDeliveryState(delivery.callback_url, completedAtIso)),
-            status: "queued",
-            next_attempt_at_iso: completedAtIso,
-            last_error: null,
-            failed_at_iso: null
-          }
-        : null
-    };
-    state.deliveries.set(pending.deliveryId, nextDelivery);
-  }
-  state.pendingExecutions.delete(transactionId);
-  return next;
-}
-
-function hydratePendingExecutions(state) {
-  for (const transactionId of Array.from(state.pendingExecutions.keys())) {
-    completePendingExecution(state, transactionId);
-  }
-}
-
-function createCommandResult(state, payload, quote, options) {
-  const opts = options || {};
-  const deferredCompletion = payload && payload.defer_completion === true;
-  const { transaction, receipt, command } = createCommandArtifacts(payload, quote, {
-    deferredCompletion,
-    paymentVerification: opts.paymentVerification || null,
-    externalExecution: opts.externalExecution || null
-  });
-  const result = { transaction, receipt, command };
-  state.transactions.set(transaction.transaction_id, result);
-  state.receipts.set(receipt.receipt_id, result);
-  let paymentRecord = null;
-  if (!opts.skipPaymentLedger) {
-    paymentRecord = {
-      payment_id: `pay_${quote.quote_id}`,
-      quote_id: quote.quote_id,
-      transaction_id: transaction.transaction_id,
-      receipt_id: receipt.receipt_id,
-      account_id: quote.account_id,
-      amount_minor: quote.amount_minor,
-      currency: quote.currency,
-      settlement_adapter: quote.settlement_adapter,
-      settlement_integration_id: quote.settlement_integration_id || null,
-      recorded_at_iso: receipt.created_at_iso,
-      payment: transaction.payment,
-      settlement: transaction.settlement,
-      treasury: transaction.treasury,
-      default_path: transaction.default_path,
-      payment_verification: opts.paymentVerification
-        ? {
-            verification_mode: opts.paymentVerification.verification_mode || null,
-            wallet_id: opts.paymentVerification.wallet_id || null,
-            age_seconds: Number.isFinite(Number(opts.paymentVerification.age_seconds))
-              ? Number(opts.paymentVerification.age_seconds)
-              : null
-          }
-        : null
-    };
-    state.paymentLedger = [
-      paymentRecord,
-      ...(Array.isArray(state.paymentLedger) ? state.paymentLedger : [])
-    ].slice(0, 100);
-    const liveSettlement = createBsvSettlementRecord(state, transaction, receipt, paymentRecord);
-    if (liveSettlement) {
-      paymentRecord.live_settlement = {
-        settlement_id: liveSettlement.settlement_id,
-        status: liveSettlement.status,
-        finality_status: liveSettlement.finality_status,
-        txid: liveSettlement.txid,
-        rail: liveSettlement.rail
-      };
-      transaction.settlement.live = paymentRecord.live_settlement;
-      receipt.settlement.live = paymentRecord.live_settlement;
-    }
-  }
-  if (opts.creditSpend) {
-    transaction.credit_spend = opts.creditSpend;
-    receipt.credit_spend = opts.creditSpend;
-  }
-  const deliveryRecord = {
-    delivery_id: `delivery_${transaction.transaction_id}`,
-    transaction_id: transaction.transaction_id,
-    receipt_id: receipt.receipt_id,
-    quote_id: quote.quote_id,
-    account_id: quote.account_id,
-    callback_url: transaction.callback_url,
-    output_ref: transaction.output_ref,
-    proof_ref: receipt.proof_ref,
-    payment_id: paymentRecord ? paymentRecord.payment_id : null,
-    delivery_target_kind: transaction.callback_url ? "callback" : "direct",
-    status: deferredCompletion ? "pending_delivery" : "delivered",
-    created_at_iso: transaction.created_at_iso,
-    delivered_at_iso: deferredCompletion ? null : receipt.created_at_iso,
-    attempt_count: deferredCompletion ? 0 : 1,
-    last_attempt_at_iso: deferredCompletion ? null : receipt.created_at_iso,
-    callback_delivery: buildCallbackDeliveryState(
-      transaction.callback_url,
-      deferredCompletion ? null : receipt.created_at_iso,
-      {
-        initial_status: deferredCompletion ? "pending_execution" : "queued"
-      }
-    ),
-    history: [
-      buildDeliveryEvent("created", {
-        callback_url: transaction.callback_url,
-        output_ref: transaction.output_ref,
-        proof_ref: receipt.proof_ref,
-        status: deferredCompletion ? "pending_delivery" : "delivered"
-      }, transaction.created_at_iso),
-      ...(!deferredCompletion ? [
-        buildDeliveryEvent("delivered", {
-          callback_url: transaction.callback_url,
-          output_ref: transaction.output_ref,
-          proof_ref: receipt.proof_ref,
-          status: "delivered"
-        }, receipt.created_at_iso, { attempt_number: 1 })
-      ] : [])
-    ]
-  };
-  state.deliveries.set(deliveryRecord.delivery_id, deliveryRecord);
-  markQuoteExecuted(state, quote, result, paymentRecord, { deferredCompletion });
-  if (deferredCompletion) {
-    state.pendingExecutions.set(transaction.transaction_id, {
-      readyAtMs: Date.now() + 300,
-      quoteId: quote.quote_id,
-      deliveryId: deliveryRecord.delivery_id,
-      durationMs: 250,
-      observedLatencyClass: "instant",
-      assessment: "within_posture"
-    });
-  }
-  return result;
-}
-
-module.exports = {
-  buildCallbackDeliveryState,
-  completePendingExecution,
-  createCommandResult,
-  createDispute,
-  createQuote,
-  createRefund,
-  createRemediationTicket,
-  createRuntimeState,
-  hydrateQuoteStates,
-  hydratePendingExecutions,
-  actOnDispute,
-  actOnRefund,
-  actOnRemediationTicket,
-  settleRefundAsCredit,
-  listRecords
-};

package/lib/commerce_shell.js

@@ -1,257 +0,0 @@
-"use strict";
-
-const crypto = require("crypto");
-
-function normalizeString(value) {
-  return String(value == null ? "" : value).trim();
-}
-
-function shellHash(seed) {
-  return crypto.createHash("sha256").update(seed).digest("hex");
-}
-
-function buildShellRef(prefix, seed) {
-  return `${prefix}.${shellHash(JSON.stringify(seed)).slice(0, 16)}`;
-}
-
-function buildAgentAccountPublicView(payload, includeOnboarding = false) {
-  const item = payload && typeof payload === "object" ? payload : {};
-  const view = {
-    ok: item.ok === true,
-    account: item.account && typeof item.account === "object" ? item.account : null
-  };
-  if (includeOnboarding) {
-    view.onboarding = item.onboarding && typeof item.onboarding === "object" ? item.onboarding : null;
-  }
-  return view;
-}
-
-function createAgentAccount(state, body) {
-  const input = body && typeof body === "object" && !Array.isArray(body) ? body : {};
-  const requestedLabel = normalizeString(input.label || input.name || input.account_label || "");
-  const settlementMode = normalizeString(input.settlement_mode || "ethereum_evm");
-  const protocol = normalizeString(input.protocol || "mcp");
-  const adapterProfile = normalizeString(input.adapter_profile || "default");
-  const seed = shellHash(JSON.stringify({
-    requestedLabel,
-    settlementMode,
-    protocol,
-    adapterProfile,
-    createdAt: new Date().toISOString()
-  }));
-  const accountId = `acct_${seed.slice(0, 12)}`;
-  const walletId = `wallet_${seed.slice(12, 24)}`;
-  const apiKey = `xytara_live_${seed.slice(24, 48)}`;
-  const walletSecret = `xytara_wallet_${seed.slice(0, 32)}`;
-  const account = {
-    account_id: accountId,
-    wallet_id: walletId,
-    label: requestedLabel || accountId,
-    settlement_mode: settlementMode,
-    protocol,
-    adapter_profile: adapterProfile,
-    status: "active",
-    created_at_iso: new Date().toISOString()
-  };
-  const payload = {
-    ok: true,
-    account,
-    onboarding: {
-      api_key: apiKey,
-      wallet_secret: walletSecret,
-      default_headers: {
-        authorization: `Bearer ${apiKey}`,
-        "x-xytara-wallet-id": walletId
-      },
-      default_context: {
-        account_id: accountId,
-        settlement_mode: settlementMode,
-        protocol
-      },
-      next_surfaces: {
-        transaction_center: "/v1/transaction-center",
-        operations_dashboard: `/v1/operations/dashboard?account_id=${encodeURIComponent(accountId)}`,
-        operator_shell_summary: "/v1/operator-shell/summary"
-      }
-    }
-  };
-  state.agentAccounts.set(accountId, payload);
-  return payload;
-}
-
-function listAgentAccounts(state) {
-  const accounts = Array.from(state.agentAccounts.values()).map((entry) => entry.account);
-  return {
-    ok: true,
-    count: accounts.length,
-    accounts
-  };
-}
-
-function getAgentAccount(state, accountId) {
-  const payload = state.agentAccounts.get(accountId) || null;
-  return payload ? buildAgentAccountPublicView(payload, false) : null;
-}
-
-function buildOperatorShellCenter() {
-  return {
-    center_ref: "operator-shell.center",
-    account_issue_surface: "/v1/agent-accounts",
-    summary_surface: "/v1/operator-shell/summary",
-    workflow_pack_surface: "/v1/operator-shell/workflow-pack",
-    admin_pack_surface: "/v1/operator-shell/admin-pack",
-    supported_capabilities: [
-      "agent_account_onboarding",
-      "operator_shell_summary",
-      "workflow_packaging",
-      "admin_packaging",
-      "cross_layer_visibility",
-      "hosted_checkout_review_visibility"
-    ]
-  };
-}
-
-function summarizeOperatorShellCenter() {
-  const center = buildOperatorShellCenter();
-  return {
-    center_ref: center.center_ref,
-    capability_count: center.supported_capabilities.length,
-    account_issue_surface: center.account_issue_surface,
-    workflow_pack_surface: center.workflow_pack_surface
-  };
-}
-
-function buildOperatorShellSummary(input) {
-  const body = input && typeof input === "object" && !Array.isArray(input) ? input : {};
-  const accountId = normalizeString(body.account_id || "acct_demo");
-  const operationsDashboard = body.operations_dashboard || {};
-  const operatorExportPack = body.operator_export_pack || {};
-  const economicsOperatorView = body.economics_operator_view || {};
-  const economicsOperatorDashboard = body.economics_operator_dashboard || {};
-  const coordinationOperatorView = body.coordination_operator_view || {};
-  const coordinationAdminView = body.coordination_admin_view || {};
-  const hostedCheckoutOperatorSummary = body.hosted_checkout_operator_summary || {};
-  const entitlementReplenishmentSummary = body.entitlement_replenishment_summary || {};
-  const runtimeDurability = body.runtime_durability || {};
-  const nativeSettlementReadiness = body.native_settlement_readiness || {};
-
-  return {
-    ok: true,
-    shell_summary_ref: buildShellRef("operator-shell.summary", {
-      account_id: accountId,
-      attention_count: operationsDashboard.attention_count || 0,
-      export_version: operatorExportPack.export_version || null
-    }),
-    account_id: accountId,
-    shell_surfaces: {
-      operations_dashboard: "/v1/operations/dashboard",
-      operator_export_pack: "/v1/operator-export-pack",
-      economics_operator_view: `/v1/economics/accounts/${encodeURIComponent(accountId)}/operator-view`,
-      economics_operator_dashboard: `/v1/economics/accounts/${encodeURIComponent(accountId)}/operator-dashboard`,
-      coordination_operator_view: "/v1/coordination-center/operator-view",
-      coordination_admin_view: "/v1/coordination-center/admin-view",
-      hosted_checkout_purchase_intents: `/v1/checkout/purchase-intents?account_id=${encodeURIComponent(accountId)}`,
-      hosted_checkout_runtime_bridge_dispatches: `/v1/runtime-bridge/dispatches?account_id=${encodeURIComponent(accountId)}`,
-      runtime_durability: "/v1/runtime/durability",
-      native_settlement_readiness: "/v1/settlement/bsv-teranode/readiness",
-      proof_governance_dashboard: "/v1/proof-center/governance/dashboard",
-      proof_bridge_admin_pack: "/v1/proof-center/bridge/admin-pack"
-    },
-    shell_state: {
-      attention_count: Number(operationsDashboard.attention_count || 0),
-      open_issue_count: Number(operationsDashboard.open_issue_count || 0),
-      export_generated_at_iso: operatorExportPack.generated_at_iso || null,
-      economics_receipt_count: Number(
-        economicsOperatorDashboard.receipt_summary && economicsOperatorDashboard.receipt_summary.receipt_count || 0
-      ),
-      coordination_zone_count: Number(coordinationAdminView.zone_count || coordinationOperatorView.zone_count || 0),
-      hosted_checkout_purchase_intent_count: Number(hostedCheckoutOperatorSummary.purchase_intent_count || 0),
-      hosted_checkout_refund_review_required_count: Number(hostedCheckoutOperatorSummary.refund_review_required_count || 0),
-      hosted_checkout_execution_dispatched_count: Number(hostedCheckoutOperatorSummary.execution_dispatched_count || 0),
-      hosted_checkout_auto_compensated_count: Number(hostedCheckoutOperatorSummary.auto_compensated_count || 0),
-      hosted_checkout_compensation_review_required_count: Number(hostedCheckoutOperatorSummary.compensation_review_required_count || 0),
-      hosted_checkout_compensation_failed_count: Number(hostedCheckoutOperatorSummary.compensation_failed_count || 0),
-      low_balance_entitlement_count: Number(entitlementReplenishmentSummary.low_balance_count || 0),
-      depleted_entitlement_count: Number(entitlementReplenishmentSummary.depleted_count || 0),
-      runtime_snapshot_enabled: runtimeDurability.enabled === true,
-      runtime_snapshot_exists: runtimeDurability.snapshot_exists === true,
-      runtime_recovery_posture: runtimeDurability.recovery_posture || null,
-      native_settlement_runtime_mode: runtimeDurability.enabled === true || nativeSettlementReadiness.runtime_mode
-        ? nativeSettlementReadiness.runtime_mode || null
-        : null,
-      native_settlement_ready: nativeSettlementReadiness.ready === true,
-      native_settlement_blocker_count: Array.isArray(nativeSettlementReadiness.blockers)
-        ? nativeSettlementReadiness.blockers.length
-        : 0
-    },
-    linked_refs: {
-      operations_dashboard_ref: buildShellRef("operator-shell.operations-dashboard", {
-        account_id: accountId,
-        attention_count: operationsDashboard.attention_count || 0,
-        attention_signal_count: operationsDashboard.attention_signal_count || 0
-      }),
-      economics_operator_view_ref: economicsOperatorView.operator_view_ref || null,
-      economics_operator_dashboard_ref: economicsOperatorDashboard.operator_dashboard_ref || null,
-      coordination_operator_view_ref: coordinationOperatorView.operator_view_ref || null,
-      coordination_admin_view_ref: coordinationAdminView.admin_view_ref || null,
-      hosted_checkout_operator_summary_ref: hostedCheckoutOperatorSummary.operator_summary_ref || null
-      ,
-      entitlement_replenishment_summary_ref: entitlementReplenishmentSummary.entitlement_count != null
-        ? `/v1/economics/accounts/${encodeURIComponent(accountId)}/entitlements/replenishment-summary`
-        : null,
-      runtime_durability_ref: runtimeDurability.inspect_ref || "/v1/runtime/durability",
-      native_settlement_readiness_ref: nativeSettlementReadiness.readiness_ref || "/v1/settlement/bsv-teranode/readiness"
-    }
-  };
-}
-
-function buildOperatorShellWorkflowPack(summary) {
-  const shellSummary = buildOperatorShellSummary(summary);
-  return {
-    ok: true,
-    workflow_pack_ref: buildShellRef("operator-shell.workflow-pack", shellSummary),
-    shell_summary_ref: shellSummary.shell_summary_ref,
-    account_id: shellSummary.account_id,
-    workflow_steps: [
-      "issue_or_select_agent_account",
-      "start_or_review_governed_transaction",
-      "review_hosted_checkout_purchase_and_refund_queue",
-      "inspect_economics_and_coordination",
-      "export_operator_pack",
-      "handoff_to_proof_review_when_needed"
-    ],
-    linked_surfaces: shellSummary.shell_surfaces
-  };
-}
-
-function buildOperatorShellAdminPack(summary) {
-  const shellSummary = buildOperatorShellSummary(summary);
-  const workflowPack = buildOperatorShellWorkflowPack(summary);
-  return {
-    ok: true,
-    admin_pack_ref: buildShellRef("operator-shell.admin-pack", {
-      shell_summary_ref: shellSummary.shell_summary_ref,
-      workflow_pack_ref: workflowPack.workflow_pack_ref
-    }),
-    shell_summary_ref: shellSummary.shell_summary_ref,
-    workflow_pack_ref: workflowPack.workflow_pack_ref,
-    operator_refs: shellSummary.linked_refs,
-    export_surface: "/v1/operator-export-pack",
-    guidance: [
-      "operator_shell_is_a_public_control_surface_inside_xytara",
-      "operator_shell_does_not_create_a_separate_product_identity"
-    ]
-  };
-}
-
-module.exports = {
-  buildAgentAccountPublicView,
-  createAgentAccount,
-  listAgentAccounts,
-  getAgentAccount,
-  buildOperatorShellCenter,
-  summarizeOperatorShellCenter,
-  buildOperatorShellSummary,
-  buildOperatorShellWorkflowPack,
-  buildOperatorShellAdminPack
-};

package/lib/crypto_agility_matrix.js

@@ -1,125 +0,0 @@
-"use strict";
-
-const packageJson = require("../package.json");
-
-function buildCryptoAgilityMatrixPack() {
-  return {
-    ok: true,
-    product: packageJson.name,
-    category: "naxytra-crypto-agility-matrix",
-    pack_version: "naxytra-crypto-agility-matrix-v1",
-    doctrine: "xytara_consumes_crypto_agility_rules_without_claiming_unverified_future_algorithms_as_core_truth",
-    model_state: "core_now",
-    core_claim: "the stack must be explicit about which algorithms are core today, supported today, future lane, blocked, or never core",
-    lane_classes: [
-      {
-        lane_class: "core_today",
-        description: "verified and claimable today",
-        items: [
-          "sha256_domain_separated_commitments",
-          "ed25519",
-          "secp256k1",
-          "p256",
-          "native_anchor_binding",
-          "line_rate_transport_frame"
-        ]
-      },
-      {
-        lane_class: "supported_today",
-        description: "supported as interop or external verification lanes today",
-        items: [
-          "jwt",
-          "jws",
-          "jwk",
-          "did",
-          "vc",
-          "sd_jwt_vc",
-          "webauthn_cose_when_verifier_present"
-        ]
-      },
-      {
-        lane_class: "future_lane",
-        description: "explicit future cryptographic direction, not claimable as the current core",
-        items: [
-          "ml_dsa",
-          "slh_dsa",
-          "xoonya_native_hybrid_v1",
-          "xoonya_native_atom_v2"
-        ]
-      },
-      {
-        lane_class: "blocked_until_vectors",
-        description: "not claimable until validators and vectors exist",
-        items: [
-          "webauthn_cose",
-          "dilithium",
-          "falcon",
-          "sphincs_plus"
-        ]
-      },
-      {
-        lane_class: "never_core",
-        description: "must never become implicit or silent core behavior",
-        items: [
-          "silent_algorithm_negotiation",
-          "implicit_downgrade",
-          "unversioned_signature_assumptions",
-          "hidden_verifier_boundaries"
-        ]
-      }
-    ],
-    signature_suites: [
-      { suite_id: "ed25519", state: "core_today" },
-      { suite_id: "secp256k1", state: "core_today" },
-      { suite_id: "p256", state: "core_today" },
-      { suite_id: "webauthn-cose", state: "blocked_until_vectors" },
-      { suite_id: "dilithium", state: "blocked_until_vectors" },
-      { suite_id: "falcon", state: "blocked_until_vectors" },
-      { suite_id: "sphincs-plus", state: "blocked_until_vectors" },
-      { suite_id: "ml-dsa", state: "future_lane" },
-      { suite_id: "slh-dsa", state: "future_lane" }
-    ],
-    proof_envelope_rules: [
-      "signature_suite_must_be_explicit",
-      "unsupported_suites_must_not_be_claimed_as_verified",
-      "native_proof_methods_remain_optional",
-      "envelopes_must_not_redefine_receipt_validity",
-      "envelope_claims_must_stay_bounded_to_verified_behavior"
-    ],
-    linked_surfaces: {
-      native_standard_ref: "/v1/proof-center/native-standard",
-      native_standard_summary_ref: "/v1/proof-center/native-standard/summary",
-      native_atom_spec_ref: "/v1/proof-center/native-atom-spec",
-      native_payload_profile_ref: "/v1/proof-center/native-payload-profile",
-      native_anchor_profile_ref: "/v1/proof-center/native-anchor-profile"
-    },
-    claim_boundary: "claim_the_crypto_agility_policy_for_xytara_only_without_claiming_unverified_future_algorithms_as_current_core_truth"
-  };
-}
-
-function summarizeCryptoAgilityMatrixPack() {
-  const pack = buildCryptoAgilityMatrixPack();
-  return {
-    ok: true,
-    product: pack.product,
-    category: pack.category,
-    summary_version: "naxytra-crypto-agility-matrix-summary-v1",
-    pack_version: pack.pack_version,
-    model_state: pack.model_state,
-    lane_class_count: pack.lane_classes.length,
-    signature_suite_count: pack.signature_suites.length,
-    rule_count: pack.proof_envelope_rules.length,
-    linked_surfaces: pack.linked_surfaces
-  };
-}
-
-function getCryptoAgilitySuiteDetail(suiteId) {
-  const normalized = String(suiteId || "").trim().toLowerCase();
-  return (buildCryptoAgilityMatrixPack().signature_suites || []).find((entry) => entry.suite_id === normalized) || null;
-}
-
-module.exports = {
-  buildCryptoAgilityMatrixPack,
-  summarizeCryptoAgilityMatrixPack,
-  getCryptoAgilitySuiteDetail
-};