@ultimat3/cli 20.1.2 → 20.1.4

package/src/test-shards.ts

@@ -40,6 +40,7 @@ import { execOutput } from './exec';
 import { msg } from './messages';
 import type { CommandResult, Finding, JsonValue, StepResult } from './output';
 import { quoteArg } from './shell-quote';
+import { testEnvOverrides } from './test-dotenv';
 import { testPasses } from './test-passes';
 import type { TestFile } from './test-select';
 import type { TestType } from './verify-tests';
@@ -165,6 +166,13 @@ export interface RunShardsOptions {
   readonly affected?: AffectedSelection;
   /** Everything after the caller's `--`, forwarded to every pass and printed in the reproduce. */
   readonly passthrough?: readonly string[];
+  /**
+   * This process's own environment, as `exec.ts` would otherwise hand it whole to the spawned
+   * child. Optional and defaulted to `Bun.env`: every real caller's is `Bun.env` already (`x
+   * test`/`x verify` read `CommandContext.env`, itself `Bun.env`), so the default is not a
+   * fallback so much as a seam this file's own tests use to hand it a fixture instead.
+   */
+  readonly env?: Readonly<Record<string, string | undefined>>;
 }
 
 /**
@@ -219,6 +227,11 @@ export const failureOf = (code: number, files: number, plan: ReproduceOptions):
  */
 export async function runShards(options: RunShardsOptions): Promise<CommandResult> {
   const only = options.only;
+  // Computed ONCE per invocation, never per pass: every pass spawns from the same `root` and the
+  // same parent env, so the leaked-key set cannot differ pass to pass.
+  const envOverrides: Record<string, string | undefined> = {
+    ...testEnvOverrides(options.root, options.env ?? Bun.env),
+  };
   const passes = testPasses({
     files: options.files,
     workers: options.workers,
@@ -241,7 +254,14 @@ export async function runShards(options: RunShardsOptions): Promise<CommandResul
       }),
       {
         cwd: options.root,
-        ...(only === undefined ? {} : { env: { ULTIMATE_TEST_WORKER: String(only) } }),
+        ...(Object.keys(envOverrides).length === 0 && only === undefined
+          ? {}
+          : {
+              env: {
+                ...envOverrides,
+                ...(only === undefined ? {} : { ULTIMATE_TEST_WORKER: String(only) }),
+              },
+            }),
       },
     );
     const plan = planOf(options, pass);

package/src/verify-step.ts

@@ -65,6 +65,13 @@ export type HostCheck = (root: string) => Promise<readonly Finding[]>;
 export interface VerifyContext {
   readonly root: string;
   readonly runner: Runner;
+  /**
+   * This process's own environment. Optional and defaulted to `Bun.env` at every reader
+   * (`verify-tests.ts`'s `runSerial`/`runType`): every real caller's IS `Bun.env` already
+   * (`cmd-verify.ts` passes `ctx.env`, itself `Bun.env`), so the default only matters to a test
+   * that constructs a `VerifyContext` fixture and never mentions `env`.
+   */
+  readonly env?: Readonly<Record<string, string | undefined>>;
   readonly hostChecks?: Partial<Record<VerifyStepName, HostCheck>>;
   /**
    * How wide the parallel test steps go. Absent means `defaultWorkers()` — a knob, never a

package/src/verify-test-run.ts

@@ -6,6 +6,7 @@ import type { Runner } from './exec';
 import { execOutput } from './exec';
 import type { Finding } from './output';
 import { countsOf } from './test-counts';
+import { testEnvOverrides } from './test-dotenv';
 import type { TestFile } from './test-select';
 import { failureOf, testArgs } from './test-shards';
 import type { StepOutcome } from './verify-step';
@@ -20,6 +21,8 @@ export interface ParallelRunOptions {
   readonly workers: number;
   /** Carried into the `fix:` so a failure reproduces as `x test <type> --workers N`. */
   readonly type: TestType;
+  /** This process's own environment. Optional and defaulted to `Bun.env` — see `VerifyContext.env`. */
+  readonly env?: Readonly<Record<string, string | undefined>>;
 }
 
 /**
@@ -38,7 +41,11 @@ export interface ParallelRunOptions {
 export async function runParallel(options: ParallelRunOptions): Promise<StepOutcome> {
   const files = options.files.map((file) => file.path);
   const workers = Math.max(1, Math.min(Math.trunc(options.workers), files.length || 1));
-  const result = await options.runner(testArgs({ files, workers }), { cwd: options.root });
+  const envOverrides = testEnvOverrides(options.root, options.env ?? Bun.env);
+  const result = await options.runner(testArgs({ files, workers }), {
+    cwd: options.root,
+    ...(Object.keys(envOverrides).length === 0 ? {} : { env: envOverrides }),
+  });
   // `failureOf` is `x test`'s own, imported rather than restated: the two paths report the SAME
   // failed `bun test`, so a second literal here is two `cause:` strings and two `fix:` lines free
   // to drift — and the one that drifts is the gate's, which is the one an agent reads first.

package/src/verify-tests.ts

@@ -15,6 +15,7 @@ import { TEST_TYPES } from '@ultimat3/testing';
 import { checkEvalBaselines, checkEvalCoverage, checkEvalRecording } from './app-evals';
 import { APP_CONFIG_FILE } from './app-root';
 import { countsOf } from './test-counts';
+import { testEnvOverrides } from './test-dotenv';
 import type { TestFile } from './test-select';
 import { discoverTests } from './test-select';
 import { defaultWorkers } from './test-workers';
@@ -201,7 +202,11 @@ export const resetTestDiscovery = (): void => discovered.clear();
 
 const runSerial = async (ctx: VerifyContext, type: TestType): Promise<StepOutcome> => {
   const command = testStepCommand(type);
-  const result = await ctx.runner(command, { cwd: ctx.root });
+  const envOverrides = testEnvOverrides(ctx.root, ctx.env ?? Bun.env);
+  const result = await ctx.runner(command, {
+    cwd: ctx.root,
+    ...(Object.keys(envOverrides).length === 0 ? {} : { env: envOverrides }),
+  });
   return {
     ...fromExec(result, {
       code: 'X_TEST_FAILED',
@@ -223,6 +228,7 @@ const runType = async (ctx: VerifyContext, type: TestType): Promise<StepOutcome>
     files,
     workers: ctx.workers ?? defaultWorkers(),
     type,
+    ...(ctx.env === undefined ? {} : { env: ctx.env }),
   });
 };