xytara 2.1.0 → 2.2.0

package/index.js

@@ -31,6 +31,10 @@ const {
   buildReleaseHistory,
   summarizeReleaseHistory
 } = require("./lib/release_history");
+const {
+  buildAdapterPack,
+  summarizeAdapterPack
+} = require("./lib/adapter_pack");
 const {
   buildPublishPlan,
   summarizePublishPlan
@@ -90,7 +94,7 @@ const {
 } = require("./integrations/registry");
 
 const COMMERCE_SDK_NAME = "xytara";
-const COMMERCE_SDK_VERSION = "2.1.0";
+const COMMERCE_SDK_VERSION = "2.2.0";
 const COMMERCE_API_VERSION = "v1";
 
 function createClient(options) {
@@ -153,6 +157,8 @@ module.exports = {
   summarizeReleaseCenter,
   buildReleaseHistory,
   summarizeReleaseHistory,
+  buildAdapterPack,
+  summarizeAdapterPack,
   buildPublishPlan,
   summarizePublishPlan,
   buildEcosystemEntryPack,

package/lib/adapter_pack.js

@@ -0,0 +1,118 @@
+"use strict";
+
+const packageJson = require("../package.json");
+
+function buildAdapterPack() {
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "machine-commerce-adapter-pack",
+    positioning: {
+      line: "adapter-first machine commerce for third-party execution, settlement, protocol, and identity surfaces",
+      intended_for: [
+        "adapter_authors",
+        "protocol_bridge_builders",
+        "settlement_integrators",
+        "identity_and_registry_integrators"
+      ]
+    },
+    onboarding: {
+      first_docs: [
+        "ADAPTER_START_HERE.md",
+        "adapters/AUTHORING_GUIDE.md",
+        "adapters/ONBOARDING_POSTURE.md",
+        "adapters/THIRD_PARTY_SUBMISSION_PROCESS.md"
+      ],
+      starter_classes: [
+        "execution_adapter",
+        "payment_rail_adapter",
+        "settlement_adapter",
+        "agent_protocol_adapter",
+        "identity_registry_adapter"
+      ],
+      first_commands: [
+        "npm run verify:adapters",
+        "node scripts/registry_cli.js validate-bundle --example protocol",
+        "node scripts/registry_cli.js review-bundle --example protocol",
+        "node scripts/registry_cli.js promotion-readiness --integration partner.protocol.acme_mcp"
+      ]
+    },
+    artifact_stack: [
+      "adapter_manifest",
+      "registration_record",
+      "certification_pack",
+      "submission_bundle",
+      "submission_bundle_set",
+      "registry_snapshot"
+    ],
+    promotion_posture: {
+      explicit_states: [
+        "review_ready",
+        "default_eligible",
+        "production_default_ready"
+      ],
+      default_third_party_posture: {
+        discoverable: true,
+        reviewable: true,
+        explicitly_selectable: true,
+        default_eligible: false,
+        production_default_ready: false
+      }
+    },
+    examples: {
+      canonical_examples: [
+        "adapters/examples/minimal-third-party-execution-adapter.manifest.json",
+        "adapters/examples/minimal-third-party-execution-adapter.js",
+        "adapters/examples/minimal-third-party-execution.submission-bundle.json",
+        "adapters/examples/example-execution-adapter.manifest.json",
+        "adapters/examples/example-execution-adapter.js",
+        "adapters/examples/example-settlement-adapter.manifest.json",
+        "adapters/examples/example-settlement-adapter.js",
+        "adapters/examples/example-third-party-registration.submission-bundle.json",
+        "adapters/examples/example-third-party-identity-registration.submission-bundle.json",
+        "adapters/examples/example-third-party-settlement-registration.submission-bundle.json"
+      ],
+      review_examples: [
+        "minimal_third_party_execution",
+        "protocol",
+        "identity",
+        "settlement"
+      ]
+    },
+    public_surfaces: {
+      integrations_summary: "/v1/integrations/summary",
+      promotion_readiness: "/v1/integrations/promotion-readiness",
+      promotion_actions: "/v1/integrations/promotion-actions",
+      submission_bundle_review: "/v1/integrations/review/submission-bundle",
+      submission_bundle_set_review: "/v1/integrations/review/submission-bundle-set",
+      registry_snapshot_review: "/v1/integrations/review/registry-snapshot"
+    },
+    why_it_matters: [
+      "third-party integrations can be staged and reviewed without becoming defaults",
+      "promotion posture is inspectable as data rather than private process",
+      "submission artifacts stay normalized across adapter classes",
+      "machine-commerce flexibility does not require vendor lock-in"
+    ]
+  };
+}
+
+function summarizeAdapterPack() {
+  const pack = buildAdapterPack();
+  return {
+    ok: true,
+    product: pack.product,
+    category: pack.category,
+    audience_count: pack.positioning.intended_for.length,
+    starter_class_count: pack.onboarding.starter_classes.length,
+    first_command_count: pack.onboarding.first_commands.length,
+    artifact_count: pack.artifact_stack.length,
+    example_count: pack.examples.canonical_examples.length,
+    review_example_count: pack.examples.review_examples.length,
+    first_doc: pack.onboarding.first_docs[0]
+  };
+}
+
+module.exports = {
+  buildAdapterPack,
+  summarizeAdapterPack
+};

package/lib/adapter_partner_pack.js

@@ -0,0 +1,89 @@
+"use strict";
+
+const packageJson = require("../package.json");
+
+function buildAdapterPartnerPack() {
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "machine-commerce-adapter-partner-pack",
+    positioning: {
+      line: "build, review, and promote third-party adapters on top of xytara without giving up explicit trust posture",
+      intended_for: [
+        "ecosystem_partners",
+        "adapter_authors",
+        "marketplace_integrators",
+        "review_operators"
+      ]
+    },
+    partner_value: [
+      "adapter authors can start from a public minimal example instead of reverse-engineering internal flows",
+      "review posture is inspectable through explicit readiness and action surfaces",
+      "default-selection trust is earned through promotion data, not hidden exceptions",
+      "xytara stays flexible without forcing partners into one vendor-specific runtime story"
+    ],
+    start_path: {
+      first_docs: [
+        "ADAPTER_START_HERE.md",
+        "ADAPTER_PROMOTION_START_HERE.md"
+      ],
+      first_commands: [
+        "npm run verify:adapters",
+        "node scripts/registry_cli.js review-bundle --file adapters/examples/minimal-third-party-execution.submission-bundle.json",
+        "node scripts/registry_cli.js promotion-workflow --integration partner.execution.minimal_echo",
+        "xytara-release --adapter-promotion --summary"
+      ],
+      first_examples: [
+        "adapters/examples/minimal-third-party-execution-adapter.manifest.json",
+        "adapters/examples/minimal-third-party-execution.submission-bundle.json"
+      ]
+    },
+    trust_path: {
+      maturity_path: [
+        "starter_example",
+        "staging_registered",
+        "review_ready",
+        "default_eligible",
+        "production_default_ready"
+      ],
+      key_questions: [
+        "what is valid to ship now?",
+        "what still blocks trust or default selection?",
+        "what evidence is still missing?",
+        "what action moves the integration forward next?"
+      ]
+    },
+    public_surfaces: {
+      adapter_pack: "/v1/adapter-pack/summary",
+      adapter_promotion: "/v1/adapter-promotion/summary",
+      promotion_readiness: "/v1/integrations/promotion-readiness",
+      promotion_workflow: "/v1/integrations/promotion-workflow",
+      promotion_actions: "/v1/integrations/promotion-actions",
+      release_center: "/v1/release-center/summary"
+    },
+    adoption_message: {
+      why_build_here: "partners get a machine-commerce spine with explicit review and promotion posture instead of opaque integration trust",
+      first_partner_type: "adapter_author",
+      first_success: "a partner can copy the minimal starter, validate it locally, review the submission bundle, and inspect the next promotion action without private coordination"
+    }
+  };
+}
+
+function summarizeAdapterPartnerPack() {
+  const pack = buildAdapterPartnerPack();
+  return {
+    ok: true,
+    product: pack.product,
+    category: pack.category,
+    audience_count: pack.positioning.intended_for.length,
+    value_count: pack.partner_value.length,
+    first_command_count: pack.start_path.first_commands.length,
+    maturity_step_count: pack.trust_path.maturity_path.length,
+    first_partner_type: pack.adoption_message.first_partner_type
+  };
+}
+
+module.exports = {
+  buildAdapterPartnerPack,
+  summarizeAdapterPartnerPack
+};

package/lib/adapter_promotion_pack.js

@@ -0,0 +1,89 @@
+"use strict";
+
+const packageJson = require("../package.json");
+
+function buildAdapterPromotionPack() {
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "machine-commerce-adapter-promotion-pack",
+    positioning: {
+      line: "promotion-first adapter maturity for third-party integrations that need explicit review, certification, and default-selection trust",
+      intended_for: [
+        "adapter_authors",
+        "review_operators",
+        "integration_owners",
+        "ecosystem_partners"
+      ]
+    },
+    maturity_path: [
+      "starter_example",
+      "staging_registered",
+      "review_ready",
+      "default_eligible",
+      "production_default_ready"
+    ],
+    first_docs: [
+      "ADAPTER_PROMOTION_START_HERE.md",
+      "ADAPTER_START_HERE.md",
+      "adapters/ONBOARDING_POSTURE.md",
+      "adapters/THIRD_PARTY_SUBMISSION_PROCESS.md"
+    ],
+    first_commands: [
+      "node scripts/registry_cli.js review-bundle --file adapters/examples/minimal-third-party-execution.submission-bundle.json",
+      "node scripts/registry_cli.js promotion-readiness --integration partner.execution.minimal_echo",
+      "node scripts/registry_cli.js promotion-workflow --integration partner.execution.minimal_echo",
+      "node scripts/registry_cli.js promotion-action-set --integration partner.execution.minimal_echo",
+      "node scripts/registry_cli.js promotion-action-preview --integration partner.execution.minimal_echo --action complete_certification"
+    ],
+    canonical_examples: {
+      starter_bundle: "adapters/examples/minimal-third-party-execution.submission-bundle.json",
+      staged_protocol_bundle: "adapters/examples/example-third-party-registration.submission-bundle.json",
+      staged_identity_bundle: "adapters/examples/example-third-party-identity-registration.submission-bundle.json",
+      staged_settlement_bundle: "adapters/examples/example-third-party-settlement-registration.submission-bundle.json",
+      staged_integration_id: "partner.protocol.acme_mcp",
+      starter_integration_id: "partner.execution.minimal_echo"
+    },
+    public_surfaces: {
+      promotion_readiness_list: "/v1/integrations/promotion-readiness",
+      promotion_workflow_list: "/v1/integrations/promotion-workflow",
+      promotion_action_list: "/v1/integrations/promotion-actions",
+      promotion_readiness_detail: "/v1/integrations/:integration_id/promotion-readiness",
+      promotion_workflow_detail: "/v1/integrations/:integration_id/promotion-workflow",
+      promotion_action_detail: "/v1/integrations/:integration_id/promotion-actions",
+      promotion_action_preview: "/v1/integrations/promotion-actions/preview"
+    },
+    review_questions: [
+      "is the integration review-ready?",
+      "what blockers still prevent default eligibility?",
+      "what certification gaps remain?",
+      "what promotion action is valid now?"
+    ],
+    why_it_matters: [
+      "third-party integrations can advance through explicit review states instead of private judgment",
+      "default selection stays gated behind visible posture and certification data",
+      "review operators and adapter authors can inspect the same promotion model",
+      "adapter flexibility stays compatible with trust and production-default discipline"
+    ]
+  };
+}
+
+function summarizeAdapterPromotionPack() {
+  const pack = buildAdapterPromotionPack();
+  return {
+    ok: true,
+    product: pack.product,
+    category: pack.category,
+    audience_count: pack.positioning.intended_for.length,
+    maturity_step_count: pack.maturity_path.length,
+    first_command_count: pack.first_commands.length,
+    review_question_count: pack.review_questions.length,
+    first_doc: pack.first_docs[0],
+    starter_integration_id: pack.canonical_examples.starter_integration_id
+  };
+}
+
+module.exports = {
+  buildAdapterPromotionPack,
+  summarizeAdapterPromotionPack
+};

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
+};

package/lib/phase_10_closeout_pack.js

@@ -0,0 +1,45 @@
+"use strict";
+
+const packageJson = require("../package.json");
+
+function buildPhase10CloseoutPack() {
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "machine-commerce-phase-10-closeout-pack",
+    phase_ref: "phase_10",
+    posture: "closeout_plan",
+    current_decision: "ready_for_program_closeout",
+    blocking_actions: [],
+    action_steps: [
+      "confirm the current long-tail lane family is the intended final Phase 10 shape",
+      "record the terminal program closeout review",
+      "recheck phase-10 gate summary for zero unsatisfied conditions",
+      "advance only once phase-10 gate resolves to ready_for_program_closeout"
+    ],
+    completion_signals: [
+      "phase-10 completion shows no remaining focus",
+      "phase-10 decision record shows no pending records",
+      "phase-10 gate resolves to ready_for_program_closeout"
+    ]
+  };
+}
+
+function summarizePhase10CloseoutPack() {
+  const pack = buildPhase10CloseoutPack();
+  return {
+    ok: true,
+    product: pack.product,
+    category: pack.category,
+    phase_ref: pack.phase_ref,
+    blocking_action_count: pack.blocking_actions.length,
+    action_step_count: pack.action_steps.length,
+    completion_signal_count: pack.completion_signals.length,
+    current_decision: pack.current_decision
+  };
+}
+
+module.exports = {
+  buildPhase10CloseoutPack,
+  summarizePhase10CloseoutPack
+};

package/lib/phase_10_completion_pack.js

@@ -0,0 +1,76 @@
+"use strict";
+
+const packageJson = require("../package.json");
+
+function buildPhase10CompletionPack() {
+  return {
+    ok: true,
+    product: packageJson.name,
+    category: "machine-commerce-phase-10-completion-pack",
+    phase_ref: "phase_10",
+    posture: "completion_review",
+    coverage: {
+      ecosystem_refs: ["demand_signal_adapters", "niche_extension_registry", "ecosystem_backlog_triage"],
+      lane_refs: [
+        "/v1/phases/phase-10/demand-signal-adapters/summary",
+        "/v1/phases/phase-10/niche-extension-registry/summary",
+        "/v1/phases/phase-10/ecosystem-backlog-triage/summary"
+      ],
+      extension_modes: ["demand_signal_capture", "extension_registry_mapping", "backlog_triage"],
+      demand_modes: ["partner_signal_flow", "extension_fit_flow", "queue_handoff_flow"],
+      extension_artifacts: ["demand_signal_ref", "extension_registry_ref", "triage_queue_ref"],
+      operator_surfaces: [
+        "/v1/release-center/summary",
+        "/v1/publish-plan/summary",
+        "/v1/phases/phase-10/long-tail-continuity/summary"
+      ]
+    },
+    completion: {
+      checks: [
+        "broad Phase 10 long-tail ecosystem pack is public and inspectable",
+        "all current Phase 10 long-tail lanes are public and inspectable",
+        "extension posture is visible at phase level",
+        "long-tail continuity is explicit across the lane family",
+        "release-center summary reflects Phase 10 breadth and lane coverage",
+        "Phase 10 closeout criteria are explicit before final program closeout"
+      ],
+      readiness_criteria: [
+        { ref: "criterion.phase_surface_public", label: "Phase 10 broad summary is live and inspectable", satisfied: true },
+        { ref: "criterion.long_tail_lane_coverage", label: "All current long-tail lanes are live and inspectable", satisfied: true },
+        { ref: "criterion.long_tail_continuity_visible", label: "Long-tail continuity is visible at phase level", satisfied: true },
+        { ref: "criterion.operator_surfaces_attached", label: "Operator surfaces remain attached to the long-tail family", satisfied: true },
+        { ref: "criterion.freeze_shape_confirmed", label: "The final Phase 10 long-tail lane shape is explicitly frozen", satisfied: true },
+        { ref: "criterion.program_closeout_reviewed", label: "A final program closeout review has been recorded", satisfied: true }
+      ],
+      ready_for_next_phase: false,
+      remaining_focus: []
+    }
+  };
+}
+
+function summarizePhase10CompletionPack() {
+  const pack = buildPhase10CompletionPack();
+  return {
+    ok: true,
+    product: pack.product,
+    category: pack.category,
+    phase_ref: pack.phase_ref,
+    ecosystem_count: pack.coverage.ecosystem_refs.length,
+    lane_count: pack.coverage.lane_refs.length,
+    extension_mode_count: pack.coverage.extension_modes.length,
+    demand_mode_count: pack.coverage.demand_modes.length,
+    extension_artifact_count: pack.coverage.extension_artifacts.length,
+    operator_surface_count: pack.coverage.operator_surfaces.length,
+    completion_check_count: pack.completion.checks.length,
+    readiness_criteria_count: pack.completion.readiness_criteria.length,
+    satisfied_criteria_count: pack.completion.readiness_criteria.filter((criterion) => criterion.satisfied === true).length,
+    unsatisfied_criteria_count: pack.completion.readiness_criteria.filter((criterion) => criterion.satisfied !== true).length,
+    remaining_focus_count: pack.completion.remaining_focus.length,
+    ready_for_next_phase: pack.completion.ready_for_next_phase
+  };
+}
+
+module.exports = {
+  buildPhase10CompletionPack,
+  summarizePhase10CompletionPack
+};