@prismatic-io/lux 0.0.2-preview.18 → 0.0.2-preview.21

package/src/index.ts

@@ -258,9 +258,11 @@ export {
   type DriverRuntime,
   defineDriver,
   driverRef,
+  type HarnessSelection,
   type ResolvedFixtures,
   ResolvedFixturesSchema,
   type StartContext,
+  selectModelAndReasoningEffort,
 } from "./core/driver.js";
 export {
   type DriverMetric,
@@ -344,6 +346,38 @@ export {
   type OptimizerInput,
 } from "./core/experiment.js";
 export { type GlobalIdParts, tryParseGlobalId } from "./core/global-id.js";
+export {
+  type CatalogModels,
+  catalogEfforts,
+  defaultCatalogEffort,
+  defineHarnessCatalog,
+  HARNESS_EFFORTS,
+  type HarnessCatalog,
+  type ReasoningEffort,
+  ReasoningEffortSchema,
+} from "./core/harness-catalog.js";
+export {
+  antigravityCatalog,
+  type BuiltInHarnessDriver,
+  builtInHarnessCatalogs,
+  claudeCodeCatalog,
+  codexCatalog,
+  copilotCatalog,
+  cursorCatalog,
+  harnessCatalogFor,
+} from "./core/harness-catalogs/index.js";
+export {
+  type BuiltInHarnessMatrixEntry,
+  BuiltInHarnessMatrixEntrySchema,
+  type CustomHarnessMatrixEntry,
+  expandHarnessMatrix,
+  type HarnessMatrix,
+  type HarnessMatrixEntry,
+  HarnessMatrixEntrySchema,
+  HarnessMatrixSchema,
+  type HarnessPermutation,
+  permutationId,
+} from "./core/harness-matrix.js";
 export {
   defineFixtures,
   type LifecycleFixture,
@@ -379,14 +413,11 @@ export {
 export {
   DEFAULT_CLAUDE_MODEL,
   DEFAULT_CODEX_MODEL,
-  DEFAULT_CODEX_REASONING_EFFORT,
   defaultHarnessModel,
   type HarnessModelConfig,
   HarnessModelConfigSchema,
   type ModelCliProvider,
   ModelCliProviderSchema,
-  type ReasoningEffort,
-  ReasoningEffortSchema,
 } from "./core/model-cli.js";
 export {
   type AssertionProgress,
@@ -472,6 +503,11 @@ export {
   type WireEvent,
   WireEventSchema,
 } from "./core/wire.js";
+export {
+  type AntigravityDriverConfig,
+  AntigravityDriverConfigSchema,
+  antigravityDriver,
+} from "./drivers/antigravity/index.js";
 export {
   type ClaudeCodeDriverConfig,
   ClaudeCodeDriverConfigSchema,
@@ -482,6 +518,11 @@ export {
   CodexDriverConfigSchema,
   codexDriver,
 } from "./drivers/codex/index.js";
+export {
+  type CopilotDriverConfig,
+  CopilotDriverConfigSchema,
+  copilotDriver,
+} from "./drivers/copilot/index.js";
 export {
   type CursorDriverConfig,
   CursorDriverConfigSchema,

package/src/orchestrator/comparison-identity.ts

@@ -36,6 +36,7 @@ export const runComparisonIdentity = (metadata: RunMetadata): string =>
     assertionsHash: metadata.provenance?.assertionsHash,
     fixturesHash: metadata.provenance?.fixturesHash,
     profileId: metadata.provenance?.profileId,
+    permutationId: metadata.provenance?.permutationId,
     driverConfigHash: metadata.provenance?.driverConfigHash,
     answererConfigHash: metadata.provenance?.answererConfigHash,
     evaluatorConfigHash: metadata.provenance?.evaluatorConfigHash,

package/src/orchestrator/config.ts

@@ -18,13 +18,16 @@ import {
   type DriverPlugin,
   DriverRefSchema,
   formatZodIssues,
+  HarnessMatrixSchema,
   HarnessModelConfigSchema,
   type LifecycleHooksPlugin,
   lifecycleHooksPluginIssue,
   Registry,
 } from "../core/index.js";
+import { antigravityDriver } from "../drivers/antigravity/index.js";
 import { claudeCodeDriver } from "../drivers/claude-code/index.js";
 import { codexDriver } from "../drivers/codex/index.js";
+import { copilotDriver } from "../drivers/copilot/index.js";
 import { cursorDriver } from "../drivers/cursor/index.js";
 import { mcpProbeDriver } from "../drivers/mcp/index.js";
 import { subprocessDriver } from "../drivers/subprocess/index.js";
@@ -80,6 +83,8 @@ const LuxConfigSchema = z
     subjectRoot: z.string().optional(),
     defaultAnswerer: AnswererRefSchema.default("persona"),
     defaultDriver: DriverRefSchema.optional(),
+    /** Driver, model, and effort permutations every case runs through by default. */
+    matrix: HarnessMatrixSchema.optional(),
     /** Shared provider/model defaults for persona answering and rubric judging. */
     harness: HarnessModelConfigSchema.optional(),
     concurrency: z.number().int().min(1).default(1),
@@ -166,6 +171,7 @@ export const loadLuxConfig = async (cwd: string = process.cwd()): Promise<Resolv
     ...(validated.fixturesRoot ? { fixturesRoot: resolve(root, validated.fixturesRoot) } : {}),
     defaultAnswerer: validated.defaultAnswerer,
     ...(validated.defaultDriver ? { defaultDriver: validated.defaultDriver } : {}),
+    ...(validated.matrix ? { matrix: validated.matrix } : {}),
     ...(validated.harness ? { harness: validated.harness } : {}),
     concurrency: validated.concurrency,
     ...(validated.environment ? { environment: validated.environment } : {}),
@@ -181,6 +187,8 @@ const builtinDrivers: DriverPlugin<never>[] = [
   claudeCodeDriver,
   codexDriver,
   cursorDriver,
+  copilotDriver,
+  antigravityDriver,
   subprocessDriver,
   mcpProbeDriver,
 ];

package/src/orchestrator/doctor.ts

@@ -4,7 +4,15 @@ import { resolve } from "node:path";
 import { glob } from "tinyglobby";
 import { z } from "zod";
 import { RubricConfigSchema } from "../assertions/rubric/index.js";
-import type { EvalCase, Registry } from "../core/index.js";
+import {
+  casePermutations,
+  type EvalCase,
+  expandHarnessMatrix,
+  type HarnessPermutation,
+  permutationDriverRef,
+  permutationId,
+  type Registry,
+} from "../core/index.js";
 import { registryForEvalCase } from "./case-extensions.js";
 import { buildRegistryFromConfig, loadLuxConfig, type ResolvedLuxConfig } from "./config.js";
 import { type DiscoveredCase, type DiscoveryResult, discoverCases } from "./discover.js";
@@ -17,6 +25,12 @@ import {
 } from "./experiment-loader.js";
 import { cliIdentity } from "./experiment-runtime-identity.js";
 import { assertionConfigForSchema } from "./grading.js";
+import {
+  describeHarnessCatalogDrift,
+  harnessCatalogDrift,
+  harnessCatalogProbes,
+  hasHarnessCatalogDrift,
+} from "./harness-catalog-drift.js";
 import { loadEvalCase } from "./loader.js";
 import { validatePluginConfig, validatePluginConfigAsync } from "./validate-plugin-config.js";
 
@@ -132,7 +146,28 @@ const effectiveDriverReference = (local: unknown, fallback: unknown): unknown =>
   };
 };
 
-const caseDriverReferences = (local: unknown, config: ResolvedLuxConfig): unknown[] => {
+const boundPermutation = (
+  permutation: HarnessPermutation,
+  config: ResolvedLuxConfig,
+  registry: Registry,
+): unknown => {
+  const plugin = registry.getDriver(permutation.driver);
+  if (!plugin) throw new Error(`unknown driver '${permutation.driver}'`);
+  return permutationDriverRef(permutation, config.defaultDriver, plugin);
+};
+
+const caseDriverReferences = (
+  authored: Pick<EvalCase, "driver" | "matrix">,
+  config: ResolvedLuxConfig,
+  registry: Registry,
+): unknown[] => {
+  const local = authored.driver;
+  const permutations = casePermutations(authored, config.matrix);
+  if (permutations.length > 0) {
+    return permutations.map((permutation) =>
+      effectiveDriverReference(local, boundPermutation(permutation, config, registry)),
+    );
+  }
   const fallbacks = [
     config.defaultDriver,
     ...Object.values(config.profiles ?? {}).map((profile) => profile.driver),
@@ -192,6 +227,17 @@ const configuredCliTargets = (config: ResolvedLuxConfig, registry: Registry): Cl
   };
   for (const command of driverCommands(config.defaultDriver, registry))
     add("default driver", command);
+  for (const permutation of expandHarnessMatrix(config.matrix ?? [])) {
+    try {
+      for (const command of driverCommands(
+        boundPermutation(permutation, config, registry),
+        registry,
+      ))
+        add(`matrix '${permutationId(permutation)}' driver`, command);
+    } catch {
+      /* Reported by validateConfiguredMatrix. */
+    }
+  }
   add("default answerer", answererCommand(config.defaultAnswerer));
   if (config.harness) {
     add(
@@ -357,6 +403,32 @@ const validateConfiguredDrivers = (
   }
 };
 
+const validateConfiguredMatrix = (
+  config: ResolvedLuxConfig,
+  registry: Registry,
+  recorder: DoctorRecorder,
+): void => {
+  for (const permutation of expandHarnessMatrix(config.matrix ?? [])) {
+    const id = permutationId(permutation);
+    try {
+      const reference = boundPermutation(permutation, config, registry);
+      const plugin = registry.getDriver(permutation.driver);
+      validatePluginConfig(
+        plugin?.configSchema,
+        rawRefConfig(reference),
+        `matrix '${id}' driver '${permutation.driver}'`,
+      );
+    } catch (error) {
+      recorder.add(
+        `matrix:${id}`,
+        "fail",
+        `matrix permutation '${id}' is not runnable`,
+        firstLine(error),
+      );
+    }
+  }
+};
+
 const validateConfiguredAnswerers = (
   config: ResolvedLuxConfig,
   registry: Registry,
@@ -576,7 +648,7 @@ const inspectCase = async (
   try {
     const authored = await loadEvalCase(discovered.path);
     const caseRegistry = registryForEvalCase(registry, authored);
-    const drivers = caseDriverReferences(authored.driver, config);
+    const drivers = caseDriverReferences(authored, config, caseRegistry);
     const answerer = authored.answerer ?? config.defaultAnswerer;
     validateCaseDrivers(discovered.id, drivers, caseRegistry, recorder, authored.requires);
     validateCaseAnswerer(discovered.id, answerer, caseRegistry, recorder);
@@ -659,6 +731,54 @@ const inspectCliTargets = async (
   }
 };
 
+const catalogDriverReferences = (config: ResolvedLuxConfig): unknown[] => [
+  ...configuredDriverReferences(config).map(([, reference]) => reference),
+  ...(config.matrix ?? []).map((entry) => ({ name: entry.driver, config: entry.config })),
+];
+
+const configuredDriverCommand = (config: ResolvedLuxConfig, driver: string): string | undefined => {
+  for (const reference of catalogDriverReferences(config)) {
+    if (refName(reference) !== driver) continue;
+    const command = (rawRefConfig(reference) as { command?: unknown } | undefined)?.command;
+    if (typeof command === "string") return command;
+  }
+  return undefined;
+};
+
+const inspectHarnessCatalogs = async (
+  config: ResolvedLuxConfig,
+  recorder: DoctorRecorder,
+): Promise<void> => {
+  const configured = new Set(
+    catalogDriverReferences(config)
+      .map(refName)
+      .filter((name): name is string => name !== undefined),
+  );
+  for (const probe of harnessCatalogProbes) {
+    const driver = probe.catalog.driver;
+    if (!configured.has(driver)) continue;
+    const live = await probe.read(configuredDriverCommand(config, driver));
+    if (!live) {
+      recorder.add(
+        `catalog:${driver}`,
+        "warn",
+        `${driver} harness catalog (verified ${probe.catalog.verified}) could not be compared with the installed CLI`,
+        `${probe.source} was unavailable`,
+      );
+      continue;
+    }
+    const drift = harnessCatalogDrift(probe.catalog, live);
+    recorder.add(
+      `catalog:${driver}`,
+      hasHarnessCatalogDrift(drift) ? "warn" : "pass",
+      hasHarnessCatalogDrift(drift)
+        ? `${driver} harness catalog (verified ${probe.catalog.verified}) differs from the installed CLI`
+        : `${driver} harness catalog matches the installed CLI`,
+      describeHarnessCatalogDrift(drift) || undefined,
+    );
+  }
+};
+
 const isBlockingCampaignWarning = (warning: string): boolean =>
   warning.includes("below confidence minSamples=") || warning.includes("cannot attain confidence");
 
@@ -752,6 +872,7 @@ export const doctorProject = async (options: DoctorOptions): Promise<DoctorRepor
   if (!registry) return recorder.finish(config.rootDir);
 
   validateConfiguredDrivers(config, registry, recorder);
+  validateConfiguredMatrix(config, registry, recorder);
   validateConfiguredAnswerers(config, registry, recorder);
   const caseCliTargets = await inspectCases(config, registry, recorder);
   if (parsedOptions.static) {
@@ -766,6 +887,7 @@ export const doctorProject = async (options: DoctorOptions): Promise<DoctorRepor
       config,
       recorder,
     );
+    await inspectHarnessCatalogs(config, recorder);
   }
   await inspectCampaigns(
     parsedOptions.campaigns ?? [],

package/src/orchestrator/harness-catalog-drift.ts

@@ -0,0 +1,132 @@
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+import {
+  type ClosedHarnessCatalog,
+  codexCatalog,
+  copilotCatalog,
+  exec,
+  type ReasoningEffort,
+  tryParseJson,
+} from "../core/index.js";
+
+export type LiveHarnessModel = {
+  id: string;
+  efforts?: readonly ReasoningEffort[] | undefined;
+};
+
+export type HarnessCatalogDrift = {
+  unlisted: string[];
+  mismatched: string[];
+  unavailable: string[];
+};
+
+export const harnessCatalogDrift = (
+  catalog: ClosedHarnessCatalog,
+  live: readonly LiveHarnessModel[],
+): HarnessCatalogDrift => {
+  const liveIds = new Set(live.map((model) => model.id));
+  return {
+    unlisted: live.filter((model) => !(model.id in catalog.models)).map((model) => model.id),
+    mismatched: live
+      .filter(
+        (model) =>
+          model.efforts !== undefined &&
+          model.id in catalog.models &&
+          model.efforts.join(",") !== catalog.models[model.id]?.join(","),
+      )
+      .map((model) => `${model.id} (${model.efforts?.join(", ") || "no effort"})`),
+    unavailable: Object.keys(catalog.models).filter((id) => !liveIds.has(id)),
+  };
+};
+
+export const hasHarnessCatalogDrift = (drift: HarnessCatalogDrift): boolean =>
+  drift.unlisted.length > 0 || drift.mismatched.length > 0;
+
+export const describeHarnessCatalogDrift = (drift: HarnessCatalogDrift): string =>
+  [
+    drift.unlisted.length > 0 ? `not in catalog: ${drift.unlisted.join(", ")}` : undefined,
+    drift.mismatched.length > 0 ? `efforts differ: ${drift.mismatched.join("; ")}` : undefined,
+    drift.unavailable.length > 0 ? `not offered here: ${drift.unavailable.join(", ")}` : undefined,
+  ]
+    .filter((part) => part !== undefined)
+    .join(". ");
+
+const CodexModelsCacheSchema = z.object({
+  models: z.array(
+    z.looseObject({
+      slug: z.string(),
+      visibility: z.string().optional(),
+      supported_reasoning_levels: z.array(z.looseObject({ effort: z.string() })).default([]),
+    }),
+  ),
+});
+
+const codexModelsCachePath = (env: NodeJS.ProcessEnv = process.env): string =>
+  join(env.CODEX_HOME ?? join(homedir(), ".codex"), "models_cache.json");
+
+export const parseCodexModelsCache = (text: string): LiveHarnessModel[] | undefined => {
+  const parsed = CodexModelsCacheSchema.safeParse(tryParseJson(text));
+  if (!parsed.success) return undefined;
+  return parsed.data.models
+    .filter((model) => model.visibility !== "hide")
+    .map((model) => ({
+      id: model.slug,
+      efforts: model.supported_reasoning_levels.map((level) => level.effort as ReasoningEffort),
+    }));
+};
+
+const readCodexLiveModels = async (
+  path = codexModelsCachePath(),
+): Promise<LiveHarnessModel[] | undefined> => {
+  try {
+    return parseCodexModelsCache(await readFile(path, "utf8"));
+  } catch {
+    return undefined;
+  }
+};
+
+export const parseCopilotModelValues = (helpText: string): LiveHarnessModel[] | undefined => {
+  const lines = helpText.split("\n");
+  const start = lines.findIndex((line) => /^\s*`model`:/.test(line));
+  if (start < 0) return undefined;
+  const models: LiveHarnessModel[] = [];
+  for (const line of lines.slice(start + 1)) {
+    const match = /^\s*-\s*"([^"]+)"\s*$/.exec(line);
+    if (!match?.[1]) break;
+    models.push({ id: match[1] });
+  }
+  return models.length > 0 ? models : undefined;
+};
+
+const readCopilotLiveModels = async (
+  command = "copilot",
+): Promise<LiveHarnessModel[] | undefined> => {
+  try {
+    const result = await exec(command, ["help", "config"], { timeoutMs: 15_000 });
+    if (result.exitCode !== 0 || result.timedOut) return undefined;
+    return parseCopilotModelValues(result.stdout);
+  } catch {
+    return undefined;
+  }
+};
+
+export type HarnessCatalogProbe = {
+  catalog: ClosedHarnessCatalog;
+  source: string;
+  read: (command: string | undefined) => Promise<LiveHarnessModel[] | undefined>;
+};
+
+export const harnessCatalogProbes: readonly HarnessCatalogProbe[] = [
+  {
+    catalog: codexCatalog,
+    source: "models_cache.json",
+    read: () => readCodexLiveModels(),
+  },
+  {
+    catalog: copilotCatalog,
+    source: "help config",
+    read: (command) => readCopilotLiveModels(command),
+  },
+];

package/src/orchestrator/orchestrator.ts

@@ -6,6 +6,8 @@ import {
   type AnswererRef,
   bindSubjectRoot,
   type DriverRef,
+  driverConfigOf,
+  driverNameOf,
   type EvalCase,
   type GradingAssertionEntry,
   type GradingReport,
@@ -13,6 +15,7 @@ import {
   type HarnessModelConfig,
   type LifecycleHooksPlugin,
   mergeHarnessModelConfig,
+  mergePluginConfig,
   type Registry,
   type RunMetadata,
   type RunObserver,
@@ -142,6 +145,12 @@ export type RunRequest = {
   subjectRoot?: string | undefined;
   subjectHash?: string | undefined;
   profileId?: string | undefined;
+  /**
+   * Driver bound by a harness permutation. It replaces the project default;
+   * a case pinned to another driver is rejected rather than silently rerouted.
+   */
+  driver?: DriverRef | undefined;
+  permutationId?: string | undefined;
   experimentId?: string | undefined;
   variantId?: string | undefined;
   candidateId?: string | undefined;
@@ -200,7 +209,13 @@ export type SuiteObserver = RunObserver & {
  * `caseId` is the canonical id runs are filed under when the case declares
  * none — display decorations (a `--loop` suffix) must not fork run history.
  */
-export type SuiteItem = { path: string; id: string; caseId?: string | undefined };
+export type SuiteItem = {
+  path: string;
+  id: string;
+  caseId?: string | undefined;
+  driver?: DriverRef | undefined;
+  permutationId?: string | undefined;
+};
 
 const resolveCaseId = (casePath: string, evalCase: EvalCase, fallback?: string): string => {
   if (evalCase.id) return evalCase.id;
@@ -211,39 +226,29 @@ const resolveCaseId = (casePath: string, evalCase: EvalCase, fallback?: string):
   return ext ? base.slice(0, -ext.length) : base;
 };
 
-const driverNameOf = (ref: DriverRef): string => (typeof ref === "string" ? ref : ref.name);
-
-const isRecord = (value: unknown): value is Record<string, unknown> =>
-  Boolean(value) && typeof value === "object" && !Array.isArray(value);
-
-/** Merge plugin config recursively so nested Codex `config`/`env` overrides stay additive. */
-const mergePluginConfig = (base: unknown, local: unknown): unknown => {
-  if (!isRecord(base) || !isRecord(local)) return local ?? base;
-  const merged: Record<string, unknown> = { ...base };
-  for (const [key, value] of Object.entries(local)) {
-    merged[key] = key in merged ? mergePluginConfig(merged[key], value) : value;
-  }
-  return merged;
-};
-
 export const resolveDriverReference = (
   evalCase: EvalCase,
   fallback: DriverRef | undefined,
+  permutation?: DriverRef | undefined,
 ): DriverRef => {
   const local = evalCase.driver;
+  if (permutation && local && driverNameOf(local) !== driverNameOf(permutation)) {
+    throw new Error(
+      `case is pinned to driver '${driverNameOf(local)}' but the run selected '${driverNameOf(permutation)}'`,
+    );
+  }
+  const base = permutation ?? fallback;
   if (!local) {
-    if (!fallback) throw new Error("case names no driver and no defaultDriver is configured");
-    return fallback;
+    if (!base) throw new Error("case names no driver and no defaultDriver is configured");
+    return base;
   }
-  if (!fallback || driverNameOf(local) !== driverNameOf(fallback)) return local;
+  if (!base || driverNameOf(local) !== driverNameOf(base)) return local;
 
   // Naming the same driver opts into project defaults. A case object only
   // needs to carry the fields it wants to override (for example a timeout).
-  const baseConfig = typeof fallback === "object" ? fallback.config : undefined;
-  const localConfig = typeof local === "object" ? local.config : undefined;
   return {
     name: driverNameOf(local),
-    config: mergePluginConfig(baseConfig, localConfig),
+    config: mergePluginConfig(driverConfigOf(base), driverConfigOf(local)),
   };
 };
 
@@ -264,9 +269,6 @@ export const resolveAnswererReference = (
 
 const answererNameOf = (ref: AnswererRef): string => (typeof ref === "string" ? ref : ref.name);
 
-const driverConfigOf = (ref: DriverRef): unknown =>
-  typeof ref === "object" ? ref.config : undefined;
-
 const answererConfigOf = (ref: AnswererRef): unknown =>
   typeof ref === "object" ? ref.config : undefined;
 
@@ -352,7 +354,7 @@ export class Orchestrator {
       registry,
     );
 
-    const driverRef = resolveDriverReference(evalCase, this.defaultDriver);
+    const driverRef = resolveDriverReference(evalCase, this.defaultDriver, request.driver);
     const driverName = driverNameOf(driverRef);
     const answererRef = resolveAnswererReference(
       evalCase,
@@ -422,6 +424,7 @@ export class Orchestrator {
           validatedAssertionConfigs,
           caseId,
           driverName,
+          permutationId: request.permutationId,
           answererName,
           answererConfig: answererCfg,
           driverConfigHash: valueHash(driverCfg),
@@ -643,6 +646,8 @@ export class Orchestrator {
             subjectRoot: opts.subjectRoot,
             subjectHash: opts.subjectHash,
             profileId: opts.profileId,
+            driver: item.driver,
+            permutationId: item.permutationId,
             experimentId: opts.experimentId,
             variantId: opts.variantId,
             candidateId: opts.candidateId,

package/src/orchestrator/run-dir.ts

@@ -154,6 +154,8 @@ export type OpenRunDirOptions = {
   runsRoot: string;
   caseId: string;
   driverName: string;
+  /** Files the run under the permutation instead of the bare driver name. */
+  permutationId?: string | undefined;
   startedAt?: Date | undefined;
   /** Tap on the event stream, called for every appended event. Must not throw. */
   onEvent?: ((event: RunEvent) => void) | undefined;
@@ -164,7 +166,12 @@ export type OpenRunDirOptions = {
 export const openRunDir = async (options: OpenRunDirOptions): Promise<OpenedRunDir> => {
   const ts = isoTimestampSafe(options.startedAt ?? new Date());
   const slug = slugifyCaseId(options.caseId);
-  const basePath = join(options.runsRoot, slug, slugifyCaseId(options.driverName), ts);
+  const basePath = join(
+    options.runsRoot,
+    slug,
+    slugifyCaseId(options.permutationId ?? options.driverName),
+    ts,
+  );
   await mkdir(dirname(basePath), { recursive: true });
   // Same case+driver+millisecond must not share a dir — their events.jsonl
   // streams (opened with flags "a") would interleave silently. A bare mkdir

package/src/orchestrator/run-execution.ts

@@ -69,6 +69,7 @@ export type RunWithPluginsArgs = {
   validatedAssertionConfigs: readonly unknown[];
   caseId: string;
   driverName: string;
+  permutationId?: string | undefined;
   answererName: string;
   answererConfig: unknown;
   driverConfigHash: string;
@@ -338,6 +339,7 @@ class RunExecution implements RunLifecycleEffects<RunResult> {
       runsRoot: resolve(args.request.runsRoot),
       caseId: args.caseId,
       driverName: args.driverName,
+      permutationId: args.permutationId,
       startedAt,
       onEvent: observer?.event,
     });
@@ -653,6 +655,7 @@ class RunExecution implements RunLifecycleEffects<RunResult> {
       ...(this.fixturesHash ? { fixturesHash: this.fixturesHash } : {}),
       ...(request.subjectHash ? { subjectHash: request.subjectHash } : {}),
       ...(request.profileId ? { profileId: request.profileId } : {}),
+      ...(this.args.permutationId ? { permutationId: this.args.permutationId } : {}),
       ...(request.experimentId ? { experimentId: request.experimentId } : {}),
       ...(request.variantId ? { variantId: request.variantId } : {}),
       ...(request.candidateId ? { candidateId: request.candidateId } : {}),