xytara 2.0.0 → 2.1.0

package/bin/xytara-run.js

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+"use strict";
+
+const crypto = require("crypto");
+
+function parseArgs(argv) {
+  const args = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (!token.startsWith("--")) continue;
+    const key = token.slice(2);
+    const next = argv[index + 1];
+    if (!next || next.startsWith("--")) {
+      args[key] = true;
+      continue;
+    }
+    args[key] = next;
+    index += 1;
+  }
+  return args;
+}
+
+function printUsage() {
+  process.stdout.write([
+    "Usage: xytara-run --url <service_url> --account <account_id> --command <intent> --task <task_ref> [options]",
+    "",
+    "Options:",
+    "  --body-json <json>        JSON body for the task payload",
+    "  --wallet-id <id>          Wallet id for local_signed x402 payment",
+    "  --wallet-secret <secret>  Shared secret for local_signed payment",
+    "  --txid <txid>             Existing BSV txid for bsv_teranode settlement",
+    "  --raw-tx <hex>            Raw BSV transaction for arc submission flows",
+    "  --quote-only              Stop after returning the payment challenge",
+    "  --pretty                  Pretty-print JSON output",
+    "  --help                    Show this help message"
+  ].join("\n"));
+}
+
+function parseJson(value, label) {
+  if (value == null || value === "") return {};
+  try {
+    return JSON.parse(value);
+  } catch (error) {
+    throw new Error(`${label}_must_be_valid_json`);
+  }
+}
+
+async function postJson(url, payload, headers = {}) {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      ...headers
+    },
+    body: JSON.stringify(payload)
+  });
+  const text = await response.text();
+  let json = null;
+  try {
+    json = text ? JSON.parse(text) : null;
+  } catch (_) {
+    json = null;
+  }
+  return {
+    status: response.status,
+    ok: response.ok,
+    json,
+    text
+  };
+}
+
+function buildLocalSignedPaymentSignature({ quote, accountId, walletId, walletSecret, txid, rawTx }) {
+  const payment = {
+    account_id: accountId,
+    wallet_id: walletId,
+    quote_id: quote.quote_id,
+    amount_minor: quote.amount_minor,
+    currency: quote.currency,
+    settlement_mode: quote.settlement.mode,
+    settlement_binding_hash: quote.settlement_binding_hash
+  };
+
+  if (quote.settlement && quote.settlement.mode === "bsv_teranode") {
+    payment.bsv_teranode = {
+      network: quote.settlement.hints && quote.settlement.hints.network ? quote.settlement.hints.network : null,
+      merchant_address: quote.settlement.hints && quote.settlement.hints.merchant_address ? quote.settlement.hints.merchant_address : null,
+      amount_satoshis: quote.settlement.hints && quote.settlement.hints.amount_satoshis != null ? quote.settlement.hints.amount_satoshis : null,
+      settlement_reference: quote.settlement.hints && quote.settlement.hints.settlement_reference ? quote.settlement.hints.settlement_reference : null
+    };
+    if (txid) payment.bsv_teranode.txid = txid;
+    if (rawTx) payment.bsv_teranode.raw_tx = rawTx;
+  }
+
+  payment.issued_at_iso = new Date().toISOString();
+  payment.nonce = `xytara-cli-${Date.now()}`;
+
+  const encoded = Buffer.from(JSON.stringify(payment), "utf8").toString("base64url");
+  const signature = crypto.createHmac("sha256", walletSecret).update(encoded).digest("hex");
+  return Buffer.from(JSON.stringify({
+    scheme: "exact",
+    wallet_id: walletId,
+    payload: encoded,
+    signature
+  }), "utf8").toString("base64url");
+}
+
+function writeOutput(payload, pretty) {
+  process.stdout.write(JSON.stringify(payload, null, pretty ? 2 : 0));
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.help) {
+    printUsage();
+    return;
+  }
+
+  const serviceUrl = String(args.url || "").replace(/\/$/, "");
+  const accountId = String(args.account || "").trim();
+  const command = String(args.command || "").trim();
+  const taskRef = String(args.task || args["task-ref"] || "").trim();
+  const body = parseJson(args["body-json"], "body_json");
+  const walletId = String(args["wallet-id"] || "").trim();
+  const walletSecret = String(args["wallet-secret"] || "").trim();
+  const txid = String(args.txid || "").trim() || null;
+  const rawTx = String(args["raw-tx"] || "").trim() || null;
+  const pretty = args.pretty === true;
+
+  if (!serviceUrl || !accountId || !command || !taskRef) {
+    printUsage();
+    process.exitCode = 1;
+    return;
+  }
+
+  const executeUrl = `${serviceUrl}/x402/commands/execute`;
+  const payload = {
+    account_id: accountId,
+    command,
+    task_ref: taskRef,
+    body
+  };
+
+  const challengeResult = await postJson(executeUrl, payload);
+  if (challengeResult.ok) {
+    writeOutput(challengeResult.json || { ok: true }, pretty);
+    return;
+  }
+  if (challengeResult.status !== 402 || !challengeResult.json || !challengeResult.json.payment_required) {
+    writeOutput(challengeResult.json || { ok: false, status: challengeResult.status, body: challengeResult.text || null }, pretty);
+    process.exitCode = 1;
+    return;
+  }
+
+  if (args["quote-only"] === true || !walletId || !walletSecret) {
+    writeOutput(challengeResult.json, pretty);
+    return;
+  }
+
+  const quote = challengeResult.json.payment_required.quote;
+  const paymentSignature = buildLocalSignedPaymentSignature({
+    quote,
+    accountId,
+    walletId,
+    walletSecret,
+    txid,
+    rawTx
+  });
+  const paidPayload = {
+    ...payload,
+    quote_id: quote.quote_id
+  };
+  const paidResult = await postJson(executeUrl, paidPayload, {
+    "payment-signature": paymentSignature
+  });
+  if (!paidResult.ok) {
+    writeOutput(paidResult.json || { ok: false, status: paidResult.status, body: paidResult.text || null }, pretty);
+    process.exitCode = 1;
+    return;
+  }
+  writeOutput(paidResult.json || { ok: true }, pretty);
+}
+
+main().catch((error) => {
+  process.stderr.write(`${error.message}\n`);
+  process.exitCode = 1;
+});

package/index.js

@@ -5,6 +5,56 @@ const {
   ADAPTER_INTERFACE_VERSION,
   validateAdapterImplementation
 } = require("./adapters/interfaces");
+const {
+  buildReleasePack,
+  summarizeReleasePack,
+  buildComparisonPack,
+  summarizeComparisonPack,
+  buildAdoptionPack,
+  summarizeAdoptionPack,
+  buildScenarioPack,
+  summarizeScenarioPack,
+  buildLaunchPack,
+  summarizeLaunchPack
+} = require("./lib/release_pack");
+const {
+  buildReleaseManifest,
+  summarizeReleaseManifest,
+  buildLaunchNotes,
+  summarizeLaunchNotes
+} = require("./lib/release_manifest");
+const {
+  buildReleaseCenter,
+  summarizeReleaseCenter
+} = require("./lib/release_center");
+const {
+  buildReleaseHistory,
+  summarizeReleaseHistory
+} = require("./lib/release_history");
+const {
+  buildPublishPlan,
+  summarizePublishPlan
+} = require("./lib/publish_plan");
+const {
+  buildEcosystemEntryPack,
+  summarizeEcosystemEntryPack
+} = require("./lib/ecosystem_entry");
+const {
+  buildLaunchNarrativePack,
+  summarizeLaunchNarrativePack
+} = require("./lib/launch_narrative");
+const {
+  buildOutreachProofPack,
+  summarizeOutreachProofPack
+} = require("./lib/outreach_proof");
+const {
+  buildAnnouncementPack,
+  summarizeAnnouncementPack
+} = require("./lib/announcement_pack");
+const {
+  buildReleaseCandidatePack,
+  summarizeReleaseCandidatePack
+} = require("./lib/release_candidate");
 const {
   getIntegration,
   listIntegrations,
@@ -40,7 +90,7 @@ const {
 } = require("./integrations/registry");
 
 const COMMERCE_SDK_NAME = "xytara";
-const COMMERCE_SDK_VERSION = "2.0.0";
+const COMMERCE_SDK_VERSION = "2.1.0";
 const COMMERCE_API_VERSION = "v1";
 
 function createClient(options) {
@@ -85,5 +135,35 @@ module.exports = {
   summarizeIntegrationPromotionActionPreview,
   summarizeIntegrationPromotionActionSet,
   summarizeIntegrationPromotionActionSetList,
+  buildReleasePack,
+  summarizeReleasePack,
+  buildComparisonPack,
+  summarizeComparisonPack,
+  buildAdoptionPack,
+  summarizeAdoptionPack,
+  buildScenarioPack,
+  summarizeScenarioPack,
+  buildLaunchPack,
+  summarizeLaunchPack,
+  buildReleaseManifest,
+  summarizeReleaseManifest,
+  buildLaunchNotes,
+  summarizeLaunchNotes,
+  buildReleaseCenter,
+  summarizeReleaseCenter,
+  buildReleaseHistory,
+  summarizeReleaseHistory,
+  buildPublishPlan,
+  summarizePublishPlan,
+  buildEcosystemEntryPack,
+  summarizeEcosystemEntryPack,
+  buildLaunchNarrativePack,
+  summarizeLaunchNarrativePack,
+  buildOutreachProofPack,
+  summarizeOutreachProofPack,
+  buildAnnouncementPack,
+  summarizeAnnouncementPack,
+  buildReleaseCandidatePack,
+  summarizeReleaseCandidatePack,
   validateAdapterImplementation
 };

package/lib/announcement_pack.js

@@ -0,0 +1,61 @@
+"use strict";
+
+const packageJson = require("../package.json");
+
+function buildAnnouncementPack() {
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "machine-commerce-announcement-pack",
+    public_quickstart: {
+      install: "npm install xytara",
+      first_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",
+      first_release_view: "xytara-release --center --summary",
+      first_http: "/v1/release-center/summary"
+    },
+    release_candidate: {
+      checks: [
+        "install the package on a clean machine",
+        "run xytara-release --center --summary",
+        "run npm run verify:all",
+        "verify /v1/release-center/summary on the deployed service",
+        "verify /v1/outreach-proof/summary on the deployed service"
+      ]
+    },
+    publish_day: {
+      sequence: [
+        "publish the npm package",
+        "redeploy the service and docs surfaces",
+        "verify release-center, launch-narrative, and outreach-proof summaries live",
+        "run the first public proof path",
+        "share the announcement artifact with the target ecosystem audience"
+      ]
+    },
+    public_message: {
+      headline: "governed machine commerce with direct paid execution, reusable credits, and proof-aware followthrough",
+      who_should_try_first: [
+        "agent builders",
+        "tool and marketplace authors",
+        "repeat-use runtime operators"
+      ]
+    }
+  };
+}
+
+function summarizeAnnouncementPack() {
+  const pack = buildAnnouncementPack();
+  return {
+    ok: true,
+    product: pack.product,
+    category: pack.category,
+    rc_check_count: pack.release_candidate.checks.length,
+    publish_step_count: pack.publish_day.sequence.length,
+    first_cli: pack.public_quickstart.first_cli,
+    audience_count: pack.public_message.who_should_try_first.length
+  };
+}
+
+module.exports = {
+  buildAnnouncementPack,
+  summarizeAnnouncementPack
+};

package/lib/commerce_artifacts.js

@@ -222,6 +222,9 @@ function createCommandArtifacts(payload, quote, options) {
     network: bsvHints ? bsvHints.network : null,
     hints: bsvHints,
     txid: bsvPaymentReference && bsvPaymentReference.txid ? bsvPaymentReference.txid : null,
+    raw_tx: bsvPaymentReference && (bsvPaymentReference.raw_tx || bsvPaymentReference.rawTx)
+      ? (bsvPaymentReference.raw_tx || bsvPaymentReference.rawTx)
+      : null,
     status: deferredCompletion ? "pending_completion" : "recorded",
     recorded_at_iso: deferredCompletion ? null : completedAt.toISOString()
   };

package/lib/commerce_economics.js

@@ -638,6 +638,13 @@ function buildEconomicConsequenceHandoffBundle(state, body) {
     };
   }
   const meterProfileRef = normalizeString(payload.meter_profile_ref, `meter-profile.${usageMeter.pricing_band || "utility"}.v1`);
+  const paymentRef = normalizeString(payload.payment_ref, null);
+  const settlementRef = normalizeString(payload.settlement_ref, null);
+  const settlementTxid = normalizeString(payload.settlement_txid, null);
+  const settlementStatus = normalizeString(payload.settlement_status, null);
+  const settlementFinalityStatus = normalizeString(payload.settlement_finality_status, null);
+  const treasuryReceiptRef = normalizeString(payload.treasury_receipt_ref, null);
+  const proofRef = normalizeString(payload.proof_ref, null);
   const handoffBundle = {
     contract_version: "naxytra-economic-consequence-handoff-v1",
     source_system: "xytara",
@@ -647,6 +654,13 @@ function buildEconomicConsequenceHandoffBundle(state, body) {
     credit_spend_ref: creditSpend.credit_spend_id,
     usage_meter: usageMeter,
     credit_spend: creditSpend,
+    payment_ref: paymentRef,
+    settlement_ref: settlementRef,
+    settlement_txid: settlementTxid,
+    settlement_status: settlementStatus,
+    settlement_finality_status: settlementFinalityStatus,
+    treasury_receipt_ref: treasuryReceiptRef,
+    proof_ref: proofRef,
     handoff_surfaces: {
       proof_bridge_surface: "/v1/proof-center/bridge/economic-handoff",
       proof_conformance_surface: "/v1/proof-center/bridge/economic-conformance-pack"

package/lib/commerce_reports.js

@@ -13690,12 +13690,18 @@ function buildReconciliationReport(state, filters, listRecords) {
   };
 }
 
-function buildOperatorExportPack(state, filters, listRecords) {
+function buildOperatorExportPack(state, filters, listRecords, options = {}) {
   const report = buildReconciliationReport(state, filters, listRecords);
   const accountId = report.summary && report.summary.account_id ? report.summary.account_id : null;
   const transactions = Array.from(state.transactions.values()).map((item) => item.transaction);
   const receipts = Array.from(state.receipts.values()).map((item) => item.receipt);
   const paymentLedger = Array.isArray(state.paymentLedger) ? state.paymentLedger.slice(0, 20) : [];
+  const runtimeDurability = options.runtime_durability && typeof options.runtime_durability === "object"
+    ? options.runtime_durability
+    : null;
+  const nativeSettlementReadiness = options.native_settlement_readiness && typeof options.native_settlement_readiness === "object"
+    ? options.native_settlement_readiness
+    : null;
   return {
     ok: true,
     export_version: "commerce-operator-export-pack-v1",
@@ -13729,6 +13735,25 @@ function buildOperatorExportPack(state, filters, listRecords) {
         metering_summary_ref: report.summary && report.summary.linked_surfaces ? report.summary.linked_surfaces.metering_summary : null,
         usage_meters_ref: report.summary && report.summary.linked_surfaces ? report.summary.linked_surfaces.usage_meters : null
       },
+      runtime_center: {
+        snapshot_enabled: runtimeDurability ? runtimeDurability.enabled === true : false,
+        snapshot_exists: runtimeDurability ? runtimeDurability.snapshot_exists === true : false,
+        snapshot_updated_at_iso: runtimeDurability ? runtimeDurability.snapshot_updated_at_iso || null : null,
+        last_persisted_at_iso: runtimeDurability ? runtimeDurability.last_persisted_at_iso || null : null,
+        last_flush_succeeded: runtimeDurability ? runtimeDurability.last_flush_succeeded === true : false,
+        recovery_posture: runtimeDurability ? runtimeDurability.recovery_posture || null : null,
+        blockers: runtimeDurability ? runtimeDurability.blockers || [] : [],
+        inspect_ref: runtimeDurability ? runtimeDurability.inspect_ref || "/v1/runtime/durability" : "/v1/runtime/durability"
+      },
+      native_settlement_center: {
+        ready: nativeSettlementReadiness ? nativeSettlementReadiness.ready === true : false,
+        runtime_mode: nativeSettlementReadiness ? nativeSettlementReadiness.runtime_mode || null : null,
+        receiving_identity_kind: nativeSettlementReadiness ? nativeSettlementReadiness.receiving_identity_kind || null : null,
+        verification_mode: nativeSettlementReadiness ? nativeSettlementReadiness.payment_verification_mode || null : null,
+        blockers: nativeSettlementReadiness ? nativeSettlementReadiness.blockers || [] : [],
+        next_manual_inputs: nativeSettlementReadiness ? nativeSettlementReadiness.next_manual_inputs || [] : [],
+        readiness_ref: nativeSettlementReadiness ? nativeSettlementReadiness.readiness_ref || "/v1/settlement/bsv-teranode/readiness" : "/v1/settlement/bsv-teranode/readiness"
+      },
       coordination_center: {
         zone_count: report.coordination ? report.coordination.zone_count : 0,
         handoff_count: report.coordination ? report.coordination.handoff_count : 0,

package/lib/commerce_shell.js

@@ -132,6 +132,8 @@ function buildOperatorShellSummary(input) {
   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,
@@ -150,6 +152,8 @@ function buildOperatorShellSummary(input) {
       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"
     },
@@ -166,7 +170,17 @@ function buildOperatorShellSummary(input) {
       hosted_checkout_execution_dispatched_count: Number(hostedCheckoutOperatorSummary.execution_dispatched_count || 0)
       ,
       low_balance_entitlement_count: Number(entitlementReplenishmentSummary.low_balance_count || 0),
-      depleted_entitlement_count: Number(entitlementReplenishmentSummary.depleted_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", {
@@ -182,7 +196,9 @@ function buildOperatorShellSummary(input) {
       ,
       entitlement_replenishment_summary_ref: entitlementReplenishmentSummary.entitlement_count != null
         ? `/v1/economics/accounts/${encodeURIComponent(accountId)}/entitlements/replenishment-summary`
-        : null
+        : null,
+      runtime_durability_ref: runtimeDurability.inspect_ref || "/v1/runtime/durability",
+      native_settlement_readiness_ref: nativeSettlementReadiness.readiness_ref || "/v1/settlement/bsv-teranode/readiness"
     }
   };
 }

package/lib/ecosystem_entry.js

@@ -0,0 +1,64 @@
+"use strict";
+
+const packageJson = require("../package.json");
+
+function buildEcosystemEntryPack() {
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "machine-commerce-ecosystem-entry",
+    audiences: [
+      {
+        audience_ref: "agent_builder",
+        why_now: "needs a first paid machine capability path with governed execution and proof-aware followthrough",
+        first_path_ref: "scenario.direct_pay.trust_verify",
+        first_http_entrypoint: "/v1/release-pack/scenarios/summary",
+        first_cli_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"
+      },
+      {
+        audience_ref: "marketplace_or_tool_author",
+        why_now: "needs a neutral default path for quoting, payment admission, execution, and operator inspection",
+        first_path_ref: "scenario.direct_pay.trust_verify",
+        first_http_entrypoint: "/v1/release-pack/launch/summary",
+        first_cli_entrypoint: "xytara-release --launch --summary"
+      },
+      {
+        audience_ref: "repeat_usage_operator",
+        why_now: "needs reusable account balance posture without redesigning the public execution surface",
+        first_path_ref: "scenario.credits_first.repeat_run",
+        first_http_entrypoint: "/v1/economics/accounts/:account_id/credit-balance",
+        first_cli_entrypoint: "xytara-release --scenarios --summary"
+      },
+      {
+        audience_ref: "proof_aware_runtime_team",
+        why_now: "needs a runtime result that can continue directly into proof review instead of ending as logs",
+        first_path_ref: "scenario.runtime_to_proof.followthrough",
+        first_http_entrypoint: "/v1/transaction-center/result-packages",
+        first_cli_entrypoint: "xytara-release --center --summary"
+      }
+    ],
+    public_lead_sequence: [
+      "identify the audience and first success path",
+      "show the one-line cli or one-http-entrypoint path",
+      "show the matching comparison and adoption summary",
+      "show the release center when credibility and breadth need one compact artifact"
+    ]
+  };
+}
+
+function summarizeEcosystemEntryPack() {
+  const pack = buildEcosystemEntryPack();
+  return {
+    ok: true,
+    product: pack.product,
+    category: pack.category,
+    audience_count: pack.audiences.length,
+    first_audience: pack.audiences[0] ? pack.audiences[0].audience_ref : null,
+    lead_step_count: pack.public_lead_sequence.length
+  };
+}
+
+module.exports = {
+  buildEcosystemEntryPack,
+  summarizeEcosystemEntryPack
+};

package/lib/launch_narrative.js

@@ -0,0 +1,53 @@
+"use strict";
+
+const packageJson = require("../package.json");
+
+function buildLaunchNarrativePack() {
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "machine-commerce-launch-narrative",
+    why_now: "agents and machine systems increasingly need to cross weak-trust boundaries where payment, execution, proof, and replayability cannot stay disconnected",
+    problem_patchwork_misses: [
+      "runtime-only stacks do not carry pricing, settlement, and proof continuity together",
+      "payment-only stacks do not stay attached to real machine work and reusable spend posture",
+      "ad hoc glue leaves operators to reconstruct trust and consequence after the fact"
+    ],
+    strongest_public_claim: "quote pay execute prove in one governed machine flow",
+    first_proof_to_run: {
+      path_ref: "scenario.direct_pay.trust_verify",
+      why_this_first: "smallest strong-signal run that shows paid machine execution, inspectable records, and proof-aware followthrough",
+      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"
+    },
+    first_success_looks_like: [
+      "one capability is discovered and quoted",
+      "payment or credits admission succeeds",
+      "transaction, payment, and settlement records are inspectable",
+      "result output can continue into xoonya instead of ending as runtime exhaust"
+    ],
+    immediate_should_care: [
+      "agent builders needing paid capability execution",
+      "tool and marketplace authors needing neutral transaction handling",
+      "operators needing credits-first repeat machine use",
+      "runtime teams needing proof-aware continuation"
+    ]
+  };
+}
+
+function summarizeLaunchNarrativePack() {
+  const pack = buildLaunchNarrativePack();
+  return {
+    ok: true,
+    product: pack.product,
+    category: pack.category,
+    patchwork_gap_count: pack.problem_patchwork_misses.length,
+    success_signal_count: pack.first_success_looks_like.length,
+    immediate_audience_count: pack.immediate_should_care.length,
+    first_path_ref: pack.first_proof_to_run.path_ref
+  };
+}
+
+module.exports = {
+  buildLaunchNarrativePack,
+  summarizeLaunchNarrativePack
+};

package/lib/outreach_proof.js

@@ -0,0 +1,71 @@
+"use strict";
+
+const packageJson = require("../package.json");
+
+function buildOutreachProofPack() {
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "machine-commerce-outreach-proof",
+    proven_live_today: [
+      "x402 payment admission for direct machine execution",
+      "native BSV settlement observe path with finalized state",
+      "credits-first account-funded spend and deterministic usage metering",
+      "operator inspection across payment, settlement, treasury, and proof carry"
+    ],
+    live_rails: [
+      {
+        rail_ref: "direct_machine_payment",
+        status: "proven_live",
+        trust_signal: "payment admitted, transaction recorded, settlement-linked execution path present"
+      },
+      {
+        rail_ref: "credits_first_repeat_use",
+        status: "proven_live",
+        trust_signal: "account credits consume against real runs with deterministic usage meters"
+      },
+      {
+        rail_ref: "native_bsv_settlement_observe",
+        status: "proven_live",
+        trust_signal: "observe runtime finalized against a real txid with confirmations"
+      }
+    ],
+    credible_public_proof_path: {
+      path_ref: "scenario.direct_pay.trust_verify",
+      why_credible: "smallest public run that already aligns with the demonstrated live payment and settlement posture",
+      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"
+    },
+    trust_today_vs_later: {
+      trust_today: [
+        "direct paid machine execution",
+        "credits-first repeat usage",
+        "operator and launch surfaces",
+        "proof-aware runtime followthrough"
+      ],
+      later_depth: [
+        "broader ecosystem adoption after release",
+        "deeper settlement-path breadth beyond current proven posture",
+        "continued release-line expansion after public package launch"
+      ]
+    }
+  };
+}
+
+function summarizeOutreachProofPack() {
+  const pack = buildOutreachProofPack();
+  return {
+    ok: true,
+    product: pack.product,
+    category: pack.category,
+    proven_count: pack.proven_live_today.length,
+    live_rail_count: pack.live_rails.length,
+    trust_today_count: pack.trust_today_vs_later.trust_today.length,
+    later_depth_count: pack.trust_today_vs_later.later_depth.length,
+    first_path_ref: pack.credible_public_proof_path.path_ref
+  };
+}
+
+module.exports = {
+  buildOutreachProofPack,
+  summarizeOutreachProofPack
+};