xytara 3.1.16 → 3.2.0

package/scripts/verify_execution_surfacing.js

@@ -1,76 +0,0 @@
-"use strict";
-
-// Verifies that when a real execution target runs, its actual output is surfaced
-// into the buyer-facing artifacts (command.deliverables + execution.results_by_task_id)
-// — provider-agnostically across the target response shapes — and that the
-// synthetic ("simulated") path is unchanged when no target runs.
-
-const assert = require("assert");
-const { createCommandArtifacts } = require("../lib/commerce_artifacts");
-
-const basePayload = {
-  command: "command.execute",
-  tasks: [{ task_id: "t1", task_ref: "adapter.mcp.invoke" }],
-  body: { tool_name: "keccak256" }
-};
-const baseQuote = {
-  quote_id: "quote_test1",
-  account_id: "acct_test",
-  amount_minor: 5,
-  currency: "USD_CENTS",
-  settlement_mode: null,
-  integration_ids: [],
-  protocols: ["mcp"],
-  capabilities: [],
-  adapters: ["http"],
-  execution_integration_ids: [],
-  payment_scheme: "exact",
-  payment_protocol: "x402"
-};
-
-function run(label, opts, check) {
-  const out = createCommandArtifacts(basePayload, baseQuote, opts);
-  check({
-    out,
-    deliv: out.command.deliverables[0],
-    taskResult: out.transaction.execution.results_by_task_id.t1
-  });
-  console.log("  ok:", label);
-}
-
-// 1. Nested MCP-executor shape: { result: { output: <real> } }
-run("nested result.output (MCP executor shape)",
-  { externalExecution: { provider: "mcp", target_id: "tg1", target_response: { ok: true, result: { output: { digest: "0xdeadbeef", length: 8 } }, provider_status: "completed" } } },
-  ({ deliv, taskResult }) => {
-    assert.deepStrictEqual(deliv.output_payload, { digest: "0xdeadbeef", length: 8 }, "deliverable carries real output");
-    assert.strictEqual(deliv.invocation_status, "provider_completed");
-    assert.strictEqual(deliv.execution_provider, "mcp");
-    assert.deepStrictEqual(taskResult.output_payload, { digest: "0xdeadbeef", length: 8 }, "task result carries real output");
-    assert.strictEqual(taskResult.invocation_status, "provider_completed");
-  });
-
-// 2. Contract-conformant shape: { output_payload, output_ref, provider_status }
-run("conformant output_payload + output_ref",
-  { externalExecution: { provider: "p", target_id: "tg2", target_response: { output_payload: { answer: 42 }, output_ref: "ref_xyz", provider_status: "ok" } } },
-  ({ deliv, taskResult }) => {
-    assert.deepStrictEqual(deliv.output_payload, { answer: 42 });
-    assert.strictEqual(deliv.output_ref, "ref_xyz");
-    assert.strictEqual(deliv.provider_status, "ok");
-    assert.strictEqual(taskResult.output_ref, "ref_xyz");
-  });
-
-// 3. Bare output field
-run("bare output field",
-  { externalExecution: { provider: "p", target_id: "tg3", target_response: { output: "hello" } } },
-  ({ deliv }) => assert.strictEqual(deliv.output_payload, "hello"));
-
-// 4. No external target -> synthetic path unchanged
-run("no target -> simulated, no output_payload",
-  {},
-  ({ deliv, taskResult }) => {
-    assert.strictEqual(deliv.output_payload, undefined, "no payload when synthetic");
-    assert.strictEqual(taskResult.invocation_status, "simulated");
-    assert.ok(String(deliv.ref).startsWith("deliverable_"), "placeholder ref preserved");
-  });
-
-console.log("verify_execution_surfacing: all execution output-surfacing checks passed");

package/scripts/verify_external_execution_retry.js

@@ -1,140 +0,0 @@
-"use strict";
-
-// Verifies the transient-retry behavior of executeExternalTarget (lib/external_execution_runtime.js):
-// a provider-rejected status (429/503/408) is retried with backoff, but ambiguous gateway errors
-// (502/504) and network failures are NOT retried — so a retry can never double-execute a
-// side-effectful provider on the open network. Deferred settlement means a non-retried failure
-// simply does not charge.
-
-const assert = require("assert");
-
-function fakeResponse({ ok, status, body, retryAfter }) {
-  return {
-    ok,
-    status,
-    headers: { get: (h) => (String(h).toLowerCase() === "retry-after" && retryAfter != null ? String(retryAfter) : null) },
-    text: async () => (typeof body === "string" ? body : JSON.stringify(body || {}))
-  };
-}
-
-async function withFetch(sequence, fn) {
-  const orig = global.fetch;
-  let i = 0;
-  const calls = [];
-  global.fetch = async (url, opts) => {
-    calls.push({ url, opts });
-    const next = sequence[Math.min(i, sequence.length - 1)];
-    i += 1;
-    if (next instanceof Error) throw next;
-    return fakeResponse(next);
-  };
-  try { return await fn(calls); } finally { global.fetch = orig; }
-}
-
-async function main() {
-  const prev = process.env.XYTARA_EXTERNAL_EXECUTION_MAX_RETRIES;
-  process.env.XYTARA_EXTERNAL_EXECUTION_MAX_RETRIES = "2";
-  delete require.cache[require.resolve("../lib/external_execution_runtime")];
-  const { executeExternalTarget } = require("../lib/external_execution_runtime");
-  const target = { endpoint_url: "https://p.example/execute", timeout_ms: 2000, provider: "p", target_id: "t", auth_token: "tok" };
-  const payload = { command: "x", task_ref: "adapter.demo.invoke", body: {} };
-
-  try {
-    // 1. 429 then 200 -> retried once, succeeds.
-    await withFetch([
-      { ok: false, status: 429, body: "Too Many Requests\n", retryAfter: 0 },
-      { ok: true, status: 200, body: { result: { output: { hash: "0xabc" } } } }
-    ], async (calls) => {
-      const r = await executeExternalTarget(target, payload, {});
-      assert.strictEqual(r.ok, true, "429-then-200 succeeds after retry");
-      assert.ok(r.target_response, "carries target_response");
-      assert.strictEqual(calls.length, 2, "exactly one retry (2 calls)");
-    });
-
-    // 2. 429 persistently -> exhausted (1 + 2 retries = 3 attempts) -> rejected, surfaced.
-    await withFetch([{ ok: false, status: 429, body: "Too Many Requests\n", retryAfter: 0 }], async (calls) => {
-      const r = await executeExternalTarget(target, payload, {});
-      assert.strictEqual(r.ok, false, "exhausted 429 fails");
-      assert.strictEqual(r.reason, "external_execution_target_rejected", "reject reason");
-      assert.strictEqual(r.upstream_status, 429, "upstream 429 surfaced");
-      assert.strictEqual(r.attempts, 3, "3 attempts");
-      assert.strictEqual(calls.length, 3, "3 fetch calls");
-    });
-
-    // 3. 503 is retryable too.
-    await withFetch([
-      { ok: false, status: 503, body: "unavailable", retryAfter: 0 },
-      { ok: true, status: 200, body: { result: { output: {} } } }
-    ], async (calls) => {
-      const r = await executeExternalTarget(target, payload, {});
-      assert.strictEqual(r.ok, true, "503-then-200 succeeds");
-      assert.strictEqual(calls.length, 2, "retried once");
-    });
-
-    // 4. 502 is NOT retried (ambiguous gateway error; provider may already have executed).
-    await withFetch([{ ok: false, status: 502, body: "bad gateway" }], async (calls) => {
-      const r = await executeExternalTarget(target, payload, {});
-      assert.strictEqual(r.ok, false, "502 fails");
-      assert.strictEqual(r.attempts, 1, "502 NOT retried (single attempt)");
-      assert.strictEqual(calls.length, 1, "one fetch call");
-    });
-
-    // 5. Network error is NOT retried (provider may already have executed).
-    await withFetch([new Error("socket hang up")], async (calls) => {
-      const r = await executeExternalTarget(target, payload, {});
-      assert.strictEqual(r.ok, false, "network error fails");
-      assert.strictEqual(r.reason, "external_execution_failed", "failed reason");
-      assert.strictEqual(calls.length, 1, "network error NOT retried");
-    });
-
-    // 6. First-try success -> no retry.
-    await withFetch([{ ok: true, status: 200, body: { result: { output: {} } } }], async (calls) => {
-      const r = await executeExternalTarget(target, payload, {});
-      assert.strictEqual(r.ok, true, "200 ok");
-      assert.strictEqual(calls.length, 1, "no retry on success");
-    });
-
-    // 7. Retries disabled (max=0) -> a 429 fails on the first attempt.
-    process.env.XYTARA_EXTERNAL_EXECUTION_MAX_RETRIES = "0";
-    delete require.cache[require.resolve("../lib/external_execution_runtime")];
-    const mod0 = require("../lib/external_execution_runtime");
-    await withFetch([{ ok: false, status: 429, body: "x", retryAfter: 0 }], async (calls) => {
-      const r = await mod0.executeExternalTarget(target, payload, {});
-      assert.strictEqual(r.ok, false, "max=0: 429 fails immediately");
-      assert.strictEqual(calls.length, 1, "max=0: no retry");
-    });
-
-    // 8. COLD-START RIDE-OUT (default retries): several 429s then 200 -> rides out within the window.
-    delete process.env.XYTARA_EXTERNAL_EXECUTION_MAX_RETRIES;
-    delete require.cache[require.resolve("../lib/external_execution_runtime")];
-    const modRide = require("../lib/external_execution_runtime");
-    await withFetch([
-      { ok: false, status: 429, body: "x", retryAfter: 0 }, { ok: false, status: 429, body: "x", retryAfter: 0 },
-      { ok: false, status: 429, body: "x", retryAfter: 0 }, { ok: false, status: 429, body: "x", retryAfter: 0 },
-      { ok: false, status: 429, body: "x", retryAfter: 0 }, { ok: false, status: 429, body: "x", retryAfter: 0 },
-      { ok: true, status: 200, body: { result: { output: {} } } }
-    ], async (calls) => {
-      const r = await modRide.executeExternalTarget(target, payload, {});
-      assert.strictEqual(r.ok, true, "ride-out: 6x429 then 200 succeeds (cold start ridden out)");
-      assert.strictEqual(calls.length, 7, "ride-out retried through the cold start");
-    });
-
-    // 9. Time window exhausted (RETRY_WINDOW_MS=0) -> no ride-out even on a 429.
-    process.env.XYTARA_EXTERNAL_EXECUTION_RETRY_WINDOW_MS = "0";
-    delete require.cache[require.resolve("../lib/external_execution_runtime")];
-    const modNoWin = require("../lib/external_execution_runtime");
-    await withFetch([{ ok: false, status: 429, body: "x", retryAfter: 0 }], async (calls) => {
-      const r = await modNoWin.executeExternalTarget(target, payload, {});
-      assert.strictEqual(r.ok, false, "window=0: 429 fails immediately");
-      assert.strictEqual(calls.length, 1, "window=0: no retry");
-    });
-    delete process.env.XYTARA_EXTERNAL_EXECUTION_RETRY_WINDOW_MS;
-
-    console.log("xytara verify:external-execution-retry passed");
-  } finally {
-    if (prev === undefined) delete process.env.XYTARA_EXTERNAL_EXECUTION_MAX_RETRIES; else process.env.XYTARA_EXTERNAL_EXECUTION_MAX_RETRIES = prev;
-    delete process.env.XYTARA_EXTERNAL_EXECUTION_RETRY_WINDOW_MS;
-  }
-}
-
-main().catch((e) => { console.error(e && e.message ? e.message : e); process.exitCode = 1; });

package/scripts/verify_final_activation.js

@@ -1,191 +0,0 @@
-"use strict";
-
-const assert = require("assert");
-
-function parseCsvEnv(value) {
-  if (!value) {
-    return [];
-  }
-  return value
-    .split(",")
-    .map((entry) => entry.trim())
-    .filter(Boolean);
-}
-
-async function getJson(baseUrl, path, headers) {
-  const response = await fetch(`${baseUrl}${path}`, {
-    headers: headers || {}
-  });
-  const json = await response.json();
-  return {
-    status: response.status,
-    json
-  };
-}
-
-function assertContainsAll(actual, expected, label) {
-  for (const entry of expected) {
-    assert.strictEqual(
-      actual.includes(entry),
-      true,
-      `${label} missing expected entry: ${entry}`
-    );
-  }
-}
-
-async function main() {
-  const baseUrl = process.env.XYTARA_VERIFY_BASE_URL || "https://xytara.onrender.com";
-  const expectedLiveRails = parseCsvEnv(process.env.XYTARA_EXPECTED_LIVE_RAILS);
-  const expectedReadinessOnlyRails = parseCsvEnv(process.env.XYTARA_EXPECTED_READINESS_ONLY_RAILS);
-  const expectedBsvRuntimeMode = process.env.XYTARA_EXPECTED_BSV_RUNTIME_MODE || "arc";
-  const operatorAccountId = process.env.XYTARA_VERIFY_ACCOUNT_ID || process.env.XYTARA_TREASURY_ACCOUNT_ID || "";
-  const operatorBearerToken = process.env.XYTARA_ACCOUNT_AUTH_BEARER_TOKEN || "";
-  const operatorHeaders = operatorBearerToken
-    ? { authorization: `Bearer ${operatorBearerToken}` }
-    : null;
-
-  const treasurySummary = await getJson(baseUrl, "/v1/treasury-destinations/summary");
-  assert.strictEqual(treasurySummary.status, 200, "treasury destinations summary route failed");
-  assert.strictEqual(
-    treasurySummary.json.category,
-    "machine-commerce-treasury-destinations-pack-summary",
-    "treasury destinations summary category mismatch"
-  );
-  assert.strictEqual(
-    treasurySummary.json.public_claimable_profile_count > 0,
-    true,
-    "public claimable treasury profile count must be positive"
-  );
-  assert.strictEqual(
-    Array.isArray(treasurySummary.json.public_claim_boundary.live_claimable_rails),
-    true,
-    "treasury summary live claimable rails missing"
-  );
-  assert.strictEqual(
-    Array.isArray(treasurySummary.json.public_claim_boundary.readiness_only_rails),
-    true,
-    "treasury summary readiness-only rails missing"
-  );
-
-  const paymentRailTruthSummary = await getJson(baseUrl, "/v1/payment-rail-truth/summary");
-  assert.strictEqual(paymentRailTruthSummary.status, 200, "payment rail truth summary route failed");
-  assert.strictEqual(
-    paymentRailTruthSummary.json.category,
-    "machine-commerce-payment-rail-truth-model",
-    "payment rail truth summary category mismatch"
-  );
-  assert.strictEqual(
-    paymentRailTruthSummary.json.public_live_landing_rail_count > 0,
-    true,
-    "public live landing rail count must be positive"
-  );
-
-  const autonomousEntrySummary = await getJson(baseUrl, "/v1/autonomous-entry/summary");
-  assert.strictEqual(autonomousEntrySummary.status, 200, "autonomous entry summary route failed");
-  assert.strictEqual(
-    autonomousEntrySummary.json.category,
-    "machine-commerce-autonomous-entry-pack-summary",
-    "autonomous entry summary category mismatch"
-  );
-  assert.strictEqual(
-    autonomousEntrySummary.json.public_live_landing_rail_count > 0,
-    true,
-    "autonomous entry live landing rail count must be positive"
-  );
-
-  const bsvReadiness = await getJson(baseUrl, "/v1/settlement/bsv-teranode/readiness");
-  assert.strictEqual(bsvReadiness.status, 200, "BSV readiness route failed");
-  assert.strictEqual(bsvReadiness.json.rail, "bsv_teranode", "BSV readiness rail mismatch");
-  assert.strictEqual(bsvReadiness.json.ready, true, "BSV readiness must be true");
-  assert.strictEqual(
-    bsvReadiness.json.runtime_mode,
-    expectedBsvRuntimeMode,
-    `BSV readiness runtime mode must be ${expectedBsvRuntimeMode}`
-  );
-
-  if (expectedLiveRails.length > 0) {
-    assertContainsAll(
-      treasurySummary.json.public_claim_boundary.live_claimable_rails,
-      expectedLiveRails,
-      "live claimable rails"
-    );
-  }
-
-  if (expectedReadinessOnlyRails.length > 0) {
-    assertContainsAll(
-      treasurySummary.json.public_claim_boundary.readiness_only_rails,
-      expectedReadinessOnlyRails,
-      "readiness-only rails"
-    );
-  }
-
-  let operatorChecks = {
-    attempted: false
-  };
-
-  if (operatorHeaders && operatorAccountId) {
-    operatorChecks = {
-      attempted: true
-    };
-
-    const paymentLedger = await getJson(baseUrl, "/v1/payment-ledger", operatorHeaders);
-    assert.strictEqual(paymentLedger.status, 200, "payment ledger route failed");
-
-    const activityLedger = await getJson(baseUrl, "/v1/activity-ledger", operatorHeaders);
-    assert.strictEqual(activityLedger.status, 200, "activity ledger route failed");
-
-    const treasurySummaryRoute = await getJson(
-      baseUrl,
-      `/v1/economics/accounts/${encodeURIComponent(operatorAccountId)}/treasury-summary`,
-      operatorHeaders
-    );
-    assert.strictEqual(treasurySummaryRoute.status, 200, "account treasury summary route failed");
-
-    const railSummaryRoute = await getJson(
-      baseUrl,
-      `/v1/economics/accounts/${encodeURIComponent(operatorAccountId)}/rail-summary`,
-      operatorHeaders
-    );
-    assert.strictEqual(railSummaryRoute.status, 200, "account rail summary route failed");
-
-    const reconciliationReport = await getJson(baseUrl, "/v1/reconciliation-report", operatorHeaders);
-    assert.strictEqual(reconciliationReport.status, 200, "reconciliation report route failed");
-
-    operatorChecks.payment_ledger_count = Array.isArray(paymentLedger.json.entries)
-      ? paymentLedger.json.entries.length
-      : Array.isArray(paymentLedger.json.payments)
-        ? paymentLedger.json.payments.length
-        : null;
-    operatorChecks.activity_ledger_count = Array.isArray(activityLedger.json.entries)
-      ? activityLedger.json.entries.length
-      : Array.isArray(activityLedger.json.activities)
-        ? activityLedger.json.activities.length
-        : null;
-    operatorChecks.account_id = operatorAccountId;
-    operatorChecks.reconciliation_category = reconciliationReport.json.category || null;
-  }
-
-  const output = {
-    ok: true,
-    product: "xytara",
-    category: "xytara-final-activation-verification",
-    base_url: baseUrl,
-    expected_bsv_runtime_mode: expectedBsvRuntimeMode,
-    live_claimable_rails: treasurySummary.json.public_claim_boundary.live_claimable_rails,
-    readiness_only_rails: treasurySummary.json.public_claim_boundary.readiness_only_rails,
-    public_claimable_profile_count: treasurySummary.json.public_claimable_profile_count,
-    public_live_landing_rail_count: paymentRailTruthSummary.json.public_live_landing_rail_count,
-    autonomous_entry_live_landing_rail_count: autonomousEntrySummary.json.public_live_landing_rail_count,
-    bsv_ready: bsvReadiness.json.ready,
-    bsv_runtime_mode: bsvReadiness.json.runtime_mode,
-    operator_checks: operatorChecks,
-    boundary: "launch_activation_truth_must_match_live_treasury_payment_autonomous_entry_and_bsv_readiness_surfaces"
-  };
-
-  process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
-}
-
-main().catch((error) => {
-  process.stderr.write(`${error.stack || error.message}\n`);
-  process.exit(1);
-});

package/scripts/verify_first_run_conversions.js

@@ -1,81 +0,0 @@
-"use strict";
-
-const assert = require("assert");
-const { createServer } = require("../server");
-const {
-  buildFirstRunConversionPack,
-  summarizeFirstRunConversionPack,
-  getFirstRunConversionDetail
-} = require("../lib/first_run_conversion_contract");
-
-async function getJson(baseUrl, routePath) {
-  const response = await fetch(`${baseUrl}${routePath}`);
-  return {
-    status: response.status,
-    json: await response.json()
-  };
-}
-
-async function main() {
-  const pack = buildFirstRunConversionPack();
-  const summary = summarizeFirstRunConversionPack();
-
-  assert.strictEqual(pack.ok, true, "first-run conversion pack ok missing");
-  assert.strictEqual(summary.conversion_count >= 3, true, "first-run conversion count missing");
-  assert.strictEqual(summary.public_first_contact_ready_count >= 2, true, "public first-contact conversion count missing");
-  assert.strictEqual(summary.revenue_ready_conversion_count >= 2, true, "revenue-ready conversion count missing");
-  assert.strictEqual(summary.proof_ready_conversion_count >= 3, true, "proof-ready conversion count missing");
-  assert.strictEqual(summary.operator_inspection_ready_count >= 3, true, "operator inspection conversion count missing");
-  assert.strictEqual(Boolean(getFirstRunConversionDetail("direct_x402_paid_proof")), true, "direct x402 conversion missing");
-  assert.strictEqual(Boolean(getFirstRunConversionDetail("credits_first_paid_proof")), true, "credits-first conversion missing");
-  assert.strictEqual(Boolean(getFirstRunConversionDetail("result_package_proof_pickup")), true, "result-package proof pickup conversion missing");
-
-  const server = createServer();
-  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
-  const address = server.address();
-  const baseUrl = `http://127.0.0.1:${address.port}`;
-
-  try {
-    const packResponse = await getJson(baseUrl, "/v1/first-run/conversions");
-    assert.strictEqual(packResponse.status, 200, "first-run conversions route failed");
-    assert.strictEqual(packResponse.json.conversion_count >= 3, true, "first-run conversions route count missing");
-
-    const summaryResponse = await getJson(baseUrl, "/v1/first-run/conversions/summary");
-    assert.strictEqual(summaryResponse.status, 200, "first-run conversions summary route failed");
-    assert.strictEqual(summaryResponse.json.revenue_ready_conversion_count >= 2, true, "first-run conversions summary revenue count missing");
-
-    const directPayResponse = await getJson(baseUrl, "/v1/first-run/conversions/direct_x402_paid_proof");
-    assert.strictEqual(directPayResponse.status, 200, "direct x402 first-run conversion detail route failed");
-    assert.strictEqual(directPayResponse.json.conversion.revenue_ready, true, "direct x402 first-run conversion revenue missing");
-
-    const creditsResponse = await getJson(baseUrl, "/v1/first-run/conversions/credits_first_paid_proof");
-    assert.strictEqual(creditsResponse.status, 200, "credits-first first-run conversion detail route failed");
-    assert.strictEqual(creditsResponse.json.conversion.operator_inspection_ready, true, "credits-first conversion inspection missing");
-
-    const proofPickupResponse = await getJson(baseUrl, "/v1/first-run/conversions/result_package_proof_pickup");
-    assert.strictEqual(proofPickupResponse.status, 200, "proof pickup first-run conversion detail route failed");
-    assert.strictEqual(proofPickupResponse.json.conversion.proof_ready, true, "proof pickup conversion proof readiness missing");
-
-    console.log(JSON.stringify({
-      ok: true,
-      product: "xytara",
-      category: "machine-commerce-first-run-conversion-verification",
-      verification_version: "xytara-first-run-conversion-verification-v1",
-      conversion_count: summary.conversion_count,
-      public_first_contact_ready_count: summary.public_first_contact_ready_count,
-      revenue_ready_conversion_count: summary.revenue_ready_conversion_count,
-      proof_ready_conversion_count: summary.proof_ready_conversion_count,
-      operator_inspection_ready_count: summary.operator_inspection_ready_count,
-      boundary: "launch_grade_first_run_claims_require_public_quote_fund_execute_proof_and_inspection_paths"
-    }, null, 2));
-  } finally {
-    await new Promise((resolve, reject) => {
-      server.close((error) => (error ? reject(error) : resolve()));
-    });
-  }
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exitCode = 1;
-});

package/scripts/verify_framework_provider_promotion.js

@@ -1,152 +0,0 @@
-"use strict";
-
-const assert = require("assert");
-const {
-  FRAMEWORK_PROVIDER_CANDIDATES,
-  buildFrameworkProviderPromotionPack,
-  summarizeFrameworkProviderPromotionPack,
-  validateFrameworkProviderPromotionEvidence
-} = require("../lib/framework_provider_promotion");
-
-function normalizeUrl(baseUrl, healthPath) {
-  const url = new URL(baseUrl);
-  const normalizedPath = String(healthPath || "/health").startsWith("/")
-    ? String(healthPath || "/health")
-    : `/${healthPath}`;
-  url.pathname = normalizedPath;
-  return url.toString();
-}
-
-async function checkHealth(candidate, env) {
-  const endpoint = env[candidate.endpoint_env];
-  const token = env[candidate.auth_env];
-  const healthPath = env[candidate.health_path_env] || "/health";
-  const started = Date.now();
-  const response = await fetch(normalizeUrl(endpoint, healthPath), {
-    method: "GET",
-    headers: {
-      Authorization: `Bearer ${token}`,
-      Accept: "application/json"
-    }
-  });
-  const latencyMs = Date.now() - started;
-  let body = null;
-  try {
-    body = await response.json();
-  } catch (_error) {
-    body = null;
-  }
-  return {
-    framework_id: candidate.framework_id,
-    adapter_id: candidate.adapter_id,
-    status_code: response.status,
-    latency_ms: latencyMs,
-    health_ok: response.ok && (!body || ["ok", "ready", "auth_required"].includes(String(body.status || body.readiness || "ok"))),
-    body_status: body && (body.status || body.readiness || null)
-  };
-}
-
-function buildValidPromotionEvidence(candidateSummary) {
-  return {
-    framework_id: candidateSummary.framework_id,
-    adapter_id: candidateSummary.adapter_id,
-    task_ref: candidateSummary.task_ref,
-    operator_evidence_ref: `ops.framework_provider.${candidateSummary.framework_id}.2026-04-22`,
-    auth_boundary_ref: `ops.framework_provider.auth_boundary.${candidateSummary.framework_id}.2026-04-22`,
-    health_check: {
-      status_code: 200,
-      health_ok: true
-    },
-    latency_ms: 250,
-    latency_budget_ms: 2000,
-    failure_behavior_ref: `ops.framework_provider.failure_behavior.${candidateSummary.framework_id}.2026-04-22`,
-    proof_fact_shape_ref: `ops.framework_provider.proof_facts.${candidateSummary.framework_id}.2026-04-22`
-  };
-}
-
-function assertRejected(pack, evidence, expectedCode) {
-  const validation = validateFrameworkProviderPromotionEvidence(pack, evidence);
-  assert.strictEqual(validation.promotion_allowed, false, `expected ${expectedCode} to block framework provider promotion`);
-  assert.strictEqual(
-    validation.rejection_codes.includes(expectedCode),
-    true,
-    `missing deterministic rejection code ${expectedCode}`
-  );
-  return validation;
-}
-
-async function main() {
-  const pack = buildFrameworkProviderPromotionPack();
-  const summary = summarizeFrameworkProviderPromotionPack();
-  assert.strictEqual(pack.ok, true, "framework provider promotion pack failed");
-  assert.strictEqual(summary.framework_candidate_count, FRAMEWORK_PROVIDER_CANDIDATES.length, "framework candidate count mismatch");
-  assert.strictEqual(pack.promoted_provider_count, 0, "promotion pack must not auto-promote providers");
-  assert.strictEqual(pack.deterministic_rejection_codes.length >= 13, true, "framework promotion rejection codes missing");
-  assert.strictEqual(summary.deterministic_rejection_code_count, pack.deterministic_rejection_codes.length, "framework promotion summary rejection code count mismatch");
-  assert.strictEqual(
-    pack.strict_boundaries.includes("reference_framework_adapters_do_not_equal_live_provider_integrations"),
-    true,
-    "framework reference boundary missing"
-  );
-
-  assertRejected(pack, buildValidPromotionEvidence(pack.candidates[0]), "candidate_not_live_check_ready");
-  assertRejected(pack, { framework_id: "unknown_framework" }, "framework_not_registered");
-
-  const syntheticEnv = {
-    XYTARA_LANGGRAPH_PROVIDER_URL: "https://provider.example.test",
-    XYTARA_LANGGRAPH_PROVIDER_TOKEN: "configured-token-placeholder",
-    XYTARA_LANGGRAPH_PROVIDER_HEALTH_PATH: "/health"
-  };
-  const promotablePack = buildFrameworkProviderPromotionPack({ env: syntheticEnv });
-  const promotableCandidate = promotablePack.candidates.find((candidate) => candidate.framework_id === "langgraph");
-  const validEvidence = buildValidPromotionEvidence(promotableCandidate);
-  const validValidation = validateFrameworkProviderPromotionEvidence(promotablePack, validEvidence);
-  assert.strictEqual(promotableCandidate.state, "live_check_ready", "synthetic provider should be live-check ready");
-  assert.strictEqual(validValidation.promotion_allowed, true, "complete synthetic evidence should validate");
-  assert.deepStrictEqual(validValidation.rejection_codes, [], "complete synthetic evidence should not carry rejections");
-
-  assertRejected(promotablePack, { ...validEvidence, adapter_id: "wrong.adapter" }, "adapter_id_mismatch");
-  assertRejected(promotablePack, { ...validEvidence, task_ref: "wrong.task" }, "task_ref_mismatch");
-  assertRejected(promotablePack, { ...validEvidence, operator_evidence_ref: null }, "operator_evidence_missing");
-  assertRejected(promotablePack, { ...validEvidence, auth_boundary_ref: null }, "auth_boundary_evidence_missing");
-  assertRejected(promotablePack, { ...validEvidence, health_check: null }, "health_check_missing");
-  assertRejected(promotablePack, { ...validEvidence, health_check: { status_code: 503, health_ok: false } }, "health_check_failed");
-  assertRejected(promotablePack, { ...validEvidence, latency_ms: null }, "latency_measurement_missing");
-  assertRejected(promotablePack, { ...validEvidence, latency_ms: 3000, latency_budget_ms: 1000 }, "latency_budget_exceeded");
-  assertRejected(promotablePack, { ...validEvidence, failure_behavior_ref: null }, "failure_behavior_evidence_missing");
-  assertRejected(promotablePack, { ...validEvidence, proof_fact_shape_ref: null }, "proof_fact_shape_evidence_missing");
-  assertRejected(promotablePack, { ...validEvidence, provider_token: "sk_live_accidental_secret" }, "secret_material_forbidden");
-
-  const readyCandidates = pack.candidates.filter((candidate) => candidate.state === "live_check_ready");
-  if (pack.require_live) {
-    assert.strictEqual(readyCandidates.length > 0, true, "live provider promotion required but no endpoint/auth pair is configured");
-  }
-
-  const live_checks = [];
-  for (const candidate of FRAMEWORK_PROVIDER_CANDIDATES) {
-    const candidateSummary = pack.candidates.find((entry) => entry.framework_id === candidate.framework_id);
-    if (!candidateSummary || candidateSummary.state !== "live_check_ready") continue;
-    const result = await checkHealth(candidate, process.env);
-    assert.strictEqual(result.health_ok, true, `${candidate.framework_id} live health check failed`);
-    live_checks.push(result);
-  }
-
-  const result = {
-    ok: true,
-    product: "xytara",
-    category: "xytara-framework-provider-promotion-verification",
-    status: live_checks.length > 0 ? "live_provider_health_checks_passed" : "no_live_provider_evidence_configured",
-    live_check_count: live_checks.length,
-    promotion_allowed: false,
-    deterministic_rejection_code_count: pack.deterministic_rejection_codes.length,
-    adversarial_case_count: 13,
-    live_checks,
-    boundary: "this_verifier_checks_promotion_evidence_but_does_not_promote_reference_adapters_to_live_provider_claims"
-  };
-  process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
-}
-
-main().catch((error) => {
-  console.error(error && error.stack ? error.stack : error);
-  process.exit(1);
-});