xytara 2.6.0 → 2.7.0

package/scripts/verify_adapters.js

@@ -0,0 +1,554 @@
+"use strict";
+
+const assert = require("assert");
+const fs = require("fs");
+const path = require("path");
+
+const manifestSchema = JSON.parse(
+  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "adapter-manifest.schema.json"), "utf8")
+);
+const registrationRecordSchema = JSON.parse(
+  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "integration-registration-record.schema.json"), "utf8")
+);
+const certificationPackSchema = JSON.parse(
+  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "integration-certification-pack.schema.json"), "utf8")
+);
+const submissionBundleSchema = JSON.parse(
+  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "integration-submission-bundle.schema.json"), "utf8")
+);
+const exampleManifest = JSON.parse(
+  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "examples", "example-execution-adapter.manifest.json"), "utf8")
+);
+const exampleSettlementManifest = JSON.parse(
+  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "examples", "example-settlement-adapter.manifest.json"), "utf8")
+);
+const exampleRegistrationRecord = JSON.parse(
+  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "examples", "example-third-party-registration.record.json"), "utf8")
+);
+const exampleCertificationPack = JSON.parse(
+  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "examples", "example-third-party-registration.certification-pack.json"), "utf8")
+);
+const exampleIdentityRegistrationRecord = JSON.parse(
+  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "examples", "example-third-party-identity-registration.record.json"), "utf8")
+);
+const exampleIdentityCertificationPack = JSON.parse(
+  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "examples", "example-third-party-identity-registration.certification-pack.json"), "utf8")
+);
+const exampleSettlementRegistrationRecord = JSON.parse(
+  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "examples", "example-third-party-settlement-registration.record.json"), "utf8")
+);
+const exampleSettlementCertificationPack = JSON.parse(
+  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "examples", "example-third-party-settlement-registration.certification-pack.json"), "utf8")
+);
+const exampleSubmissionBundle = JSON.parse(
+  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "examples", "example-third-party-registration.submission-bundle.json"), "utf8")
+);
+const minimalThirdPartyExecutionManifest = JSON.parse(
+  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "examples", "minimal-third-party-execution-adapter.manifest.json"), "utf8")
+);
+const langgraphReferenceManifest = JSON.parse(
+  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "examples", "langgraph-reference-execution-adapter.manifest.json"), "utf8")
+);
+const langchainReferenceManifest = JSON.parse(
+  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "examples", "langchain-reference-execution-adapter.manifest.json"), "utf8")
+);
+const minimalThirdPartyExecutionRegistrationRecord = JSON.parse(
+  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "examples", "minimal-third-party-execution-registration.record.json"), "utf8")
+);
+const minimalThirdPartyExecutionCertificationPack = JSON.parse(
+  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "examples", "minimal-third-party-execution.certification-pack.json"), "utf8")
+);
+const minimalThirdPartyExecutionSubmissionBundle = JSON.parse(
+  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "examples", "minimal-third-party-execution.submission-bundle.json"), "utf8")
+);
+const exampleIdentitySubmissionBundle = JSON.parse(
+  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "examples", "example-third-party-identity-registration.submission-bundle.json"), "utf8")
+);
+const exampleSettlementSubmissionBundle = JSON.parse(
+  fs.readFileSync(path.resolve(__dirname, "..", "adapters", "examples", "example-third-party-settlement-registration.submission-bundle.json"), "utf8")
+);
+const minimalThirdPartyExecutionAdapter = require("../adapters/examples/minimal-third-party-execution-adapter");
+const langgraphReferenceAdapter = require("../adapters/examples/langgraph-reference-execution-adapter");
+const langchainReferenceAdapter = require("../adapters/examples/langchain-reference-execution-adapter");
+const exampleAdapter = require("../adapters/examples/example-execution-adapter");
+const exampleSettlementAdapter = require("../adapters/examples/example-settlement-adapter");
+const { ADAPTER_INTERFACE_VERSION, validateAdapterImplementation } = require("../adapters/interfaces");
+const {
+  createIntegrationSubmissionBundle,
+  validateIntegrationCertificationPack,
+  validateIntegrationSubmission,
+  validateIntegrationSubmissionBundle
+} = require("../integrations/registry");
+
+function validateType(value, type) {
+  if (type === "array") return Array.isArray(value);
+  if (type === "object") return value !== null && typeof value === "object" && !Array.isArray(value);
+  if (type === "boolean") return typeof value === "boolean";
+  if (type === "string") return typeof value === "string";
+  return true;
+}
+
+function validateManifest(manifest, schema, pathLabel, errors) {
+  const targetPath = pathLabel || "manifest";
+  if (!validateType(manifest, schema.type)) {
+    errors.push(`${targetPath} should be ${schema.type}`);
+    return;
+  }
+
+  if (schema.type === "object") {
+    const properties = schema.properties || {};
+    const required = Array.isArray(schema.required) ? schema.required : [];
+
+    for (const key of required) {
+      if (!Object.prototype.hasOwnProperty.call(manifest, key)) {
+        errors.push(`${targetPath}.${key} is required`);
+      }
+    }
+
+    if (schema.additionalProperties === false) {
+      for (const key of Object.keys(manifest)) {
+        if (!Object.prototype.hasOwnProperty.call(properties, key)) {
+          errors.push(`${targetPath}.${key} is not allowed`);
+        }
+      }
+    }
+
+    for (const [key, propertySchema] of Object.entries(properties)) {
+      if (Object.prototype.hasOwnProperty.call(manifest, key)) {
+        validateManifest(manifest[key], propertySchema, `${targetPath}.${key}`, errors);
+      }
+    }
+    return;
+  }
+
+  if (schema.type === "array") {
+    if (typeof schema.minItems === "number" && manifest.length < schema.minItems) {
+      errors.push(`${targetPath} must contain at least ${schema.minItems} item(s)`);
+    }
+    manifest.forEach((value, index) => {
+      validateManifest(value, schema.items || {}, `${targetPath}[${index}]`, errors);
+    });
+    return;
+  }
+
+  if (schema.type === "string") {
+    if (typeof schema.minLength === "number" && manifest.length < schema.minLength) {
+      errors.push(`${targetPath} must be at least ${schema.minLength} character(s)`);
+    }
+    if (Array.isArray(schema.enum) && !schema.enum.includes(manifest)) {
+      errors.push(`${targetPath} must be one of: ${schema.enum.join(", ")}`);
+    }
+  }
+}
+
+async function main() {
+  const errors = [];
+  validateManifest(exampleManifest, manifestSchema, "manifest", errors);
+  validateManifest(exampleSettlementManifest, manifestSchema, "settlement_manifest", errors);
+  validateManifest(exampleRegistrationRecord, registrationRecordSchema, "registration_record", errors);
+  validateManifest(exampleCertificationPack, certificationPackSchema, "certification_pack", errors);
+  validateManifest(exampleIdentityRegistrationRecord, registrationRecordSchema, "identity_registration_record", errors);
+  validateManifest(exampleIdentityCertificationPack, certificationPackSchema, "identity_certification_pack", errors);
+  validateManifest(exampleSettlementRegistrationRecord, registrationRecordSchema, "settlement_registration_record", errors);
+  validateManifest(exampleSettlementCertificationPack, certificationPackSchema, "settlement_certification_pack", errors);
+  validateManifest(exampleSubmissionBundle, submissionBundleSchema, "submission_bundle", errors);
+  validateManifest(minimalThirdPartyExecutionManifest, manifestSchema, "minimal_third_party_execution_manifest", errors);
+  validateManifest(langgraphReferenceManifest, manifestSchema, "langgraph_reference_manifest", errors);
+  validateManifest(langchainReferenceManifest, manifestSchema, "langchain_reference_manifest", errors);
+  validateManifest(minimalThirdPartyExecutionRegistrationRecord, registrationRecordSchema, "minimal_third_party_execution_registration_record", errors);
+  validateManifest(minimalThirdPartyExecutionCertificationPack, certificationPackSchema, "minimal_third_party_execution_certification_pack", errors);
+  validateManifest(minimalThirdPartyExecutionSubmissionBundle, submissionBundleSchema, "minimal_third_party_execution_submission_bundle", errors);
+  validateManifest(exampleIdentitySubmissionBundle, submissionBundleSchema, "identity_submission_bundle", errors);
+  validateManifest(exampleSettlementSubmissionBundle, submissionBundleSchema, "settlement_submission_bundle", errors);
+  assert.deepStrictEqual(errors, [], `adapter manifest validation failed:\n${errors.join("\n")}`);
+
+  assert.strictEqual(exampleManifest.adapter_class, "execution_adapter", "example adapter class mismatch");
+  assert.strictEqual(exampleManifest.proof_contract.emits_proof_compatible_facts, true, "example adapter proof contract mismatch");
+  assert.strictEqual(
+    exampleManifest.compatibility.commerce_contract,
+    "commerce-repo-final-contract/v1",
+    "example adapter commerce compatibility mismatch"
+  );
+  assert.strictEqual(
+    exampleManifest.compatibility.proof_contract,
+    "proof-repo-final-contract/v1",
+    "example adapter proof compatibility mismatch"
+  );
+  assert.strictEqual(
+    exampleManifest.registration_contract.integration_id,
+    exampleManifest.adapter_id,
+    "example adapter registration integration_id mismatch"
+  );
+  assert.strictEqual(
+    exampleManifest.registration_contract.integration_maturity,
+    "reference_example",
+    "example adapter registration maturity mismatch"
+  );
+  assert.strictEqual(
+    exampleManifest.certification_contract.certification_state,
+    "reference_example",
+    "example adapter certification state mismatch"
+  );
+  assert.strictEqual(
+    exampleManifest.failure_contract.retryable_categories.every((entry) => exampleManifest.failure_contract.categories.includes(entry)),
+    true,
+    "retryable categories must be declared in categories"
+  );
+  assert.strictEqual(exampleManifest.interface_version, ADAPTER_INTERFACE_VERSION, "example adapter interface version mismatch");
+  assert.strictEqual(exampleSettlementManifest.adapter_class, "settlement_adapter", "example settlement adapter class mismatch");
+  assert.strictEqual(exampleSettlementManifest.interface_version, ADAPTER_INTERFACE_VERSION, "example settlement adapter interface version mismatch");
+  assert.strictEqual(
+    exampleSettlementManifest.registration_contract.integration_id,
+    exampleSettlementManifest.adapter_id,
+    "example settlement adapter registration integration_id mismatch"
+  );
+  assert.strictEqual(
+    exampleSettlementManifest.certification_contract.certification_state,
+    "reference_example",
+    "example settlement adapter certification state mismatch"
+  );
+  assert.strictEqual(
+    exampleRegistrationRecord.adapter_class,
+    "agent_protocol_adapter",
+    "example registration record adapter class mismatch"
+  );
+  assert.strictEqual(
+    exampleRegistrationRecord.registration_state,
+    "staging_registered",
+    "example registration record state mismatch"
+  );
+  assert.strictEqual(
+    exampleRegistrationRecord.bundled,
+    false,
+    "example registration record bundled posture mismatch"
+  );
+  assert.strictEqual(
+    exampleRegistrationRecord.requires_explicit_selection,
+    true,
+    "example registration record explicit-selection posture mismatch"
+  );
+  assert.strictEqual(
+    exampleIdentityRegistrationRecord.adapter_class,
+    "identity_registry_adapter",
+    "example identity registration record adapter class mismatch"
+  );
+  assert.strictEqual(
+    exampleIdentityRegistrationRecord.registration_state,
+    "staging_registered",
+    "example identity registration record state mismatch"
+  );
+  assert.strictEqual(
+    exampleIdentityRegistrationRecord.requires_explicit_selection,
+    true,
+    "example identity registration record explicit-selection posture mismatch"
+  );
+  assert.strictEqual(
+    exampleSettlementRegistrationRecord.adapter_class,
+    "settlement_adapter",
+    "example settlement registration record adapter class mismatch"
+  );
+  assert.strictEqual(
+    exampleSettlementRegistrationRecord.registration_state,
+    "staging_registered",
+    "example settlement registration record state mismatch"
+  );
+  assert.strictEqual(
+    exampleSettlementRegistrationRecord.requires_explicit_selection,
+    true,
+    "example settlement registration record explicit-selection posture mismatch"
+  );
+  assert.strictEqual(
+    exampleCertificationPack.integration_id,
+    exampleRegistrationRecord.integration_id,
+    "example certification pack integration_id mismatch"
+  );
+  assert.strictEqual(
+    exampleCertificationPack.adapter_class,
+    exampleRegistrationRecord.adapter_class,
+    "example certification pack adapter class mismatch"
+  );
+  assert.strictEqual(
+    exampleIdentityCertificationPack.integration_id,
+    exampleIdentityRegistrationRecord.integration_id,
+    "example identity certification pack integration_id mismatch"
+  );
+  assert.strictEqual(
+    exampleIdentityCertificationPack.adapter_class,
+    exampleIdentityRegistrationRecord.adapter_class,
+    "example identity certification pack adapter class mismatch"
+  );
+  assert.strictEqual(
+    exampleSettlementCertificationPack.integration_id,
+    exampleSettlementRegistrationRecord.integration_id,
+    "example settlement certification pack integration_id mismatch"
+  );
+  assert.strictEqual(
+    exampleSettlementManifest.failure_contract.retryable_categories.every((entry) => exampleSettlementManifest.failure_contract.categories.includes(entry)),
+    true,
+    "settlement adapter retryable categories must be declared in categories"
+  );
+  assert.strictEqual(
+    validateIntegrationCertificationPack(exampleCertificationPack).ok,
+    true,
+    "example certification pack validation mismatch"
+  );
+  assert.strictEqual(
+    validateIntegrationCertificationPack(exampleIdentityCertificationPack).ok,
+    true,
+    "example identity certification pack validation mismatch"
+  );
+  assert.strictEqual(
+    validateIntegrationCertificationPack(exampleSettlementCertificationPack).ok,
+    true,
+    "example settlement certification pack validation mismatch"
+  );
+  assert.strictEqual(
+    validateIntegrationSubmission({
+      adapter_id: exampleRegistrationRecord.adapter_id,
+      adapter_class: exampleRegistrationRecord.adapter_class
+    }, exampleRegistrationRecord, exampleCertificationPack).ok,
+    true,
+    "third-party protocol submission validation mismatch"
+  );
+  assert.strictEqual(
+    validateIntegrationSubmission({
+      adapter_id: exampleIdentityRegistrationRecord.adapter_id,
+      adapter_class: exampleIdentityRegistrationRecord.adapter_class
+    }, exampleIdentityRegistrationRecord, exampleIdentityCertificationPack).ok,
+    true,
+    "third-party identity submission validation mismatch"
+  );
+  assert.strictEqual(
+    validateIntegrationSubmission({
+      adapter_id: exampleSettlementRegistrationRecord.adapter_id,
+      adapter_class: exampleSettlementRegistrationRecord.adapter_class
+    }, exampleSettlementRegistrationRecord, exampleSettlementCertificationPack).ok,
+    true,
+    "third-party settlement submission validation mismatch"
+  );
+  assert.strictEqual(
+    validateIntegrationSubmissionBundle(exampleSubmissionBundle).ok,
+    true,
+    "submission bundle validation mismatch"
+  );
+  assert.strictEqual(
+    validateIntegrationSubmissionBundle(exampleIdentitySubmissionBundle).ok,
+    true,
+    "identity submission bundle validation mismatch"
+  );
+  assert.strictEqual(
+    validateIntegrationSubmissionBundle(exampleSettlementSubmissionBundle).ok,
+    true,
+    "settlement submission bundle validation mismatch"
+  );
+  assert.strictEqual(
+    minimalThirdPartyExecutionManifest.adapter_class,
+    "execution_adapter",
+    "minimal third-party execution manifest adapter class mismatch"
+  );
+  assert.strictEqual(
+    minimalThirdPartyExecutionManifest.registration_contract.bundled,
+    false,
+    "minimal third-party execution bundled posture mismatch"
+  );
+  assert.strictEqual(langgraphReferenceManifest.adapter_class, "execution_adapter", "langgraph reference adapter class mismatch");
+  assert.strictEqual(langgraphReferenceManifest.registration_contract.bundled, true, "langgraph reference bundled posture mismatch");
+  assert.strictEqual(langgraphReferenceManifest.certification_contract.certification_state, "reference_example", "langgraph reference certification mismatch");
+  assert.strictEqual(langchainReferenceManifest.adapter_class, "execution_adapter", "langchain reference adapter class mismatch");
+  assert.strictEqual(langchainReferenceManifest.registration_contract.bundled, true, "langchain reference bundled posture mismatch");
+  assert.strictEqual(langchainReferenceManifest.certification_contract.certification_state, "reference_example", "langchain reference certification mismatch");
+  assert.strictEqual(
+    minimalThirdPartyExecutionRegistrationRecord.integration_id,
+    minimalThirdPartyExecutionManifest.adapter_id,
+    "minimal third-party execution registration integration_id mismatch"
+  );
+  assert.strictEqual(
+    minimalThirdPartyExecutionCertificationPack.integration_id,
+    minimalThirdPartyExecutionRegistrationRecord.integration_id,
+    "minimal third-party execution certification integration_id mismatch"
+  );
+  assert.strictEqual(
+    validateIntegrationCertificationPack(minimalThirdPartyExecutionCertificationPack).ok,
+    true,
+    "minimal third-party execution certification pack validation mismatch"
+  );
+  assert.strictEqual(
+    validateIntegrationSubmission(minimalThirdPartyExecutionManifest, minimalThirdPartyExecutionRegistrationRecord, minimalThirdPartyExecutionCertificationPack).ok,
+    true,
+    "minimal third-party execution submission validation mismatch"
+  );
+  assert.strictEqual(
+    validateIntegrationSubmissionBundle(minimalThirdPartyExecutionSubmissionBundle).ok,
+    true,
+    "minimal third-party execution submission bundle validation mismatch"
+  );
+  assert.strictEqual(
+    createIntegrationSubmissionBundle(minimalThirdPartyExecutionSubmissionBundle, {
+      source: "third_party_example",
+      protocols: [],
+      execution_backends: ["http"],
+      adapter_lanes: ["http"],
+      task_refs: ["task.execute", "task.preview"]
+    }).snapshot_entry.integration_id,
+    "partner.execution.minimal_echo",
+    "minimal third-party execution submission bundle normalization mismatch"
+  );
+  assert.strictEqual(
+    createIntegrationSubmissionBundle(exampleIdentitySubmissionBundle, {
+      source: "third_party_example",
+      protocols: [],
+      execution_backends: ["http", "chain"],
+      adapter_lanes: ["http", "chain"],
+      task_refs: ["registry.register", "trust.handoff.emit", "trust.handoff.validate"]
+    }).snapshot_entry.integration_id,
+    "partner.identity.attest_registry",
+    "identity submission bundle normalization mismatch"
+  );
+  assert.strictEqual(
+    createIntegrationSubmissionBundle(exampleSubmissionBundle, {
+      source: "third_party_example",
+      protocols: ["mcp"],
+      execution_backends: ["mcp"],
+      adapter_lanes: ["mcp"],
+      task_refs: ["adapter.mcp.invoke"]
+    }).snapshot_entry.integration_id,
+    "partner.protocol.acme_mcp",
+    "submission bundle normalization mismatch"
+  );
+
+  const implementationErrors = validateAdapterImplementation(exampleAdapter);
+  assert.deepStrictEqual(implementationErrors, [], `adapter implementation validation failed:\n${implementationErrors.join("\n")}`);
+  assert.deepStrictEqual(exampleAdapter.manifest, exampleManifest, "example adapter manifest/export mismatch");
+  const minimalImplementationErrors = validateAdapterImplementation(minimalThirdPartyExecutionAdapter);
+  assert.deepStrictEqual(minimalImplementationErrors, [], `minimal execution adapter implementation validation failed:\n${minimalImplementationErrors.join("\n")}`);
+  assert.deepStrictEqual(
+    minimalThirdPartyExecutionAdapter.manifest,
+    minimalThirdPartyExecutionManifest,
+    "minimal third-party execution adapter manifest/export mismatch"
+  );
+  const langgraphImplementationErrors = validateAdapterImplementation(langgraphReferenceAdapter);
+  assert.deepStrictEqual(langgraphImplementationErrors, [], `langgraph reference adapter implementation validation failed:\n${langgraphImplementationErrors.join("\n")}`);
+  assert.deepStrictEqual(langgraphReferenceAdapter.manifest, langgraphReferenceManifest, "langgraph reference adapter manifest/export mismatch");
+  const langchainImplementationErrors = validateAdapterImplementation(langchainReferenceAdapter);
+  assert.deepStrictEqual(langchainImplementationErrors, [], `langchain reference adapter implementation validation failed:\n${langchainImplementationErrors.join("\n")}`);
+  assert.deepStrictEqual(langchainReferenceAdapter.manifest, langchainReferenceManifest, "langchain reference adapter manifest/export mismatch");
+  const settlementImplementationErrors = validateAdapterImplementation(exampleSettlementAdapter);
+  assert.deepStrictEqual(
+    settlementImplementationErrors,
+    [],
+    `settlement adapter implementation validation failed:\n${settlementImplementationErrors.join("\n")}`
+  );
+  assert.deepStrictEqual(
+    exampleSettlementAdapter.manifest,
+    exampleSettlementManifest,
+    "example settlement adapter manifest/export mismatch"
+  );
+
+  const health = await exampleAdapter.getHealth();
+  assert.strictEqual(health.status, "ok", "example adapter health mismatch");
+  assert.strictEqual(health.adapter_id, exampleManifest.adapter_id, "example adapter health adapter_id mismatch");
+
+  const capabilities = exampleAdapter.describeCapabilities();
+  assert.deepStrictEqual(capabilities.capabilities, exampleManifest.capabilities, "example adapter capabilities mismatch");
+
+  const preview = await exampleAdapter.preview({
+    task_ref: "trust.verify",
+    body: { subject_id: "subject-1" }
+  });
+  assert.strictEqual(preview.accepted, true, "example adapter preview acceptance mismatch");
+  assert.strictEqual(preview.preview.task_ref, "trust.verify", "example adapter preview task_ref mismatch");
+
+  const minimalHealth = await minimalThirdPartyExecutionAdapter.getHealth();
+  assert.strictEqual(minimalHealth.status, "ok", "minimal execution adapter health mismatch");
+  assert.strictEqual(minimalHealth.adapter_id, minimalThirdPartyExecutionManifest.adapter_id, "minimal execution adapter health adapter_id mismatch");
+
+  const minimalPreview = await minimalThirdPartyExecutionAdapter.preview({
+    task_ref: "task.execute",
+    body: { subject_id: "subject-minimal-1" }
+  });
+  assert.strictEqual(minimalPreview.accepted, true, "minimal execution adapter preview acceptance mismatch");
+  assert.strictEqual(minimalPreview.preview.task_ref, "task.execute", "minimal execution adapter preview task_ref mismatch");
+
+  const minimalExecution = await minimalThirdPartyExecutionAdapter.execute({
+    task_ref: "task.execute",
+    body: { subject_id: "subject-minimal-1" }
+  });
+  assert.strictEqual(minimalExecution.status, "completed", "minimal execution adapter execute status mismatch");
+  assert.strictEqual(
+    minimalExecution.proof_facts.emits_proof_compatible_facts,
+    true,
+    "minimal execution adapter execute proof contract mismatch"
+  );
+
+  const langgraphHealth = await langgraphReferenceAdapter.getHealth();
+  assert.strictEqual(langgraphHealth.status, "ok", "langgraph reference health mismatch");
+  const langgraphExecution = await langgraphReferenceAdapter.execute({
+    task_ref: "framework.langgraph.execute",
+    body: {
+      graph_ref: "graph.demo",
+      node_ref: "summarize",
+      checkpoint_ref: "checkpoint.demo",
+      input: { text: "demo" }
+    }
+  });
+  assert.strictEqual(langgraphExecution.status, "completed", "langgraph reference execution status mismatch");
+  assert.strictEqual(langgraphExecution.result.framework, "langgraph", "langgraph reference framework mismatch");
+  assert.strictEqual(langgraphExecution.proof_facts.graph_ref, "graph.demo", "langgraph proof graph ref mismatch");
+
+  const langchainHealth = await langchainReferenceAdapter.getHealth();
+  assert.strictEqual(langchainHealth.status, "ok", "langchain reference health mismatch");
+  const langchainExecution = await langchainReferenceAdapter.execute({
+    task_ref: "framework.langchain.execute",
+    body: {
+      chain_ref: "chain.demo",
+      tool_trace_ref: "trace.demo",
+      context_ref: "context.demo",
+      input: { text: "demo" }
+    }
+  });
+  assert.strictEqual(langchainExecution.status, "completed", "langchain reference execution status mismatch");
+  assert.strictEqual(langchainExecution.result.framework, "langchain", "langchain reference framework mismatch");
+  assert.strictEqual(langchainExecution.proof_facts.chain_ref, "chain.demo", "langchain proof chain ref mismatch");
+
+  const execution = await exampleAdapter.execute({
+    task_ref: "trust.verify",
+    body: { subject_id: "subject-1" }
+  });
+  assert.strictEqual(execution.status, "completed", "example adapter execute status mismatch");
+  assert.strictEqual(
+    execution.proof_facts.emits_proof_compatible_facts,
+    true,
+    "example adapter execute proof contract mismatch"
+  );
+
+  const settlementHealth = await exampleSettlementAdapter.getHealth();
+  assert.strictEqual(settlementHealth.status, "ok", "example settlement adapter health mismatch");
+  assert.strictEqual(settlementHealth.adapter_id, exampleSettlementManifest.adapter_id, "example settlement adapter health adapter_id mismatch");
+
+  const settlementCapabilities = exampleSettlementAdapter.describeCapabilities();
+  assert.deepStrictEqual(
+    settlementCapabilities.capabilities,
+    exampleSettlementManifest.capabilities,
+    "example settlement adapter capabilities mismatch"
+  );
+
+  const settlementResult = await exampleSettlementAdapter.settle({
+    intent_id: "intent-demo"
+  });
+  assert.strictEqual(settlementResult.status, "submitted", "example settlement adapter settle status mismatch");
+  assert.strictEqual(
+    settlementResult.proof_facts.emits_proof_compatible_facts,
+    true,
+    "example settlement adapter proof contract mismatch"
+  );
+
+  const finality = await exampleSettlementAdapter.getFinality(settlementResult.settlement_ref);
+  assert.strictEqual(finality.finality_status, "confirmed", "example settlement adapter finality mismatch");
+
+  process.stdout.write("xytara verify:adapters passed\n");
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});