xoonya 3.0.1 → 3.1.0

package/scripts/verify_integrations.js

@@ -1,170 +1,170 @@
-"use strict";
-
-const assert = require("assert");
-const stagedPartnerVerifierRegistrationRecord = require("../integrations/examples/example-third-party-verifier-registration.record.json");
-const root = require("../index.js");
-
-async function main() {
-  const integrations = root.listIntegrations();
-  assert.ok(Array.isArray(integrations), "proof integrations list missing");
-  assert.ok(integrations.length >= 4, "proof integration breadth missing");
-  assert.ok(integrations.some((integration) => integration.integration_id === "builtin.identity.legacy_material"), "legacy identity integration missing");
-  assert.ok(integrations.some((integration) => integration.integration_id === "builtin.verifier.registry_profile"), "registry verifier integration missing");
-  assert.ok(integrations.some((integration) => integration.integration_id === stagedPartnerVerifierRegistrationRecord.integration_id), "staged proof verifier integration missing");
-  assert.ok(integrations.some((integration) => integration.certification_state === "certified"), "proof integration certification metadata missing");
-
-  const summary = root.summarizeIntegrations();
-  assert.strictEqual(summary.ok, true, "proof integration summary ok mismatch");
-  assert.ok(summary.integration_count >= integrations.length, "proof integration count mismatch");
-  assert.strictEqual(summary.certified_integration_count >= 5, true, "proof integration certified count mismatch");
-  assert.strictEqual(summary.production_default_count >= 5, true, "proof integration production-default count mismatch");
-  assert.strictEqual(summary.staged_registration_count >= 1, true, "proof integration staged registration count mismatch");
-
-  const detail = root.getIntegration("builtin.verifier.economic_profile");
-  assert.ok(detail, "proof integration detail missing");
-  assert.strictEqual(detail.integration_class, "verification_helper_adapter", "proof integration class mismatch");
-  assert.strictEqual(detail.integration_maturity, "production_default", "proof integration maturity mismatch");
-
-  const bundledFiltered = root.listIntegrations({
-    source: "builtin",
-    certification_state: "certified",
-    integration_maturity: "production_default",
-    bundled: "true"
-  });
-  assert.ok(bundledFiltered.length >= 5, "proof builtin integration filtering mismatch");
-
-  const stagedFiltered = root.listIntegrations({
-    source: "third_party_example",
-    registration_state: "staging_registered",
-    proof_scope: "profile_verification",
-    bundled: "false"
-  });
-  assert.strictEqual(stagedFiltered.length, 1, "proof staged integration filtering mismatch");
-  assert.strictEqual(stagedFiltered[0].registration.requires_explicit_selection, true, "proof staged integration explicit-selection mismatch");
-
-  const validation = root.validateIntegrationRegistration({
-    integration_id: stagedPartnerVerifierRegistrationRecord.integration_id,
-    integration_class: stagedPartnerVerifierRegistrationRecord.integration_class,
-    proof_scope: stagedPartnerVerifierRegistrationRecord.proof_scope
-  }, stagedPartnerVerifierRegistrationRecord);
-  assert.strictEqual(validation.ok, true, "proof integration registration validation failed");
-
-  const imported = root.importRegisteredIntegration({
-    integration_id: "partner.verifier.memory_canary",
-    integration_class: "verification_helper_adapter",
-    display_name: "Memory Canary Verifier",
-    description: "Imported proof-side verifier used to validate normalization.",
-    proof_scope: "profile_verification",
-    capabilities: ["memory_canary.verify"],
-    public_surfaces: ["sdk"],
-    required_inputs: ["profile"],
-    emitted_artifacts: [],
-    verification_targets: ["memory_canary_profile"]
-  }, {
-    integration_id: "partner.verifier.memory_canary",
-    integration_class: "verification_helper_adapter",
-    proof_scope: "profile_verification",
-    registration_state: "local_only",
-    integration_maturity: "reference_example",
-    certification_state: "reference_example",
-    bundled: false,
-    default_selection_enabled: false,
-    requires_explicit_selection: true,
-    registered_at: "2026-03-20T00:00:00Z"
-  }, {
-    source: "verification_import_test",
-    certification_scope: ["contract_shape"],
-    operational_readiness: "reference"
-  });
-  assert.strictEqual(imported.integration_id, "partner.verifier.memory_canary", "proof imported integration id mismatch");
-  assert.strictEqual(imported.registration.registration_state, "local_only", "proof imported integration registration state mismatch");
-
-  const snapshot = root.exportIntegrationRegistrySnapshot({
-    registration_state: "staging_registered"
-  });
-  assert.strictEqual(snapshot.integration_count >= 1, true, "proof integration snapshot count mismatch");
-  assert.strictEqual(root.validateIntegrationRegistrySnapshot(snapshot).ok, true, "proof integration snapshot validation mismatch");
-
-  const builtinPromotion = root.summarizeIntegrationPromotionReadiness("builtin.verifier.registry_profile");
-  assert.strictEqual(builtinPromotion.ok, true, "proof builtin promotion readiness mismatch");
-  assert.strictEqual(builtinPromotion.promotion_readiness.default_eligible, true, "proof builtin default eligibility mismatch");
-  assert.strictEqual(builtinPromotion.promotion_readiness.production_default_ready, true, "proof builtin production-default readiness mismatch");
-
-  const stagedPromotion = root.summarizeIntegrationPromotionReadiness("partner.verifier.lattice_notary");
-  assert.strictEqual(stagedPromotion.ok, true, "proof staged promotion readiness mismatch");
-  assert.strictEqual(stagedPromotion.promotion_readiness.review_ready, true, "proof staged review-ready mismatch");
-  assert.strictEqual(stagedPromotion.promotion_readiness.default_eligible, false, "proof staged default eligibility mismatch");
-  assert.strictEqual(stagedPromotion.promotion_readiness.production_default_ready, false, "proof staged production-default readiness mismatch");
-  assert.ok(stagedPromotion.promotion_readiness.blockers.includes("not_certified"), "proof staged certification blocker missing");
-
-  const builtinPromotionWorkflow = root.summarizeIntegrationPromotionWorkflow("builtin.verifier.registry_profile");
-  assert.strictEqual(builtinPromotionWorkflow.ok, true, "proof builtin promotion workflow mismatch");
-  assert.strictEqual(
-    builtinPromotionWorkflow.next_transition.action,
-    "maintain_production_default",
-    "proof builtin promotion workflow next-transition mismatch"
-  );
-  assert.strictEqual(
-    builtinPromotionWorkflow.promotion_recommendation.recommendation,
-    "eligible_for_production_default",
-    "proof builtin promotion workflow recommendation mismatch"
-  );
-
-  const stagedPromotionWorkflow = root.summarizeIntegrationPromotionWorkflow("partner.verifier.lattice_notary");
-  assert.strictEqual(stagedPromotionWorkflow.ok, true, "proof staged promotion workflow mismatch");
-  assert.strictEqual(
-    stagedPromotionWorkflow.next_transition.action,
-    "complete_certification",
-    "proof staged promotion workflow next-transition mismatch"
-  );
-  assert.strictEqual(
-    stagedPromotionWorkflow.next_transition.later_actions.includes("promote_maturity"),
-    true,
-    "proof staged promotion workflow later-actions mismatch"
-  );
-  assert.strictEqual(
-    stagedPromotionWorkflow.promotion_recommendation.recommendation,
-    "keep_staged_until_requirements_clear",
-    "proof staged promotion workflow recommendation mismatch"
-  );
-  assert.strictEqual(
-    stagedPromotionWorkflow.certification_gaps.missing_requirements.includes("certification_state"),
-    true,
-    "proof staged promotion workflow certification gap mismatch"
-  );
-  assert.strictEqual(
-    stagedPromotionWorkflow.blocker_categories.some((entry) => entry.category === "certification"),
-    true,
-    "proof staged promotion workflow blocker-category mismatch"
-  );
-
-  const promotionWorkflowList = root.summarizeIntegrationPromotionWorkflowList({
-    source: "third_party_example",
-    registration_state: "staging_registered",
-    bundled: "false"
-  });
-  assert.strictEqual(promotionWorkflowList.ok, true, "proof promotion workflow list mismatch");
-  assert.strictEqual(promotionWorkflowList.integration_count >= 1, true, "proof promotion workflow list breadth mismatch");
-  assert.strictEqual(
-    promotionWorkflowList.next_actions.some((entry) => entry.action === "complete_certification"),
-    true,
-    "proof promotion workflow list next-action mismatch"
-  );
-  assert.strictEqual(
-    promotionWorkflowList.recommendations.some((entry) => entry.recommendation === "keep_staged_until_requirements_clear"),
-    true,
-    "proof promotion workflow list recommendation mismatch"
-  );
-  assert.strictEqual(
-    promotionWorkflowList.blocker_categories.some((entry) => entry.category === "certification"),
-    true,
-    "proof promotion workflow list blocker-category mismatch"
-  );
-
-  console.log("xoonya verify:integrations passed");
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
-});
+"use strict";
+
+const assert = require("assert");
+const stagedPartnerVerifierRegistrationRecord = require("../integrations/examples/example-third-party-verifier-registration.record.json");
+const root = require("../index.js");
+
+async function main() {
+  const integrations = root.listIntegrations();
+  assert.ok(Array.isArray(integrations), "proof integrations list missing");
+  assert.ok(integrations.length >= 4, "proof integration breadth missing");
+  assert.ok(integrations.some((integration) => integration.integration_id === "builtin.identity.legacy_material"), "legacy identity integration missing");
+  assert.ok(integrations.some((integration) => integration.integration_id === "builtin.verifier.registry_profile"), "registry verifier integration missing");
+  assert.ok(integrations.some((integration) => integration.integration_id === stagedPartnerVerifierRegistrationRecord.integration_id), "staged proof verifier integration missing");
+  assert.ok(integrations.some((integration) => integration.certification_state === "certified"), "proof integration certification metadata missing");
+
+  const summary = root.summarizeIntegrations();
+  assert.strictEqual(summary.ok, true, "proof integration summary ok mismatch");
+  assert.ok(summary.integration_count >= integrations.length, "proof integration count mismatch");
+  assert.strictEqual(summary.certified_integration_count >= 5, true, "proof integration certified count mismatch");
+  assert.strictEqual(summary.production_default_count >= 5, true, "proof integration production-default count mismatch");
+  assert.strictEqual(summary.staged_registration_count >= 1, true, "proof integration staged registration count mismatch");
+
+  const detail = root.getIntegration("builtin.verifier.economic_profile");
+  assert.ok(detail, "proof integration detail missing");
+  assert.strictEqual(detail.integration_class, "verification_helper_adapter", "proof integration class mismatch");
+  assert.strictEqual(detail.integration_maturity, "production_default", "proof integration maturity mismatch");
+
+  const bundledFiltered = root.listIntegrations({
+    source: "builtin",
+    certification_state: "certified",
+    integration_maturity: "production_default",
+    bundled: "true"
+  });
+  assert.ok(bundledFiltered.length >= 5, "proof builtin integration filtering mismatch");
+
+  const stagedFiltered = root.listIntegrations({
+    source: "third_party_example",
+    registration_state: "staging_registered",
+    proof_scope: "profile_verification",
+    bundled: "false"
+  });
+  assert.strictEqual(stagedFiltered.length, 1, "proof staged integration filtering mismatch");
+  assert.strictEqual(stagedFiltered[0].registration.requires_explicit_selection, true, "proof staged integration explicit-selection mismatch");
+
+  const validation = root.validateIntegrationRegistration({
+    integration_id: stagedPartnerVerifierRegistrationRecord.integration_id,
+    integration_class: stagedPartnerVerifierRegistrationRecord.integration_class,
+    proof_scope: stagedPartnerVerifierRegistrationRecord.proof_scope
+  }, stagedPartnerVerifierRegistrationRecord);
+  assert.strictEqual(validation.ok, true, "proof integration registration validation failed");
+
+  const imported = root.importRegisteredIntegration({
+    integration_id: "partner.verifier.memory_canary",
+    integration_class: "verification_helper_adapter",
+    display_name: "Memory Canary Verifier",
+    description: "Imported proof-side verifier used to validate normalization.",
+    proof_scope: "profile_verification",
+    capabilities: ["memory_canary.verify"],
+    public_surfaces: ["sdk"],
+    required_inputs: ["profile"],
+    emitted_artifacts: [],
+    verification_targets: ["memory_canary_profile"]
+  }, {
+    integration_id: "partner.verifier.memory_canary",
+    integration_class: "verification_helper_adapter",
+    proof_scope: "profile_verification",
+    registration_state: "local_only",
+    integration_maturity: "reference_example",
+    certification_state: "reference_example",
+    bundled: false,
+    default_selection_enabled: false,
+    requires_explicit_selection: true,
+    registered_at: "2026-03-20T00:00:00Z"
+  }, {
+    source: "verification_import_test",
+    certification_scope: ["contract_shape"],
+    operational_readiness: "reference"
+  });
+  assert.strictEqual(imported.integration_id, "partner.verifier.memory_canary", "proof imported integration id mismatch");
+  assert.strictEqual(imported.registration.registration_state, "local_only", "proof imported integration registration state mismatch");
+
+  const snapshot = root.exportIntegrationRegistrySnapshot({
+    registration_state: "staging_registered"
+  });
+  assert.strictEqual(snapshot.integration_count >= 1, true, "proof integration snapshot count mismatch");
+  assert.strictEqual(root.validateIntegrationRegistrySnapshot(snapshot).ok, true, "proof integration snapshot validation mismatch");
+
+  const builtinPromotion = root.summarizeIntegrationPromotionReadiness("builtin.verifier.registry_profile");
+  assert.strictEqual(builtinPromotion.ok, true, "proof builtin promotion readiness mismatch");
+  assert.strictEqual(builtinPromotion.promotion_readiness.default_eligible, true, "proof builtin default eligibility mismatch");
+  assert.strictEqual(builtinPromotion.promotion_readiness.production_default_ready, true, "proof builtin production-default readiness mismatch");
+
+  const stagedPromotion = root.summarizeIntegrationPromotionReadiness("partner.verifier.lattice_notary");
+  assert.strictEqual(stagedPromotion.ok, true, "proof staged promotion readiness mismatch");
+  assert.strictEqual(stagedPromotion.promotion_readiness.review_ready, true, "proof staged review-ready mismatch");
+  assert.strictEqual(stagedPromotion.promotion_readiness.default_eligible, false, "proof staged default eligibility mismatch");
+  assert.strictEqual(stagedPromotion.promotion_readiness.production_default_ready, false, "proof staged production-default readiness mismatch");
+  assert.ok(stagedPromotion.promotion_readiness.blockers.includes("not_certified"), "proof staged certification blocker missing");
+
+  const builtinPromotionWorkflow = root.summarizeIntegrationPromotionWorkflow("builtin.verifier.registry_profile");
+  assert.strictEqual(builtinPromotionWorkflow.ok, true, "proof builtin promotion workflow mismatch");
+  assert.strictEqual(
+    builtinPromotionWorkflow.next_transition.action,
+    "maintain_production_default",
+    "proof builtin promotion workflow next-transition mismatch"
+  );
+  assert.strictEqual(
+    builtinPromotionWorkflow.promotion_recommendation.recommendation,
+    "eligible_for_production_default",
+    "proof builtin promotion workflow recommendation mismatch"
+  );
+
+  const stagedPromotionWorkflow = root.summarizeIntegrationPromotionWorkflow("partner.verifier.lattice_notary");
+  assert.strictEqual(stagedPromotionWorkflow.ok, true, "proof staged promotion workflow mismatch");
+  assert.strictEqual(
+    stagedPromotionWorkflow.next_transition.action,
+    "complete_certification",
+    "proof staged promotion workflow next-transition mismatch"
+  );
+  assert.strictEqual(
+    stagedPromotionWorkflow.next_transition.later_actions.includes("promote_maturity"),
+    true,
+    "proof staged promotion workflow later-actions mismatch"
+  );
+  assert.strictEqual(
+    stagedPromotionWorkflow.promotion_recommendation.recommendation,
+    "keep_staged_until_requirements_clear",
+    "proof staged promotion workflow recommendation mismatch"
+  );
+  assert.strictEqual(
+    stagedPromotionWorkflow.certification_gaps.missing_requirements.includes("certification_state"),
+    true,
+    "proof staged promotion workflow certification gap mismatch"
+  );
+  assert.strictEqual(
+    stagedPromotionWorkflow.blocker_categories.some((entry) => entry.category === "certification"),
+    true,
+    "proof staged promotion workflow blocker-category mismatch"
+  );
+
+  const promotionWorkflowList = root.summarizeIntegrationPromotionWorkflowList({
+    source: "third_party_example",
+    registration_state: "staging_registered",
+    bundled: "false"
+  });
+  assert.strictEqual(promotionWorkflowList.ok, true, "proof promotion workflow list mismatch");
+  assert.strictEqual(promotionWorkflowList.integration_count >= 1, true, "proof promotion workflow list breadth mismatch");
+  assert.strictEqual(
+    promotionWorkflowList.next_actions.some((entry) => entry.action === "complete_certification"),
+    true,
+    "proof promotion workflow list next-action mismatch"
+  );
+  assert.strictEqual(
+    promotionWorkflowList.recommendations.some((entry) => entry.recommendation === "keep_staged_until_requirements_clear"),
+    true,
+    "proof promotion workflow list recommendation mismatch"
+  );
+  assert.strictEqual(
+    promotionWorkflowList.blocker_categories.some((entry) => entry.category === "certification"),
+    true,
+    "proof promotion workflow list blocker-category mismatch"
+  );
+
+  console.log("xoonya verify:integrations passed");
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/scripts/verify_native_hybrid_design_gate.js

@@ -1,114 +1,114 @@
-"use strict";
-
-const assert = require("assert");
-const crypto = require("crypto");
-const sdk = require("..");
-
-function runNativeHybridVerification() {
-  const readiness = sdk.summarizexoonyaNativeHybridReadinessPack();
-  assert.strictEqual(readiness.status, "implemented", "hybrid readiness must be implemented");
-  assert.strictEqual(readiness.implemented_hybrid_suite_count >= 1, true, "hybrid readiness must expose implemented suites");
-  assert.strictEqual(
-    readiness.current_decision.includes("runtime_supported"),
-    true,
-    "hybrid readiness must describe runtime-supported suites"
-  );
-
-  const event = sdk.canonicalizeEvent({
-    version: "canonical-event-bundle/v1",
-    domain_id: "hybrid.live",
-    sequence: "1",
-    actor_id: "agent-hybrid",
-    adapter_source: "verify_native_hybrid_design_gate",
-    event_type: "native.hybrid.verify",
-    event_hash: "89".repeat(32)
-  });
-
-  const classical = crypto.generateKeyPairSync("ed25519");
-  const pq = crypto.generateKeyPairSync("ml-dsa-65");
-  const receipt = sdk.emitReceipt(event, {
-    agent_identity: "agent-hybrid-signing",
-    algorithm: "xoonya-native-hybrid-v1",
-    identity_ref: "did:xoonya:agent-hybrid-signing",
-    classical_signature_suite: "ed25519",
-    pq_signature_suite: "ml-dsa-65",
-    classical_public_key_pem: classical.publicKey.export({ type: "spki", format: "pem" }),
-    classical_private_key_pem: classical.privateKey.export({ type: "pkcs8", format: "pem" }),
-    pq_public_key_pem: pq.publicKey.export({ type: "spki", format: "pem" }),
-    pq_private_key_pem: pq.privateKey.export({ type: "pkcs8", format: "pem" })
-  });
-
-  const verification = sdk.verifyProofBundle(sdk.buildProofBundle({
-    ceb: event,
-    receipt
-  }));
-  assert.strictEqual(verification.valid, true, "hybrid method must verify");
-  assert.strictEqual(
-    verification.verification_state,
-    "verified_native_hybrid_signature",
-    "hybrid method verification state mismatch"
-  );
-
-  const downgradeEvent = sdk.canonicalizeEvent({
-    version: "canonical-event-bundle/v1",
-    domain_id: "hybrid.downgrade",
-    sequence: "1",
-    actor_id: "agent-hybrid",
-    adapter_source: "verify_native_hybrid_design_gate",
-    event_type: "native.hybrid.downgrade",
-    event_hash: "90".repeat(32)
-  });
-  const detachedReceipt = sdk.emitReceipt(downgradeEvent, {
-    agent_identity: "agent-hybrid-signing",
-    algorithm: "detached-assertion-v1",
-    signature: receipt.signature
-  });
-  const downgradeVerification = sdk.verifyProofBundle(sdk.buildProofBundle({
-    ceb: downgradeEvent,
-    receipt: detachedReceipt
-  }));
-  assert.strictEqual(downgradeVerification.valid, false, "hybrid-looking signature must not verify as detached");
-  assert.strictEqual(
-    downgradeVerification.reason,
-    "signature_method_mismatch",
-    "hybrid-looking external signature must fail as method mismatch"
-  );
-
-  return {
-    ok: true,
-    product: "xoonya",
-    category: "xoonya-native-hybrid-verification",
-    method: "xoonya-native-hybrid-v1",
-    readiness_status: readiness.status,
-    implemented_hybrid_suites: readiness.implemented_hybrid_suites,
-    verification_state: verification.verification_state,
-    downgrade_reject_reason: downgradeVerification.reason,
-    boundary: "registered_runtime_supported_vector_covered_hybrid_suites_may_be_claimed"
-  };
-}
-
-function main() {
-  const json = process.argv.includes("--json");
-  const summary = runNativeHybridVerification();
-  if (json) {
-    process.stdout.write(`${JSON.stringify(summary, null, 2)}\n`);
-    return;
-  }
-  process.stdout.write(
-    [
-      "xoonya verify:native-hybrid-gate passed",
-      `method: ${summary.method}`,
-      `readiness: ${summary.readiness_status}`,
-      `verification state: ${summary.verification_state}`,
-      `downgrade reject: ${summary.downgrade_reject_reason}`
-    ].join("\n") + "\n"
-  );
-}
-
-if (require.main === module) {
-  main();
-}
-
-module.exports = {
-  runNativeHybridVerification
-};
+"use strict";
+
+const assert = require("assert");
+const crypto = require("crypto");
+const sdk = require("..");
+
+function runNativeHybridVerification() {
+  const readiness = sdk.summarizexoonyaNativeHybridReadinessPack();
+  assert.strictEqual(readiness.status, "implemented", "hybrid readiness must be implemented");
+  assert.strictEqual(readiness.implemented_hybrid_suite_count >= 1, true, "hybrid readiness must expose implemented suites");
+  assert.strictEqual(
+    readiness.current_decision.includes("runtime_supported"),
+    true,
+    "hybrid readiness must describe runtime-supported suites"
+  );
+
+  const event = sdk.canonicalizeEvent({
+    version: "canonical-event-bundle/v1",
+    domain_id: "hybrid.live",
+    sequence: "1",
+    actor_id: "agent-hybrid",
+    adapter_source: "verify_native_hybrid_design_gate",
+    event_type: "native.hybrid.verify",
+    event_hash: "89".repeat(32)
+  });
+
+  const classical = crypto.generateKeyPairSync("ed25519");
+  const pq = crypto.generateKeyPairSync("ml-dsa-65");
+  const receipt = sdk.emitReceipt(event, {
+    agent_identity: "agent-hybrid-signing",
+    algorithm: "xoonya-native-hybrid-v1",
+    identity_ref: "did:xoonya:agent-hybrid-signing",
+    classical_signature_suite: "ed25519",
+    pq_signature_suite: "ml-dsa-65",
+    classical_public_key_pem: classical.publicKey.export({ type: "spki", format: "pem" }),
+    classical_private_key_pem: classical.privateKey.export({ type: "pkcs8", format: "pem" }),
+    pq_public_key_pem: pq.publicKey.export({ type: "spki", format: "pem" }),
+    pq_private_key_pem: pq.privateKey.export({ type: "pkcs8", format: "pem" })
+  });
+
+  const verification = sdk.verifyProofBundle(sdk.buildProofBundle({
+    ceb: event,
+    receipt
+  }));
+  assert.strictEqual(verification.valid, true, "hybrid method must verify");
+  assert.strictEqual(
+    verification.verification_state,
+    "verified_native_hybrid_signature",
+    "hybrid method verification state mismatch"
+  );
+
+  const downgradeEvent = sdk.canonicalizeEvent({
+    version: "canonical-event-bundle/v1",
+    domain_id: "hybrid.downgrade",
+    sequence: "1",
+    actor_id: "agent-hybrid",
+    adapter_source: "verify_native_hybrid_design_gate",
+    event_type: "native.hybrid.downgrade",
+    event_hash: "90".repeat(32)
+  });
+  const detachedReceipt = sdk.emitReceipt(downgradeEvent, {
+    agent_identity: "agent-hybrid-signing",
+    algorithm: "detached-assertion-v1",
+    signature: receipt.signature
+  });
+  const downgradeVerification = sdk.verifyProofBundle(sdk.buildProofBundle({
+    ceb: downgradeEvent,
+    receipt: detachedReceipt
+  }));
+  assert.strictEqual(downgradeVerification.valid, false, "hybrid-looking signature must not verify as detached");
+  assert.strictEqual(
+    downgradeVerification.reason,
+    "signature_method_mismatch",
+    "hybrid-looking external signature must fail as method mismatch"
+  );
+
+  return {
+    ok: true,
+    product: "xoonya",
+    category: "xoonya-native-hybrid-verification",
+    method: "xoonya-native-hybrid-v1",
+    readiness_status: readiness.status,
+    implemented_hybrid_suites: readiness.implemented_hybrid_suites,
+    verification_state: verification.verification_state,
+    downgrade_reject_reason: downgradeVerification.reason,
+    boundary: "registered_runtime_supported_vector_covered_hybrid_suites_may_be_claimed"
+  };
+}
+
+function main() {
+  const json = process.argv.includes("--json");
+  const summary = runNativeHybridVerification();
+  if (json) {
+    process.stdout.write(`${JSON.stringify(summary, null, 2)}\n`);
+    return;
+  }
+  process.stdout.write(
+    [
+      "xoonya verify:native-hybrid-gate passed",
+      `method: ${summary.method}`,
+      `readiness: ${summary.readiness_status}`,
+      `verification state: ${summary.verification_state}`,
+      `downgrade reject: ${summary.downgrade_reject_reason}`
+    ].join("\n") + "\n"
+  );
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  runNativeHybridVerification
+};