xytara 3.1.16 → 3.2.0

package/lib/buyer_safety_policy.js

@@ -1,132 +0,0 @@
-"use strict";
-
-// Money-safety policy for the buyer path. Like the provider endpoint policy, each rule is
-// "strict" by default on a hosted deploy (RENDER is set) and "permissive" locally, so the local
-// verification suites (which exercise catalog tasks without a live execution target) keep working.
-//
-//  - Paid execution: only a task that resolves to a REAL execution target (an operator-pinned
-//    env target or an active open-network provider) may be quoted for payment. Anything else is
-//    refused up front with capability_not_executable, so a buyer is never charged for a
-//    synthetic result. (XYTARA_PAID_EXECUTION_POLICY=strict|permissive)
-//  - Credit spend: spending an account's credits requires a spend credential (xytara_spend_…
-//    bearer) bound to that account. A bare account_id is never authority — payer addresses are
-//    public on-chain. (XYTARA_CREDIT_SPEND_POLICY=strict|permissive)
-
-function policyMode(envName) {
-  const raw = String(process.env[envName] || "").trim().toLowerCase();
-  if (raw === "strict" || raw === "permissive") return raw;
-  return process.env.RENDER ? "strict" : "permissive";
-}
-
-function paidExecutionPolicyMode() {
-  return policyMode("XYTARA_PAID_EXECUTION_POLICY");
-}
-
-function creditSpendPolicyMode() {
-  return policyMode("XYTARA_CREDIT_SPEND_POLICY");
-}
-
-// Ledger/business reads (payer addresses, every quote, receipts, operations, revenue metrics) are
-// operator-only on a hosted deploy. (XYTARA_LEDGER_READ_POLICY=strict|permissive)
-function ledgerReadPolicyMode() {
-  return policyMode("XYTARA_LEDGER_READ_POLICY");
-}
-
-const PRIVATE_READ_PREFIXES = [
-  "/v1/payment-ledger",
-  "/v1/operator-export-pack",
-  "/v1/receipts",
-  "/v1/operations/",
-  "/v1/economics/accounts/",
-  "/v1/pricing-optimization/",
-  "/v1/revenue-signal",
-  "/v1/activity-ledger"
-];
-
-// Whether a GET is a private ledger read. A single quote by id stays public (its holder needs it).
-function isPrivateLedgerRead(method, pathname) {
-  if (String(method || "").toUpperCase() !== "GET") return false;
-  if (pathname === "/v1/payment-quotes") return true;
-  return PRIVATE_READ_PREFIXES.some((prefix) => pathname === prefix || pathname.startsWith(prefix.endsWith("/") ? prefix : `${prefix}/`) || pathname.startsWith(`${prefix}-`));
-}
-
-// Test networks: their USDC is free from faucets, so by default it cannot buy credits that are
-// spendable on real (mainnet-paid-out) provider work. Pay-per-call on a testnet is unaffected.
-const TESTNET_NETWORKS = new Set(["eip155:84532", "eip155:11155111"]);
-
-function isTestnetNetwork(network) {
-  return TESTNET_NETWORKS.has(String(network || "").trim().toLowerCase());
-}
-
-// What one credit unit costs, in the payment asset's base units (USDC: 6 decimals). Default
-// 2500 = $0.0025, so a decision-support call (3 units) costs $0.0075 — never more than the flat
-// pay-per-call price for the executable lanes.
-function creditUnitPriceAtomic() {
-  const value = Number(process.env.XYTARA_CREDIT_UNIT_PRICE_ATOMIC || 2500);
-  return Number.isFinite(value) && value >= 1 ? Math.floor(value) : 2500;
-}
-
-// A top-up is priced as a multiple of the per-call accepts amount (default 100x: $0.01 -> $1.00).
-function topupAmountMultiplier() {
-  const value = Number(process.env.XYTARA_X402_TOPUP_AMOUNT_MULTIPLIER || 100);
-  return Number.isFinite(value) && value >= 1 ? Math.floor(value) : 100;
-}
-
-// The accepts a credit top-up is paid with: mainnet-only unless testnet top-ups are explicitly
-// enabled, each amount scaled to the top-up price.
-function buildTopupAccepts(accepts) {
-  const allowTestnet = String(process.env.XYTARA_X402_TESTNET_TOPUP || "").trim() === "1";
-  const multiplier = BigInt(topupAmountMultiplier());
-  return (Array.isArray(accepts) ? accepts : [])
-    .filter((accept) => accept && (allowTestnet || !isTestnetNetwork(accept.network)))
-    .filter((accept) => /^\d{1,30}$/.test(String(accept.amount)))
-    .map((accept) => ({ ...accept, amount: (BigInt(String(accept.amount)) * multiplier).toString() }));
-}
-
-// Credits granted for a settled top-up: always derived from what was actually paid, so a unit is
-// never worth less than creditUnitPriceAtomic(). An accepts entry's own extra.credits may lower
-// that, never raise it.
-function topupUnitsForAccept(accept) {
-  const amount = accept && /^\d{1,30}$/.test(String(accept.amount)) ? Number(accept.amount) : 0;
-  const derived = Math.floor(amount / creditUnitPriceAtomic());
-  const explicit = accept && accept.extra ? Number(accept.extra.credits) : NaN;
-  return Number.isFinite(explicit) && explicit > 0 ? Math.min(Math.floor(explicit), derived) : derived;
-}
-
-// While the durable state has not been restored yet (boot, or a Supabase outage), balances read
-// as empty: a credit spend would wrongly say "insufficient credits" and a top-up could be lost if
-// the process died before the restore merged. Those routes answer 503 + Retry-After instead.
-let stateRestorePendingProbe = () => false;
-
-function setStateRestorePendingProbe(probe) {
-  stateRestorePendingProbe = typeof probe === "function" ? probe : () => false;
-}
-
-function isStateRestorePending() {
-  try {
-    return stateRestorePendingProbe() === true;
-  } catch (_) {
-    return false;
-  }
-}
-
-const STATE_RESTORE_PENDING_RESPONSE = Object.freeze({
-  ok: false,
-  reason: "state_restore_pending",
-  detail: "Account balances are being restored after a restart. Retry in about 30 seconds; nothing was charged. Pay-per-call x402 (without payment_preference) works meanwhile."
-});
-
-module.exports = {
-  STATE_RESTORE_PENDING_RESPONSE,
-  isPrivateLedgerRead,
-  ledgerReadPolicyMode,
-  isStateRestorePending,
-  setStateRestorePendingProbe,
-  paidExecutionPolicyMode,
-  creditSpendPolicyMode,
-  isTestnetNetwork,
-  creditUnitPriceAtomic,
-  topupAmountMultiplier,
-  buildTopupAccepts,
-  topupUnitsForAccept
-};

package/lib/capability_execution_truth.js

@@ -1,276 +0,0 @@
-"use strict";
-
-const packageJson = require("../package.json");
-const { catalog } = require("../fixtures/catalog");
-const { summarizeAdapterDepthPack } = require("./adapter_depth_contract");
-const { loadExecutionTargetRegistry } = require("./external_execution_runtime");
-const { loadBsvSettlementRuntimeConfig } = require("./settlement_bsv_live");
-const { summarizeTreasuryDestinationsPack } = require("./treasury_destinations_contract");
-
-const NATIVE_RUNTIME_CATEGORIES = new Set([
-  "trust",
-  "receipt",
-  "runtime",
-  "jobs",
-  "credits",
-  "a2a",
-  "a2c",
-  "policy",
-  "identity",
-  "registry",
-  "anchoring",
-  "discovery",
-  "admission"
-]);
-
-function normalizeString(value) {
-  return typeof value === "string" ? value.trim() : "";
-}
-
-function hasMerchantIdentity() {
-  return Boolean(
-    normalizeString(process.env.XYTARA_BSV_TERANODE_MERCHANT_ADDRESS)
-    || normalizeString(process.env.XYTARA_BSV_TERANODE_MERCHANT_PAYMAIL)
-  );
-}
-
-function isLiveRuntimeMode(mode) {
-  return normalizeString(mode).toLowerCase() !== "mock";
-}
-
-function buildSettlementReadiness() {
-  const runtimeConfig = loadBsvSettlementRuntimeConfig();
-  const treasurySummary = summarizeTreasuryDestinationsPack();
-  const liveMode = isLiveRuntimeMode(runtimeConfig.mode);
-  const merchantConfigured = hasMerchantIdentity();
-  const treasuryConfigured = Number(treasurySummary.configured_profile_count || 0) > 0;
-  const ready = liveMode && merchantConfigured && treasuryConfigured;
-  return {
-    ready,
-    runtime_mode: runtimeConfig.mode,
-    merchant_identity_configured: merchantConfigured,
-    treasury_configured: treasuryConfigured,
-    configured_profile_count: Number(treasurySummary.configured_profile_count || 0),
-    explicit_per_rail_configured_count: Number(treasurySummary.explicit_per_rail_configured_count || 0)
-  };
-}
-
-function findMatchingExecutionTargets(task) {
-  const targets = loadExecutionTargetRegistry();
-  const taskRefs = new Set(
-    [task && task.task_ref, task && task.public_task_ref]
-      .map((value) => normalizeString(value))
-      .filter(Boolean)
-  );
-  return targets.filter((target) => {
-    const targetTaskRef = normalizeString(target && target.task_ref);
-    if (targetTaskRef && taskRefs.has(targetTaskRef)) return true;
-    if (
-      normalizeString(task && task.public_task_ref) === "adapter.mcp.invoke"
-      || normalizeString(task && task.public_task_ref).startsWith("adapter.mcp.")
-    ) {
-      return Boolean(normalizeString(target && target.tool_name) || normalizeString(target && target.integration_id));
-    }
-    return false;
-  });
-}
-
-function classifyTask(task, settlementReadiness) {
-  const matches = findMatchingExecutionTargets(task);
-  const providerTargets = matches.map((target) => ({
-    target_id: target.target_id,
-    provider: target.provider,
-    task_ref: target.task_ref || null,
-    tool_name: target.tool_name || null,
-    integration_id: target.integration_id || null,
-    enabled: target.enabled !== false
-  }));
-
-  if (normalizeString(task && task.public_category) === "settlement") {
-    return {
-      task_ref: task.public_task_ref,
-      internal_task_ref: task.task_ref,
-      public_title: task.public_title,
-      public_category: task.public_category,
-      execution_mode: task.execution_mode,
-      latency_class: task.latency_class,
-      execution_truth: settlementReadiness.ready ? "native_live" : "operator_inputs_pending",
-      execution_origin: "native_settlement_runtime",
-      commercialization_posture: settlementReadiness.ready ? "sellable_live_now" : "sellable_when_operator_configured",
-      matching_execution_target_count: providerTargets.length,
-      matching_execution_targets: providerTargets,
-      requirements: {
-        bsv_runtime_mode: settlementReadiness.runtime_mode,
-        merchant_identity_configured: settlementReadiness.merchant_identity_configured,
-        treasury_configured: settlementReadiness.treasury_configured
-      }
-    };
-  }
-
-  if (normalizeString(task && task.public_category) === "adapter") {
-    // Only ENABLED targets make an adapter lane live — a bound-but-disabled target must not be
-    // reported as provider_live (adapter-depth filters the same way; the two surfaces must agree).
-    const enabledTargets = providerTargets.filter((target) => target.enabled);
-    return {
-      task_ref: task.public_task_ref,
-      internal_task_ref: task.task_ref,
-      public_title: task.public_title,
-      public_category: task.public_category,
-      execution_mode: task.execution_mode,
-      latency_class: task.latency_class,
-      execution_truth: enabledTargets.length > 0 ? "provider_live" : "provider_wiring_required",
-      execution_origin: enabledTargets.length > 0 ? "external_execution_target" : "adapter_lane_without_bound_target",
-      commercialization_posture: enabledTargets.length > 0 ? "sellable_live_now" : "sellable_by_integration",
-      matching_execution_target_count: enabledTargets.length,
-      disabled_execution_target_count: providerTargets.length - enabledTargets.length,
-      matching_execution_targets: providerTargets,
-      requirements: {
-        configured_provider_target_required: true
-      }
-    };
-  }
-
-  if (NATIVE_RUNTIME_CATEGORIES.has(normalizeString(task && task.public_category))) {
-    return {
-      task_ref: task.public_task_ref,
-      internal_task_ref: task.task_ref,
-      public_title: task.public_title,
-      public_category: task.public_category,
-      execution_mode: task.execution_mode,
-      latency_class: task.latency_class,
-      execution_truth: "native_live",
-      execution_origin: "native_runtime_contract",
-      commercialization_posture: "sellable_live_now",
-      matching_execution_target_count: providerTargets.length,
-      matching_execution_targets: providerTargets,
-      requirements: {
-        configured_provider_target_required: false
-      }
-    };
-  }
-
-  return {
-    task_ref: task.public_task_ref,
-    internal_task_ref: task.task_ref,
-    public_title: task.public_title,
-    public_category: task.public_category,
-    execution_mode: task.execution_mode,
-    latency_class: task.latency_class,
-    execution_truth: providerTargets.length > 0 ? "provider_live" : "operator_classification_required",
-    execution_origin: providerTargets.length > 0 ? "external_execution_target" : "uncategorized_runtime_surface",
-    commercialization_posture: providerTargets.length > 0 ? "sellable_live_now" : "hold_until_classified",
-    matching_execution_target_count: providerTargets.length,
-    matching_execution_targets: providerTargets,
-    requirements: {
-      configured_provider_target_required: providerTargets.length < 1
-    }
-  };
-}
-
-function buildCapabilityExecutionTruthBundle() {
-  const settlementReadiness = buildSettlementReadiness();
-  const adapterDepth = summarizeAdapterDepthPack();
-  const tasks = (Array.isArray(catalog.tasks) ? catalog.tasks : []).map((task) => classifyTask(task, settlementReadiness));
-  const counts = {
-    task_count: tasks.length,
-    native_live_count: tasks.filter((task) => task.execution_truth === "native_live").length,
-    provider_live_count: tasks.filter((task) => task.execution_truth === "provider_live").length,
-    operator_inputs_pending_count: tasks.filter((task) => task.execution_truth === "operator_inputs_pending").length,
-    provider_wiring_required_count: tasks.filter((task) => task.execution_truth === "provider_wiring_required").length,
-    operator_classification_required_count: tasks.filter((task) => task.execution_truth === "operator_classification_required").length
-  };
-
-  return {
-    ok: true,
-    product: packageJson.name,
-    category: "machine-commerce-capability-execution-truth",
-    bundle_version: "xytara-capability-execution-truth-v1",
-    execution_posture: {
-      native_runtime_categories: Array.from(NATIVE_RUNTIME_CATEGORIES.values()),
-      settlement_readiness: settlementReadiness,
-      configured_execution_target_count: loadExecutionTargetRegistry().length,
-      adapter_depth_state: adapterDepth.adapter_depth_state,
-      adapter_depth_counts: adapterDepth.counts
-    },
-    counts,
-    tasks,
-    linked_surfaces: {
-      capability_registry_ref: "/v1/capability-registry",
-      execution_truth_summary_ref: "/v1/capability-registry/execution-truth/summary",
-      adapter_depth_ref: "/v1/adapter-depth",
-      adapter_depth_summary_ref: "/v1/adapter-depth/summary",
-      treasury_readiness_ref: "/v1/treasury-destinations",
-      native_settlement_readiness_ref: "/v1/settlement/bsv-teranode/readiness"
-    }
-  };
-}
-
-function summarizeCapabilityExecutionTruthBundle() {
-  const bundle = buildCapabilityExecutionTruthBundle();
-  return {
-    ok: true,
-    product: bundle.product,
-    category: bundle.category,
-    bundle_version: bundle.bundle_version,
-    counts: bundle.counts,
-    execution_posture: bundle.execution_posture,
-    linked_surfaces: bundle.linked_surfaces
-  };
-}
-
-function buildCapabilityCommercializationSummary() {
-  const bundle = buildCapabilityExecutionTruthBundle();
-  const tasks = Array.isArray(bundle.tasks) ? bundle.tasks : [];
-  const selfServeLiveNow = tasks.filter((task) =>
-    task.commercialization_posture === "sellable_live_now"
-  );
-  const operatorEnabledAfterConfig = tasks.filter((task) =>
-    task.commercialization_posture === "sellable_when_operator_configured"
-    || task.commercialization_posture === "sellable_by_integration"
-  );
-  const holdUntilClassified = tasks.filter((task) =>
-    task.commercialization_posture === "hold_until_classified"
-  );
-
-  return {
-    ok: true,
-    product: packageJson.name,
-    category: "machine-commerce-capability-commercialization-summary",
-    summary_version: "xytara-capability-commercialization-summary-v1",
-    commercialization_posture: {
-      primary_agent_entry_surfaces: ["x402", "mcp", "a2a", "a2c", "http_api"],
-      secondary_human_entry_surfaces: ["hosted_checkout", "web_docs", "npm_package"],
-      primary_payment_surfaces: ["x402", "credits", "hosted_checkout"],
-      discovery_surfaces: ["capability_registry", "catalog", "execution_truth"]
-    },
-    counts: {
-      self_serve_live_now: selfServeLiveNow.length,
-      operator_enabled_after_config: operatorEnabledAfterConfig.length,
-      hold_until_classified: holdUntilClassified.length
-    },
-    sellable_now_task_refs: selfServeLiveNow.map((task) => task.task_ref),
-    operator_enabled_task_refs: operatorEnabledAfterConfig.map((task) => task.task_ref),
-    hold_task_refs: holdUntilClassified.map((task) => task.task_ref),
-    recommendations: [
-      "Use x402 for machine-native pay-per-use access and keep hosted checkout as the human-friendly money-in lane.",
-      "Expose MCP and A2A entry paths for interoperable agent consumption while preserving execution-truth visibility.",
-      "Only market provider-backed capabilities as instant self-serve once execution targets are configured and operator readiness is green."
-    ],
-    linked_surfaces: {
-      capability_registry_ref: "/v1/capability-registry",
-      execution_truth_ref: "/v1/capability-registry/execution-truth",
-      execution_truth_summary_ref: "/v1/capability-registry/execution-truth/summary",
-      x402_ref: "/v1/x402",
-      mcp_ref: "/v1/mcp",
-      a2a_ref: "/v1/a2a",
-      a2c_ref: "/v1/a2c",
-      checkout_ref: "/v1/checkout/purchase-intents"
-    }
-  };
-}
-
-module.exports = {
-  buildCapabilityExecutionTruthBundle,
-  summarizeCapabilityExecutionTruthBundle,
-  buildCapabilityCommercializationSummary
-};