xytara 2.0.0 → 2.2.0

package/lib/release_history.js

@@ -0,0 +1,72 @@
+"use strict";
+
+const packageJson = require("../package.json");
+
+function buildReleaseHistory() {
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "machine-commerce-release-history",
+    current_version: packageJson.version,
+    release_track: "public_release",
+    history: [
+      {
+        version: "2.2.0",
+        channel: "public_release",
+        maturity_posture: "launch_ready",
+        headline: "public machine-commerce release-candidate with release-center, announcement, and candidate rehearsal surfaces",
+        milestone_refs: [
+          "runtime_and_economics_spine",
+          "native_settlement_observe_path",
+          "operator_pack_surfaces",
+          "release_pack_surfaces",
+          "release_center_surfaces",
+          "announcement_pack_surfaces",
+          "release_candidate_surfaces"
+        ]
+      },
+      {
+        version: "2.0.0",
+        channel: "public_release",
+        maturity_posture: "launch_ready",
+        headline: "public machine-commerce release with direct run, launch packaging, and release center surfaces",
+        milestone_refs: [
+          "runtime_and_economics_spine",
+          "native_settlement_observe_path",
+          "operator_pack_surfaces",
+          "release_pack_surfaces",
+          "release_center_surfaces"
+        ]
+      },
+      {
+        version: "1.x",
+        channel: "pre_public_foundation",
+        maturity_posture: "foundation_building",
+        headline: "pre-public commerce runtime, catalog, and settlement groundwork",
+        milestone_refs: [
+          "catalog_contract_growth",
+          "integration_registry_growth",
+          "commerce_runtime_foundations"
+        ]
+      }
+    ]
+  };
+}
+
+function summarizeReleaseHistory() {
+  const history = buildReleaseHistory();
+  return {
+    ok: true,
+    product: history.product,
+    category: history.category,
+    current_version: history.current_version,
+    release_count: history.history.length,
+    latest_channel: history.history[0].channel,
+    latest_maturity_posture: history.history[0].maturity_posture
+  };
+}
+
+module.exports = {
+  buildReleaseHistory,
+  summarizeReleaseHistory
+};

package/lib/release_manifest.js

@@ -0,0 +1,114 @@
+"use strict";
+
+const packageJson = require("../package.json");
+
+function buildReleaseManifest() {
+  return {
+    ok: true,
+    product: packageJson.name,
+    version: packageJson.version,
+    release_track: "public_release",
+    package: {
+      name: packageJson.name,
+      version: packageJson.version,
+      description: packageJson.description,
+      license: packageJson.license,
+      homepage: packageJson.homepage,
+      repository: packageJson.repository && packageJson.repository.url ? packageJson.repository.url : null
+    },
+    install: {
+      install_command: "npm install xytara",
+      engine: packageJson.engines && packageJson.engines.node ? packageJson.engines.node : null,
+      start_command: "npm start",
+      verify_command: "npm run verify:all"
+    },
+    package_entrypoints: {
+      main: packageJson.main,
+      bin: packageJson.bin || {}
+    },
+    published_files: Array.isArray(packageJson.files) ? packageJson.files.slice() : [],
+    verification_surfaces: [
+      "verify:package",
+      "verify:integrations",
+      "verify:adapters",
+      "verify:tooling",
+      "verify:examples",
+      "verify:service"
+    ],
+    public_contract_docs: [
+      "README.md",
+      "START_HERE.md",
+      "RELEASE_CHECKLIST.md",
+      "FINAL_CONTRACT.md",
+      "SERVICE_CONTRACT.md",
+      "BSV_TERANODE_SETUP.md",
+      "REAL_PAYMENT_SETUP.md"
+    ]
+  };
+}
+
+function summarizeReleaseManifest() {
+  const manifest = buildReleaseManifest();
+  return {
+    ok: true,
+    product: manifest.product,
+    version: manifest.version,
+    release_track: manifest.release_track,
+    published_file_count: manifest.published_files.length,
+    verification_surface_count: manifest.verification_surfaces.length,
+    doc_count: manifest.public_contract_docs.length,
+    bin_count: Object.keys(manifest.package_entrypoints.bin || {}).length
+  };
+}
+
+function buildLaunchNotes() {
+  return {
+    ok: true,
+    product: packageJson.name,
+    version: packageJson.version,
+    release_notes: {
+      release_theme: "machine-commerce stack with direct run, release-candidate rehearsal, and operator-facing launch surfaces",
+      headline_capabilities: [
+        "one-line direct run cli",
+        "release, comparison, adoption, scenario, and launch packs",
+        "announcement, release-center, and release-candidate surfaces",
+        "credits-first machine spend posture",
+        "native settlement-aware runtime inspection",
+        "proof-compatible result handoff into xoonya"
+      ],
+      strongest_public_claims: [
+        "quote pay execute prove in one machine flow",
+        "governed execution for weak-trust agent interactions",
+        "settlement and metering continuity on the runtime side",
+        "clear proof followthrough instead of dead-end machine output"
+      ],
+      operator_checks_before_launch: [
+        "verify all package checks pass",
+        "verify release-candidate rehearsal passes",
+        "verify release-pack launch summary is reachable",
+        "verify runtime durability summary is healthy",
+        "verify native settlement readiness is healthy",
+        "verify first-run scenarios remain accurate"
+      ]
+    }
+  };
+}
+
+function summarizeLaunchNotes() {
+  const notes = buildLaunchNotes();
+  return {
+    ok: true,
+    product: notes.product,
+    version: notes.version,
+    headline_capability_count: notes.release_notes.headline_capabilities.length,
+    claim_count: notes.release_notes.strongest_public_claims.length,
+    operator_check_count: notes.release_notes.operator_checks_before_launch.length
+  };
+}
+
+module.exports = {
+  buildReleaseManifest,
+  summarizeReleaseManifest,
+  buildLaunchNotes,
+  summarizeLaunchNotes
+};

package/lib/release_pack.js

@@ -0,0 +1,454 @@
+"use strict";
+
+const packageJson = require("../package.json");
+const {
+  buildDefaultTransactionCenter,
+  summarizeCatalog,
+  summarizeCreditPacks,
+  summarizeDefaultTransactionEconomics,
+  summarizeDefaultTransactionGuidedLoops,
+  summarizeDefaultTransactionTaskPacks,
+  summarizeInteractionResultPackages,
+  summarizeInteractionSpinePaths,
+  summarizePrecommitInteractionPacks,
+  summarizeTransactionClassPacks
+} = require("./catalog_contract");
+const {
+  summarizeIntegrationProtocols,
+  summarizeIntegrationSettlementModes,
+  summarizeIntegrations
+} = require("../integrations/registry");
+
+function buildComparisonPack() {
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "machine-commerce-comparison",
+    comparisons: [
+      {
+        alternative: "runtime_only_stack",
+        missing_capabilities: [
+          "priced_quote_before_execution",
+          "native_payment_admission",
+          "reusable_credit_balance",
+          "settlement_aware_runtime_records",
+          "proof_ready_result_handoff"
+        ],
+        xytara_advantage: "one spine for discovery, pricing, payment or credit spend, execution, inspection, and proof-compatible handoff"
+      },
+      {
+        alternative: "payment_only_stack",
+        missing_capabilities: [
+          "task_catalog_and_workflow_classes",
+          "deterministic_usage_metering",
+          "runtime_result_packages",
+          "operator_payment_to_execution_linkage",
+          "post_payment_proof_followthrough"
+        ],
+        xytara_advantage: "payments remain attached to actual machine work, settlement state, treasury state, and result delivery"
+      },
+      {
+        alternative: "ad_hoc_agent_glue",
+        missing_capabilities: [
+          "stable_default_transaction_center",
+          "typed_task_pack_catalog",
+          "credit_and_entitlement_posture",
+          "operator_pack_surfaces",
+          "consistent_machine_contracts"
+        ],
+        xytara_advantage: "direct machine-commerce defaults reduce custom glue while preserving adapter breadth"
+      }
+    ],
+    strongest_reasons_to_try: [
+      "one-line direct run with payment-aware retry posture",
+      "credits-first repeat execution without changing the public runtime surface",
+      "operator-facing payment and settlement inspection surfaces",
+      "proof-compatible handoff into xoonya instead of dead-end runtime output"
+    ]
+  };
+}
+
+function summarizeComparisonPack() {
+  const pack = buildComparisonPack();
+  return {
+    ok: true,
+    product: pack.product,
+    comparison_count: pack.comparisons.length,
+    strongest_reason_count: pack.strongest_reasons_to_try.length,
+    alternatives: pack.comparisons.map((entry) => entry.alternative)
+  };
+}
+
+function buildAdoptionPack() {
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "machine-commerce-adoption",
+    positioning_line: "neutral machine transaction spine for agents that need governed execution, payment, proof, and replayability",
+    best_initial_wedge: "paid machine capability execution where trust is weak and proof matters",
+    initial_adoption_targets: [
+      {
+        target: "paid_agent_tools_and_services",
+        why_now: "builders already need quote, pay, execute, and inspect behavior around premium machine capabilities"
+      },
+      {
+        target: "cross_organization_agent_workflows",
+        why_now: "weak-trust interactions make payment and proof linkage materially more valuable than plain orchestration"
+      },
+      {
+        target: "high_frequency_microtask_systems",
+        why_now: "credits-first spend, deterministic metering, and reusable runtime posture reduce friction for repeated machine work"
+      },
+      {
+        target: "adapter_rich_execution_environments",
+        why_now: "protocol and settlement neutrality matters when teams do not want to lock into one runtime or one rail"
+      }
+    ],
+    target_ecosystems: [
+      "agent_builders",
+      "mcp_tool_authors",
+      "agent_marketplaces",
+      "x402_and_machine_payment_builders",
+      "weak_trust_multi_org_automation_teams"
+    ],
+    first_success_paths: [
+      {
+        path: "direct_pay_single_run",
+        start_with: "xytara-run",
+        success_condition: "agent discovers one capability, quotes it, pays, executes, and receives inspectable result records"
+      },
+      {
+        path: "credits_first_repeat_run",
+        start_with: "credit_pack_and_balance_surfaces",
+        success_condition: "funded agent reuses credits across repeated tasks without changing the public execution surface"
+      },
+      {
+        path: "runtime_to_proof_followthrough",
+        start_with: "result_package_export",
+        success_condition: "runtime output continues directly into xoonya proof review without ad hoc glue"
+      }
+    ],
+    what_to_say_publicly: [
+      "quote pay execute prove in one machine flow",
+      "governed execution for weak-trust agent interactions",
+      "payment, settlement, metering, and proof continuity in one stack",
+      "adapter-first machine commerce instead of one-off glue"
+    ],
+    what_not_to_lead_with: [
+      "just another agent framework",
+      "generic ai infrastructure",
+      "wallet-first branding",
+      "provider-specific lock-in language"
+    ]
+  };
+}
+
+function summarizeAdoptionPack() {
+  const pack = buildAdoptionPack();
+  return {
+    ok: true,
+    product: pack.product,
+    wedge: pack.best_initial_wedge,
+    target_count: pack.initial_adoption_targets.length,
+    ecosystem_count: pack.target_ecosystems.length,
+    first_success_path_count: pack.first_success_paths.length,
+    lead_message_count: pack.what_to_say_publicly.length
+  };
+}
+
+function buildScenarioPack() {
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "machine-commerce-scenarios",
+    scenarios: [
+      {
+        scenario_ref: "scenario.direct_pay.trust_verify",
+        title: "Direct Pay Trust Verify",
+        intended_for: "first_paid_machine_call",
+        why_it_matters: "shows the full quote pay execute inspect loop with the smallest strong-signal task",
+        steps: [
+          "inspect /v1/catalog/summary",
+          "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",
+        surfaces: [
+          "/v1/catalog/summary",
+          "/x402/commands/execute",
+          "/v1/payment-ledger",
+          "/v1/settlement/bsv-teranode"
+        ],
+        success_signals: [
+          "transaction recorded",
+          "payment admitted",
+          "settlement record created",
+          "deliverable available"
+        ]
+      },
+      {
+        scenario_ref: "scenario.credits_first.repeat_run",
+        title: "Credits-First Repeat Run",
+        intended_for: "reusable_machine_balance",
+        why_it_matters: "shows repeat machine execution without reintroducing pay-in friction for each call",
+        steps: [
+          "fund credits through credit packs or external grant",
+          "inspect credit balance",
+          "execute with payment_preference credits_first",
+          "inspect usage meters and entitlements"
+        ],
+        entrypoint: "POST /v1/commands/execute with payment_preference=credits_first",
+        surfaces: [
+          "/v1/credit-packs/summary",
+          "/v1/economics/accounts/:account_id/credit-balance",
+          "/v1/economics/accounts/:account_id/usage-meters",
+          "/v1/economics/accounts/:account_id/entitlements"
+        ],
+        success_signals: [
+          "available units decrease",
+          "usage meter recorded",
+          "same execution surface reused",
+          "no extra payment challenge required"
+        ]
+      },
+      {
+        scenario_ref: "scenario.runtime_to_proof.followthrough",
+        title: "Runtime To Proof Followthrough",
+        intended_for: "proof_aware_machine_execution",
+        why_it_matters: "shows that runtime output is not a dead end and can continue into proof review directly",
+        steps: [
+          "execute one transaction-class or default loop",
+          "export result package or economic consequence handoff",
+          "continue into xoonya review"
+        ],
+        entrypoint: "POST /v1/transaction-center/result-packages/export or xytara result-package surfaces",
+        surfaces: [
+          "/v1/transaction-center/result-packages",
+          "/v1/transaction-center/result-package/export-template",
+          "/v1/economics/handoff-bundles/economic-consequence"
+        ],
+        success_signals: [
+          "result package produced",
+          "handoff bundle emitted",
+          "proof-side review path clear"
+        ]
+      }
+    ]
+  };
+}
+
+function summarizeScenarioPack() {
+  const pack = buildScenarioPack();
+  return {
+    ok: true,
+    product: pack.product,
+    scenario_count: pack.scenarios.length,
+    scenario_refs: pack.scenarios.map((entry) => entry.scenario_ref),
+    first_entrypoint: pack.scenarios[0] ? pack.scenarios[0].entrypoint : null
+  };
+}
+
+function buildLaunchPack(options = {}) {
+  const releaseSummary = summarizeReleasePack();
+  const comparisonSummary = summarizeComparisonPack();
+  const adoptionSummary = summarizeAdoptionPack();
+  const scenarioSummary = summarizeScenarioPack();
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "machine-commerce-launch-pack",
+    launch_readiness: {
+      release_summary: releaseSummary,
+      comparison_summary: comparisonSummary,
+      adoption_summary: adoptionSummary,
+      scenario_summary: scenarioSummary,
+      live_readiness: options.liveReadiness || null,
+      operator_posture: {
+        payment_ledger_surface: "/v1/payment-ledger",
+        settlement_surface: "/v1/settlement/bsv-teranode",
+        durability_surface: "/v1/runtime/durability"
+      }
+    },
+    launch_operator_checks: [
+      "release summary is reachable",
+      "comparison summary is reachable",
+      "adoption summary is reachable",
+      "scenario summary is reachable",
+      "runtime durability is inspectable",
+      "native settlement readiness is inspectable"
+    ],
+    first_public_pointer: "/v1/release-pack/launch/summary"
+  };
+}
+
+function summarizeLaunchPack(options = {}) {
+  const pack = buildLaunchPack(options);
+  return {
+    ok: true,
+    product: pack.product,
+    category: pack.category,
+    task_count: pack.launch_readiness.release_summary.task_count,
+    integration_count: pack.launch_readiness.release_summary.integration_count,
+    comparison_count: pack.launch_readiness.comparison_summary.comparison_count,
+    target_count: pack.launch_readiness.adoption_summary.target_count,
+    scenario_count: pack.launch_readiness.scenario_summary.scenario_count,
+    operator_check_count: pack.launch_operator_checks.length,
+    live_ready: pack.launch_readiness.live_readiness ? pack.launch_readiness.live_readiness.ready : null
+  };
+}
+
+function buildReleasePack() {
+  const transactionCenter = buildDefaultTransactionCenter();
+  const catalogSummary = summarizeCatalog();
+  const transactionEconomics = summarizeDefaultTransactionEconomics();
+  const taskPackSummary = summarizeDefaultTransactionTaskPacks();
+  const guidedLoopSummary = summarizeDefaultTransactionGuidedLoops();
+  const transactionClassSummary = summarizeTransactionClassPacks();
+  const precommitSummary = summarizePrecommitInteractionPacks();
+  const spineSummary = summarizeInteractionSpinePaths();
+  const resultPackageSummary = summarizeInteractionResultPackages();
+  const creditPackSummary = summarizeCreditPacks();
+  const integrationSummary = summarizeIntegrations();
+  const protocolSummary = summarizeIntegrationProtocols();
+  const settlementModeSummary = summarizeIntegrationSettlementModes();
+  const defaultProtocol = transactionCenter && transactionCenter.default_protocol
+    ? transactionCenter.default_protocol.protocol
+    : null;
+  const defaultPaymentProtocol = transactionCenter && transactionCenter.default_payment
+    ? transactionCenter.default_payment.protocol
+    : null;
+  const defaultSettlementMode = transactionCenter && transactionCenter.default_settlement
+    ? transactionCenter.default_settlement.settlement_mode
+    : null;
+
+  return {
+    ok: true,
+    product: {
+      name: packageJson.name,
+      version: packageJson.version,
+      description: packageJson.description,
+      homepage: packageJson.homepage,
+      repository: packageJson.repository && packageJson.repository.url ? packageJson.repository.url : null,
+      license: packageJson.license
+    },
+    positioning: {
+      category: "machine-commerce-spine",
+      primary_audiences: [
+        "agent_builders",
+        "machine_economy_developers",
+        "adapter_authors",
+        "settlement_aware_runtime_operators"
+      ],
+      core_claims: [
+        "discover_quote_pay_execute_inspect_handoff",
+        "credits_first_or_direct_payment",
+        "deterministic_usage_metering",
+        "settlement_aware_runtime_records",
+        "proof_compatible_handoff_into_xoonya"
+      ]
+    },
+    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",
+      discovery_surface: "/v1/catalog/summary",
+      transaction_center_surface: "/v1/transaction-center/summary",
+      economics_surface: "/v1/transaction-center/economics/summary",
+      handoff_expectation: "transaction result packages should continue into xoonya proof review and proof-native completion"
+    },
+    package_usage: {
+      install_command: "npm install xytara",
+      verify_command: "npm run verify:all",
+      local_service_command: "npm start",
+      release_cli: "xytara-release --summary",
+      docs: [
+        "README.md",
+        "START_HERE.md",
+        "FINAL_CONTRACT.md",
+        "SERVICE_CONTRACT.md",
+        "BSV_TERANODE_SETUP.md",
+        "REAL_PAYMENT_SETUP.md"
+      ]
+    },
+    default_path: {
+      protocol: defaultProtocol,
+      payment_protocol: defaultPaymentProtocol,
+      settlement_mode: defaultSettlementMode,
+      suggested_paths: Array.isArray(transactionCenter && transactionCenter.suggested_paths)
+        ? transactionCenter.suggested_paths
+        : []
+    },
+    commerce_loop: {
+      stages: ["discover", "quote", "pay_or_spend", "execute", "deliver", "inspect", "prove"],
+      spend_postures: ["direct_payment", "credits_first", "bounded_spend_credential"],
+      operator_surfaces: [
+        "/v1/operator-shell/summary",
+        "/v1/payment-ledger",
+        "/v1/settlement/bsv-teranode",
+        "/v1/runtime/durability"
+      ]
+    },
+    catalog_summary: catalogSummary,
+    transaction_economics_summary: transactionEconomics,
+    task_pack_summary: taskPackSummary,
+    guided_loop_summary: guidedLoopSummary,
+    transaction_class_summary: transactionClassSummary,
+    precommit_summary: precommitSummary,
+    spine_summary: spineSummary,
+    result_package_summary: resultPackageSummary,
+    credit_pack_summary: creditPackSummary,
+    integration_summary: integrationSummary,
+    protocol_summary: protocolSummary,
+    settlement_mode_summary: settlementModeSummary
+  };
+}
+
+function summarizeReleasePack() {
+  const pack = buildReleasePack();
+  return {
+    ok: true,
+    product: pack.product.name,
+    version: pack.product.version,
+    category: pack.positioning.category,
+    primary_audience_count: pack.positioning.primary_audiences.length,
+    core_claim_count: pack.positioning.core_claims.length,
+    default_protocol: pack.default_path.protocol,
+    default_payment_protocol: pack.default_path.payment_protocol,
+    default_settlement_mode: pack.default_path.settlement_mode,
+    suggested_path_count: Array.isArray(pack.default_path.suggested_paths) ? pack.default_path.suggested_paths.length : 0,
+    task_count: pack.catalog_summary.task_count,
+    workflow_count: pack.catalog_summary.workflow_count,
+    credit_pack_count: pack.credit_pack_summary.credit_pack_count,
+    integration_count: pack.integration_summary.integration_count,
+    production_default_integration_count: pack.integration_summary.production_default_count,
+    protocol_count: pack.protocol_summary.protocol_count,
+    settlement_mode_count: pack.settlement_mode_summary.settlement_mode_count,
+    transaction_class_count: pack.transaction_class_summary.class_pack_count,
+    result_package_count: pack.result_package_summary.result_package_count,
+    first_contact_cli: pack.first_contact.direct_run_cli,
+    install_command: pack.package_usage.install_command,
+    verify_command: pack.package_usage.verify_command,
+    release_cli: pack.package_usage.release_cli,
+    doc_count: pack.package_usage.docs.length,
+    comparison_surface: "/v1/release-pack/comparison",
+    comparison_cli: "xytara-release --comparison",
+    adoption_surface: "/v1/release-pack/adoption",
+    adoption_cli: "xytara-release --adoption",
+    scenario_surface: "/v1/release-pack/scenarios",
+    scenario_cli: "xytara-release --scenarios",
+    launch_surface: "/v1/release-pack/launch",
+    launch_cli: "xytara-release --launch"
+  };
+}
+
+module.exports = {
+  buildReleasePack,
+  summarizeReleasePack,
+  buildComparisonPack,
+  summarizeComparisonPack,
+  buildAdoptionPack,
+  summarizeAdoptionPack,
+  buildScenarioPack,
+  summarizeScenarioPack,
+  buildLaunchPack,
+  summarizeLaunchPack
+};