@wix/pathgrade 0.36.0 → 1.0.0

package/dist/commands/run-args.d.ts

@@ -2,11 +2,12 @@
  * Parse `pathgrade run` arguments.
  *
  * Recognized pathgrade-specific flags are consumed here; everything else
- * passes through to vitest. After a literal `--` separator, all remaining
- * args are forwarded verbatim (vitest uses `--` the same way).
+ * passes through to the selected runner. After a literal `--` separator,
+ * all remaining args are forwarded verbatim.
  */
 export interface PathgradeRunArgs {
-    vitestArgs: string[];
+    runnerArgs: string[];
+    adapterName?: string;
     forceDiagnostics: boolean;
     forceVerbose: boolean;
     changed: boolean;

package/dist/commands/run-args.js

@@ -2,21 +2,22 @@
  * Parse `pathgrade run` arguments.
  *
  * Recognized pathgrade-specific flags are consumed here; everything else
- * passes through to vitest. After a literal `--` separator, all remaining
- * args are forwarded verbatim (vitest uses `--` the same way).
+ * passes through to the selected runner. After a literal `--` separator,
+ * all remaining args are forwarded verbatim.
  */
 export function parsePathgradeRunArgs(args) {
-    const vitestArgs = [];
+    const runnerArgs = [];
     let forceDiagnostics = false;
     let forceVerbose = false;
     let changed = false;
     let quiet = false;
     let since;
     let changedFilesPath;
+    let adapterName;
     let passthrough = false;
     for (const arg of args) {
         if (passthrough) {
-            vitestArgs.push(arg);
+            runnerArgs.push(arg);
             continue;
         }
         if (arg === '--') {
@@ -39,6 +40,10 @@ export function parsePathgradeRunArgs(args) {
             quiet = true;
             continue;
         }
+        if (arg.startsWith('--adapter=')) {
+            adapterName = arg.slice('--adapter='.length);
+            continue;
+        }
         if (arg.startsWith('--since=')) {
             since = arg.slice('--since='.length);
             continue;
@@ -47,7 +52,7 @@ export function parsePathgradeRunArgs(args) {
             changedFilesPath = arg.slice('--changed-files='.length);
             continue;
         }
-        vitestArgs.push(arg);
+        runnerArgs.push(arg);
     }
     const warnings = [];
     if (!changed && since !== undefined) {
@@ -57,11 +62,12 @@ export function parsePathgradeRunArgs(args) {
         warnings.push('--changed-files has no effect without --changed; the flag is being ignored.');
     }
     const base = {
-        vitestArgs,
+        runnerArgs,
         forceDiagnostics,
         forceVerbose,
         changed,
         quiet,
+        adapterName,
         since,
         changedFilesPath,
     };

package/dist/commands/run-changed.d.ts

@@ -12,15 +12,15 @@
  * Git-resolution failures exit non-zero. The selection pipeline is the
  * only producer of the file list here.
  */
+import type { RunnerInvocationAdapter } from '../runners/invocation.js';
+import type { SpawnVitest } from '../runners/vitest-invocation.js';
 import type { PathgradeRunArgs } from './run-args.js';
-export interface SpawnVitestRequest {
-    argv: string[];
-}
-export type SpawnVitest = (req: SpawnVitestRequest) => Promise<number> | number;
+export type { SpawnVitest };
 export interface RunChangedOptions {
     cwd: string;
     parsed: PathgradeRunArgs;
     /** Override for tests; default spawns `npx vitest` inheriting stdio. */
     spawnVitest?: SpawnVitest;
+    runnerInvocation?: RunnerInvocationAdapter;
 }
 export declare function runChanged(opts: RunChangedOptions): Promise<number>;

package/dist/commands/run-changed.js

@@ -13,15 +13,42 @@
  * only producer of the file list here.
  */
 import * as fs from 'fs';
-import picomatch from 'picomatch';
 import { selectAffected } from '../affected/select.js';
 import { resolveBaseRef, computeChangedFiles } from '../affected/git.js';
-import { loadAffectedConfig } from '../affected/config.js';
 import { writeSidecar } from '../affected/sidecar.js';
-import { discoverEvalFiles } from './affected.js';
+import { discoverPathgradeEvalFiles } from '../evals/discovery.js';
+import { resolvePathgradeConfig } from '../config/pathgrade.js';
+import { loadRunnerInvocationAdapter } from '../runners/adapter-loader.js';
 export async function runChanged(opts) {
     const { cwd, parsed } = opts;
-    const spawnVitest = opts.spawnVitest ?? defaultSpawnVitest;
+    const runnerEnv = {
+        ...process.env,
+        ...(parsed.forceDiagnostics ? { PATHGRADE_DIAGNOSTICS: '1' } : {}),
+        ...(parsed.forceVerbose ? { PATHGRADE_VERBOSE: '1' } : {}),
+    };
+    const configPath = findVitestConfigArg(parsed.runnerArgs);
+    let config;
+    let runnerInvocation;
+    try {
+        config = await resolvePathgradeConfig({
+            cwd,
+            legacyVitestConfigPath: configPath,
+            warn: w => {
+                if (!parsed.quiet)
+                    process.stderr.write(`${w}\n`);
+            },
+        });
+        runnerInvocation = opts.runnerInvocation ?? await loadRunnerInvocationAdapter({
+            adapterName: parsed.adapterName ?? config.runner.adapter,
+            cwd,
+            config,
+            spawnVitest: opts.spawnVitest,
+        });
+    }
+    catch (err) {
+        process.stderr.write(`${errMsg(err)}\n`);
+        return 1;
+    }
     // 1. Change-set
     let baseRef;
     let changedFiles;
@@ -53,22 +80,11 @@ export async function runChanged(opts) {
         baseRefLine = `pathgrade: base = ${baseRef} (merge-base with HEAD)`;
     }
     // 2. Selection
-    const configPath = findVitestConfigArg(parsed.vitestArgs);
-    let config;
-    try {
-        config = await loadAffectedConfig(cwd, {
-            configPath,
-            onWarning: w => {
-                if (!parsed.quiet)
-                    process.stderr.write(`${w}\n`);
-            },
-        });
-    }
-    catch (err) {
-        process.stderr.write(`${errMsg(err)}\n`);
-        return 1;
-    }
-    const evalFiles = filterEvalFilesForConfig(discoverEvalFiles(cwd), config);
+    const evalFiles = discoverPathgradeEvalFiles({
+        cwd,
+        include: config.evals.include,
+        exclude: config.evals.exclude,
+    });
     let result;
     try {
         result = selectAffected({
@@ -76,7 +92,7 @@ export async function runChanged(opts) {
             changedFiles,
             repoRoot: cwd,
             baseRef,
-            global: config.global,
+            global: config.affected.global,
         });
     }
     catch (err) {
@@ -103,16 +119,16 @@ export async function runChanged(opts) {
         return 0;
     }
     const selectedFiles = result.selected.map(s => s.file);
-    if (hasPassWithNoTests(parsed.vitestArgs)) {
-        process.stderr.write('pathgrade run: --passWithNoTests cannot be used with pathgrade run --changed. ' +
-            'The command already exits 0 when no evals are selected; if selected evals resolve to no Vitest files, CI must fail.\n');
-        return 1;
-    }
-    const argv = ['run', ...selectedFiles, ...parsed.vitestArgs];
+    const runnerArgs = [...config.runner.args, ...parsed.runnerArgs];
     if (!parsed.quiet) {
-        process.stderr.write(`→ vitest run ${selectedFiles.join(' ')}\n`);
+        process.stderr.write(`→ ${runnerInvocation.name} run ${selectedFiles.join(' ')}\n`);
     }
-    return await spawnVitest({ argv });
+    return await runnerInvocation.run({
+        cwd,
+        runnerArgs,
+        selectedFiles,
+        env: runnerEnv,
+    });
 }
 function printRunStartSummary(input) {
     const { baseRefLine, totalEvals, changedCount, result } = input;
@@ -141,15 +157,6 @@ function readChangedFilesList(filePath) {
 function errMsg(err) {
     return err instanceof Error ? err.message : String(err);
 }
-function hasPassWithNoTests(args) {
-    return args.some(arg => {
-        if (arg === '--passWithNoTests')
-            return true;
-        if (!arg.startsWith('--passWithNoTests='))
-            return false;
-        return arg.slice('--passWithNoTests='.length).toLowerCase() !== 'false';
-    });
-}
 function findVitestConfigArg(args) {
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
@@ -162,23 +169,3 @@ function findVitestConfigArg(args) {
     }
     return undefined;
 }
-function filterEvalFilesForConfig(evalFiles, config) {
-    if (!config.include && !config.exclude)
-        return evalFiles;
-    const includeMatchers = config.include?.map(g => picomatch(g, { dot: true }));
-    const excludeMatchers = config.exclude?.map(g => picomatch(g, { dot: true })) ?? [];
-    return evalFiles.filter(file => {
-        const included = includeMatchers ? includeMatchers.some(m => m(file)) : true;
-        return included && !excludeMatchers.some(m => m(file));
-    });
-}
-async function defaultSpawnVitest(req) {
-    const { spawn } = await import('child_process');
-    return await new Promise(resolve => {
-        const child = spawn('npx', ['vitest', ...req.argv], {
-            stdio: 'inherit',
-            shell: true,
-        });
-        child.on('close', code => resolve(code ?? 0));
-    });
-}

package/dist/config/pathgrade.d.ts

@@ -0,0 +1,48 @@
+export interface PathgradeConfig {
+    runner?: {
+        adapter?: string;
+        args?: string[];
+    };
+    evals?: {
+        include?: string[];
+        exclude?: string[];
+    };
+    affected?: {
+        global?: string[];
+    };
+    reporter?: 'cli' | 'browser' | 'json';
+    diagnostics?: boolean;
+    verbose?: boolean;
+    ci?: {
+        threshold?: number;
+    };
+}
+export interface ResolvedPathgradeConfig {
+    runner: {
+        adapter: string;
+        args: string[];
+    };
+    evals: {
+        include: string[];
+        exclude: string[];
+    };
+    affected: {
+        global: string[];
+    };
+    reporter?: 'cli' | 'browser' | 'json';
+    diagnostics: boolean;
+    verbose: boolean;
+    ci: {
+        threshold?: number;
+    };
+}
+export declare const DEFAULT_EVAL_INCLUDE: string[];
+export declare const DEFAULT_EVAL_EXCLUDE: string[];
+export declare function defaultPathgradeConfig(): ResolvedPathgradeConfig;
+export declare function resolvePathgradeConfig(input: {
+    cwd: string;
+    cli?: PathgradeConfig;
+    configPath?: string;
+    legacyVitestConfigPath?: string;
+    warn?: (message: string) => void;
+}): Promise<ResolvedPathgradeConfig>;

package/dist/config/pathgrade.js

@@ -0,0 +1,204 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { createJiti } from 'jiti';
+export const DEFAULT_EVAL_INCLUDE = ['**/*.eval.ts'];
+export const DEFAULT_EVAL_EXCLUDE = [
+    '**/node_modules/**',
+    '**/.git/**',
+    '.worktrees/**',
+    'worktrees/**',
+    '**/fixtures/**',
+];
+const PATHGRADE_CONFIG_CANDIDATES = [
+    'pathgrade.config.ts',
+    'pathgrade.config.mts',
+    'pathgrade.config.js',
+    'pathgrade.config.mjs',
+];
+export function defaultPathgradeConfig() {
+    return {
+        runner: {
+            adapter: 'vitest',
+            args: [],
+        },
+        evals: {
+            include: [...DEFAULT_EVAL_INCLUDE],
+            exclude: [...DEFAULT_EVAL_EXCLUDE],
+        },
+        affected: {
+            global: [],
+        },
+        diagnostics: false,
+        verbose: false,
+        ci: {},
+    };
+}
+export async function resolvePathgradeConfig(input) {
+    const fileConfig = await loadPathgradeConfigFile(input.cwd, input.configPath);
+    const legacyConfig = await loadLegacyVitestConfig(input.cwd, input.legacyVitestConfigPath, input.warn);
+    return mergePathgradeConfig(mergePathgradeConfig(mergePathgradeConfig(defaultPathgradeConfig(), legacyConfig), fileConfig), input.cli);
+}
+function mergePathgradeConfig(base, override) {
+    if (!override)
+        return base;
+    return {
+        runner: {
+            adapter: override.runner?.adapter ?? base.runner.adapter,
+            args: override.runner?.args ?? base.runner.args,
+        },
+        evals: {
+            include: override.evals?.include ?? base.evals.include,
+            exclude: override.evals?.exclude ?? base.evals.exclude,
+        },
+        affected: {
+            global: override.affected?.global ?? base.affected.global,
+        },
+        reporter: override.reporter ?? base.reporter,
+        diagnostics: override.diagnostics ?? base.diagnostics,
+        verbose: override.verbose ?? base.verbose,
+        ci: {
+            threshold: override.ci?.threshold ?? base.ci.threshold,
+        },
+    };
+}
+async function loadPathgradeConfigFile(cwd, configPath) {
+    const resolved = configPath
+        ? path.resolve(cwd, configPath)
+        : PATHGRADE_CONFIG_CANDIDATES
+            .map(candidate => path.join(cwd, candidate))
+            .find(candidate => fs.existsSync(candidate));
+    if (!resolved)
+        return undefined;
+    try {
+        const jiti = createJiti(cwd, { interopDefault: true });
+        const loaded = await jiti.import(resolved, { default: true });
+        return validatePathgradeConfig(loaded, path.relative(cwd, resolved));
+    }
+    catch (err) {
+        if (err instanceof InvalidPathgradeConfigError) {
+            throw err;
+        }
+        throw new Error(`pathgrade: failed to load ${path.relative(cwd, resolved)}: ${errMsg(err)}`);
+    }
+}
+function isObject(value) {
+    return value !== null && typeof value === 'object';
+}
+class InvalidPathgradeConfigError extends Error {
+}
+function validatePathgradeConfig(value, label) {
+    if (!isObject(value)) {
+        throw invalidConfig(label, 'default export must be an object');
+    }
+    validateOptionalObject(value.runner, label, 'runner');
+    const runner = asOptionalObject(value.runner);
+    validateOptionalString(runner?.adapter, label, 'runner.adapter');
+    validateOptionalStringArray(runner?.args, label, 'runner.args');
+    validateOptionalObject(value.evals, label, 'evals');
+    const evals = asOptionalObject(value.evals);
+    validateOptionalStringArray(evals?.include, label, 'evals.include');
+    validateOptionalStringArray(evals?.exclude, label, 'evals.exclude');
+    validateOptionalObject(value.affected, label, 'affected');
+    const affected = asOptionalObject(value.affected);
+    validateOptionalStringArray(affected?.global, label, 'affected.global');
+    if (value.reporter !== undefined && !['cli', 'browser', 'json'].includes(String(value.reporter))) {
+        throw invalidConfig(label, 'reporter must be one of cli, browser, or json');
+    }
+    validateOptionalBoolean(value.diagnostics, label, 'diagnostics');
+    validateOptionalBoolean(value.verbose, label, 'verbose');
+    validateOptionalObject(value.ci, label, 'ci');
+    const ci = asOptionalObject(value.ci);
+    validateOptionalNumber(ci?.threshold, label, 'ci.threshold');
+    return value;
+}
+function asOptionalObject(value) {
+    return isObject(value) ? value : undefined;
+}
+function validateOptionalObject(value, label, field) {
+    if (value !== undefined && !isObject(value)) {
+        throw invalidConfig(label, `${field} must be an object`);
+    }
+}
+function validateOptionalString(value, label, field) {
+    if (value !== undefined && typeof value !== 'string') {
+        throw invalidConfig(label, `${field} must be a string`);
+    }
+}
+function validateOptionalStringArray(value, label, field) {
+    if (value !== undefined && (!Array.isArray(value) || value.some(item => typeof item !== 'string'))) {
+        throw invalidConfig(label, `${field} must be an array of strings`);
+    }
+}
+function validateOptionalBoolean(value, label, field) {
+    if (value !== undefined && typeof value !== 'boolean') {
+        throw invalidConfig(label, `${field} must be a boolean`);
+    }
+}
+function validateOptionalNumber(value, label, field) {
+    if (value !== undefined && typeof value !== 'number') {
+        throw invalidConfig(label, `${field} must be a number`);
+    }
+}
+function invalidConfig(label, reason) {
+    return new InvalidPathgradeConfigError(`pathgrade: invalid ${label}: ${reason}`);
+}
+function errMsg(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+const VITEST_CONFIG_CANDIDATES = [
+    'vitest.config.ts',
+    'vitest.config.mts',
+    'vitest.config.js',
+    'vitest.config.mjs',
+];
+async function loadLegacyVitestConfig(cwd, configPath, warn = () => { }) {
+    const resolved = configPath
+        ? path.resolve(cwd, configPath)
+        : VITEST_CONFIG_CANDIDATES
+            .map(candidate => path.join(cwd, candidate))
+            .find(candidate => fs.existsSync(candidate));
+    if (!resolved)
+        return undefined;
+    let loaded;
+    try {
+        const jiti = createJiti(cwd, { interopDefault: true });
+        loaded = await jiti.import(resolved, { default: true });
+    }
+    catch (err) {
+        const message = `pathgrade: failed to load ${path.relative(cwd, resolved)}: ${errMsg(err)}`;
+        if (configPath)
+            throw new Error(message);
+        warn(message);
+        return undefined;
+    }
+    const plugins = findPluginsList(loaded);
+    const pathgradePlugin = plugins?.find(plugin => isPathgradePlugin(plugin));
+    const opts = isObject(pathgradePlugin)
+        ? pathgradePlugin.__pathgradeOptions
+        : undefined;
+    if (!isObject(opts))
+        return undefined;
+    return {
+        evals: {
+            ...(Array.isArray(opts.include) ? { include: opts.include } : {}),
+            ...(Array.isArray(opts.exclude) ? { exclude: opts.exclude } : {}),
+        },
+        affected: {
+            global: isObject(opts.affected) && Array.isArray(opts.affected.global)
+                ? opts.affected.global
+                : [],
+        },
+    };
+}
+function findPluginsList(config) {
+    if (!isObject(config))
+        return null;
+    if (Array.isArray(config.plugins))
+        return config.plugins;
+    if (isObject(config.test) && Array.isArray(config.test.plugins))
+        return config.test.plugins;
+    return null;
+}
+function isPathgradePlugin(plugin) {
+    return isObject(plugin) && (plugin.name === 'pathgrade' || '__pathgradeOptions' in plugin);
+}

package/dist/pathgrade.d.ts

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 /**
- * pathgrade CLI — thin wrapper around vitest
+ * pathgrade CLI — runner-neutral wrapper around Pathgrade adapters
  *
  * Usage:
- *   pathgrade run [-- vitest-args]   Run evals via vitest (loads .env, validates API keys)
+ *   pathgrade run [-- runner-args]   Run evals via the selected adapter
  *   pathgrade init [--force]         Generate eval scaffolding
  *   pathgrade preview [browser]      View results (CLI default, or browser)
  */

package/dist/pathgrade.js

@@ -1,15 +1,14 @@
 #!/usr/bin/env node
 /**
- * pathgrade CLI — thin wrapper around vitest
+ * pathgrade CLI — runner-neutral wrapper around Pathgrade adapters
  *
  * Usage:
- *   pathgrade run [-- vitest-args]   Run evals via vitest (loads .env, validates API keys)
+ *   pathgrade run [-- runner-args]   Run evals via the selected adapter
  *   pathgrade init [--force]         Generate eval scaffolding
  *   pathgrade preview [browser]      View results (CLI default, or browser)
  */
 import * as fs from 'fs';
 import * as path from 'path';
-import { spawn } from 'child_process';
 import { runInit } from './commands/init.js';
 import { runAnalyze } from './commands/analyze.js';
 import { runValidate, runValidateAffected } from './commands/validate.js';
@@ -20,6 +19,8 @@ import { runReport } from './commands/report.js';
 import { runAffected } from './commands/affected.js';
 import { runChanged } from './commands/run-changed.js';
 import { clearSidecar } from './affected/sidecar.js';
+import { resolvePathgradeConfig } from './config/pathgrade.js';
+import { loadRunnerInvocationAdapter } from './runners/adapter-loader.js';
 import { fmt } from './utils/cli.js';
 import { shutdown } from './utils/shutdown.js';
 function loadDotenv() {
@@ -52,7 +53,7 @@ function validateApiKeys() {
     const hasClaude = !!process.env.HOME; // Claude CLI uses OS keychain, just check it exists
     if (!hasAnthropic && !hasOpenAI) {
         console.log(`\n  ${fmt.dim('warning:')} No API keys found. Set ANTHROPIC_API_KEY or OPENAI_API_KEY in .env or environment.\n` +
-            `  ${fmt.dim('         Claude CLI auth (keychain) and Codex cached login (~/.codex/auth.json) may still work if installed.')}\n`);
+            `  ${fmt.dim('         Claude CLI auth (keychain) and Codex exec cached login (~/.codex/auth.json) may still work if installed.')}\n`);
     }
 }
 async function main() {
@@ -144,7 +145,7 @@ async function main() {
         return;
     }
     if (command === 'run' || !command || command.startsWith('-')) {
-        // pathgrade run [--changed [--since=…|--changed-files=…]] [--] [vitest-args]
+        // pathgrade run [--changed [--since=…|--changed-files=…]] [--] [runner-args]
         loadDotenv();
         validateApiKeys();
         const parsed = parsePathgradeRunArgs(command === 'run' ? args.slice(1) : args);
@@ -155,18 +156,6 @@ async function main() {
             const exitCode = await runChanged({
                 cwd: process.cwd(),
                 parsed,
-                spawnVitest: ({ argv }) => new Promise(resolve => {
-                    const child = spawn('npx', ['vitest', ...argv], {
-                        stdio: 'inherit',
-                        env: {
-                            ...process.env,
-                            ...(parsed.forceDiagnostics ? { PATHGRADE_DIAGNOSTICS: '1' } : {}),
-                            ...(parsed.forceVerbose ? { PATHGRADE_VERBOSE: '1' } : {}),
-                        },
-                        shell: true,
-                    });
-                    child.on('close', code => resolve(code ?? 0));
-                }),
             });
             process.exitCode = exitCode;
             return;
@@ -175,18 +164,28 @@ async function main() {
         // previous `--changed` run so it doesn't leak into this full-suite
         // run (the reporter would otherwise merge old metadata).
         await clearSidecar(process.cwd());
-        const child = spawn('npx', ['vitest', 'run', ...parsed.vitestArgs], {
-            stdio: 'inherit',
-            env: {
-                ...process.env,
-                ...(parsed.forceDiagnostics ? { PATHGRADE_DIAGNOSTICS: '1' } : {}),
-                ...(parsed.forceVerbose ? { PATHGRADE_VERBOSE: '1' } : {}),
-            },
-            shell: true,
-        });
-        child.on('close', (code) => {
-            process.exitCode = code ?? 0;
-        });
+        const env = {
+            ...process.env,
+            ...(parsed.forceDiagnostics ? { PATHGRADE_DIAGNOSTICS: '1' } : {}),
+            ...(parsed.forceVerbose ? { PATHGRADE_VERBOSE: '1' } : {}),
+        };
+        try {
+            const config = await resolvePathgradeConfig({ cwd: process.cwd() });
+            const runner = await loadRunnerInvocationAdapter({
+                adapterName: parsed.adapterName ?? config.runner.adapter,
+                cwd: process.cwd(),
+                config,
+            });
+            process.exitCode = await runner.run({
+                cwd: process.cwd(),
+                runnerArgs: [...config.runner.args, ...parsed.runnerArgs],
+                env,
+            });
+        }
+        catch (err) {
+            console.error(err instanceof Error ? err.message : String(err));
+            process.exitCode = 1;
+        }
         return;
     }
     console.error(`Unknown command: ${command}`);
@@ -195,13 +194,15 @@ async function main() {
 }
 function printHelp() {
     console.log(`
-  pathgrade - Evaluate AI agent skills with vitest
+  pathgrade - Evaluate AI agent skills with a runner adapter
 
   Usage:
-    pathgrade run [-- vitest-args]   Run evals (loads .env, delegates to vitest)
+    pathgrade run [-- runner-args]   Run evals (loads .env, delegates to the selected adapter)
                      [--changed]               Run only evals affected by the current PR/change-set
                      [--since=<ref>]           Override base ref (implies git mode)
                      [--changed-files=<path>]  Use an explicit newline-delimited file list
+                     [--adapter=<name|path>]   Select built-in or third-party runner adapter
+                     [--diagnostics]           Print full diagnostics for passing evals too
                      [--quiet]                 Suppress the run-start summary
                      [--verbose|-v]            Stream live per-turn events to stderr during the run
     pathgrade init [--force]         Generate eval scaffolding
@@ -223,9 +224,9 @@ function printHelp() {
                      [--json]                  Emit structured JSON (snake_case) to stdout
 
   Environment:
-    PATHGRADE_AGENT=codex            Override agent for all trials
-    ANTHROPIC_API_KEY                API key for Claude
-    OPENAI_API_KEY                   API key for Codex (optional if Codex CLI is already logged in)
+    PATHGRADE_AGENT=codex            Fallback agent when createAgent({ agent }) is omitted
+    ANTHROPIC_API_KEY                API key for Claude and Anthropic-backed judges
+    OPENAI_API_KEY                   API key for Codex and OpenAI-backed judges
 
   Examples:
     pathgrade run                    # run all *.eval.ts files

package/dist/plugin/index.d.ts

@@ -1,9 +1,2 @@
-import type { PathgradePluginOptions } from '../sdk/types.js';
-export type { PathgradePluginOptions };
-/**
- * Vitest plugin for pathgrade evaluations.
- *
- * Configures test file patterns, timeout, auto-dispose lifecycle hooks,
- * and the pathgrade reporter for aggregate statistics.
- */
-export declare function pathgrade(opts?: PathgradePluginOptions): any;
+export { pathgrade } from '../adapters/vitest/index.js';
+export type { PathgradePluginOptions } from '../adapters/vitest/index.js';