xoonya 3.1.17 → 3.2.0

package/scripts/verify_integrations.js

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

package/scripts/verify_paid_execute.js

@@ -1,133 +0,0 @@
-"use strict";
-
-// Verifies the bearer-authed /execute backend that exposes xoonya's real proof
-// verification pay-per-call through the xytara x402 spine (xytara settles, then calls
-// this as an external execution target). Covers: fail-closed when the bearer env is
-// unset (503), 401 on missing/wrong bearer, 422 on unknown tool / unprocessable input /
-// private-key material, 200 with the MCP-executor-compatible output contract for a real
-// EdDSA JWS verification, and that existing free routes are unchanged.
-
-const assert = require("assert");
-const crypto = require("crypto");
-const http = require("http");
-
-const b64url = (buf) => Buffer.from(buf).toString("base64url");
-function makeJws(alg, payloadObj, signFn) {
-  const protectedB64 = b64url(Buffer.from(JSON.stringify({ alg }), "utf8"));
-  const payloadB64 = b64url(Buffer.from(JSON.stringify(payloadObj), "utf8"));
-  const signingInput = `${protectedB64}.${payloadB64}`;
-  return `${signingInput}.${b64url(signFn(Buffer.from(signingInput, "utf8")))}`;
-}
-
-async function post(baseUrl, path, body, headers = {}) {
-  const res = await fetch(`${baseUrl}${path}`, {
-    method: "POST",
-    headers: { "content-type": "application/json", ...headers },
-    body: JSON.stringify(body)
-  });
-  let json = null;
-  try { json = await res.json(); } catch (_) { json = null; }
-  return { status: res.status, json };
-}
-
-function executeBody(toolName, args, taskRef) {
-  return { command: "xoonya proof verify", task_ref: taskRef || "adapter.xoonya.invoke", tasks: [], body: { tool_name: toolName, arguments: args }, account_id: "acct_test", quote: {}, authorization_context: null };
-}
-
-async function main() {
-  const prev = {
-    bearer: process.env.XOONYA_EXECUTOR_BEARER_TOKEN,
-    pkm: process.env.XOONYA_ACCEPT_PRIVATE_KEY_MATERIAL
-  };
-  delete process.env.XOONYA_EXECUTOR_BEARER_TOKEN;
-
-  delete require.cache[require.resolve("../server.js")];
-  const { createServer } = require("../server.js");
-  const server = createServer();
-  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
-  const baseUrl = `http://127.0.0.1:${server.address().port}`;
-  const TOKEN = "test-executor-bearer-token";
-  const authHdr = { authorization: `Bearer ${TOKEN}` };
-
-  // Build a real EdDSA JWS + its public key for a genuine verification.
-  const ed = crypto.generateKeyPairSync("ed25519");
-  const edPubPem = ed.publicKey.export({ type: "spki", format: "pem" });
-  const edJws = makeJws("EdDSA", { sub: "agent-1" }, (d) => crypto.sign(null, d, ed.privateKey));
-
-  try {
-    // 1. Fail-closed: bearer env unset -> 503, never runs unauthenticated.
-    let r = await post(baseUrl, "/execute", executeBody("proof.verify-signature", {}), authHdr);
-    assert.strictEqual(r.status, 503, "unset bearer env must 503");
-    assert.strictEqual(r.json.reason, "executor_not_configured", "503 reason");
-
-    process.env.XOONYA_EXECUTOR_BEARER_TOKEN = TOKEN;
-
-    // 2. Missing / wrong bearer -> 401.
-    r = await post(baseUrl, "/execute", executeBody("proof.verify-signature", {}));
-    assert.strictEqual(r.status, 401, "missing bearer must 401");
-    r = await post(baseUrl, "/execute", executeBody("proof.verify-signature", {}), { authorization: "Bearer wrong" });
-    assert.strictEqual(r.status, 401, "wrong bearer must 401");
-
-    // 3. Unknown tool -> 422 (don't-charge class).
-    r = await post(baseUrl, "/execute", executeBody("proof.nope", {}), authHdr);
-    assert.strictEqual(r.status, 422, "unknown tool must 422");
-    assert.strictEqual(r.json.reason, "unknown_tool", "unknown_tool reason");
-    assert.ok(Array.isArray(r.json.enabled_tools) && r.json.enabled_tools.includes("proof.verify-signature"), "enabled_tools listed");
-
-    // 4. Real EdDSA JWS verification -> 200 with the MCP-executor output contract.
-    r = await post(baseUrl, "/execute", executeBody("proof.verify-signature", { signature_verification: { jws: edJws, trusted_public_key: edPubPem } }), authHdr);
-    assert.strictEqual(r.status, 200, "valid verification must 200");
-    assert.strictEqual(r.json.ok, true, "200 ok");
-    assert.strictEqual(r.json.status, "completed", "status completed");
-    assert.strictEqual(r.json.provider_status, "completed", "provider_status completed");
-    assert.ok(r.json.output_payload && r.json.output_payload.signature_valid === true, "real signature verified valid in output_payload");
-    assert.ok(r.json.result && r.json.result.output && r.json.result.output.signature_valid === true, "nested result.output present (xytara lifts this)");
-    assert.strictEqual(r.json.output_payload.trust_anchored, false, "no expected_key_ref -> not trust-anchored (honest model preserved)");
-
-    // 4b. A NEGATIVE verdict (wrong key) is NOT billed: money-safety rule charges only on
-    //     a positively-successful verification. 422, not charged, verdict surfaced.
-    const ed2 = crypto.generateKeyPairSync("ed25519");
-    r = await post(baseUrl, "/execute", executeBody("proof.verify-signature", { signature_verification: { jws: edJws, trusted_public_key: ed2.publicKey.export({ type: "spki", format: "pem" }) } }), authHdr);
-    assert.strictEqual(r.status, 422, "a ran-but-invalid verdict must not be charged (422)");
-    assert.ok(r.json.verdict && r.json.verdict.signature_valid === false, "negative verdict surfaced in 422 body");
-
-    // 5. Unprocessable input (no signature_verification) -> 422, not charged.
-    r = await post(baseUrl, "/execute", executeBody("proof.verify-signature", {}), authHdr);
-    assert.strictEqual(r.status, 422, "no sig input must 422");
-    assert.strictEqual(r.json.reason, "no_signature_verification_input", "unprocessable reason surfaced");
-
-    // 5b. The other three tools report unprocessable/negative via {valid:false} with NO
-    //     `ok` field — empty args to each must be 422 (the structural-reject bug fix), so
-    //     a paid caller is never charged for sending nothing verifiable.
-    for (const tool of ["proof.verify-bundle", "proof.verify-envelope", "proof.verify-receipt"]) {
-      r = await post(baseUrl, "/execute", executeBody(tool, {}), authHdr);
-      assert.strictEqual(r.status, 422, `${tool} with empty args must 422 (not a billable 200)`);
-      assert.strictEqual(r.json.ok, false, `${tool} empty-args must report ok:false`);
-    }
-    // A malformed receipt hex is likewise a structural reject -> 422, not a billed 200.
-    r = await post(baseUrl, "/execute", executeBody("proof.verify-receipt", { opreturn_hex: "zz" }), authHdr);
-    assert.strictEqual(r.status, 422, "non-hex receipt must 422");
-    assert.strictEqual(r.json.reason, "non_hex", "non_hex reason surfaced");
-
-    // 6. Private-key material refused -> 422 (only when the deployment rejects it).
-    process.env.XOONYA_ACCEPT_PRIVATE_KEY_MATERIAL = "false";
-    r = await post(baseUrl, "/execute", executeBody("proof.verify-signature", { signature_verification: { private_key: "-----BEGIN PRIVATE KEY-----\nAAAA\n-----END PRIVATE KEY-----" } }), authHdr);
-    assert.strictEqual(r.status, 422, "private key material must 422");
-    assert.strictEqual(r.json.reason, "private_key_material_not_accepted", "pkm reason");
-
-    // 7. Non-breaking: an existing free route still answers unchanged.
-    const health = await fetch(`${baseUrl}/health`);
-    assert.strictEqual(health.status, 200, "free /health route unchanged");
-
-    console.log("xoonya verify:paid-execute passed");
-  } finally {
-    await new Promise((resolve) => server.close(resolve));
-    if (prev.bearer === undefined) delete process.env.XOONYA_EXECUTOR_BEARER_TOKEN; else process.env.XOONYA_EXECUTOR_BEARER_TOKEN = prev.bearer;
-    if (prev.pkm === undefined) delete process.env.XOONYA_ACCEPT_PRIVATE_KEY_MATERIAL; else process.env.XOONYA_ACCEPT_PRIVATE_KEY_MATERIAL = prev.pkm;
-  }
-}
-
-main().catch((error) => {
-  console.error(error && error.message ? error.message : error);
-  process.exitCode = 1;
-});

package/scripts/verify_paywall_flag.js

@@ -1,86 +0,0 @@
-"use strict";
-
-// Verifies the optional paywall flag (XOONYA_REQUIRE_PAID_VERIFICATION) for the FREE
-// direct verification routes. Default OFF => routes stay free (non-breaking). ON => the
-// five crypto-verify routes that have a metered paid equivalent return 402 pointing to
-// the paid x402 lane, while /execute, /health and descriptor GETs stay free.
-
-const assert = require("assert");
-const crypto = require("crypto");
-const http = require("http");
-
-const b64url = (buf) => Buffer.from(buf).toString("base64url");
-function makeJws(payloadObj, privateKey) {
-  const protectedB64 = b64url(Buffer.from(JSON.stringify({ alg: "EdDSA" }), "utf8"));
-  const payloadB64 = b64url(Buffer.from(JSON.stringify(payloadObj), "utf8"));
-  const signingInput = `${protectedB64}.${payloadB64}`;
-  return `${signingInput}.${b64url(crypto.sign(null, Buffer.from(signingInput, "utf8"), privateKey))}`;
-}
-
-async function post(baseUrl, path, body) {
-  const res = await fetch(`${baseUrl}${path}`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body) });
-  let json = null; try { json = await res.json(); } catch (_) { json = null; }
-  return { status: res.status, json };
-}
-
-const GATED = [
-  ["/v1/proof-center/import-adapter/verify-signature", "proof.verify-signature"],
-  ["/v1/proof-bundles/verify", "proof.verify-bundle"],
-  ["/v1/proofs/verify", "proof.verify-envelope"],
-  ["/validate", "proof.verify-receipt"],
-  ["/v1/receipts/verify", "proof.verify-receipt"]
-];
-
-async function main() {
-  const prevFlag = process.env.XOONYA_REQUIRE_PAID_VERIFICATION;
-  const prevBearer = process.env.XOONYA_EXECUTOR_BEARER_TOKEN;
-  delete process.env.XOONYA_REQUIRE_PAID_VERIFICATION;
-  process.env.XOONYA_EXECUTOR_BEARER_TOKEN = "paywall-test-bearer";
-
-  delete require.cache[require.resolve("../server.js")];
-  const { createServer } = require("../server.js");
-  const server = createServer();
-  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
-  const baseUrl = `http://127.0.0.1:${server.address().port}`;
-
-  const ed = crypto.generateKeyPairSync("ed25519");
-  const edPubPem = ed.publicKey.export({ type: "spki", format: "pem" });
-  const jws = makeJws({ sub: "a" }, ed.privateKey);
-
-  try {
-    // Flag OFF (default): free direct verification works unchanged (non-breaking).
-    let r = await post(baseUrl, "/v1/proof-center/import-adapter/verify-signature", { signature_verification: { jws, trusted_public_key: edPubPem } });
-    assert.strictEqual(r.status, 200, "flag off: verify-signature free (200)");
-    assert.strictEqual(r.json.signature_valid, true, "flag off: real verdict returned free");
-
-    // Flag ON: every gated route returns 402 pointing to the paid lane.
-    process.env.XOONYA_REQUIRE_PAID_VERIFICATION = "true";
-    for (const [path, tool] of GATED) {
-      r = await post(baseUrl, path, {});
-      assert.strictEqual(r.status, 402, `flag on: ${path} must 402`);
-      assert.strictEqual(r.json.reason, "direct_verification_paywalled", `flag on: ${path} paywall reason`);
-      assert.ok(r.json.paid_lane && r.json.paid_lane.task_ref === "adapter.xoonya.invoke", `flag on: ${path} points to paid lane`);
-      assert.strictEqual(r.json.paid_lane.tool_name, tool, `flag on: ${path} names the paid tool`);
-    }
-    // And the paywalled route no longer performs the free verification (402, not 200).
-    r = await post(baseUrl, "/v1/proof-center/import-adapter/verify-signature", { signature_verification: { jws, trusted_public_key: edPubPem } });
-    assert.strictEqual(r.status, 402, "flag on: a valid request is still paywalled (no free bypass)");
-
-    // Flag ON must NOT paywall /execute (the paid backend) or /health (free).
-    const exec = await fetch(`${baseUrl}/execute`, { method: "POST", headers: { "content-type": "application/json" }, body: "{}" });
-    assert.notStrictEqual(exec.status, 402, "/execute must not be paywalled (it IS the paid path; 401 without bearer here)");
-    const health = await fetch(`${baseUrl}/health`);
-    assert.strictEqual(health.status, 200, "/health stays free");
-
-    console.log("xoonya verify:paywall-flag passed");
-  } finally {
-    await new Promise((resolve) => server.close(resolve));
-    if (prevFlag === undefined) delete process.env.XOONYA_REQUIRE_PAID_VERIFICATION; else process.env.XOONYA_REQUIRE_PAID_VERIFICATION = prevFlag;
-    if (prevBearer === undefined) delete process.env.XOONYA_EXECUTOR_BEARER_TOKEN; else process.env.XOONYA_EXECUTOR_BEARER_TOKEN = prevBearer;
-  }
-}
-
-main().catch((error) => {
-  console.error(error && error.message ? error.message : error);
-  process.exitCode = 1;
-});

package/scripts/verify_reference_promotion_gate.js

@@ -1,74 +0,0 @@
-"use strict";
-
-const assert = require("assert");
-const {
-  buildxoonyaNativeReferenceImplementationPack,
-  summarizexoonyaNativeReferenceImplementationPack,
-  validatexoonyaNativeReferencePromotionEvidence
-} = require("../proof_sdk");
-
-function buildValidPromotionEvidence(pack, language = "python") {
-  return {
-    language,
-    candidate_repository_ref: `xoonya-native-${language}@candidate`,
-    vector_sets_passed: pack.required_vector_sets.slice(),
-    deterministic_error_code_parity_ref: `xnya.reference.error_codes.${language}.2026-04-22`,
-    independent_parser_ref: `xnya.reference.parser.${language}.2026-04-22`,
-    signature_crypto_parity_ref: `xnya.reference.crypto.${language}.2026-04-22`,
-    round_trip_ref: `xnya.reference.round_trip.${language}.2026-04-22`,
-    conformance_mark_review_ref: `xnya.reference.conformance_mark.${language}.2026-04-22`,
-    forbidden_claim_review_ref: `xnya.reference.claim_boundary.${language}.2026-04-22`,
-    wraps_javascript_runtime: false
-  };
-}
-
-function assertRejected(pack, evidence, expectedCode) {
-  const validation = validatexoonyaNativeReferencePromotionEvidence(pack, evidence);
-  assert.strictEqual(validation.promotion_allowed, false, `expected ${expectedCode} to block reference promotion`);
-  assert.strictEqual(
-    validation.rejection_codes.includes(expectedCode),
-    true,
-    `missing deterministic rejection code ${expectedCode}`
-  );
-  return validation;
-}
-
-function main() {
-  const pack = buildxoonyaNativeReferenceImplementationPack();
-  const summary = summarizexoonyaNativeReferenceImplementationPack();
-  const validPythonEvidence = buildValidPromotionEvidence(pack, "python");
-  const validPythonPromotion = validatexoonyaNativeReferencePromotionEvidence(pack, validPythonEvidence);
-
-  assert.strictEqual(pack.category, "xoonya-native-reference-implementation-pack", "native reference pack category mismatch");
-  assert.strictEqual(summary.category, "xoonya-native-reference-implementation-summary", "native reference summary category mismatch");
-  assert.strictEqual(pack.implemented_reference_implementations.length, 1, "only JavaScript should be implemented today");
-  assert.strictEqual(pack.deterministic_rejection_codes.length >= 11, true, "reference promotion rejection codes missing");
-  assert.strictEqual(summary.deterministic_rejection_code_count, pack.deterministic_rejection_codes.length, "summary rejection code count mismatch");
-  assert.strictEqual(validPythonPromotion.promotion_allowed, true, "complete Python promotion evidence should pass validation");
-  assert.deepStrictEqual(validPythonPromotion.rejection_codes, [], "complete Python evidence should not carry rejection codes");
-
-  assertRejected(pack, buildValidPromotionEvidence(pack, "javascript"), "reference_language_not_registered");
-  assertRejected(pack, { ...validPythonEvidence, candidate_repository_ref: null }, "candidate_repository_missing");
-  assertRejected(pack, { ...validPythonEvidence, vector_sets_passed: pack.required_vector_sets.slice(0, 1) }, "required_vector_set_missing");
-  assertRejected(pack, { ...validPythonEvidence, deterministic_error_code_parity_ref: null }, "deterministic_error_code_parity_missing");
-  assertRejected(pack, { ...validPythonEvidence, independent_parser_ref: null }, "independent_parser_evidence_missing");
-  assertRejected(pack, { ...validPythonEvidence, signature_crypto_parity_ref: null }, "signature_crypto_parity_missing");
-  assertRejected(pack, { ...validPythonEvidence, round_trip_ref: null }, "round_trip_evidence_missing");
-  assertRejected(pack, { ...validPythonEvidence, conformance_mark_review_ref: null }, "conformance_mark_review_missing");
-  assertRejected(pack, { ...validPythonEvidence, forbidden_claim_review_ref: null }, "forbidden_claim_review_missing");
-  assertRejected(pack, { ...validPythonEvidence, wraps_javascript_runtime: true }, "javascript_wrapper_forbidden");
-  assertRejected(pack, { ...validPythonEvidence, npm_token: "npm_accidental_secret" }, "secret_material_forbidden");
-
-  const output = {
-    ok: true,
-    product: "xoonya",
-    category: "xoonya-native-reference-promotion-gate-verification",
-    status: "reference_promotion_requires_independent_vector_crypto_round_trip_and_mark_evidence",
-    deterministic_rejection_code_count: pack.deterministic_rejection_codes.length,
-    adversarial_case_count: 11,
-    boundary: "python_and_rust_reference_claims_remain_gated_until_independent_promotion_evidence_is_complete"
-  };
-  process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
-}
-
-main();

package/scripts/verify_reference_python.js

@@ -1,49 +0,0 @@
-"use strict";
-
-const assert = require("assert");
-const path = require("path");
-const { spawnSync } = require("child_process");
-
-function runPython(command, args) {
-  return spawnSync(command, args, {
-    cwd: path.resolve(__dirname, ".."),
-    encoding: "utf8"
-  });
-}
-
-function main() {
-  const script = path.resolve(__dirname, "..", "reference", "python", "verify_vectors.py");
-  let result = runPython("python", [script]);
-  if (result.error && result.error.code === "ENOENT") {
-    result = runPython("py", ["-3", script]);
-  }
-  if (result.error) {
-    throw result.error;
-  }
-  if (result.status !== 0) {
-    process.stderr.write(result.stdout || "");
-    process.stderr.write(result.stderr || "");
-    throw new Error("Python XNYA reference vector verification failed");
-  }
-  const summary = JSON.parse(result.stdout);
-  assert.strictEqual(summary.ok, true, "Python XNYA reference summary did not pass");
-  assert.strictEqual(summary.category, "xnya-python-reference-vector-parity", "Python XNYA reference category mismatch");
-  assert.strictEqual(summary.atom_vector_count >= 4, true, "Python XNYA atom vectors missing");
-  assert.strictEqual(summary.atom_adversarial_count >= 9, true, "Python XNYA adversarial vectors missing");
-  assert.strictEqual(summary.payload_profile_vector_count, 1, "Python XNYP payload vector missing");
-  assert.strictEqual(summary.proof_bundle_vector_count >= 10, true, "Python proof bundle vectors missing");
-  assert.strictEqual(summary.proof_bundle_verified_vector_count >= 9, true, "Python proof bundle verified vectors missing");
-  assert.strictEqual(
-    summary.native_signed_crypto_gated_vector_count + summary.native_signed_crypto_verified_vector_count,
-    1,
-    "Python native signed crypto vector accounting mismatch"
-  );
-  assert.strictEqual(
-    summary.verified_signature_suite_count === 0 || summary.verified_signature_suite_count === 1,
-    true,
-    "Python verified signature suite count mismatch"
-  );
-  process.stdout.write("xoonya verify:reference-python passed\n");
-}
-
-main();