xoonya 2.0.0 → 2.1.0

package/lib/release_pack.js

@@ -0,0 +1,391 @@
+"use strict";
+
+const packageJson = require("../package.json");
+const proofSdk = require("../proof_sdk");
+const { summarizeIntegrations } = require("../integrations/registry");
+
+function buildComparisonPack() {
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "proof-comparison",
+    comparisons: [
+      {
+        alternative: "runtime_only_result_logs",
+        missing_capabilities: [
+          "deterministic_canonical_event_model",
+          "portable_receipt_boundary",
+          "proof_bundle_verification",
+          "proof_side_review_before_followthrough",
+          "replayable_evidence_contract"
+        ],
+        xoonya_advantage: "runtime output becomes durable proof material instead of unstructured logs"
+      },
+      {
+        alternative: "receipt_only_minimalism",
+        missing_capabilities: [
+          "proof_bundle_layer",
+          "bridge_carry_for_runtime_context",
+          "governance_and_operator_review_surfaces",
+          "result_package_handoff_review",
+          "proof_side_default_loops"
+        ],
+        xoonya_advantage: "keeps base proof narrow while still supporting richer portable verification and review flows"
+      },
+      {
+        alternative: "settlement_specific_proof_system",
+        missing_capabilities: [
+          "settlement_agnostic_proof_core",
+          "workflow_agnostic_proof_contract",
+          "bridge_for_multiple_runtime_sources",
+          "cross_runtime_replay_posture",
+          "adapter_friendly_handoff_boundary"
+        ],
+        xoonya_advantage: "one proof contract can survive changing payment rails, runtimes, and adapters"
+      }
+    ],
+    strongest_reasons_to_try: [
+      "one-line proof-side review for carried handoff bundles",
+      "canonical proof contract independent of payment and settlement churn",
+      "bridge/governance surfaces for real operator review instead of opaque proof blobs",
+      "deterministic carry of runtime economics and settlement refs without widening proof scope"
+    ]
+  };
+}
+
+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: "proof-adoption",
+    positioning_line: "proof spine for machine systems that need deterministic evidence, reviewable handoff, and replayable verification",
+    best_initial_wedge: "proof-side review and verification for machine actions that cross trust boundaries",
+    initial_adoption_targets: [
+      {
+        target: "runtime_builders_needing_proof_followthrough",
+        why_now: "many systems can execute work, but far fewer can hand runtime results into a stable proof-native contract"
+      },
+      {
+        target: "operators_needing_reviewable_machine_evidence",
+        why_now: "bridge and governance surfaces help teams inspect proof posture instead of trusting opaque receipts"
+      },
+      {
+        target: "adapter_integrators_with_multiple_runtime_sources",
+        why_now: "a narrow proof core is more durable when runtimes, payment rails, or settlement modes change"
+      },
+      {
+        target: "cross_runtime_replay_and_audit_flows",
+        why_now: "deterministic carry and replayable bundles matter when machine actions may later be disputed or verified"
+      }
+    ],
+    target_ecosystems: [
+      "runtime_verifiers",
+      "proof_operators",
+      "agent_builders",
+      "cross_runtime_audit_teams",
+      "adapter_integrators"
+    ],
+    first_success_paths: [
+      {
+        path: "carried_handoff_review",
+        start_with: "xoonya-review",
+        success_condition: "review summary exposes proof readiness and carried economic context from one handoff bundle"
+      },
+      {
+        path: "proof_center_default_loop",
+        start_with: "/v1/proof-center/default-loops/run",
+        success_condition: "builder creates and verifies a proof bundle through the default proof-native loop"
+      },
+      {
+        path: "result_package_handoff_followthrough",
+        start_with: "/v1/proof-center/result-package-handoff/review/summary",
+        success_condition: "runtime result package becomes a stable proof-side continuation instead of dead-end output"
+      }
+    ],
+    what_to_say_publicly: [
+      "deterministic proof contract independent of runtime churn",
+      "reviewable handoff before proof-native continuation",
+      "portable proof bundles instead of opaque logs",
+      "bridge and governance surfaces for real operator trust"
+    ],
+    what_not_to_lead_with: [
+      "proof only for one settlement rail",
+      "workflow-specific proof lock-in",
+      "receipt-only minimalism as the whole story",
+      "opaque cryptographic branding without machine usability"
+    ]
+  };
+}
+
+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: "proof-scenarios",
+    scenarios: [
+      {
+        scenario_ref: "scenario.carried_handoff.review",
+        title: "Carried Handoff Review",
+        intended_for: "first_proof_side_intake",
+        why_it_matters: "shows how a machine runtime handoff becomes a reviewable proof-side boundary",
+        steps: [
+          "take one handoff bundle from xytara or inline json",
+          "run xoonya-review --summary",
+          "inspect proof readiness and economic audit carry"
+        ],
+        entrypoint: "xoonya-review --file ./handoff.json --summary",
+        surfaces: [
+          "/v1/proof-center/result-package-handoff/review/summary",
+          "/v1/proof-center/result-package-handoff/review/bridge-summary"
+        ],
+        success_signals: [
+          "review accepted",
+          "run_ready true",
+          "economic audit summary preserved"
+        ]
+      },
+      {
+        scenario_ref: "scenario.default_proof.loop",
+        title: "Default Proof Loop",
+        intended_for: "proof_native_builder",
+        why_it_matters: "shows the narrow proof-native path without requiring the full commerce stack first",
+        steps: [
+          "construct one canonical event",
+          "run default proof loop",
+          "verify bundle and receipt"
+        ],
+        entrypoint: "POST /v1/proof-center/default-loops/run",
+        surfaces: [
+          "/v1/proof-center/summary",
+          "/v1/proof-center/default-loops",
+          "/v1/proof-center/default-loops/run"
+        ],
+        success_signals: [
+          "proof bundle created",
+          "receipt verified",
+          "bundle verification valid"
+        ]
+      },
+      {
+        scenario_ref: "scenario.result_package.followthrough",
+        title: "Result Package Followthrough",
+        intended_for: "runtime_to_proof_continuation",
+        why_it_matters: "shows that xoonya can become the stable proof continuation for runtime outputs from other systems",
+        steps: [
+          "receive a result package handoff",
+          "review continuation posture",
+          "run proof-native continuation"
+        ],
+        entrypoint: "POST /v1/proof-center/result-package-handoff/review/summary",
+        surfaces: [
+          "/v1/proof-center/result-package-handoff",
+          "/v1/proof-center/result-package-handoff/review/summary",
+          "/v1/proof-center/result-package-handoff/run"
+        ],
+        success_signals: [
+          "stable handoff contract visible",
+          "proof continuation path clear",
+          "bridge and governance followthrough available"
+        ]
+      }
+    ]
+  };
+}
+
+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() {
+  const releaseSummary = summarizeReleasePack();
+  const comparisonSummary = summarizeComparisonPack();
+  const adoptionSummary = summarizeAdoptionPack();
+  const scenarioSummary = summarizeScenarioPack();
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "proof-launch-pack",
+    launch_readiness: {
+      release_summary: releaseSummary,
+      comparison_summary: comparisonSummary,
+      adoption_summary: adoptionSummary,
+      scenario_summary: scenarioSummary,
+      proof_posture: {
+        proof_center_surface: "/v1/proof-center/summary",
+        bridge_surface: "/v1/proof-center/bridge/summary",
+        governance_surface: "/v1/proof-center/governance/summary"
+      }
+    },
+    launch_operator_checks: [
+      "release summary is reachable",
+      "comparison summary is reachable",
+      "adoption summary is reachable",
+      "scenario summary is reachable",
+      "proof center summary is reachable",
+      "bridge summary is reachable",
+      "governance summary is reachable"
+    ],
+    first_public_pointer: "/v1/release-pack/launch/summary"
+  };
+}
+
+function summarizeLaunchPack() {
+  const pack = buildLaunchPack();
+  return {
+    ok: true,
+    product: pack.product,
+    category: pack.category,
+    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,
+    proof_bundle_version: pack.launch_readiness.release_summary.proof_bundle_version
+  };
+}
+
+function buildReleasePack() {
+  const proofCenterSummary = proofSdk.summarizeDefaultProofCenter();
+  const proofLoopSummary = proofSdk.summarizeDefaultProofLoops();
+  const transactionHandoffSummary = proofSdk.summarizeTransactionProofHandoffCenter();
+  const interactionSpineHandoffSummary = proofSdk.summarizeInteractionSpineProofHandoffCenter();
+  const resultPackageHandoffSummary = proofSdk.summarizeInteractionResultPackageHandoffCenter();
+  const bridgeSummary = proofSdk.summarizeBridgeCenter();
+  const governanceSummary = proofSdk.summarizeGovernanceCenter();
+  const integrationSummary = summarizeIntegrations();
+
+  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: "proof-spine",
+      primary_audiences: [
+        "agent_builders",
+        "runtime_verifiers",
+        "proof_operators",
+        "adapter_integrators"
+      ],
+      core_claims: [
+        "deterministic_canonical_event_and_receipt_model",
+        "portable_proof_bundle_verification",
+        "replayable_machine_evidence",
+        "narrow_bridge_for_runtime_carry",
+        "result_package_handoff_review_and_run"
+      ]
+    },
+    first_contact: {
+      install: "npm install xoonya",
+      review_cli: "xoonya-review --file ./handoff.json --summary",
+      proof_center_surface: "/v1/proof-center/summary",
+      handoff_review_surface: "/v1/proof-center/result-package-handoff/review/summary",
+      handoff_run_surface: "/v1/proof-center/result-package-handoff/run",
+      bridge_surface: "/v1/proof-center/bridge/summary"
+    },
+    package_usage: {
+      install_command: "npm install xoonya",
+      verify_command: "npm run verify:all",
+      local_service_command: "npm start",
+      release_cli: "xoonya-release --summary",
+      docs: [
+        "README.md",
+        "START_HERE.md",
+        "FINAL_CONTRACT.md",
+        "SERVICE_CONTRACT.md",
+        "CROSS_RUNTIME_POSTURE.md",
+        "COMPATIBILITY_NOTE.md"
+      ]
+    },
+    proof_model: proofCenterSummary,
+    proof_loop_summary: proofLoopSummary,
+    transaction_handoff_summary: transactionHandoffSummary,
+    interaction_spine_handoff_summary: interactionSpineHandoffSummary,
+    result_package_handoff_summary: resultPackageHandoffSummary,
+    bridge_summary: bridgeSummary,
+    governance_summary: governanceSummary,
+    integration_summary: integrationSummary
+  };
+}
+
+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,
+    proof_bundle_version: pack.proof_model.proof_bundle_version,
+    helper_count: pack.proof_model.helper_count,
+    loop_count: pack.proof_loop_summary.loop_count,
+    transaction_handoff_source_count: pack.transaction_handoff_summary.supported_source_ref_count,
+    interaction_spine_source_count: pack.interaction_spine_handoff_summary.supported_source_ref_count,
+    result_package_source_count: pack.result_package_handoff_summary.supported_source_ref_count,
+    integration_count: pack.integration_summary.integration_count,
+    production_default_integration_count: pack.integration_summary.production_default_count,
+    first_contact_cli: pack.first_contact.review_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: "xoonya-release --comparison",
+    adoption_surface: "/v1/release-pack/adoption",
+    adoption_cli: "xoonya-release --adoption",
+    scenario_surface: "/v1/release-pack/scenarios",
+    scenario_cli: "xoonya-release --scenarios",
+    launch_surface: "/v1/release-pack/launch",
+    launch_cli: "xoonya-release --launch"
+  };
+}
+
+module.exports = {
+  buildReleasePack,
+  summarizeReleasePack,
+  buildComparisonPack,
+  summarizeComparisonPack,
+  buildAdoptionPack,
+  summarizeAdoptionPack,
+  buildScenarioPack,
+  summarizeScenarioPack,
+  buildLaunchPack,
+  summarizeLaunchPack
+};

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "xoonya",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Deterministic proof SDK for canonical events, receipts, proof bundles, and verification.",
   "main": "index.js",
+  "bin": {
+    "xoonya-review": "./bin/xoonya-review.js",
+    "xoonya-release": "./bin/xoonya-release.js"
+  },
   "type": "commonjs",
   "license": "Apache-2.0",
   "homepage": "https://xoonya.com",
@@ -24,8 +28,13 @@
     "index.js",
     "proof_sdk.js",
     "server.js",
+    "bin/",
+    "lib/",
     "integrations/",
     "vectors/",
+    "RELEASE_NOTES.md",
+    "RELEASE_CHECKLIST.md",
+    "PUBLISH_PLAN.md",
     ".env.example",
     "README.md",
     "START_HERE.md",
@@ -38,6 +47,9 @@
     "NOTICE"
   ],
   "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
   "keywords": [
     "proof",
     "receipt",
@@ -55,6 +67,8 @@
     "verify:vectors": "node scripts/verify_vectors.js",
     "verify:examples": "node scripts/verify_examples.js",
     "verify:service": "node scripts/verify_service.js",
-    "verify:all": "node scripts/verify_all.js && node scripts/verify_integrations.js && node scripts/verify_tooling.js && node scripts/verify_vectors.js && node scripts/verify_examples.js && node scripts/verify_service.js"
+    "verify:release-candidate": "node scripts/verify_release_candidate.js",
+    "verify:all": "node scripts/verify_all.js && node scripts/verify_integrations.js && node scripts/verify_tooling.js && node scripts/verify_vectors.js && node scripts/verify_examples.js && node scripts/verify_service.js",
+    "prepublishOnly": "npm run verify:release-candidate"
   }
 }

package/proof_sdk.js

@@ -1093,6 +1093,23 @@ function extractEconomicConsequenceCarry(handoff) {
       usage_units: conformance.deterministic_consequence.usage_units,
       pricing_band: conformance.deterministic_consequence.pricing_band,
       meter_profile_ref: conformance.deterministic_consequence.meter_profile_ref,
+      economic_audit_summary: {
+        account_ref: conformance.deterministic_consequence.account_ref,
+        usage_meter_ref: conformance.deterministic_consequence.usage_meter_ref,
+        credit_spend_ref: conformance.deterministic_consequence.credit_spend_ref,
+        usage_units: conformance.deterministic_consequence.usage_units,
+        pricing_band: conformance.deterministic_consequence.pricing_band,
+        meter_profile_ref: conformance.deterministic_consequence.meter_profile_ref,
+        payment_ref: conformance.deterministic_consequence.payment_ref,
+        settlement_ref: conformance.deterministic_consequence.settlement_ref,
+        settlement_txid: conformance.deterministic_consequence.settlement_txid,
+        settlement_status: conformance.deterministic_consequence.settlement_status,
+        settlement_finality_status: conformance.deterministic_consequence.settlement_finality_status,
+        treasury_receipt_ref: conformance.deterministic_consequence.treasury_receipt_ref,
+        proof_ref: conformance.deterministic_consequence.proof_ref,
+        conformance_pack_ref: conformance.conformance_pack_ref,
+        review_summary_surface: conformance.review_summary_surface
+      },
       next_surface: conformance.next_surface,
       review_summary_surface: conformance.review_summary_surface
     }
@@ -1412,6 +1429,9 @@ function summarizeReviewedInteractionResultPackageHandoff(input) {
     economic_consequence_ready: Boolean(review.economic_consequence_review),
     usage_meter_ref: review.economic_consequence_review ? review.economic_consequence_review.usage_meter_ref : null,
     credit_spend_ref: review.economic_consequence_review ? review.economic_consequence_review.credit_spend_ref : null,
+    economic_audit_summary: review.economic_consequence_review
+      ? review.economic_consequence_review.economic_audit_summary || null
+      : null,
     economic_consequence_review: review.economic_consequence_review || null
   };
 }
@@ -2218,6 +2238,13 @@ function buildEconomicConsequenceBridgeHandoff(input) {
   const usageMeterRef = normalizeString(body.usage_meter_ref);
   const meterProfileRef = normalizeString(body.meter_profile_ref);
   const creditSpendRef = normalizeString(body.credit_spend_ref);
+  const paymentRef = normalizeString(body.payment_ref);
+  const settlementRef = normalizeString(body.settlement_ref);
+  const settlementTxid = normalizeString(body.settlement_txid);
+  const settlementStatus = normalizeString(body.settlement_status);
+  const settlementFinalityStatus = normalizeString(body.settlement_finality_status);
+  const treasuryReceiptRef = normalizeString(body.treasury_receipt_ref);
+  const proofRef = normalizeString(body.proof_ref);
   const usageMeter = body.usage_meter && typeof body.usage_meter === "object" && !Array.isArray(body.usage_meter)
     ? body.usage_meter
     : null;
@@ -2249,7 +2276,14 @@ function buildEconomicConsequenceBridgeHandoff(input) {
       meter_profile_ref: meterProfileRef,
       credit_spend_ref: creditSpendRef,
       credit_spend_hash: canonicalJsonSha256Hex(creditSpend),
-      credit_spend: creditSpend
+      credit_spend: creditSpend,
+      payment_ref: paymentRef || null,
+      settlement_ref: settlementRef || null,
+      settlement_txid: settlementTxid || null,
+      settlement_status: settlementStatus || null,
+      settlement_finality_status: settlementFinalityStatus || null,
+      treasury_receipt_ref: treasuryReceiptRef || null,
+      proof_ref: proofRef || null
     }
   };
   return {
@@ -2277,7 +2311,14 @@ function buildEconomicConsequenceConformancePack(input) {
       credit_spend_ref: economicsContext.credit_spend_ref,
       usage_units: Number(economicsContext.usage_meter.units || 0),
       pricing_band: normalizeString(economicsContext.usage_meter.pricing_band || null) || null,
-      meter_profile_ref: economicsContext.meter_profile_ref
+      meter_profile_ref: economicsContext.meter_profile_ref,
+      payment_ref: economicsContext.payment_ref || null,
+      settlement_ref: economicsContext.settlement_ref || null,
+      settlement_txid: economicsContext.settlement_txid || null,
+      settlement_status: economicsContext.settlement_status || null,
+      settlement_finality_status: economicsContext.settlement_finality_status || null,
+      treasury_receipt_ref: economicsContext.treasury_receipt_ref || null,
+      proof_ref: economicsContext.proof_ref || null
     },
     preserved_routes: [
       "/v1/proof-center/bridge/economic-handoff",