xytara 2.1.0 → 2.3.0

package/lib/commerce_economics.js

@@ -478,6 +478,113 @@ function buildCreditBalanceSummary(state, accountId) {
   };
 }
 
+function buildWalletSummary(state, accountId) {
+  const balance = buildCreditBalanceSummary(state, accountId);
+  const allocations = listAllocationEventsForAccount(state, accountId);
+  const usageMeters = listUsageMetersForAccount(state, accountId);
+  const reserveUnits = allocations
+    .filter((entry) => entry && entry.direction === "reserve")
+    .reduce((sum, entry) => sum + Number(entry.units || 0), 0);
+  const committedUnits = allocations
+    .filter((entry) => entry && entry.direction === "commit")
+    .reduce((sum, entry) => sum + Number(entry.units || 0), 0);
+  const releasedUnits = allocations
+    .filter((entry) => entry && entry.direction === "release")
+    .reduce((sum, entry) => sum + Number(entry.units || 0), 0);
+  const reversedUnits = allocations
+    .filter((entry) => entry && entry.direction === "reverse")
+    .reduce((sum, entry) => sum + Number(entry.units || 0), 0);
+  const reserveCount = allocations.filter((entry) => entry && entry.direction === "reserve").length;
+  const walletState = balance.available_units <= 0
+    ? "depleted"
+    : balance.entitlement_summary.low_entitlement_count > 0
+      ? "low_balance"
+      : "healthy";
+
+  return {
+    wallet_version: "xytara-machine-wallet-summary-v1",
+    wallet_id: `wallet_${accountId}`,
+    account_id: accountId,
+    canonical_unit: "usage_units",
+    wallet_state: walletState,
+    issued_units: balance.issued_units,
+    available_units: balance.available_units,
+    reserved_units: reserveUnits,
+    committed_units: committedUnits,
+    released_units: releasedUnits,
+    reversed_units: reversedUnits,
+    consumed_units: balance.consumed_units,
+    reserve_count: reserveCount,
+    entitlement_count: balance.entitlement_summary.entitlement_count,
+    active_entitlement_count: balance.entitlement_summary.active_entitlement_count,
+    usage_meter_count: usageMeters.length,
+    replenishment_posture: balance.replenishment_summary.depleted_count > 0
+      ? "replenishment_required"
+      : balance.replenishment_summary.low_balance_count > 0
+        ? "replenishment_recommended"
+        : "sufficient_capacity",
+    linked_surfaces: {
+      credit_balance_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/credit-balance`,
+      entitlements_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/entitlements`,
+      usage_meters_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/usage-meters`,
+      wallet_ledger_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/wallet-ledger-summary`
+    },
+    generated_at_iso: nowIso()
+  };
+}
+
+function buildWalletLedgerSummary(state, accountId) {
+  const wallet = buildWalletSummary(state, accountId);
+  const allocations = listAllocationEventsForAccount(state, accountId);
+  const spends = listCreditSpendsForAccount(state, accountId);
+  const railCredits = listRailCreditsForAccount(state, accountId);
+  const consequences = {
+    mint_count: allocations.filter((entry) => entry && entry.direction === "mint").length + railCredits.length,
+    reserve_count: allocations.filter((entry) => entry && entry.direction === "reserve").length,
+    commit_count: allocations.filter((entry) => entry && entry.direction === "commit").length + spends.length,
+    release_count: allocations.filter((entry) => entry && entry.direction === "release").length,
+    reverse_count: allocations.filter((entry) => entry && entry.direction === "reverse").length
+  };
+
+  return {
+    summary_version: "xytara-wallet-ledger-summary-v1",
+    wallet_id: wallet.wallet_id,
+    account_id: accountId,
+    canonical_truth_posture: "allocation_and_consequence_records_with_materialized_wallet_summary",
+    canonical_unit: wallet.canonical_unit,
+    wallet_state: wallet.wallet_state,
+    wallet_summary: {
+      issued_units: wallet.issued_units,
+      available_units: wallet.available_units,
+      reserved_units: wallet.reserved_units,
+      committed_units: wallet.committed_units,
+      released_units: wallet.released_units,
+      reversed_units: wallet.reversed_units,
+      consumed_units: wallet.consumed_units
+    },
+    ledger_lifecycle_counts: consequences,
+    source_record_counts: {
+      allocation_count: allocations.length,
+      rail_credit_count: railCredits.length,
+      credit_spend_count: spends.length,
+      entitlement_count: wallet.entitlement_count,
+      usage_meter_count: wallet.usage_meter_count
+    },
+    translation_boundary: {
+      public_commercial_shell: "credits",
+      canonical_hidden_unit: "usage_units",
+      canonical_wallet_truth: "hidden_machine_wallet",
+      materialized_projection: "wallet_summary"
+    },
+    linked_surfaces: {
+      wallet_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/wallet`,
+      ledger_export_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/ledger-export`,
+      reconciliation_pack_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/reconciliation-pack`
+    },
+    generated_at_iso: nowIso()
+  };
+}
+
 function getWorkflowTaskRefs(workflowRef) {
   const workflow = findWorkflow(workflowRef);
   if (!workflow || !Array.isArray(workflow.tasks)) return [];
@@ -922,6 +1029,199 @@ function buildTreasurySummary(state, accountId) {
   };
 }
 
+function selectRecommendedCreditPack(totalUnits, usageMeterCount) {
+  if (totalUnits >= 1500 || usageMeterCount >= 20) return "credits.fleet";
+  if (totalUnits >= 500 || usageMeterCount >= 10) return "credits.agent";
+  if (totalUnits >= 100 || usageMeterCount >= 3) return "credits.builder";
+  if (totalUnits > 0 || usageMeterCount > 0) return "credits.starter";
+  return null;
+}
+
+function buildEconomicsIntelligenceSummary(state, accountId) {
+  const balanceSummary = buildCreditBalanceSummary(state, accountId);
+  const meteringSummary = buildUsageMeteringSummary(state, accountId);
+  const replenishmentSummary = buildEntitlementReplenishmentSummary(state, accountId);
+  const treasurySummary = buildTreasurySummary(state, accountId);
+
+  const usageMeterCount = Number(meteringSummary.usage_meter_count || 0);
+  const totalUnits = Number(meteringSummary.total_units || 0);
+  const availableUnits = Number(balanceSummary.available_units || 0);
+  const consumedUnits = Number(balanceSummary.consumed_units || 0);
+  const lowBalanceCount = Number(replenishmentSummary.low_balance_count || 0);
+  const depletedCount = Number(replenishmentSummary.depleted_count || 0);
+  const mintedUnits = Number(treasurySummary.treasury && treasurySummary.treasury.minted_units || 0);
+  const settledAmountMinor = Number(treasurySummary.treasury && treasurySummary.treasury.settled_amount_minor || 0);
+  const budgetCount = Number(treasurySummary.budgets && treasurySummary.budgets.total || 0);
+
+  let recommendedFundingPosture = "direct_pay_first";
+  if (availableUnits > 0 || consumedUnits > 0 || usageMeterCount > 0) {
+    recommendedFundingPosture = "credits_first";
+  }
+  if (availableUnits <= 0 && (usageMeterCount > 0 || consumedUnits > 0)) {
+    recommendedFundingPosture = "pack_backed_credits_first";
+  }
+
+  const recommendedPackId = replenishmentSummary.recommended_pack_ids[0] || selectRecommendedCreditPack(totalUnits, usageMeterCount);
+
+  let replenishmentRiskState = "low";
+  if (lowBalanceCount > 0) replenishmentRiskState = "watch";
+  if (depletedCount > 0 || (availableUnits > 0 && availableUnits <= Math.max(8, totalUnits))) {
+    replenishmentRiskState = "high";
+  }
+
+  let treasuryHealthState = "healthy";
+  if (mintedUnits === 0 && settledAmountMinor === 0 && usageMeterCount === 0) {
+    treasuryHealthState = "pre_funding";
+  } else if (availableUnits <= 0 && (consumedUnits > 0 || usageMeterCount > 0)) {
+    treasuryHealthState = "constrained";
+  } else if (lowBalanceCount > 0 || budgetCount > 0) {
+    treasuryHealthState = "watch";
+  }
+
+  let nextBestAction = "continue_current_posture";
+  if (recommendedFundingPosture === "direct_pay_first") {
+    nextBestAction = "start_with_direct_pay";
+  }
+  if (recommendedFundingPosture === "credits_first" && recommendedPackId && usageMeterCount >= 3) {
+    nextBestAction = "consider_pack_funding";
+  }
+  if (replenishmentRiskState === "watch") {
+    nextBestAction = "prepare_replenishment";
+  }
+  if (replenishmentRiskState === "high") {
+    nextBestAction = "replenish_credits";
+  }
+  if (treasuryHealthState === "constrained") {
+    nextBestAction = "restore_runtime_balance";
+  }
+
+  return {
+    account_id: accountId,
+    category: "machine-commerce-account-economics-intelligence-summary",
+    recommended_funding_posture: recommendedFundingPosture,
+    recommended_pack_id: recommendedPackId,
+    replenishment_risk_state: replenishmentRiskState,
+    treasury_health_state: treasuryHealthState,
+    next_best_action: nextBestAction,
+    explanation_signals: {
+      available_units: availableUnits,
+      consumed_units: consumedUnits,
+      usage_meter_count: usageMeterCount,
+      metered_units: totalUnits,
+      low_balance_count: lowBalanceCount,
+      depleted_count: depletedCount,
+      recommended_replenishment_pack_ids: replenishmentSummary.recommended_pack_ids,
+      pricing_bands: meteringSummary.pricing_bands,
+      minted_units: mintedUnits,
+      settled_amount_minor: settledAmountMinor,
+      budget_count: budgetCount
+    },
+    linked_surfaces: {
+      credit_balance_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/credit-balance`,
+      metering_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/metering-summary`,
+      entitlement_replenishment_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/entitlements/replenishment-summary`,
+      treasury_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/treasury-summary`,
+      operator_dashboard_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/operator-dashboard`
+    },
+    generated_at_iso: nowIso()
+  };
+}
+
+function buildTreasuryIntelligenceSummary(state, accountId) {
+  const treasurySummary = buildTreasurySummary(state, accountId);
+  const treasuryDrilldown = buildTreasuryDrilldown(state, accountId);
+  const reconciliationPack = buildReconciliationPack(state, accountId);
+  const meteringSummary = buildUsageMeteringSummary(state, accountId);
+  const balanceSummary = buildCreditBalanceSummary(state, accountId);
+  const railSummary = buildRailSummary(state, accountId);
+
+  const mintedUnits = Number(treasurySummary.treasury.minted_units || 0);
+  const consumedUnits = Number(treasurySummary.treasury.consumed_units || 0);
+  const availableUnits = Number(treasurySummary.treasury.available_units || 0);
+  const settledAmountMinor = Number(treasurySummary.treasury.settled_amount_minor || 0);
+  const usageMeterCount = Number(meteringSummary.usage_meter_count || 0);
+  const pendingTransactions = Number(treasuryDrilldown.unresolved_flags.pending_transactions || 0);
+  const pendingReceipts = Number(treasuryDrilldown.unresolved_flags.pending_receipts || 0);
+  const disputedReceipts = Number(reconciliationPack.unresolved_state.disputed_receipt_count || 0);
+  const escalatedReceipts = Number(reconciliationPack.unresolved_state.escalated_receipt_count || 0);
+  const paymentLedgerCount = Number(treasurySummary.payment_ledger_count || 0);
+  const railCreditEventCount = Number(railSummary.credit_event_count || 0);
+
+  let treasuryEfficiencyState = "healthy";
+  if (mintedUnits === 0 && settledAmountMinor === 0 && usageMeterCount === 0) {
+    treasuryEfficiencyState = "pre_funding";
+  } else if (availableUnits <= 0 && (consumedUnits > 0 || usageMeterCount > 0)) {
+    treasuryEfficiencyState = "constrained";
+  } else if (pendingTransactions > 0 || pendingReceipts > 0) {
+    treasuryEfficiencyState = "watch";
+  }
+
+  let valueCaptureState = "aligned";
+  if (usageMeterCount === 0 && paymentLedgerCount === 0 && railCreditEventCount === 0) {
+    valueCaptureState = "pre_conversion";
+  } else if (usageMeterCount >= 3 && paymentLedgerCount <= 1 && consumedUnits > 0) {
+    valueCaptureState = "repeat_use_ready";
+  } else if (consumedUnits > mintedUnits && mintedUnits > 0) {
+    valueCaptureState = "leaking";
+  }
+
+  let reconciliationRiskState = "low";
+  if (pendingTransactions > 0 || pendingReceipts > 0) reconciliationRiskState = "watch";
+  if (disputedReceipts > 0 || escalatedReceipts > 0) reconciliationRiskState = "high";
+
+  let replenishmentFatigueState = "low";
+  if (railCreditEventCount >= 2 && availableUnits <= Math.max(8, meteringSummary.total_units || 0)) {
+    replenishmentFatigueState = "watch";
+  }
+  if (railCreditEventCount >= 3 && balanceSummary.replenishment_summary.low_balance_count > 0) {
+    replenishmentFatigueState = "high";
+  }
+
+  let nextBestAction = "continue_treasury_posture";
+  if (treasuryEfficiencyState === "pre_funding") {
+    nextBestAction = "establish_runtime_funding";
+  } else if (treasuryEfficiencyState === "constrained") {
+    nextBestAction = "restore_runtime_balance";
+  } else if (reconciliationRiskState === "high") {
+    nextBestAction = "review_reconciliation_pack";
+  } else if (reconciliationRiskState === "watch") {
+    nextBestAction = "inspect_treasury_drilldown";
+  } else if (replenishmentFatigueState === "high" || valueCaptureState === "repeat_use_ready") {
+    nextBestAction = "recommend_larger_pack_posture";
+  }
+
+  return {
+    account_id: accountId,
+    category: "machine-commerce-account-treasury-intelligence-summary",
+    treasury_efficiency_state: treasuryEfficiencyState,
+    value_capture_state: valueCaptureState,
+    reconciliation_risk_state: reconciliationRiskState,
+    replenishment_fatigue_state: replenishmentFatigueState,
+    next_best_action: nextBestAction,
+    explanation_signals: {
+      minted_units: mintedUnits,
+      consumed_units: consumedUnits,
+      available_units: availableUnits,
+      settled_amount_minor: settledAmountMinor,
+      usage_meter_count: usageMeterCount,
+      payment_ledger_count: paymentLedgerCount,
+      rail_credit_event_count: railCreditEventCount,
+      pending_transaction_count: pendingTransactions,
+      pending_receipt_count: pendingReceipts,
+      disputed_receipt_count: disputedReceipts,
+      escalated_receipt_count: escalatedReceipts
+    },
+    linked_surfaces: {
+      treasury_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/treasury-summary`,
+      treasury_drilldown_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/treasury-drilldown`,
+      reconciliation_pack_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/reconciliation-pack`,
+      metering_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/metering-summary`,
+      rail_summary_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/rail-summary`
+    },
+    generated_at_iso: nowIso()
+  };
+}
+
 function buildLedgerExport(state, accountId) {
   return {
     export_version: "xytara-economics-ledger-export-v1",
@@ -1402,6 +1702,10 @@ module.exports = {
   previewRailCredits,
   applyRailCredits,
   buildCreditBalanceSummary,
+  buildWalletSummary,
+  buildWalletLedgerSummary,
+  buildEconomicsIntelligenceSummary,
+  buildTreasuryIntelligenceSummary,
   buildTreasurySummary,
   buildLedgerExport,
   buildTreasuryDrilldown,

package/lib/operator_intelligence.js

@@ -0,0 +1,90 @@
+"use strict";
+
+const { buildEconomicsIntelligenceSummary } = require("./commerce_economics");
+const { buildPartnerIntelligencePack } = require("./partner_intelligence");
+
+function buildOperatorIntelligencePack(state, input) {
+  const payload = input && typeof input === "object" && !Array.isArray(input) ? input : {};
+  const accountId = String(payload.account_id || "acct_demo").trim() || "acct_demo";
+  const economicsIntelligence = buildEconomicsIntelligenceSummary(state, accountId);
+  const partnerIntelligence = buildPartnerIntelligencePack();
+
+  const actionQueue = [];
+
+  if (economicsIntelligence.next_best_action && economicsIntelligence.next_best_action !== "continue_current_posture") {
+    actionQueue.push({
+      lane: "runtime_economics",
+      priority: economicsIntelligence.replenishment_risk_state === "high" ? "high" : "medium",
+      action: economicsIntelligence.next_best_action,
+      reason: `funding posture is ${economicsIntelligence.recommended_funding_posture} with ${economicsIntelligence.replenishment_risk_state} replenishment risk`
+    });
+  }
+
+  if (partnerIntelligence.next_best_action) {
+    actionQueue.push({
+      lane: "partner_adoption",
+      priority: partnerIntelligence.onboarding_friction_state === "low" ? "medium" : "high",
+      action: partnerIntelligence.next_best_action,
+      reason: `partner readiness is ${partnerIntelligence.partner_readiness_state} and onboarding friction is ${partnerIntelligence.onboarding_friction_state}`
+    });
+  }
+
+  if (actionQueue.length === 0) {
+    actionQueue.push({
+      lane: "operator_posture",
+      priority: "low",
+      action: "continue_current_posture",
+      reason: "runtime economics and partner posture are both stable enough to continue current operation"
+    });
+  }
+
+  return {
+    ok: true,
+    account_id: accountId,
+    category: "machine-commerce-operator-intelligence-pack",
+    overall_operator_state: {
+      runtime_economics_state: economicsIntelligence.treasury_health_state,
+      partner_adoption_state: partnerIntelligence.partner_readiness_state,
+      top_priority: actionQueue[0].priority
+    },
+    recommended_operator_motion: actionQueue[0].action,
+    next_action_queue: actionQueue,
+    intelligence_refs: {
+      economics_intelligence_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/intelligence-summary`,
+      partner_intelligence_ref: "/v1/partner-intelligence",
+      operator_dashboard_ref: `/v1/economics/accounts/${encodeURIComponent(accountId)}/operator-dashboard`
+    },
+    explanation_signals: {
+      runtime_next_best_action: economicsIntelligence.next_best_action,
+      runtime_funding_posture: economicsIntelligence.recommended_funding_posture,
+      runtime_replenishment_risk_state: economicsIntelligence.replenishment_risk_state,
+      runtime_treasury_health_state: economicsIntelligence.treasury_health_state,
+      partner_next_best_action: partnerIntelligence.next_best_action,
+      partner_readiness_state: partnerIntelligence.partner_readiness_state,
+      partner_onboarding_friction_state: partnerIntelligence.onboarding_friction_state,
+      partner_promotion_readiness_state: partnerIntelligence.promotion_readiness_state
+    },
+    generated_from: {
+      economics_category: economicsIntelligence.category,
+      partner_category: partnerIntelligence.category
+    }
+  };
+}
+
+function summarizeOperatorIntelligencePack(state, input) {
+  const pack = buildOperatorIntelligencePack(state, input);
+  return {
+    ok: true,
+    account_id: pack.account_id,
+    category: pack.category,
+    recommended_operator_motion: pack.recommended_operator_motion,
+    queue_length: pack.next_action_queue.length,
+    runtime_economics_state: pack.overall_operator_state.runtime_economics_state,
+    partner_adoption_state: pack.overall_operator_state.partner_adoption_state
+  };
+}
+
+module.exports = {
+  buildOperatorIntelligencePack,
+  summarizeOperatorIntelligencePack
+};

package/lib/outreach_copy_pack.js

@@ -0,0 +1,51 @@
+"use strict";
+
+const packageJson = require("../package.json");
+
+function buildOutreachCopyPack() {
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "machine-commerce-outreach-copy-pack",
+    short_post: {
+      headline: "xytara is live",
+      body: "xytara is a machine-commerce spine for builders who need quote, pay, execute, inspect, and continue into proof without stitching together separate systems. It supports direct paid execution, reusable credits, adapter-first extension, and proof-aware followthrough."
+    },
+    direct_message: {
+      subject: "xytara: paid execution plus proof-aware followthrough",
+      body: "We built xytara for agent builders, tool authors, and runtime teams that need a real machine-commerce path instead of patchwork glue. If you want, start with `xytara-release --center --summary` and then run one paid path with `xytara-run`."
+    },
+    adapter_partner_message: {
+      subject: "xytara adapter partner path",
+      body: "If you build tools or integrations, xytara now has a public third-party adapter starter, promotion path, and partner path. You can copy the minimal starter, validate it locally, inspect the promotion workflow, and see exactly what still blocks broader trust."
+    },
+    first_links: [
+      "/v1/release-center/summary",
+      "/v1/soft-launch/summary",
+      "/v1/adapter-partners/summary",
+      "/v1/outreach-proof/summary"
+    ],
+    first_ctas: [
+      "run xytara-release --center --summary",
+      "run one direct paid path with xytara-run",
+      "inspect the adapter partner path if you build integrations"
+    ]
+  };
+}
+
+function summarizeOutreachCopyPack() {
+  const pack = buildOutreachCopyPack();
+  return {
+    ok: true,
+    product: pack.product,
+    category: pack.category,
+    link_count: pack.first_links.length,
+    cta_count: pack.first_ctas.length,
+    headline: pack.short_post.headline
+  };
+}
+
+module.exports = {
+  buildOutreachCopyPack,
+  summarizeOutreachCopyPack
+};

package/lib/outreach_message_pack.js

@@ -0,0 +1,71 @@
+"use strict";
+
+const packageJson = require("../package.json");
+
+function buildOutreachMessagePack() {
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "machine-commerce-outreach-message-pack",
+    messages: [
+      {
+        message_ref: "public_launch_post",
+        audience_ref: "general_builder",
+        channel: "public_post",
+        subject: "xytara is live",
+        body: "xytara is live. It is a machine-commerce spine for builders who need quote, pay, execute, inspect, and continue into proof without stitching together separate systems. Start with `/v1/release-center/summary` or run `xytara-release --center --summary`."
+      },
+      {
+        message_ref: "agent_builder_intro",
+        audience_ref: "agent_builder",
+        channel: "direct_message",
+        subject: "xytara for paid agent execution",
+        body: "If you need a real paid capability path for agents, xytara now gives you quote, pay, execute, inspect, and proof-aware followthrough on one public spine. Best first step: run `xytara-run` once, then inspect `/v1/release-center/summary`."
+      },
+      {
+        message_ref: "adapter_partner_intro",
+        audience_ref: "adapter_author",
+        channel: "direct_message",
+        subject: "xytara adapter partner path",
+        body: "If you build tools or integrations, xytara now has a public third-party adapter starter, promotion path, and partner path. You can copy the minimal starter, validate it locally, inspect promotion workflow, and see what still blocks broader trust."
+      },
+      {
+        message_ref: "runtime_team_intro",
+        audience_ref: "proof_aware_runtime_team",
+        channel: "direct_message",
+        subject: "xytara for runtime-to-proof followthrough",
+        body: "If your runtime results currently stop at logs, xytara gives you a machine-commerce path that can continue into proof review cleanly. Best first check: `/v1/outreach-proof/summary` and `xytara-release --outreach-proof --summary`."
+      }
+    ],
+    first_artifacts: [
+      "/v1/release-center/summary",
+      "/v1/adapter-partners/summary",
+      "/v1/outreach-proof/summary",
+      "/v1/soft-launch/summary"
+    ],
+    first_commands: [
+      "xytara-release --center --summary",
+      "xytara-release --adapter-partners --summary",
+      "xytara-release --outreach-proof --summary",
+      "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"
+    ]
+  };
+}
+
+function summarizeOutreachMessagePack() {
+  const pack = buildOutreachMessagePack();
+  return {
+    ok: true,
+    product: pack.product,
+    category: pack.category,
+    message_count: pack.messages.length,
+    artifact_count: pack.first_artifacts.length,
+    command_count: pack.first_commands.length,
+    first_message: pack.messages[0] ? pack.messages[0].message_ref : null
+  };
+}
+
+module.exports = {
+  buildOutreachMessagePack,
+  summarizeOutreachMessagePack
+};

package/lib/outreach_target_pack.js

@@ -0,0 +1,60 @@
+"use strict";
+
+const packageJson = require("../package.json");
+
+function buildOutreachTargetPack() {
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "machine-commerce-outreach-target-pack",
+    target_groups: [
+      {
+        target_ref: "agent_builders",
+        why_now: "need a first paid capability path with governed execution and proof-aware followthrough",
+        first_artifact: "/v1/release-center/summary",
+        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"
+      },
+      {
+        target_ref: "adapter_authors",
+        why_now: "need a public starter plus a visible promotion path",
+        first_artifact: "/v1/adapter-partners/summary",
+        first_cli: "xytara-release --adapter-partners --summary"
+      },
+      {
+        target_ref: "tool_and_marketplace_authors",
+        why_now: "need a machine-commerce layer without stitching together payment, execution, and review",
+        first_artifact: "/v1/launch-narrative/summary",
+        first_cli: "xytara-release --launch --summary"
+      },
+      {
+        target_ref: "proof_aware_runtime_teams",
+        why_now: "need runtime results that continue cleanly into proof instead of stopping at logs",
+        first_artifact: "/v1/outreach-proof/summary",
+        first_cli: "xytara-release --outreach-proof --summary"
+      }
+    ],
+    first_wave_guidance: [
+      "start with a small technically strong set, not a broad audience",
+      "lead each target to one first artifact, not the whole surface map",
+      "watch which first cli or route they actually use",
+      "tighten language before expanding beyond the first wave"
+    ]
+  };
+}
+
+function summarizeOutreachTargetPack() {
+  const pack = buildOutreachTargetPack();
+  return {
+    ok: true,
+    product: pack.product,
+    category: pack.category,
+    target_count: pack.target_groups.length,
+    first_target: pack.target_groups[0] ? pack.target_groups[0].target_ref : null,
+    guidance_count: pack.first_wave_guidance.length
+  };
+}
+
+module.exports = {
+  buildOutreachTargetPack,
+  summarizeOutreachTargetPack
+};