xytara 3.1.16 → 3.2.0

package/scripts/verify_integrations.js

@@ -1,620 +0,0 @@
-"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);
-});