xytara 2.6.0 → 2.8.0

package/scripts/verify_integrations.js

@@ -0,0 +1,620 @@
+"use strict";
+
+const assert = require("assert");
+const root = require("../index.js");
+const {
+  createRegisteredIntegrationFromManifest,
+  createIntegrationRegistrySnapshot,
+  createIntegrationSubmissionBundle,
+  createIntegrationSubmissionBundleSet,
+  createIntegrationRegistrySnapshotFromBundles,
+  exportIntegrationRegistrySnapshot,
+  exportIntegrationSubmissionBundles,
+  exportIntegrationSubmissionBundleSet,
+  importIntegrationSubmissionBundle,
+  importRegisteredIntegration,
+  summarizeIntegrationPromotionReadiness,
+  summarizeIntegrationPromotionWorkflow,
+  summarizeIntegrationPromotionWorkflowList,
+  summarizeIntegrationRegistrySnapshotReview,
+  summarizeIntegrationSubmissionBundleReview,
+  summarizeIntegrationSubmissionBundleSetReview,
+  validateIntegrationRegistration,
+  validateIntegrationSubmissionBundle,
+  validateIntegrationSubmissionBundleSet,
+  validateIntegrationRegistrySnapshot
+} = require("../integrations/registry");
+const { resolveIntegrationSelection, validateIntegrationSelection } = require("../integrations/dispatch");
+const exampleSubmissionBundle = require("../adapters/examples/example-third-party-registration.submission-bundle.json");
+const exampleIdentitySubmissionBundle = require("../adapters/examples/example-third-party-identity-registration.submission-bundle.json");
+const exampleSettlementSubmissionBundle = require("../adapters/examples/example-third-party-settlement-registration.submission-bundle.json");
+
+async function main() {
+  const integrations = root.listIntegrations();
+  assert.ok(Array.isArray(integrations), "integrations list missing");
+  assert.ok(integrations.length >= 5, "built-in integration breadth missing");
+  assert.ok(integrations.some((integration) => integration.integration_id === "builtin.protocol.mcp"), "mcp integration missing");
+  assert.ok(integrations.some((integration) => integration.integration_id === "builtin.payment.x402"), "x402 integration missing");
+  assert.ok(integrations.some((integration) => integration.integration_id === "builtin.settlement.chain"), "chain settlement integration missing");
+  assert.ok(integrations.some((integration) => integration.integration_id === "partner.protocol.acme_mcp"), "third-party example integration missing");
+  assert.ok(integrations.some((integration) => integration.integration_id === "partner.identity.attest_registry"), "third-party identity integration missing");
+  assert.ok(integrations.some((integration) => integration.integration_id === "partner.settlement.lattice_anchor"), "third-party settlement integration missing");
+
+  const detail = root.getIntegration("builtin.protocol.mcp");
+  assert.ok(detail, "integration detail missing");
+  assert.strictEqual(detail.adapter_class, "agent_protocol_adapter", "integration class mismatch");
+  assert.strictEqual(detail.certification_state, "certified", "integration certification state mismatch");
+  assert.strictEqual(detail.integration_maturity, "production_default", "integration maturity mismatch");
+  assert.strictEqual(detail.operational_readiness.supports_default_selection, true, "integration default selection posture mismatch");
+  assert.strictEqual(detail.registration.registration_state, "unregistered", "builtin registration state mismatch");
+
+  const summary = root.summarizeIntegrations();
+  assert.strictEqual(summary.ok, true, "integration summary ok mismatch");
+  assert.ok(summary.integration_count >= integrations.length, "integration summary count mismatch");
+  assert.ok(summary.certified_integration_count >= 5, "integration summary certified count mismatch");
+  assert.ok(summary.production_default_count >= 5, "integration summary production-default count mismatch");
+  assert.ok(summary.integrations.some((entry) => entry.registration_state === "staging_registered"), "integration summary registration state missing");
+
+  const certifiedBuiltins = root.listIntegrations({
+    source: "builtin",
+    certification_state: "certified",
+    integration_maturity: "production_default",
+    bundled: "true"
+  });
+  assert.ok(certifiedBuiltins.length >= 5, "certified builtin integration filtering mismatch");
+
+  const thirdPartyIntegrations = root.listIntegrations({
+    source: "third_party_example",
+    bundled: "false"
+  });
+  assert.ok(thirdPartyIntegrations.length >= 3, "third-party integration filtering mismatch");
+  assert.ok(thirdPartyIntegrations.every((entry) => entry.registration.registration_state === "staging_registered"), "third-party registration state mismatch");
+  assert.ok(thirdPartyIntegrations.every((entry) => entry.registration.requires_explicit_selection === true), "third-party explicit-selection posture mismatch");
+  assert.ok(thirdPartyIntegrations.some((entry) => entry.adapter_class === "agent_protocol_adapter"), "third-party protocol integration class missing");
+  assert.ok(thirdPartyIntegrations.some((entry) => entry.adapter_class === "identity_registry_adapter"), "third-party identity integration class missing");
+  assert.ok(thirdPartyIntegrations.some((entry) => entry.adapter_class === "settlement_adapter"), "third-party settlement integration class missing");
+
+  const importedIntegration = createRegisteredIntegrationFromManifest({
+    adapter_id: "partner.execution.echo_plus",
+    adapter_class: "execution_adapter",
+    adapter_version: "0.2.0",
+    interface_version: "commerce-adapter-interface/v1",
+    display_name: "Echo Plus Partner Execution",
+    description: "Imported partner execution adapter used to validate registry ingestion.",
+    capabilities: ["task.execute"],
+    compatibility: {
+      node: ">=18",
+      commerce_contract: "xytara/v1",
+      proof_contract: "xoonya/v1"
+    },
+    health_contract: {
+      check_kind: "self_reported",
+      supports_readiness: true
+    },
+    idempotency_contract: {
+      strategy: "caller_supplied_key",
+      scope: "task_execution"
+    },
+    failure_contract: {
+      categories: ["invalid_input", "timeout"],
+      retryable_categories: ["timeout"]
+    },
+    proof_contract: {
+      emits_proof_compatible_facts: true,
+      proof_mode: "execution_facts_only"
+    },
+    supported_settlement_modes: ["none"]
+  }, {
+    integration_id: "partner.execution.echo_plus",
+    adapter_id: "partner.execution.echo_plus",
+    adapter_class: "execution_adapter",
+    registration_state: "staging_registered",
+    integration_maturity: "staging_candidate",
+    certification_state: "self_attested",
+    bundled: false,
+    default_selection_enabled: false,
+    selection_priority: 620,
+    requires_explicit_selection: true,
+    registered_at: "2026-03-20T00:00:00.000Z"
+  }, {
+    source: "third_party_example",
+    task_refs: ["trust.verify"],
+    protocols: [],
+    execution_backends: ["http"],
+    adapter_lanes: ["http"]
+  });
+  assert.strictEqual(importedIntegration.integration_id, "partner.execution.echo_plus", "imported integration id mismatch");
+  assert.strictEqual(importedIntegration.registration.registration_state, "staging_registered", "imported integration registration state mismatch");
+  assert.strictEqual(importedIntegration.registration.default_selection_enabled, false, "imported integration default selection mismatch");
+  assert.strictEqual(importedIntegration.registration.selection_priority, 620, "imported integration selection priority mismatch");
+
+  const importedSettlementIntegration = createRegisteredIntegrationFromManifest({
+    adapter_id: "partner.settlement.echo_anchor",
+    adapter_class: "settlement_adapter",
+    adapter_version: "0.2.0",
+    interface_version: "commerce-adapter-interface/v1",
+    display_name: "Echo Anchor Partner Settlement",
+    description: "Imported partner settlement adapter used to validate registry ingestion.",
+    capabilities: ["anchoring.submit", "settlement.reference"],
+    compatibility: {
+      node: ">=18",
+      commerce_contract: "xytara/v1",
+      proof_contract: "xoonya/v1"
+    },
+    health_contract: {
+      check_kind: "self_reported",
+      supports_readiness: true
+    },
+    idempotency_contract: {
+      strategy: "quote_and_target_binding",
+      scope: "settlement_request"
+    },
+    failure_contract: {
+      categories: ["invalid_input", "timeout", "settlement_failure"],
+      retryable_categories: ["timeout"]
+    },
+    proof_contract: {
+      emits_proof_compatible_facts: true,
+      proof_mode: "settlement_reference_only"
+    },
+    supported_settlement_modes: ["anchor_commit"]
+  }, {
+    integration_id: "partner.settlement.echo_anchor",
+    adapter_id: "partner.settlement.echo_anchor",
+    adapter_class: "settlement_adapter",
+    registration_state: "staging_registered",
+    integration_maturity: "staging_candidate",
+    certification_state: "self_attested",
+    bundled: false,
+    default_selection_enabled: false,
+    selection_priority: 645,
+    requires_explicit_selection: true,
+    registered_at: "2026-03-20T00:00:00.000Z"
+  }, {
+    source: "third_party_example",
+    task_refs: ["anchoring.submit"],
+    protocols: [],
+    execution_backends: ["chain"],
+    adapter_lanes: ["chain"]
+  });
+  assert.strictEqual(importedSettlementIntegration.integration_id, "partner.settlement.echo_anchor", "imported settlement integration id mismatch");
+  assert.strictEqual(importedSettlementIntegration.registration.registration_state, "staging_registered", "imported settlement registration state mismatch");
+  assert.strictEqual(importedSettlementIntegration.registration.selection_priority, 645, "imported settlement selection priority mismatch");
+
+  const importedIdentityIntegration = createRegisteredIntegrationFromManifest({
+    adapter_id: "partner.identity.echo_registry",
+    adapter_class: "identity_registry_adapter",
+    adapter_version: "0.2.0",
+    interface_version: "commerce-adapter-interface/v1",
+    display_name: "Echo Partner Identity Registry",
+    description: "Imported partner identity adapter used to validate registry ingestion.",
+    capabilities: ["registry.register", "trust.handoff.emit"],
+    compatibility: {
+      node: ">=18",
+      commerce_contract: "xytara/v1",
+      proof_contract: "xoonya/v1"
+    },
+    health_contract: {
+      check_kind: "self_reported",
+      supports_readiness: true
+    },
+    idempotency_contract: {
+      strategy: "record_ref_binding",
+      scope: "registry_request"
+    },
+    failure_contract: {
+      categories: ["invalid_input", "timeout", "upstream_unavailable"],
+      retryable_categories: ["timeout"]
+    },
+    proof_contract: {
+      emits_proof_compatible_facts: true,
+      proof_mode: "registry_reference_facts"
+    },
+    supported_settlement_modes: []
+  }, {
+    integration_id: "partner.identity.echo_registry",
+    adapter_id: "partner.identity.echo_registry",
+    adapter_class: "identity_registry_adapter",
+    registration_state: "staging_registered",
+    integration_maturity: "staging_candidate",
+    certification_state: "self_attested",
+    bundled: false,
+    default_selection_enabled: false,
+    selection_priority: 635,
+    requires_explicit_selection: true,
+    registered_at: "2026-03-20T00:00:00.000Z"
+  }, {
+    source: "third_party_example",
+    task_refs: ["registry.register", "trust.handoff.emit"],
+    protocols: [],
+    execution_backends: ["http", "chain"],
+    adapter_lanes: ["http", "chain"]
+  });
+  assert.strictEqual(importedIdentityIntegration.integration_id, "partner.identity.echo_registry", "imported identity integration id mismatch");
+  assert.strictEqual(importedIdentityIntegration.registration.registration_state, "staging_registered", "imported identity registration state mismatch");
+  assert.strictEqual(importedIdentityIntegration.registration.selection_priority, 635, "imported identity selection priority mismatch");
+
+  const validRegistration = validateIntegrationRegistration({
+    adapter_id: "partner.execution.validated",
+    adapter_class: "execution_adapter"
+  }, {
+    integration_id: "partner.execution.validated",
+    adapter_id: "partner.execution.validated",
+    adapter_class: "execution_adapter"
+  });
+  assert.strictEqual(validRegistration.ok, true, "valid integration registration should pass");
+
+  const invalidRegistration = validateIntegrationRegistration({
+    adapter_id: "partner.execution.alpha",
+    adapter_class: "execution_adapter"
+  }, {
+    integration_id: "partner.execution.beta",
+    adapter_id: "partner.execution.beta",
+    adapter_class: "settlement_adapter"
+  });
+  assert.strictEqual(invalidRegistration.ok, false, "invalid integration registration should fail");
+  assert.ok(invalidRegistration.errors.some((entry) => entry.includes("manifest.adapter_id")), "invalid registration adapter id mismatch missing");
+
+  const importedViaToolkit = importRegisteredIntegration({
+    adapter_id: "partner.protocol.bridge",
+    adapter_class: "agent_protocol_adapter",
+    adapter_version: "0.3.0",
+    interface_version: "commerce-adapter-interface/v1",
+    display_name: "Bridge Partner Protocol",
+    description: "Imported partner protocol adapter used to validate registry toolkit import.",
+    capabilities: ["adapter.mcp.invoke"],
+    compatibility: {
+      node: ">=18",
+      commerce_contract: "xytara/v1",
+      proof_contract: "xoonya/v1"
+    },
+    health_contract: {
+      check_kind: "self_reported",
+      supports_readiness: true
+    },
+    idempotency_contract: {
+      strategy: "quote_bound_invocation",
+      scope: "protocol_invocation"
+    },
+    failure_contract: {
+      categories: ["invalid_input", "timeout"],
+      retryable_categories: ["timeout"]
+    },
+    proof_contract: {
+      emits_proof_compatible_facts: true,
+      proof_mode: "protocol_invocation_facts"
+    },
+    supported_settlement_modes: ["evm_payment"]
+  }, {
+    integration_id: "partner.protocol.bridge",
+    adapter_id: "partner.protocol.bridge",
+    adapter_class: "agent_protocol_adapter",
+    registration_state: "staging_registered",
+    integration_maturity: "staging_candidate",
+    certification_state: "self_attested",
+    bundled: false,
+    default_selection_enabled: false,
+    selection_priority: 630,
+    requires_explicit_selection: true,
+    registered_at: "2026-03-20T00:00:00.000Z"
+  }, {
+    source: "third_party_example",
+    task_refs: ["adapter.mcp.invoke"],
+    protocols: ["mcp"],
+    execution_backends: ["mcp"],
+    adapter_lanes: ["mcp"]
+  });
+  assert.strictEqual(importedViaToolkit.integration_id, "partner.protocol.bridge", "toolkit import integration id mismatch");
+  assert.strictEqual(importedViaToolkit.registration.registration_state, "staging_registered", "toolkit import registration state mismatch");
+
+  const snapshot = createIntegrationRegistrySnapshot(thirdPartyIntegrations, {
+    source: "third_party_example",
+    bundled: "false"
+  });
+  assert.strictEqual(snapshot.integration_count, thirdPartyIntegrations.length, "registry snapshot count mismatch");
+  const snapshotValidation = validateIntegrationRegistrySnapshot(snapshot);
+  assert.strictEqual(snapshotValidation.ok, true, "registry snapshot validation should pass");
+
+  const exportedSnapshot = exportIntegrationRegistrySnapshot({
+    source: "third_party_example",
+    bundled: "false"
+  });
+  assert.strictEqual(exportedSnapshot.integration_count >= 2, true, "exported registry snapshot breadth mismatch");
+  assert.strictEqual(exportedSnapshot.filters.source, "third_party_example", "exported registry snapshot filters missing");
+
+  const submissionBundleValidation = validateIntegrationSubmissionBundle(exampleSubmissionBundle);
+  assert.strictEqual(submissionBundleValidation.ok, true, "submission bundle validation mismatch");
+  const settlementSubmissionBundleValidation = validateIntegrationSubmissionBundle(exampleSettlementSubmissionBundle);
+  assert.strictEqual(settlementSubmissionBundleValidation.ok, true, "settlement submission bundle validation mismatch");
+  const identitySubmissionBundleValidation = validateIntegrationSubmissionBundle(exampleIdentitySubmissionBundle);
+  assert.strictEqual(identitySubmissionBundleValidation.ok, true, "identity submission bundle validation mismatch");
+
+  const createdSubmissionBundle = createIntegrationSubmissionBundle(exampleSubmissionBundle, {
+    source: "third_party_example",
+    protocols: ["mcp"],
+    execution_backends: ["mcp"],
+    adapter_lanes: ["mcp"],
+    task_refs: ["adapter.mcp.invoke"]
+  });
+  assert.strictEqual(createdSubmissionBundle.bundle_version, "xytara/integration-submission-bundle/v1", "submission bundle version mismatch");
+  assert.strictEqual(createdSubmissionBundle.snapshot_entry.integration_id, "partner.protocol.acme_mcp", "submission bundle snapshot entry mismatch");
+
+  const bundleReview = summarizeIntegrationSubmissionBundleReview(exampleSubmissionBundle);
+  assert.strictEqual(bundleReview.ok, true, "bundle review summary mismatch");
+  assert.strictEqual(bundleReview.integration.integration_id, "partner.protocol.acme_mcp", "bundle review integration id mismatch");
+  assert.strictEqual(bundleReview.registration.requires_explicit_selection, true, "bundle review explicit selection mismatch");
+  assert.strictEqual(bundleReview.review_summary.default_eligible, false, "bundle review default eligibility mismatch");
+
+  const identityBundleReview = summarizeIntegrationSubmissionBundleReview(exampleIdentitySubmissionBundle);
+  assert.strictEqual(identityBundleReview.ok, true, "identity bundle review summary mismatch");
+  assert.strictEqual(identityBundleReview.integration.integration_id, "partner.identity.attest_registry", "identity bundle review integration id mismatch");
+  assert.strictEqual(identityBundleReview.review_summary.default_eligible, false, "identity bundle review default eligibility mismatch");
+
+  const importedSubmissionBundle = importIntegrationSubmissionBundle(exampleSettlementSubmissionBundle, {
+    source: "third_party_example",
+    protocols: [],
+    execution_backends: ["chain"],
+    adapter_lanes: ["chain"],
+    task_refs: ["anchoring.submit"]
+  });
+  assert.strictEqual(importedSubmissionBundle.registration_record.integration_id, "partner.settlement.lattice_anchor", "imported submission bundle integration mismatch");
+
+  const importedIdentitySubmissionBundle = importIntegrationSubmissionBundle(exampleIdentitySubmissionBundle, {
+    source: "third_party_example",
+    protocols: [],
+    execution_backends: ["http", "chain"],
+    adapter_lanes: ["http", "chain"],
+    task_refs: ["registry.register", "trust.handoff.emit", "trust.handoff.validate"]
+  });
+  assert.strictEqual(importedIdentitySubmissionBundle.registration_record.integration_id, "partner.identity.attest_registry", "imported identity submission bundle integration mismatch");
+
+  const exportedSubmissionBundles = exportIntegrationSubmissionBundles({
+    source: "third_party_example",
+    bundled: "false"
+  });
+  assert.strictEqual(exportedSubmissionBundles.length >= 3, true, "exported submission bundle breadth mismatch");
+  assert.ok(exportedSubmissionBundles.every((bundle) => bundle.bundle_version === "xytara/integration-submission-bundle/v1"), "exported submission bundle version mismatch");
+
+  const bundleSnapshot = createIntegrationRegistrySnapshotFromBundles(exportedSubmissionBundles, {
+    source: "third_party_example"
+  }, {
+    source: "third_party_example"
+  });
+  assert.strictEqual(bundleSnapshot.integration_count >= 3, true, "bundle snapshot breadth mismatch");
+  assert.strictEqual(bundleSnapshot.filters.snapshot_source, "submission_bundle", "bundle snapshot source marker missing");
+
+  const bundleSet = createIntegrationSubmissionBundleSet(exportedSubmissionBundles, {
+    source: "third_party_example"
+  }, "staging candidate bundle set");
+  assert.strictEqual(bundleSet.bundle_count, exportedSubmissionBundles.length, "bundle set count mismatch");
+  assert.strictEqual(validateIntegrationSubmissionBundleSet(bundleSet).ok, true, "bundle set validation mismatch");
+
+  const bundleSetReview = summarizeIntegrationSubmissionBundleSetReview(bundleSet);
+  assert.strictEqual(bundleSetReview.ok, true, "bundle-set review summary mismatch");
+  assert.strictEqual(bundleSetReview.bundle_count, exportedSubmissionBundles.length, "bundle-set review count mismatch");
+  assert.ok(bundleSetReview.review_summary.registration_states.some((entry) => entry.registration_state === "staging_registered"), "bundle-set review registration summary missing");
+
+  const exportedBundleSet = exportIntegrationSubmissionBundleSet({
+    source: "third_party_example",
+    bundled: "false"
+  }, "exported bundle set");
+  assert.strictEqual(exportedBundleSet.bundle_count >= 3, true, "exported bundle set breadth mismatch");
+  assert.strictEqual(exportedBundleSet.filters.source, "third_party_example", "exported bundle set filters missing");
+
+  const snapshotReview = summarizeIntegrationRegistrySnapshotReview(bundleSnapshot);
+  assert.strictEqual(snapshotReview.ok, true, "snapshot review summary mismatch");
+  assert.strictEqual(snapshotReview.integration_count, bundleSnapshot.integration_count, "snapshot review count mismatch");
+  assert.ok(snapshotReview.review_summary.registration_states.some((entry) => entry.registration_state === "staging_registered"), "snapshot review registration summary missing");
+
+  const protocolSummary = root.summarizeIntegrationProtocols();
+  assert.ok(protocolSummary.protocols.some((entry) => entry.protocol === "mcp"), "protocol summary missing mcp");
+  assert.ok(protocolSummary.protocols.some((entry) => entry.protocol === "x402"), "protocol summary missing x402");
+
+  const settlementSummary = root.summarizeIntegrationSettlementModes();
+  assert.ok(settlementSummary.settlement_modes.some((entry) => entry.settlement_mode === "evm_payment"), "settlement mode summary missing evm");
+  assert.ok(settlementSummary.settlement_modes.some((entry) => entry.settlement_mode === "bsv_teranode"), "settlement mode summary missing bsv");
+
+  const classSummary = root.summarizeIntegrationClasses();
+  assert.ok(classSummary.adapter_classes.some((entry) => entry.adapter_class === "execution_adapter"), "class summary missing execution");
+  assert.ok(classSummary.adapter_classes.some((entry) => entry.adapter_class === "settlement_adapter"), "class summary missing settlement");
+
+  const builtinPromotion = summarizeIntegrationPromotionReadiness("builtin.protocol.mcp");
+  assert.strictEqual(builtinPromotion.ok, true, "builtin promotion readiness mismatch");
+  assert.strictEqual(builtinPromotion.promotion_readiness.default_eligible, true, "builtin default eligibility mismatch");
+  assert.strictEqual(builtinPromotion.promotion_readiness.production_default_ready, true, "builtin production-default readiness mismatch");
+
+  const stagedPromotion = summarizeIntegrationPromotionReadiness("partner.protocol.acme_mcp");
+  assert.strictEqual(stagedPromotion.ok, true, "staged promotion readiness mismatch");
+  assert.strictEqual(stagedPromotion.promotion_readiness.review_ready, true, "staged review-ready mismatch");
+  assert.strictEqual(stagedPromotion.promotion_readiness.default_eligible, false, "staged default eligibility mismatch");
+  assert.strictEqual(stagedPromotion.promotion_readiness.production_default_ready, false, "staged production-default readiness mismatch");
+  assert.ok(stagedPromotion.promotion_readiness.blockers.includes("not_certified"), "staged promotion blockers missing certification");
+  assert.ok(stagedPromotion.promotion_readiness.blockers.includes("default_selection_disabled"), "staged promotion blockers missing default-selection");
+
+  const stagedIdentityPromotion = summarizeIntegrationPromotionReadiness("partner.identity.attest_registry");
+  assert.strictEqual(stagedIdentityPromotion.ok, true, "staged identity promotion readiness mismatch");
+  assert.strictEqual(stagedIdentityPromotion.promotion_readiness.review_ready, true, "staged identity review-ready mismatch");
+  assert.strictEqual(stagedIdentityPromotion.promotion_readiness.default_eligible, false, "staged identity default eligibility mismatch");
+  assert.ok(stagedIdentityPromotion.promotion_readiness.blockers.includes("not_certified"), "staged identity promotion blockers missing certification");
+
+  const stagedPromotionWorkflow = summarizeIntegrationPromotionWorkflow("partner.protocol.acme_mcp");
+  assert.strictEqual(stagedPromotionWorkflow.ok, true, "staged promotion workflow mismatch");
+  assert.strictEqual(stagedPromotionWorkflow.next_transition.action, "complete_certification", "staged promotion workflow next-transition mismatch");
+  assert.strictEqual(
+    stagedPromotionWorkflow.next_transition.later_actions.includes("promote_maturity"),
+    true,
+    "staged promotion workflow later-actions maturity mismatch"
+  );
+  assert.strictEqual(stagedPromotionWorkflow.promotion_recommendation.recommendation, "keep_staged_until_requirements_clear", "staged promotion workflow recommendation mismatch");
+  assert.strictEqual(
+    stagedPromotionWorkflow.certification_gaps.missing_requirements.includes("certification_state"),
+    true,
+    "staged promotion workflow certification gap mismatch"
+  );
+  assert.ok(
+    stagedPromotionWorkflow.blocker_categories.some((entry) => entry.category === "certification"),
+    "staged promotion workflow blocker categories missing certification"
+  );
+
+  const builtinPromotionWorkflow = summarizeIntegrationPromotionWorkflow("builtin.protocol.mcp");
+  assert.strictEqual(builtinPromotionWorkflow.ok, true, "builtin promotion workflow mismatch");
+  assert.strictEqual(builtinPromotionWorkflow.next_transition.action, "maintain_production_default", "builtin promotion workflow next-transition mismatch");
+  assert.strictEqual(builtinPromotionWorkflow.next_transition.later_actions.length, 0, "builtin promotion workflow later-actions mismatch");
+  assert.strictEqual(builtinPromotionWorkflow.promotion_recommendation.recommendation, "eligible_for_production_default", "builtin promotion workflow recommendation mismatch");
+  assert.strictEqual(builtinPromotionWorkflow.certification_gaps.certifiable, true, "builtin promotion workflow certification gaps mismatch");
+
+  const promotionWorkflowList = summarizeIntegrationPromotionWorkflowList({
+    source: "third_party_example",
+    bundled: "false"
+  });
+  assert.strictEqual(promotionWorkflowList.ok, true, "promotion workflow list mismatch");
+  assert.strictEqual(promotionWorkflowList.integration_count >= 3, true, "promotion workflow list breadth mismatch");
+  assert.strictEqual(
+    promotionWorkflowList.next_actions.some((entry) => entry.action === "complete_certification"),
+    true,
+    "promotion workflow list next-action summary mismatch"
+  );
+  assert.strictEqual(
+    promotionWorkflowList.recommendations.some((entry) => entry.recommendation === "keep_staged_until_requirements_clear"),
+    true,
+    "promotion workflow list recommendation summary mismatch"
+  );
+  assert.strictEqual(
+    promotionWorkflowList.blocker_categories.some((entry) => entry.category === "certification"),
+    true,
+    "promotion workflow list blocker-category summary mismatch"
+  );
+  assert.strictEqual(
+    promotionWorkflowList.blocker_categories.some(
+      (entry) => entry.category === "certification" && entry.severity === "high" && entry.owner === "review_operator"
+    ),
+    true,
+    "promotion workflow list blocker-category severity/owner mismatch"
+  );
+  assert.strictEqual(
+    promotionWorkflowList.owner_queue.some((entry) => entry.owner === "review_operator"),
+    true,
+    "promotion workflow list owner queue mismatch"
+  );
+  assert.strictEqual(
+    promotionWorkflowList.severity_queue.some((entry) => entry.severity === "high"),
+    true,
+    "promotion workflow list severity queue mismatch"
+  );
+  assert.strictEqual(
+    promotionWorkflowList.next_action_queues.some((entry) => entry.action === "complete_certification" && entry.count >= 3),
+    true,
+    "promotion workflow list next-action queue mismatch"
+  );
+  assert.strictEqual(
+    promotionWorkflowList.next_action_queues.some(
+      (entry) =>
+        entry.action === "complete_certification" &&
+        entry.owner_queue.some((ownerEntry) => ownerEntry.owner === "review_operator")
+    ),
+    true,
+    "promotion workflow list next-action owner queue mismatch"
+  );
+
+  const stagedPromotionActionPreview = root.summarizeIntegrationPromotionActionPreview({
+    integration_id: "partner.protocol.acme_mcp",
+    action: "complete_certification"
+  });
+  assert.strictEqual(stagedPromotionActionPreview.ok, true, "staged promotion action preview mismatch");
+  assert.strictEqual(stagedPromotionActionPreview.valid_now, true, "staged promotion action preview validity mismatch");
+  assert.strictEqual(stagedPromotionActionPreview.action.stage, "certification", "staged promotion action stage mismatch");
+  assert.strictEqual(
+    stagedPromotionActionPreview.resulting_posture.promotion_readiness.blockers.includes("not_marked_production_default"),
+    true,
+    "staged promotion action resulting posture maturity blocker mismatch"
+  );
+
+  const builtinPromotionActionSet = root.summarizeIntegrationPromotionActionSet("builtin.protocol.mcp");
+  assert.strictEqual(builtinPromotionActionSet.ok, true, "builtin promotion action-set mismatch");
+  assert.strictEqual(
+    builtinPromotionActionSet.actions.some((entry) => entry.request.action === "maintain_production_default" && entry.valid_now === true),
+    true,
+    "builtin promotion action-set steady-state preview mismatch"
+  );
+
+  const promotionActionSetList = root.summarizeIntegrationPromotionActionSetList({
+    source: "third_party_example",
+    bundled: "false"
+  });
+  assert.strictEqual(promotionActionSetList.ok, true, "promotion action-set list mismatch");
+  assert.strictEqual(promotionActionSetList.integration_count >= 3, true, "promotion action-set list breadth mismatch");
+  assert.strictEqual(
+    promotionActionSetList.valid_actions.some((entry) => entry.action === "complete_certification"),
+    true,
+    "promotion action-set list valid-action summary mismatch"
+  );
+
+  const trustSelection = resolveIntegrationSelection({
+    task_ref: "trust.verify"
+  });
+  assert.ok(trustSelection.integration_ids.includes("builtin.execution.http"), "trust selection missing http execution integration");
+  assert.ok(trustSelection.settlement_integration_id === "builtin.settlement.chain", "trust selection settlement integration mismatch");
+
+  const trustHandoffSelection = resolveIntegrationSelection({
+    task_ref: "trust.handoff.emit"
+  });
+  assert.ok(trustHandoffSelection.integration_ids.includes("builtin.identity.registry"), "trust handoff selection missing builtin identity integration");
+  assert.ok(!trustHandoffSelection.integration_ids.includes("partner.identity.attest_registry"), "trust handoff selection should not auto-pick staged identity integration");
+
+  const explicitIdentitySelection = resolveIntegrationSelection({
+    task_ref: "trust.handoff.emit",
+    integration_id: "partner.identity.attest_registry"
+  });
+  assert.strictEqual(explicitIdentitySelection.ok, true, "explicit identity selection should pass");
+  assert.ok(explicitIdentitySelection.integration_ids.includes("partner.identity.attest_registry"), "explicit identity selection missing requested integration");
+
+  const mcpSelection = resolveIntegrationSelection({
+    task_ref: "adapter.mcp.invoke",
+    protocol: "mcp"
+  });
+  assert.ok(mcpSelection.integration_ids.includes("builtin.protocol.mcp"), "mcp selection missing protocol integration");
+  assert.ok(mcpSelection.protocols.includes("mcp"), "mcp selection protocol mismatch");
+  assert.ok(!mcpSelection.integration_ids.includes("partner.protocol.acme_mcp"), "mcp selection should not auto-pick staged protocol integration");
+
+  const x402McpSelection = resolveIntegrationSelection({
+    task_ref: "adapter.mcp.invoke",
+    protocol: "mcp",
+    payment_protocol: "x402"
+  });
+  assert.ok(x402McpSelection.integration_ids.includes("builtin.protocol.mcp"), "x402 mcp selection missing protocol integration");
+  assert.ok(x402McpSelection.integration_ids.includes("builtin.payment.x402"), "x402 mcp selection missing payment integration");
+  assert.ok(x402McpSelection.protocols.includes("x402"), "x402 protocol missing from selection");
+  assert.ok(!x402McpSelection.integration_ids.includes("partner.protocol.acme_mcp"), "x402 mcp selection should not auto-pick staged protocol integration");
+
+  const explicitThirdPartyProtocolSelection = resolveIntegrationSelection({
+    task_ref: "adapter.mcp.invoke",
+    protocol: "mcp",
+    integration_id: "partner.protocol.acme_mcp"
+  });
+  assert.strictEqual(explicitThirdPartyProtocolSelection.ok, true, "explicit third-party protocol selection should pass");
+  assert.ok(
+    explicitThirdPartyProtocolSelection.integration_ids.includes("partner.protocol.acme_mcp"),
+    "explicit third-party protocol selection missing requested integration"
+  );
+
+  const invalidUnknown = validateIntegrationSelection({
+    task_ref: "trust.verify",
+    integration_id: "unknown.integration"
+  });
+  assert.strictEqual(invalidUnknown.ok, false, "unknown integration should fail validation");
+  assert.ok(invalidUnknown.errors.some((entry) => entry.includes("unknown integration ids")), "unknown integration error missing");
+
+  const invalidIncompatible = validateIntegrationSelection({
+    task_ref: "trust.verify",
+    integration_id: "builtin.protocol.mcp"
+  });
+  assert.strictEqual(invalidIncompatible.ok, false, "incompatible integration should fail validation");
+  assert.ok(invalidIncompatible.errors.some((entry) => entry.includes("incompatible")), "incompatible integration error missing");
+
+  console.log("xytara verify:integrations passed");
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});