xytara 3.1.0 → 3.1.2

package/scripts/verify_lifecycle_continuity.js

@@ -1,96 +1,96 @@
-"use strict";
-
-const assert = require("assert");
-const { once } = require("events");
-const { createServer } = require("../server");
-const {
-  buildLifecycleContinuityPack,
-  summarizeLifecycleContinuityPack
-} = require("../lib/lifecycle_continuity_contract");
-
-async function getJson(baseUrl, pathname) {
-  const response = await fetch(`${baseUrl}${pathname}`);
-  return {
-    status: response.status,
-    json: await response.json()
-  };
-}
-
-function assertSummary(summary) {
-  assert.strictEqual(summary.ok, true, "lifecycle continuity summary ok flag missing");
-  assert.strictEqual(summary.lifecycle_stage_count >= 13, true, "lifecycle continuity stage count missing");
-  assert.strictEqual(summary.fully_surfaced_lifecycle_count >= 12, true, "lifecycle continuity fully surfaced count missing");
-  assert.strictEqual(summary.first_party_callable_lifecycle_count >= 10, true, "lifecycle continuity first-party callable count missing");
-  assert.strictEqual(summary.proof_followthrough_lifecycle_count >= 3, true, "lifecycle continuity proof followthrough count missing");
-  assert.strictEqual(summary.dispute_followthrough_lifecycle_count >= 2, true, "lifecycle continuity dispute followthrough count missing");
-}
-
-function assertPack(pack) {
-  assert.strictEqual(pack.ok, true, "lifecycle continuity pack ok flag missing");
-  assert.strictEqual(pack.category, "machine-commerce-lifecycle-continuity-pack", "lifecycle continuity pack category mismatch");
-  assert.strictEqual(Array.isArray(pack.lifecycle_stages), true, "lifecycle continuity stages missing");
-  assert.strictEqual(pack.lifecycle_stages.length >= 13, true, "lifecycle continuity stage list missing");
-  assert.strictEqual(
-    pack.lifecycle_stages.some((entry) => entry.lifecycle_stage === "verify" && entry.proof_followthrough === true),
-    true,
-    "lifecycle continuity verify followthrough missing"
-  );
-  assert.strictEqual(
-    pack.lifecycle_stages.some((entry) => entry.lifecycle_stage === "dispute_open" && entry.proof_followthrough === true),
-    true,
-    "lifecycle continuity dispute-open followthrough missing"
-  );
-  assert.strictEqual(
-    pack.lifecycle_stages.some((entry) => entry.lifecycle_stage === "dispute_fetch" && entry.proof_followthrough === true),
-    true,
-    "lifecycle continuity dispute-fetch followthrough missing"
-  );
-}
-
-async function main() {
-  const pack = buildLifecycleContinuityPack();
-  const summary = summarizeLifecycleContinuityPack();
-  assertPack(pack);
-  assertSummary(summary);
-
-  const server = createServer();
-  server.listen(0, "127.0.0.1");
-  await once(server, "listening");
-
-  const address = server.address();
-  const baseUrl = `http://127.0.0.1:${address.port}`;
-
-  try {
-    const packResponse = await getJson(baseUrl, "/v1/lifecycle-continuity");
-    assert.strictEqual(packResponse.status, 200, "lifecycle continuity pack route failed");
-    assertPack(packResponse.json);
-
-    const summaryResponse = await getJson(baseUrl, "/v1/lifecycle-continuity/summary");
-    assert.strictEqual(summaryResponse.status, 200, "lifecycle continuity summary route failed");
-    assertSummary(summaryResponse.json);
-
-    const verifyDetail = await getJson(baseUrl, "/v1/lifecycle-continuity/verify");
-    assert.strictEqual(verifyDetail.status, 200, "lifecycle continuity verify detail route failed");
-    assert.strictEqual(verifyDetail.json.stage.lifecycle_stage, "verify", "lifecycle continuity verify detail mismatch");
-    assert.strictEqual(verifyDetail.json.stage.proof_followthrough, true, "lifecycle continuity verify detail followthrough missing");
-  } finally {
-    await new Promise((resolve) => server.close(resolve));
-  }
-
-  console.log(JSON.stringify({
-    ok: true,
-    product: "xytara",
-    category: "machine-commerce-lifecycle-continuity-verification",
-    verification_version: "xytara-lifecycle-continuity-verification-v1",
-    lifecycle_stage_count: summary.lifecycle_stage_count,
-    fully_surfaced_lifecycle_count: summary.fully_surfaced_lifecycle_count,
-    proof_followthrough_lifecycle_count: summary.proof_followthrough_lifecycle_count,
-    dispute_followthrough_lifecycle_count: summary.dispute_followthrough_lifecycle_count,
-    boundary: "lifecycle_continuity_should_be_publicly_inspectable_with_xoonya_followthrough_explicit"
-  }, null, 2));
-}
-
-main().catch((error) => {
-  console.error(error && error.stack ? error.stack : error);
-  process.exit(1);
-});
+"use strict";
+
+const assert = require("assert");
+const { once } = require("events");
+const { createServer } = require("../server");
+const {
+  buildLifecycleContinuityPack,
+  summarizeLifecycleContinuityPack
+} = require("../lib/lifecycle_continuity_contract");
+
+async function getJson(baseUrl, pathname) {
+  const response = await fetch(`${baseUrl}${pathname}`);
+  return {
+    status: response.status,
+    json: await response.json()
+  };
+}
+
+function assertSummary(summary) {
+  assert.strictEqual(summary.ok, true, "lifecycle continuity summary ok flag missing");
+  assert.strictEqual(summary.lifecycle_stage_count >= 13, true, "lifecycle continuity stage count missing");
+  assert.strictEqual(summary.fully_surfaced_lifecycle_count >= 12, true, "lifecycle continuity fully surfaced count missing");
+  assert.strictEqual(summary.first_party_callable_lifecycle_count >= 10, true, "lifecycle continuity first-party callable count missing");
+  assert.strictEqual(summary.proof_followthrough_lifecycle_count >= 3, true, "lifecycle continuity proof followthrough count missing");
+  assert.strictEqual(summary.dispute_followthrough_lifecycle_count >= 2, true, "lifecycle continuity dispute followthrough count missing");
+}
+
+function assertPack(pack) {
+  assert.strictEqual(pack.ok, true, "lifecycle continuity pack ok flag missing");
+  assert.strictEqual(pack.category, "machine-commerce-lifecycle-continuity-pack", "lifecycle continuity pack category mismatch");
+  assert.strictEqual(Array.isArray(pack.lifecycle_stages), true, "lifecycle continuity stages missing");
+  assert.strictEqual(pack.lifecycle_stages.length >= 13, true, "lifecycle continuity stage list missing");
+  assert.strictEqual(
+    pack.lifecycle_stages.some((entry) => entry.lifecycle_stage === "verify" && entry.proof_followthrough === true),
+    true,
+    "lifecycle continuity verify followthrough missing"
+  );
+  assert.strictEqual(
+    pack.lifecycle_stages.some((entry) => entry.lifecycle_stage === "dispute_open" && entry.proof_followthrough === true),
+    true,
+    "lifecycle continuity dispute-open followthrough missing"
+  );
+  assert.strictEqual(
+    pack.lifecycle_stages.some((entry) => entry.lifecycle_stage === "dispute_fetch" && entry.proof_followthrough === true),
+    true,
+    "lifecycle continuity dispute-fetch followthrough missing"
+  );
+}
+
+async function main() {
+  const pack = buildLifecycleContinuityPack();
+  const summary = summarizeLifecycleContinuityPack();
+  assertPack(pack);
+  assertSummary(summary);
+
+  const server = createServer();
+  server.listen(0, "127.0.0.1");
+  await once(server, "listening");
+
+  const address = server.address();
+  const baseUrl = `http://127.0.0.1:${address.port}`;
+
+  try {
+    const packResponse = await getJson(baseUrl, "/v1/lifecycle-continuity");
+    assert.strictEqual(packResponse.status, 200, "lifecycle continuity pack route failed");
+    assertPack(packResponse.json);
+
+    const summaryResponse = await getJson(baseUrl, "/v1/lifecycle-continuity/summary");
+    assert.strictEqual(summaryResponse.status, 200, "lifecycle continuity summary route failed");
+    assertSummary(summaryResponse.json);
+
+    const verifyDetail = await getJson(baseUrl, "/v1/lifecycle-continuity/verify");
+    assert.strictEqual(verifyDetail.status, 200, "lifecycle continuity verify detail route failed");
+    assert.strictEqual(verifyDetail.json.stage.lifecycle_stage, "verify", "lifecycle continuity verify detail mismatch");
+    assert.strictEqual(verifyDetail.json.stage.proof_followthrough, true, "lifecycle continuity verify detail followthrough missing");
+  } finally {
+    await new Promise((resolve) => server.close(resolve));
+  }
+
+  console.log(JSON.stringify({
+    ok: true,
+    product: "xytara",
+    category: "machine-commerce-lifecycle-continuity-verification",
+    verification_version: "xytara-lifecycle-continuity-verification-v1",
+    lifecycle_stage_count: summary.lifecycle_stage_count,
+    fully_surfaced_lifecycle_count: summary.fully_surfaced_lifecycle_count,
+    proof_followthrough_lifecycle_count: summary.proof_followthrough_lifecycle_count,
+    dispute_followthrough_lifecycle_count: summary.dispute_followthrough_lifecycle_count,
+    boundary: "lifecycle_continuity_should_be_publicly_inspectable_with_xoonya_followthrough_explicit"
+  }, null, 2));
+}
+
+main().catch((error) => {
+  console.error(error && error.stack ? error.stack : error);
+  process.exit(1);
+});

package/scripts/verify_market_lane_depth.js

@@ -1,94 +1,94 @@
-"use strict";
-
-const assert = require("assert");
-const { createServer } = require("../server");
-
-async function getJson(baseUrl, path) {
-  const response = await fetch(`${baseUrl}${path}`);
-  return {
-    status: response.status,
-    json: await response.json()
-  };
-}
-
-async function main() {
-  const previousExecutionTargets = process.env.XYTARA_EXECUTION_TARGETS_JSON;
-  process.env.XYTARA_EXECUTION_TARGETS_JSON = JSON.stringify([
-    {
-      target_id: "verify-market-lane-depth-mcp-target",
-      task_ref: "adapter.mcp.invoke",
-      endpoint_url: "http://127.0.0.1:65535/execute",
-      provider: "xytara_mcp_executor",
-      tool_name: "summarize",
-      auth_token: "verify-market-lane-depth-bearer",
-      timeout_ms: 1500,
-      enabled: true
-    },
-    {
-      target_id: "verify-market-lane-depth-zones-target",
-      task_ref: "adapter.mcp.invoke",
-      endpoint_url: "http://127.0.0.1:65535/execute",
-      provider: "xytara_mcp_executor",
-      tool_name: "zones.lookup",
-      auth_token: "verify-market-lane-depth-bearer",
-      timeout_ms: 1500,
-      enabled: true
-    }
-  ]);
-  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 pack = await getJson(baseUrl, "/v1/full-catalog/market-lanes/depth");
-    assert.strictEqual(pack.status, 200, "market lane depth route failed");
-    assert.strictEqual(pack.json.category, "machine-commerce-market-lane-depth-pack", "market lane depth category mismatch");
-    assert.strictEqual(pack.json.market_lane_depth_count >= 3, true, "market lane depth count missing");
-    assert.strictEqual(
-      pack.json.market_lane_depths.some((entry) => entry.market_class === "compute" && entry.provider_live_anchor_count >= 1),
-      true,
-      "compute provider-live depth missing"
-    );
-    assert.strictEqual(
-      pack.json.market_lane_depths.some((entry) => entry.market_class === "messaging" && entry.callable_surface_count >= 6),
-      true,
-      "messaging callable depth missing"
-    );
-    assert.strictEqual(
-      pack.json.market_lane_depths.some((entry) => entry.market_class === "treasury_payments" && entry.activation_profile_count >= 3),
-      true,
-      "treasury activation depth missing"
-    );
-
-    const summary = await getJson(baseUrl, "/v1/full-catalog/market-lanes/depth/summary");
-    assert.strictEqual(summary.status, 200, "market lane depth summary route failed");
-    assert.strictEqual(summary.json.market_lane_depth_count >= 3, true, "market lane depth summary count missing");
-    assert.strictEqual(summary.json.provider_live_anchor_lane_count >= 1, true, "market lane depth provider-live count missing");
-    assert.strictEqual(summary.json.first_party_callable_lane_count >= 3, true, "market lane depth callable count missing");
-
-    const compute = await getJson(baseUrl, "/v1/full-catalog/market-lanes/depth/compute");
-    assert.strictEqual(compute.status, 200, "market lane depth compute detail route failed");
-    assert.strictEqual(compute.json.depth.depth_state, "provider_live_path_deepened", "compute depth state mismatch");
-    assert.strictEqual(compute.json.depth.promotion_gates.auth_ready, true, "compute auth gate missing");
-
-    const messaging = await getJson(baseUrl, "/v1/full-catalog/market-lanes/depth/messaging");
-    assert.strictEqual(messaging.status, 200, "market lane depth messaging detail route failed");
-    assert.strictEqual(messaging.json.depth.promotion_gates.event_mesh_ready, true, "messaging event-mesh gate missing");
-
-    const treasury = await getJson(baseUrl, "/v1/full-catalog/market-lanes/depth/treasury_payments");
-    assert.strictEqual(treasury.status, 200, "market lane depth treasury detail route failed");
-    assert.strictEqual(treasury.json.depth.promotion_gates.settlement_family_ready, true, "treasury settlement-family gate missing");
-
-    console.log("xytara verify:market-lane-depth passed");
-  } finally {
-    await new Promise((resolve) => server.close(resolve));
-    if (previousExecutionTargets === undefined) delete process.env.XYTARA_EXECUTION_TARGETS_JSON;
-    else process.env.XYTARA_EXECUTION_TARGETS_JSON = previousExecutionTargets;
-  }
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
-});
+"use strict";
+
+const assert = require("assert");
+const { createServer } = require("../server");
+
+async function getJson(baseUrl, path) {
+  const response = await fetch(`${baseUrl}${path}`);
+  return {
+    status: response.status,
+    json: await response.json()
+  };
+}
+
+async function main() {
+  const previousExecutionTargets = process.env.XYTARA_EXECUTION_TARGETS_JSON;
+  process.env.XYTARA_EXECUTION_TARGETS_JSON = JSON.stringify([
+    {
+      target_id: "verify-market-lane-depth-mcp-target",
+      task_ref: "adapter.mcp.invoke",
+      endpoint_url: "http://127.0.0.1:65535/execute",
+      provider: "xytara_mcp_executor",
+      tool_name: "summarize",
+      auth_token: "verify-market-lane-depth-bearer",
+      timeout_ms: 1500,
+      enabled: true
+    },
+    {
+      target_id: "verify-market-lane-depth-zones-target",
+      task_ref: "adapter.mcp.invoke",
+      endpoint_url: "http://127.0.0.1:65535/execute",
+      provider: "xytara_mcp_executor",
+      tool_name: "zones.lookup",
+      auth_token: "verify-market-lane-depth-bearer",
+      timeout_ms: 1500,
+      enabled: true
+    }
+  ]);
+  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 pack = await getJson(baseUrl, "/v1/full-catalog/market-lanes/depth");
+    assert.strictEqual(pack.status, 200, "market lane depth route failed");
+    assert.strictEqual(pack.json.category, "machine-commerce-market-lane-depth-pack", "market lane depth category mismatch");
+    assert.strictEqual(pack.json.market_lane_depth_count >= 3, true, "market lane depth count missing");
+    assert.strictEqual(
+      pack.json.market_lane_depths.some((entry) => entry.market_class === "compute" && entry.provider_live_anchor_count >= 1),
+      true,
+      "compute provider-live depth missing"
+    );
+    assert.strictEqual(
+      pack.json.market_lane_depths.some((entry) => entry.market_class === "messaging" && entry.callable_surface_count >= 6),
+      true,
+      "messaging callable depth missing"
+    );
+    assert.strictEqual(
+      pack.json.market_lane_depths.some((entry) => entry.market_class === "treasury_payments" && entry.activation_profile_count >= 3),
+      true,
+      "treasury activation depth missing"
+    );
+
+    const summary = await getJson(baseUrl, "/v1/full-catalog/market-lanes/depth/summary");
+    assert.strictEqual(summary.status, 200, "market lane depth summary route failed");
+    assert.strictEqual(summary.json.market_lane_depth_count >= 3, true, "market lane depth summary count missing");
+    assert.strictEqual(summary.json.provider_live_anchor_lane_count >= 1, true, "market lane depth provider-live count missing");
+    assert.strictEqual(summary.json.first_party_callable_lane_count >= 3, true, "market lane depth callable count missing");
+
+    const compute = await getJson(baseUrl, "/v1/full-catalog/market-lanes/depth/compute");
+    assert.strictEqual(compute.status, 200, "market lane depth compute detail route failed");
+    assert.strictEqual(compute.json.depth.depth_state, "provider_live_path_deepened", "compute depth state mismatch");
+    assert.strictEqual(compute.json.depth.promotion_gates.auth_ready, true, "compute auth gate missing");
+
+    const messaging = await getJson(baseUrl, "/v1/full-catalog/market-lanes/depth/messaging");
+    assert.strictEqual(messaging.status, 200, "market lane depth messaging detail route failed");
+    assert.strictEqual(messaging.json.depth.promotion_gates.event_mesh_ready, true, "messaging event-mesh gate missing");
+
+    const treasury = await getJson(baseUrl, "/v1/full-catalog/market-lanes/depth/treasury_payments");
+    assert.strictEqual(treasury.status, 200, "market lane depth treasury detail route failed");
+    assert.strictEqual(treasury.json.depth.promotion_gates.settlement_family_ready, true, "treasury settlement-family gate missing");
+
+    console.log("xytara verify:market-lane-depth passed");
+  } finally {
+    await new Promise((resolve) => server.close(resolve));
+    if (previousExecutionTargets === undefined) delete process.env.XYTARA_EXECUTION_TARGETS_JSON;
+    else process.env.XYTARA_EXECUTION_TARGETS_JSON = previousExecutionTargets;
+  }
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/scripts/verify_market_lane_promotion.js

@@ -1,103 +1,103 @@
-"use strict";
-
-const assert = require("assert");
-const { createServer } = require("../server");
-const {
-  buildMarketLanePromotionPack,
-  validateMarketLanePromotionEvidence
-} = require("../lib/market_lane_promotion_contract");
-
-async function getJson(baseUrl, path) {
-  const response = await fetch(`${baseUrl}${path}`);
-  return {
-    status: response.status,
-    json: await response.json()
-  };
-}
-
-async function main() {
-  const previousExecutionTargets = process.env.XYTARA_EXECUTION_TARGETS_JSON;
-  process.env.XYTARA_EXECUTION_TARGETS_JSON = JSON.stringify([
-    {
-      target_id: "verify-market-lane-promotion-mcp-target",
-      task_ref: "adapter.mcp.invoke",
-      endpoint_url: "http://127.0.0.1:65535/execute",
-      provider: "xytara_mcp_executor",
-      tool_name: "summarize",
-      auth_token: "verify-market-lane-promotion-bearer",
-      timeout_ms: 1500,
-      enabled: true
-    }
-  ]);
-  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 pack = await getJson(baseUrl, "/v1/full-catalog/market-lanes/promotion");
-    assert.strictEqual(pack.status, 200, "market lane promotion route failed");
-    assert.strictEqual(pack.json.category, "machine-commerce-market-lane-promotion-pack", "market lane promotion category mismatch");
-    assert.strictEqual(pack.json.market_lane_promotion_count >= 3, true, "market lane promotion count missing");
-    assert.strictEqual(pack.json.provider_live_ready_count >= 1, true, "market lane promotion provider-live count missing");
-    assert.strictEqual(pack.json.bounded_live_ready_count >= 2, true, "market lane promotion bounded-live count missing");
-
-    const summary = await getJson(baseUrl, "/v1/full-catalog/market-lanes/promotion/summary");
-    assert.strictEqual(summary.status, 200, "market lane promotion summary route failed");
-    assert.strictEqual(summary.json.market_lane_promotion_count >= 3, true, "market lane promotion summary count missing");
-    assert.strictEqual(summary.json.deterministic_rejection_code_count >= 8, true, "market lane promotion rejection code count missing");
-
-    const compute = await getJson(baseUrl, "/v1/full-catalog/market-lanes/promotion/compute");
-    assert.strictEqual(compute.status, 200, "market lane promotion compute detail route failed");
-    assert.strictEqual(compute.json.promotion.promotion_state, "provider_live_promotion_ready", "compute promotion state mismatch");
-    assert.strictEqual(compute.json.promotion.provider_live_anchor_required, true, "compute provider-live requirement missing");
-
-    const messaging = await getJson(baseUrl, "/v1/full-catalog/market-lanes/promotion/messaging");
-    assert.strictEqual(messaging.status, 200, "market lane promotion messaging detail route failed");
-    assert.strictEqual(messaging.json.promotion.gate_assertions.event_mesh_ready, true, "messaging event mesh promotion gate missing");
-
-    const treasury = await getJson(baseUrl, "/v1/full-catalog/market-lanes/promotion/treasury_payments");
-    assert.strictEqual(treasury.status, 200, "market lane promotion treasury detail route failed");
-    assert.strictEqual(treasury.json.promotion.gate_assertions.settlement_family_ready, true, "treasury settlement-family promotion gate missing");
-
-    const promotionPack = buildMarketLanePromotionPack();
-    const validEvidence = {
-      market_class: "compute",
-      operator_evidence_ref: "ops.market_lane.compute.promotion.2026-04-24",
-      claim_boundary_ack: compute.json.promotion.claim_boundary,
-      gate_assertions: Object.fromEntries(compute.json.promotion.promotion_requirements.map((requirement) => [requirement, true])),
-      provider_live_anchor_ref: "ops.market_lane.compute.provider_anchor.2026-04-24",
-      trace_evidence_ref: "ops.market_lane.compute.trace.2026-04-24"
-    };
-    const validValidation = validateMarketLanePromotionEvidence(promotionPack, validEvidence);
-    assert.strictEqual(validValidation.promotion_allowed, true, "complete market lane promotion evidence should validate");
-
-    const invalidValidation = validateMarketLanePromotionEvidence(promotionPack, {
-      market_class: "compute",
-      operator_evidence_ref: "",
-      claim_boundary_ack: "",
-      gate_assertions: { auth_ready: true },
-      provider_live_anchor_ref: "",
-      trace_evidence_ref: "",
-      bearer_token: "bearer not-allowed"
-    });
-    assert.strictEqual(invalidValidation.promotion_allowed, false, "invalid market lane promotion evidence should be rejected");
-    assert.strictEqual(invalidValidation.rejection_codes.includes("operator_evidence_missing"), true, "missing operator evidence rejection missing");
-    assert.strictEqual(invalidValidation.rejection_codes.includes("claim_boundary_ack_missing"), true, "missing claim boundary rejection missing");
-    assert.strictEqual(invalidValidation.rejection_codes.includes("required_gate_assertion_missing"), true, "missing gate assertion rejection missing");
-    assert.strictEqual(invalidValidation.rejection_codes.includes("provider_anchor_evidence_missing"), true, "missing provider anchor rejection missing");
-    assert.strictEqual(invalidValidation.rejection_codes.includes("trace_evidence_missing"), true, "missing trace evidence rejection missing");
-    assert.strictEqual(invalidValidation.rejection_codes.includes("secret_material_forbidden"), true, "secret material rejection missing");
-
-    console.log("xytara verify:market-lane-promotion passed");
-  } finally {
-    await new Promise((resolve) => server.close(resolve));
-    if (previousExecutionTargets === undefined) delete process.env.XYTARA_EXECUTION_TARGETS_JSON;
-    else process.env.XYTARA_EXECUTION_TARGETS_JSON = previousExecutionTargets;
-  }
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
-});
+"use strict";
+
+const assert = require("assert");
+const { createServer } = require("../server");
+const {
+  buildMarketLanePromotionPack,
+  validateMarketLanePromotionEvidence
+} = require("../lib/market_lane_promotion_contract");
+
+async function getJson(baseUrl, path) {
+  const response = await fetch(`${baseUrl}${path}`);
+  return {
+    status: response.status,
+    json: await response.json()
+  };
+}
+
+async function main() {
+  const previousExecutionTargets = process.env.XYTARA_EXECUTION_TARGETS_JSON;
+  process.env.XYTARA_EXECUTION_TARGETS_JSON = JSON.stringify([
+    {
+      target_id: "verify-market-lane-promotion-mcp-target",
+      task_ref: "adapter.mcp.invoke",
+      endpoint_url: "http://127.0.0.1:65535/execute",
+      provider: "xytara_mcp_executor",
+      tool_name: "summarize",
+      auth_token: "verify-market-lane-promotion-bearer",
+      timeout_ms: 1500,
+      enabled: true
+    }
+  ]);
+  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 pack = await getJson(baseUrl, "/v1/full-catalog/market-lanes/promotion");
+    assert.strictEqual(pack.status, 200, "market lane promotion route failed");
+    assert.strictEqual(pack.json.category, "machine-commerce-market-lane-promotion-pack", "market lane promotion category mismatch");
+    assert.strictEqual(pack.json.market_lane_promotion_count >= 3, true, "market lane promotion count missing");
+    assert.strictEqual(pack.json.provider_live_ready_count >= 1, true, "market lane promotion provider-live count missing");
+    assert.strictEqual(pack.json.bounded_live_ready_count >= 2, true, "market lane promotion bounded-live count missing");
+
+    const summary = await getJson(baseUrl, "/v1/full-catalog/market-lanes/promotion/summary");
+    assert.strictEqual(summary.status, 200, "market lane promotion summary route failed");
+    assert.strictEqual(summary.json.market_lane_promotion_count >= 3, true, "market lane promotion summary count missing");
+    assert.strictEqual(summary.json.deterministic_rejection_code_count >= 8, true, "market lane promotion rejection code count missing");
+
+    const compute = await getJson(baseUrl, "/v1/full-catalog/market-lanes/promotion/compute");
+    assert.strictEqual(compute.status, 200, "market lane promotion compute detail route failed");
+    assert.strictEqual(compute.json.promotion.promotion_state, "provider_live_promotion_ready", "compute promotion state mismatch");
+    assert.strictEqual(compute.json.promotion.provider_live_anchor_required, true, "compute provider-live requirement missing");
+
+    const messaging = await getJson(baseUrl, "/v1/full-catalog/market-lanes/promotion/messaging");
+    assert.strictEqual(messaging.status, 200, "market lane promotion messaging detail route failed");
+    assert.strictEqual(messaging.json.promotion.gate_assertions.event_mesh_ready, true, "messaging event mesh promotion gate missing");
+
+    const treasury = await getJson(baseUrl, "/v1/full-catalog/market-lanes/promotion/treasury_payments");
+    assert.strictEqual(treasury.status, 200, "market lane promotion treasury detail route failed");
+    assert.strictEqual(treasury.json.promotion.gate_assertions.settlement_family_ready, true, "treasury settlement-family promotion gate missing");
+
+    const promotionPack = buildMarketLanePromotionPack();
+    const validEvidence = {
+      market_class: "compute",
+      operator_evidence_ref: "ops.market_lane.compute.promotion.2026-04-24",
+      claim_boundary_ack: compute.json.promotion.claim_boundary,
+      gate_assertions: Object.fromEntries(compute.json.promotion.promotion_requirements.map((requirement) => [requirement, true])),
+      provider_live_anchor_ref: "ops.market_lane.compute.provider_anchor.2026-04-24",
+      trace_evidence_ref: "ops.market_lane.compute.trace.2026-04-24"
+    };
+    const validValidation = validateMarketLanePromotionEvidence(promotionPack, validEvidence);
+    assert.strictEqual(validValidation.promotion_allowed, true, "complete market lane promotion evidence should validate");
+
+    const invalidValidation = validateMarketLanePromotionEvidence(promotionPack, {
+      market_class: "compute",
+      operator_evidence_ref: "",
+      claim_boundary_ack: "",
+      gate_assertions: { auth_ready: true },
+      provider_live_anchor_ref: "",
+      trace_evidence_ref: "",
+      bearer_token: "bearer not-allowed"
+    });
+    assert.strictEqual(invalidValidation.promotion_allowed, false, "invalid market lane promotion evidence should be rejected");
+    assert.strictEqual(invalidValidation.rejection_codes.includes("operator_evidence_missing"), true, "missing operator evidence rejection missing");
+    assert.strictEqual(invalidValidation.rejection_codes.includes("claim_boundary_ack_missing"), true, "missing claim boundary rejection missing");
+    assert.strictEqual(invalidValidation.rejection_codes.includes("required_gate_assertion_missing"), true, "missing gate assertion rejection missing");
+    assert.strictEqual(invalidValidation.rejection_codes.includes("provider_anchor_evidence_missing"), true, "missing provider anchor rejection missing");
+    assert.strictEqual(invalidValidation.rejection_codes.includes("trace_evidence_missing"), true, "missing trace evidence rejection missing");
+    assert.strictEqual(invalidValidation.rejection_codes.includes("secret_material_forbidden"), true, "secret material rejection missing");
+
+    console.log("xytara verify:market-lane-promotion passed");
+  } finally {
+    await new Promise((resolve) => server.close(resolve));
+    if (previousExecutionTargets === undefined) delete process.env.XYTARA_EXECUTION_TARGETS_JSON;
+    else process.env.XYTARA_EXECUTION_TARGETS_JSON = previousExecutionTargets;
+  }
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});