codexgpt 1.0.0

package/scripts/test-domains.mjs

@@ -0,0 +1,247 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import fsp from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { createOwnedTempEnvironment } from "./owned-temp-root.mjs";
+import {
+  prepareTestPerformanceDirectory,
+  validateTestPerformanceReport,
+  verifyTestPerformanceDirectory
+} from "./test-performance-reporter.mjs";
+import {
+  buildTestExecutionShards,
+  validateTestExecutionPartition,
+  validateTestExecutionProfileInventory
+} from "./test-execution-profiles.mjs";
+
+export const SERIAL_PROCESS_TESTS = Object.freeze([
+  "operational-reliability.test.mjs",
+  "phase-7-repository-acceptance.test.mjs",
+  "runner-log-bounds.test.mjs",
+  "runner-process-identity.test.mjs",
+  "runner-stop-identity-windows-control.test.mjs",
+  "task-cleanup-lifecycle.test.mjs"
+]);
+
+export const CONTROL_DOMAIN_TESTS = Object.freeze([
+  "conpty-close-order-windows-control.test.mjs",
+  "git-execution-windows-control.test.mjs",
+  "handoff-to-agent-contract.test.mjs",
+  "handoff-to-codex-contract.test.mjs",
+  "local-control-pipe-windows-control.test.mjs",
+  "phase-3d-child-crash-oracle.test.mjs",
+  "phase-3d-multiprocess-lock.test.mjs",
+  "runner-stop-identity-windows-control.test.mjs",
+  "windows-sandbox-control.test.mjs",
+  "wait-for-handoff-contract.test.mjs",
+  "windows-process-host-integration-windows-control.test.mjs",
+  "run-command-windows-control.test.mjs",
+  "process-lifecycle-windows-control.test.mjs",
+  "persistent-process-production-windows-control.test.mjs",
+  "process-local-control-cli.test.mjs",
+  "windows-process-host-control.test.mjs",
+  "task-worktree-windows-locks.test.mjs",
+  "worktree-windows-control.test.mjs"
+]);
+
+const scriptDirectory = path.dirname(fileURLToPath(import.meta.url));
+const repositoryRoot = path.resolve(scriptDirectory, "..");
+const testDirectory = path.join(repositoryRoot, "test");
+const performanceReporter = path.join(scriptDirectory, "test-performance-reporter.mjs");
+const argv = process.argv.slice(2);
+const action = argv[0] ?? "list";
+
+function option(name, fallback) {
+  const index = argv.indexOf(name);
+  return index === -1 ? fallback : argv[index + 1];
+}
+
+function fail(message, code = 1) {
+  console.error(message);
+  process.exit(code);
+}
+
+export async function classifyTestDomains() {
+  const all = (await fsp.readdir(testDirectory, { withFileTypes: true }))
+    .filter((entry) => entry.isFile() && entry.name.endsWith(".test.mjs"))
+    .map((entry) => entry.name)
+    .sort();
+  const controlSet = new Set(CONTROL_DOMAIN_TESTS);
+  const missingControl = CONTROL_DOMAIN_TESTS.filter((name) => !all.includes(name));
+  if (missingControl.length > 0) {
+    throw new Error(`Configured control-domain tests are missing: ${missingControl.join(", ")}`);
+  }
+  return {
+    all,
+    ordinary: all.filter((name) => !controlSet.has(name)),
+    control: all.filter((name) => controlSet.has(name))
+  };
+}
+
+function localControlDomainApproved() {
+  return process.env.GITHUB_ACTIONS === "true" ||
+    process.env.CI_CONTROL_DOMAIN === "1" ||
+    process.env.CODEXGPT_ALLOW_CONTROL_DOMAIN_TESTS === "1";
+}
+
+function performanceReportPath(performanceDirectory, domain, shard) {
+  const nodeMajor = process.versions.node.split(".")[0];
+  if (process.env.GITHUB_ACTIONS === "true") {
+    return path.join(
+      performanceDirectory,
+      `test-performance-${domain}-${shard}-${process.platform}-node${nodeMajor}.json`
+    );
+  }
+  const timestamp = new Date().toISOString().replaceAll(":", "-").replaceAll(".", "-");
+  return path.join(
+    performanceDirectory,
+    `test-performance-${domain}-${shard}-${process.platform}-node${nodeMajor}-${timestamp}-${process.pid}.json`
+  );
+}
+
+async function runNodeTests(testNames, concurrency, environment, performanceState, shard) {
+  if (testNames.length === 0) return 0;
+  const nodeArgs = ["--test"];
+  if (concurrency) nodeArgs.push(`--test-concurrency=${concurrency}`);
+  let childEnvironment = environment;
+  let destination = null;
+  if (performanceState !== null) {
+    destination = performanceReportPath(performanceState.performance.path, domain, shard);
+    nodeArgs.push(
+      `--test-reporter=${process.stdout.isTTY ? "spec" : "tap"}`,
+      `--test-reporter=${pathToFileURL(performanceReporter).href}`,
+      "--test-reporter-destination=stdout",
+      `--test-reporter-destination=${destination}`
+    );
+    childEnvironment = {
+      ...environment,
+      CODEXGPT_TEST_PERFORMANCE_DOMAIN: domain,
+      CODEXGPT_TEST_PERFORMANCE_SHARD: shard
+    };
+    console.log(JSON.stringify({
+      schemaVersion: 1,
+      performanceReport: path.relative(repositoryRoot, destination).split(path.sep).join("/")
+    }));
+  }
+  nodeArgs.push(...testNames.map((name) => path.posix.join("test", name)));
+  const child = spawn(process.execPath, nodeArgs, {
+    cwd: repositoryRoot,
+    env: childEnvironment,
+    shell: false,
+    windowsHide: true,
+    stdio: "inherit"
+  });
+  let exitCode = await new Promise((resolve) => {
+    child.once("error", (error) => {
+      console.error(error.stack ?? error.message);
+      resolve(127);
+    });
+    child.once("close", (code) => resolve(code ?? 1));
+  });
+  if (performanceState !== null) {
+    try {
+      await verifyTestPerformanceDirectory(performanceState);
+      await validateTestPerformanceReport(destination, {
+        domain,
+        shard,
+        testNames,
+        architecture: process.arch
+      });
+    } catch (error) {
+      console.error(`Performance report validation failed: ${error?.message ?? "unknown"}`);
+      if (exitCode === 0) exitCode = 1;
+    }
+  }
+  return exitCode;
+}
+
+const domains = await classifyTestDomains();
+validateTestExecutionProfileInventory(domains.all, {
+  controlTests: CONTROL_DOMAIN_TESTS,
+  serialTests: SERIAL_PROCESS_TESTS
+});
+const domain = option("--domain", "ordinary");
+if (!Object.hasOwn(domains, domain)) fail("--domain must be ordinary, control, or all.", 2);
+
+if (action === "list") {
+  console.log(JSON.stringify({
+    schemaVersion: 1,
+    domain,
+    count: domains[domain].length,
+    tests: domains[domain]
+  }, null, 2));
+} else if (action === "run") {
+  if (domain === "control" && !localControlDomainApproved()) {
+    fail(
+      "Control-domain tests are blocked in connector-backed local execution. Run them in GitHub Actions, an independent native terminal, or set CODEXGPT_ALLOW_CONTROL_DOMAIN_TESTS=1 after proving process-domain isolation.",
+      2
+    );
+  }
+  if (domain === "all" && !localControlDomainApproved()) {
+    fail(
+      "The all domain contains connector-hostile control-domain tests. Use --domain ordinary locally; the complete all-domain suite remains authoritative in isolated CI.",
+      2
+    );
+  }
+
+  const requestedConcurrency = option("--test-concurrency", undefined);
+  const testTopology = option(
+    "--test-topology",
+    process.env.CODEXGPT_TEST_TOPOLOGY ?? "layered"
+  );
+  const performance = argv.includes("--performance");
+  const performanceState = performance ? await prepareTestPerformanceDirectory() : null;
+  let shards;
+  try {
+    shards = buildTestExecutionShards(domains[domain], {
+      platform: process.platform,
+      topology: testTopology,
+      requestedConcurrency,
+      controlTests: CONTROL_DOMAIN_TESTS,
+      serialTests: SERIAL_PROCESS_TESTS
+    });
+    validateTestExecutionPartition(domains[domain], shards);
+  } catch (error) {
+    fail(error?.message ?? "TEST_CLASSIFICATION_INVALID", 2);
+  }
+  console.log(JSON.stringify({
+    schemaVersion: 1,
+    domain,
+    count: domains[domain].length,
+    testTopology,
+    shards: shards.map((shard) => ({
+      name: shard.name,
+      count: shard.tests.length,
+      concurrency: shard.concurrency ?? "runtime-default"
+    })),
+    performance,
+    authority: domain === "ordinary" ? "local-non-control-domain" : "isolated-control-domain"
+  }));
+
+  const suiteTemp = await createOwnedTempEnvironment(`tests-${domain}`);
+  let exitCode = 1;
+  try {
+    exitCode = 0;
+    for (const shard of shards) {
+      if (exitCode !== 0) break;
+      exitCode = await runNodeTests(
+        shard.tests,
+        shard.concurrency,
+        suiteTemp.environment,
+        performanceState,
+        shard.name
+      );
+    }
+  } finally {
+    try {
+      await suiteTemp.cleanup();
+    } catch (error) {
+      console.error(`Owned test temporary state could not be removed: ${error?.code ?? error?.message ?? "unknown"}`);
+      if (exitCode === 0) exitCode = 1;
+    }
+  }
+  process.exitCode = exitCode;
+} else {
+  fail("Usage: node scripts/test-domains.mjs <list|run> [--domain ordinary|control|all] [--test-concurrency N] [--test-topology layered|legacy] [--performance]", 2);
+}

package/scripts/test-execution-profile-manifest.mjs

@@ -0,0 +1,273 @@
+function freezeNames(value) {
+  return Object.freeze(value.trim().split(/\s+/u));
+}
+
+export const WINDOWS_TEST_EXECUTION_PROFILES = Object.freeze({
+  fast: freezeNames(`
+analysis-smoke-entry.test.mjs
+apply-patch-contract.test.mjs
+apply-patch-transaction.test.mjs
+approval-display-safety.test.mjs
+atomic-file.test.mjs
+audit-architecture.test.mjs
+audit-config.test.mjs
+audit-lifecycle-v3.test.mjs
+audit-lock-release.test.mjs
+audit-query.test.mjs
+audit-recovery-retention.test.mjs
+audit-runtime-integration.test.mjs
+audit-schema.test.mjs
+audit-store.test.mjs
+audit-transaction-participant.test.mjs
+auth-documentation.test.mjs
+backend-discovery.test.mjs
+bash-contract.test.mjs
+bridge-writer-transaction.test.mjs
+change-set-schema-and-crypto.test.mjs
+change-set-store.test.mjs
+ci-workflow.test.mjs
+cli-hostname-propagation.test.mjs
+close-workspace-contract.test.mjs
+cloudflared-installer.test.mjs
+codex-context-contract.test.mjs
+codex-sessions-contract.test.mjs
+codexgpt-contract.test.mjs
+codexgpt-inventory-contract.test.mjs
+codexgpt-self-test-contract.test.mjs
+config-realpath.test.mjs
+confirmed-root-hard-links-windows.test.mjs
+edit-contract.test.mjs
+export-pro-context-contract.test.mjs
+full-access-contract.test.mjs
+full-access-lease.test.mjs
+full-access-paths-windows.test.mjs
+full-access-warning.test.mjs
+guidance-safe-text-reader-windows.test.mjs
+guidance-safe-text-reader.test.mjs
+inspect-workspace-contract.test.mjs
+instruction-discovery-windows.test.mjs
+instruction-discovery.test.mjs
+list-workspaces-contract.test.mjs
+load-skill-contract.test.mjs
+load-skill-no-execution.test.mjs
+load-skill-resource-windows.test.mjs
+load-skill-resource.test.mjs
+local-control-protocol.test.mjs
+native-host-architecture.test.mjs
+open-current-workspace-contract.test.mjs
+open-workspace-contract.test.mjs
+output-bounds.test.mjs
+owned-temp-root.test.mjs
+package-contents.test.mjs
+path-policy.test.mjs
+phase-4-authorization-facts.test.mjs
+phase-4-capabilities.test.mjs
+phase-4-contract-v3.test.mjs
+phase-4-policy-resources.test.mjs
+phase-4-v3-audit-persistence.test.mjs
+phase-4-v3-inherited-contract.test.mjs
+phase-4-v3-persistence.test.mjs
+phase-4a-adversarial.test.mjs
+phase-4a-smoke.test.mjs
+phase-5-adversarial-acceptance.test.mjs
+phase-5-contract-v4.test.mjs
+phase-5-v4-audit-persistence.test.mjs
+phase-5-v4-inherited-contract.test.mjs
+phase-5-v4-persistence.test.mjs
+phase-6-adversarial.test.mjs
+phase-6-compatibility-boundary.test.mjs
+phase-6-default-ux.test.mjs
+phase-6-diagnostics.test.mjs
+phase-6-integration.test.mjs
+phase-6-model-sequence.test.mjs
+phase-6-root-bootstrap.test.mjs
+phase-6-standard-projection.test.mjs
+phase-7-cached-app-migration.test.mjs
+phase-7-contract-v5.test.mjs
+phase-7-core-health.test.mjs
+phase-7-documentation.test.mjs
+phase-7-http-reconnect-preview.test.mjs
+phase-7-preview-lifecycle.test.mjs
+phase-7-rename-apply.test.mjs
+phase-7-rename-races.test.mjs
+phase-7-semantic-audit.test.mjs
+phase-7-semantic-cli.test.mjs
+phase-7-semantic-manager.test.mjs
+phase-7-semantic-routing.test.mjs
+phase-7-source-boundary.test.mjs
+phase-7-typescript-worker.test.mjs
+phase-7-v5-runtime-inheritance.test.mjs
+phase-8-auth-audit.test.mjs
+phase-8-auth-cli.test.mjs
+phase-8-auth-config.test.mjs
+phase-8-auth-doctor.test.mjs
+phase-8-auth-key-rotation.test.mjs
+phase-8-auth-lock.test.mjs
+phase-8-auth-migration.test.mjs
+phase-8-auth-recovery.test.mjs
+phase-8-auth-state.test.mjs
+phase-8-auth-ui.test.mjs
+phase-8-authorization.test.mjs
+phase-8-cloudflare-config.test.mjs
+phase-8-dcr.test.mjs
+phase-8-listener-separation.test.mjs
+phase-8-local-admin-session.test.mjs
+phase-8-mcp-auth-integration.test.mjs
+phase-8-oauth-bounds.test.mjs
+phase-8-oauth-metadata.test.mjs
+phase-8-owner-approval.test.mjs
+phase-8-owner-binding.test.mjs
+phase-8-plan-command-contract.test.mjs
+phase-8-policy-identity.test.mjs
+phase-8-public-health.test.mjs
+phase-8-refresh-revoke.test.mjs
+phase-8-request-context.test.mjs
+phase-8-scope-enforcement.test.mjs
+phase-8-sdk-auth-contract.test.mjs
+phase-8-token-exchange.test.mjs
+phase-8-token-validation.test.mjs
+phase-8-tool-security-metadata.test.mjs
+policy-approval.test.mjs
+policy-compat.test.mjs
+policy-enforcement-audit.test.mjs
+policy-evaluator.test.mjs
+policy-grant-consumption.test.mjs
+policy-identity-context.test.mjs
+policy-integration.test.mjs
+policy-pending-approval.test.mjs
+policy-profile-store.test.mjs
+policy-resources.test.mjs
+policy-schema.test.mjs
+policy-transport.test.mjs
+policy-v3-approval-integration.test.mjs
+policy-windows-spike.test.mjs
+pro-apply-transaction.test.mjs
+process-conpty-contract.test.mjs
+process-manager.test.mjs
+process-output-cursor.test.mjs
+process-output-quota.test.mjs
+process-output-ring.test.mjs
+production-runtime-integration.test.mjs
+public-cli-help.test.mjs
+read-codex-session-contract.test.mjs
+read-contract.test.mjs
+read-handoff-contract.test.mjs
+run-command-contract.test.mjs
+search-contract.test.mjs
+server-config-contract.test.mjs
+show-changes-contract.test.mjs
+skill-catalog-budget.test.mjs
+skill-discovery-target.test.mjs
+skill-frontmatter.test.mjs
+skill-global-privacy.test.mjs
+skill-invocation-policy.test.mjs
+streaming-redaction.test.mjs
+test-domain-classification.test.mjs
+test-execution-profiles.test.mjs
+test-performance-reporter.test.mjs
+tree-contract.test.mjs
+undo-change-set.test.mjs
+verification-run-command-integration.test.mjs
+windows-process-host-protocol.test.mjs
+windows-sandbox-capability.test.mjs
+workspace-lifecycle.test.mjs
+workspace-snapshot-contract.test.mjs
+worktree-materializer.test.mjs
+worktree-root.test.mjs
+write-contract.test.mjs
+write-edit-transaction.test.mjs
+  `),
+  safe: freezeNames(`
+git-branch-v4.test.mjs
+git-commit-v4.test.mjs
+git-diff-contract.test.mjs
+git-durable-review-plan.test.mjs
+git-execution-capsule.test.mjs
+git-integrations-approval.test.mjs
+git-integrations-full-access.test.mjs
+git-integrations-worktree.test.mjs
+git-locks.test.mjs
+git-mutation-journal.test.mjs
+git-mutation-races.test.mjs
+git-object-quarantine.test.mjs
+git-operation-store.test.mjs
+git-policy-resources.test.mjs
+git-porcelain-parsers.test.mjs
+git-production-bootstrap-wiring.test.mjs
+git-recovery.test.mjs
+git-repository-identity.test.mjs
+git-repository-store.test.mjs
+git-restore-v4.test.mjs
+git-secret-boundary.test.mjs
+git-sha256-v4.test.mjs
+git-stage-v4.test.mjs
+git-stash-v4.test.mjs
+git-status-contract.test.mjs
+git-unsupported-formats-v4.test.mjs
+git-v4-fixture-performance.test.mjs
+git-v4-read-tools.test.mjs
+mutation-architecture.test.mjs
+mutation-runtime.test.mjs
+persistent-verification-receipt.test.mjs
+phase-3d-contract-and-config.test.mjs
+phase-3d-move-changeset-store.test.mjs
+phase-3d-move-engine.test.mjs
+phase-3d-move-planner-and-manifest.test.mjs
+phase-3d-move-service.test.mjs
+phase-3d-move-undo.test.mjs
+phase-3d-participant-and-move-recovery.test.mjs
+task-worktree-candidate-verification.test.mjs
+task-worktree-lifecycle.test.mjs
+task-worktree-merge-execute.test.mjs
+task-worktree-merge-prepare.test.mjs
+task-worktree-remove.test.mjs
+task-worktree-store.test.mjs
+task-worktree-workspace-integration.test.mjs
+transaction-architecture.test.mjs
+transaction-atomic-fs.test.mjs
+transaction-config-and-path-policy.test.mjs
+transaction-contract-version.test.mjs
+transaction-crash-recovery.test.mjs
+transaction-engine.test.mjs
+transaction-installation-state.test.mjs
+transaction-manifest-store.test.mjs
+transaction-recovery.test.mjs
+transaction-schema.test.mjs
+transaction-workspace-lock.test.mjs
+verification-receipts.test.mjs
+  `),
+  isolated: freezeNames(`
+approval-multi-server.test.mjs
+cli-approvals.test.mjs
+connector-auth-output.test.mjs
+conpty-close-order-windows-control.test.mjs
+doctor-shell.test.mjs
+git-execution-windows-control.test.mjs
+handoff-to-agent-contract.test.mjs
+handoff-to-codex-contract.test.mjs
+http-security.test.mjs
+local-control-pipe-windows-control.test.mjs
+operational-reliability.test.mjs
+persistent-process-production-windows-control.test.mjs
+phase-3d-child-crash-oracle.test.mjs
+phase-3d-multiprocess-lock.test.mjs
+phase-4a-integration.test.mjs
+phase-6-transport-parity.test.mjs
+phase-7-repository-acceptance.test.mjs
+phase-8-listener-runtime.test.mjs
+process-lifecycle-windows-control.test.mjs
+process-local-control-cli.test.mjs
+run-command-windows-control.test.mjs
+runner-log-bounds.test.mjs
+runner-process-identity.test.mjs
+runner-stop-identity-windows-control.test.mjs
+task-cleanup-lifecycle.test.mjs
+task-worktree-windows-locks.test.mjs
+wait-for-handoff-contract.test.mjs
+phase-8-windows-dpapi.test.mjs
+windows-process-host-control.test.mjs
+windows-process-host-integration-windows-control.test.mjs
+windows-sandbox-control.test.mjs
+worktree-windows-control.test.mjs
+  `)
+});

package/scripts/test-execution-profiles.mjs

@@ -0,0 +1,147 @@
+import { WINDOWS_TEST_EXECUTION_PROFILES } from "./test-execution-profile-manifest.mjs";
+
+export const WINDOWS_ADDITIONAL_ISOLATED_TESTS = Object.freeze([
+  "approval-multi-server.test.mjs",
+  "cli-approvals.test.mjs",
+  "connector-auth-output.test.mjs",
+  "doctor-shell.test.mjs",
+  "http-security.test.mjs",
+  "phase-4a-integration.test.mjs",
+  "phase-6-transport-parity.test.mjs"
+]);
+
+const PROFILE_BY_TEST = new Map();
+for (const [profile, names] of Object.entries(WINDOWS_TEST_EXECUTION_PROFILES)) {
+  for (const name of names) {
+    if (PROFILE_BY_TEST.has(name)) throw new Error(`TEST_PROFILE_DUPLICATE:${name}`);
+    PROFILE_BY_TEST.set(name, profile);
+  }
+}
+
+function validateInputs(testNames, options) {
+  if (!Array.isArray(testNames) || testNames.some((name) => typeof name !== "string")) {
+    throw new Error("TEST_CLASSIFICATION_INVALID");
+  }
+  if (new Set(testNames).size !== testNames.length) throw new Error("TEST_CLASSIFICATION_INVALID");
+  if (!["layered", "legacy"].includes(options.topology)) throw new Error("TEST_TOPOLOGY_INVALID");
+  if (
+    options.requestedConcurrency !== undefined &&
+    !/^[1-9][0-9]*$/u.test(options.requestedConcurrency)
+  ) {
+    throw new Error("TEST_CONCURRENCY_INVALID");
+  }
+  if (Number(options.requestedConcurrency ?? 1) > 64) throw new Error("TEST_CONCURRENCY_INVALID");
+  for (const list of [options.controlTests, options.serialTests]) {
+    if (!Array.isArray(list) || list.some((name) => typeof name !== "string")) {
+      throw new Error("TEST_CLASSIFICATION_INVALID");
+    }
+  }
+}
+
+function sortedUnique(values) {
+  return [...new Set(values)].sort();
+}
+
+export function validateTestExecutionProfileInventory(testNames, options) {
+  if (!Array.isArray(testNames) || testNames.some((name) => typeof name !== "string")) {
+    throw new Error("TEST_PROFILE_INVENTORY_DRIFT");
+  }
+  const actual = sortedUnique(testNames);
+  const reviewed = [...PROFILE_BY_TEST.keys()].sort();
+  const unknown = actual.filter((name) => !PROFILE_BY_TEST.has(name));
+  const missing = reviewed.filter((name) => !actual.includes(name));
+  const configured = [
+    ...options.controlTests,
+    ...options.serialTests,
+    ...WINDOWS_ADDITIONAL_ISOLATED_TESTS
+  ];
+  const missingConfigured = configured.filter((name) => !actual.includes(name));
+  const nonIsolatedConfigured = configured.filter((name) => PROFILE_BY_TEST.get(name) !== "isolated");
+  if (
+    actual.length !== testNames.length ||
+    unknown.length > 0 ||
+    missing.length > 0 ||
+    missingConfigured.length > 0 ||
+    nonIsolatedConfigured.length > 0
+  ) {
+    throw new Error([
+      "TEST_PROFILE_INVENTORY_DRIFT",
+      `unknown=${unknown.join(",") || "none"}`,
+      `missing=${missing.join(",") || "none"}`,
+      `missing_configured=${missingConfigured.join(",") || "none"}`,
+      `non_isolated_configured=${nonIsolatedConfigured.join(",") || "none"}`
+    ].join(":"));
+  }
+}
+
+export function validateTestExecutionPartition(testNames, shards) {
+  if (!Array.isArray(shards) || shards.some((shard) => !Array.isArray(shard?.tests))) {
+    throw new Error("TEST_EXECUTION_PARTITION_INVALID");
+  }
+  const flattened = shards.flatMap((shard) => shard.tests);
+  if (
+    flattened.length !== testNames.length ||
+    new Set(flattened).size !== flattened.length ||
+    JSON.stringify([...flattened].sort()) !== JSON.stringify([...testNames].sort())
+  ) {
+    throw new Error("TEST_EXECUTION_PARTITION_INVALID");
+  }
+}
+
+export function buildTestExecutionShards(testNames, options) {
+  validateInputs(testNames, options);
+  const tests = [...testNames];
+  if (options.platform === "win32" && options.topology === "legacy") {
+    if (options.requestedConcurrency !== undefined && options.requestedConcurrency !== "1") {
+      throw new Error("TEST_CONCURRENCY_INVALID");
+    }
+    return [{
+      name: "main",
+      concurrency: "1",
+      tests
+    }];
+  }
+
+  const serial = new Set(options.serialTests);
+  if (options.platform !== "win32") {
+    if (options.requestedConcurrency === "1") {
+      return [{ name: "main", concurrency: "1", tests }];
+    }
+    return [
+      {
+        name: "main",
+        concurrency: options.requestedConcurrency,
+        tests: tests.filter((name) => !serial.has(name))
+      },
+      {
+        name: "serial",
+        concurrency: "1",
+        tests: tests.filter((name) => serial.has(name))
+      }
+    ];
+  }
+
+  if (options.requestedConcurrency === "1") {
+    return [{ name: "main", concurrency: "1", tests }];
+  }
+  for (const name of tests) {
+    if (!PROFILE_BY_TEST.has(name)) throw new Error(`TEST_PROFILE_INVENTORY_DRIFT:unknown=${name}`);
+  }
+  return [
+    {
+      name: "fast",
+      concurrency: options.requestedConcurrency ?? "4",
+      tests: tests.filter((name) => PROFILE_BY_TEST.get(name) === "fast")
+    },
+    {
+      name: "safe",
+      concurrency: "2",
+      tests: tests.filter((name) => PROFILE_BY_TEST.get(name) === "safe")
+    },
+    {
+      name: "isolated",
+      concurrency: "1",
+      tests: tests.filter((name) => PROFILE_BY_TEST.get(name) === "isolated")
+    }
+  ];
+}