test(perf): add Employment separation buyer-path workload

tests/performance/employment_separation_acceptance_cardinality.test.mjs

@@ -0,0 +1,116 @@
+import assert from "node:assert/strict";
+import { createHash } from "node:crypto";
+import test from "node:test";
+
+import { validateEmploymentSeparationAcceptance } from "./employment_separation_acceptance_contract.mjs";
+import {
+  acceptanceFixtureBytes,
+  acceptanceFixtureSha256,
+  acceptanceLoadModel,
+} from "./employment_separation_acceptance_fixture_test_support.mjs";
+
+const PROFILE_PRECONDITIONS = Object.freeze({
+  first_commit: "active_current_expected_version",
+  replay: "same_key_same_semantics_already_committed",
+  rejection: "expected_version_stale_or_semantic_conflict",
+  contention: "active_current_expected_version",
+});
+const FIXTURE_BYTES = acceptanceFixtureBytes();
+const FIXTURE_SHA256 = acceptanceFixtureSha256(FIXTURE_BYTES);
+
+function performanceResult(profile, iterations) {
+  const trendName = profile === "contention"
+    ? "employment_separation_contention_duration_ms"
+    : "employment_separation_first_commit_duration_ms";
+  const latencySamples = profile === "contention" ? iterations * 2 : iterations;
+  return {
+    schema_version: "orgmetra.employment_separation.performance_result.v1",
+    candidate_sha: "a".repeat(40),
+    fixture_sha256: FIXTURE_SHA256,
+    selected_profile: profile,
+    expected_iterations: iterations,
+    completed_iterations: iterations,
+    sample_complete: true,
+    completed_at: "2026-09-13T04:10:00Z",
+    load_model: acceptanceLoadModel(iterations),
+    dataset_id: "dataset:employment-separation-perf-1",
+    clearance_reference: "data_clearance:perf-2026-09",
+    preparation_protocol_reference: "protocol:employment-separation-perf-v1",
+    prepared_state_evidence_reference: "evidence:prepared-state-perf-1",
+    resource_evidence_reference: "metrics:employment-separation-perf-1",
+    profile_preconditions: { ...PROFILE_PRECONDITIONS },
+    minimum_non_contending_records: 1000,
+    minimum_contention_pairs: 100,
+    k6: {
+      metrics: {
+        iterations: { values: { count: iterations } },
+        checks: { values: { rate: 1, passes: iterations, fails: 0 } },
+        employment_separation_unexpected_response: { values: { rate: 0, passes: 0, fails: iterations } },
+        employment_separation_latency_samples: { values: { count: latencySamples } },
+        [trendName]: {
+          values: profile === "contention"
+            ? { "p(50)": 12, "p(95)": 80, "p(99)": 120, max: 200, count: latencySamples }
+            : { "p(50)": 8.1, "p(95)": 18.4, "p(99)": 19.7, max: 22.3, count: latencySamples },
+        },
+      },
+    },
+  };
+}
+
+function runtimeEvidence(resultArtifact, profile, iterations) {
+  return {
+    schema_version: "orgmetra.employment_separation.runtime_evidence.v1",
+    candidate_sha: "a".repeat(40),
+    observed_service_sha: "a".repeat(40),
+    selected_profile: profile,
+    performance_result_sha256: createHash("sha256").update(resultArtifact).digest("hex"),
+    fixture_sha256: FIXTURE_SHA256,
+    environment_reference: "environment:perf-staging-1",
+    deployment_reference: "deployment:orgmetra-people-a1",
+    observer_reference: "observer:perf-runtime-1",
+    load_observation_reference: "evidence:perf-load-observation-1",
+    observed_load_model: acceptanceLoadModel(iterations),
+    resource_evidence_reference: "metrics:employment-separation-perf-1",
+    observed_at: "2026-09-13T04:10:01Z",
+    host_cpu_percent_p95: 42.5,
+    host_rss_bytes_max: 536870912,
+    db_pool_acquire_p95_ms: 1.2,
+    db_pool_in_use_max: 18,
+    db_pool_waiters_max: 2,
+    db_connections_max: 20,
+    residual_http_tasks: 0,
+    residual_db_sessions: 0,
+    residual_open_transactions: 0,
+    residual_sockets: 0,
+    residual_background_workers: 0,
+    residual_pool_checkouts: 0,
+    residual_pool_waiters: 0,
+  };
+}
+
+function assertRejected(result, pattern) {
+  const artifact = Buffer.from(`${JSON.stringify(result, null, 2)}\n`, "utf8");
+  assert.throws(
+    () => validateEmploymentSeparationAcceptance(
+      artifact,
+      runtimeEvidence(artifact, result.selected_profile, result.expected_iterations),
+      FIXTURE_BYTES,
+    ),
+    pattern,
+  );
+}
+
+test("requires at least 1000 ordinary buyer-path iterations", () => {
+  assertRejected(performanceResult("first_commit", 1), /at least 1000 iterations/);
+});
+
+test("requires at least 100 contention pairs", () => {
+  assertRejected(performanceResult("contention", 99), /at least 100 iterations/);
+});
+
+test("requires fixed cardinality declarations in the result artifact", () => {
+  const result = performanceResult("first_commit", 1000);
+  result.minimum_non_contending_records = 1;
+  result.minimum_contention_pairs = 1;
+  assertRejected(result, /minimum_non_contending_records must equal 1000/);
+});

tests/performance/employment_separation_acceptance_check.mjs

@@ -0,0 +1,44 @@
+import { readFile } from "node:fs/promises";
+
+import { validateEmploymentSeparationAcceptance } from "./employment_separation_acceptance_contract.mjs";
+import { requireCommercialPerformanceAuthorities } from "./employment_separation_commercial_owner_gate.mjs";
+import { validatePinnedK6AcceptanceEvidence } from "./employment_separation_k6_evidence_contract.mjs";
+import { parseRuntimeEvidenceArtifact } from "./employment_separation_runtime_evidence_artifact.mjs";
+
+async function main() {
+  // Byte/provenance attestation and deployed-candidate identity are separate
+  // trust boundaries. Surface every unresolved owner gap before touching caller
+  // paths so resolving one authority cannot accidentally enable acceptance while
+  // the other remains self-asserted.
+  requireCommercialPerformanceAuthorities();
+
+  const [resultPath, runtimeEvidencePath, fixturePath] = process.argv.slice(2);
+  if (!resultPath || !runtimeEvidencePath || !fixturePath || process.argv.length !== 5) {
+    throw new Error("usage: node employment_separation_acceptance_check.mjs <performance-result.json> <runtime-evidence.json> <performance-fixture.json>");
+  }
+  const [resultBytes, runtimeBytes, fixtureBytes] = await Promise.all([
+    readFile(resultPath),
+    readFile(runtimeEvidencePath),
+    readFile(fixturePath),
+  ]);
+  const runtimeDocument = parseRuntimeEvidenceArtifact(runtimeBytes);
+  const evidenceContract = validateEmploymentSeparationAcceptance(
+    resultBytes,
+    runtimeDocument.parsed,
+    fixtureBytes,
+  );
+  // Structural validation owns the bounded/strict result parser. Run it before
+  // this secondary pinned-runtime interpretation so duplicate members, nesting
+  // abuse, and oversized result artifacts cannot reach ordinary JSON.parse first.
+  const k6Evidence = validatePinnedK6AcceptanceEvidence(resultBytes, runtimeDocument.parsed);
+  process.stdout.write(`${JSON.stringify({
+    ...evidenceContract,
+    ...k6Evidence,
+    runtime_evidence_sha256: runtimeDocument.sha256,
+  }, null, 2)}\n`);
+}
+
+main().catch((error) => {
+  process.stderr.write(`${error.message}\n`);
+  process.exitCode = 1;
+});

tests/performance/employment_separation_acceptance_cli_digest.test.mjs

@@ -0,0 +1,34 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import test from "node:test";
+
+const acceptanceCheck = fileURLToPath(new URL("./employment_separation_acceptance_check.mjs", import.meta.url));
+
+const PERFORMANCE_ATTESTATION_GAP_PATTERN = /authenticated performance-evidence attestation.*ContextualWisdomLab\/.github#2162/;
+const DEPLOYMENT_IDENTITY_GAP_PATTERN = /authenticated deployed-candidate evidence.*ContextualWisdomLab\/Orgmetra#395/;
+
+function assertCommercialOwnerGaps(stderr) {
+  assert.match(stderr, PERFORMANCE_ATTESTATION_GAP_PATTERN);
+  assert.match(stderr, DEPLOYMENT_IDENTITY_GAP_PATTERN);
+}
+
+test("commercial acceptance fails closed before trusting a caller-supplied result digest", () => {
+  const result = spawnSync(
+    process.execPath,
+    [acceptanceCheck, "result.json", "runtime.json", "fixture.json", "a".repeat(64)],
+    { encoding: "utf8" },
+  );
+  assert.notEqual(result.status, 0);
+  assertCommercialOwnerGaps(result.stderr);
+});
+
+test("commercial acceptance cannot be restored by substituting both result bytes and digest locally", () => {
+  const result = spawnSync(
+    process.execPath,
+    [acceptanceCheck, "substituted-result.json", "substituted-runtime.json", "fixture.json", "b".repeat(64)],
+    { encoding: "utf8" },
+  );
+  assert.notEqual(result.status, 0);
+  assertCommercialOwnerGaps(result.stderr);
+});