@halecraft/verify 1.1.0 → 1.3.0

package/dist/index.js

@@ -10,11 +10,12 @@ var ConfigError = class extends Error {
     this.name = "ConfigError";
   }
 };
+var EnvSchema = z.record(z.string(), z.string().nullable()).optional();
 var VerificationCommandSchema = z.object({
   cmd: z.string(),
   args: z.array(z.string()),
   cwd: z.string().optional(),
-  env: z.record(z.string(), z.string()).optional(),
+  env: EnvSchema,
   timeout: z.number().positive().optional()
 });
 var VerificationNodeSchema = z.lazy(
@@ -30,7 +31,8 @@ var VerificationNodeSchema = z.lazy(
     successLabel: z.string().optional(),
     failureLabel: z.string().optional(),
     reportingDependsOn: z.array(z.string()).optional(),
-    timeout: z.number().positive().optional()
+    timeout: z.number().positive().optional(),
+    env: EnvSchema
   })
 );
 var VerifyOptionsSchema = z.object({
@@ -40,7 +42,8 @@ var VerifyOptionsSchema = z.object({
   cwd: z.string().optional(),
   noColor: z.boolean().optional(),
   topLevelOnly: z.boolean().optional(),
-  noTty: z.boolean().optional()
+  noTty: z.boolean().optional(),
+  passthrough: z.array(z.string()).optional()
 });
 var PackageDiscoveryOptionsSchema = z.object({
   patterns: z.array(z.string()).optional(),
@@ -50,7 +53,8 @@ var PackageDiscoveryOptionsSchema = z.object({
 var VerifyConfigSchema = z.object({
   tasks: z.array(VerificationNodeSchema),
   packages: PackageDiscoveryOptionsSchema.optional(),
-  options: VerifyOptionsSchema.optional()
+  options: VerifyOptionsSchema.optional(),
+  env: EnvSchema
 });
 function validateConfig(value, configPath) {
   const result = VerifyConfigSchema.safeParse(value);
@@ -118,7 +122,9 @@ function mergeOptions(configOptions, cliOptions) {
     cwd: cliOptions?.cwd ?? configOptions?.cwd ?? process.cwd(),
     noColor: cliOptions?.noColor ?? configOptions?.noColor ?? false,
     topLevelOnly: cliOptions?.topLevelOnly ?? configOptions?.topLevelOnly ?? false,
-    noTty: cliOptions?.noTty ?? configOptions?.noTty ?? false
+    noTty: cliOptions?.noTty ?? configOptions?.noTty ?? false,
+    quiet: cliOptions?.quiet ?? configOptions?.quiet ?? false,
+    passthrough: cliOptions?.passthrough ?? configOptions?.passthrough
   };
 }
 
@@ -508,7 +514,7 @@ function extractOptimizedCommand(cwd, scriptContent) {
     const match = scriptContent.match(tool.pattern);
     if (match && binaryExists(cwd, tool.binary)) {
       const args = tool.getArgs(match, scriptContent);
-      const command = args ? `./node_modules/.bin/${tool.binary} ${args}` : `./node_modules/.bin/${tool.binary}`;
+      const command = args ? `${tool.binary} ${args}` : tool.binary;
       return { command, parser: tool.parser };
     }
   }
@@ -585,7 +591,7 @@ function detectTasks(cwd) {
   const packageManager = detectPackageManager(cwd);
   const tasks = detectFromPackageJson(cwd);
   return tasks.map((task) => {
-    if (task.command.startsWith("./")) {
+    if (!task.command.startsWith("npm run ")) {
       return task;
     }
     return {
@@ -621,12 +627,15 @@ function generateSkeleton(format) {
   return `${importStatement}
 
 export default defineConfig({
+  env: {
+    NO_COLOR: "1",
+  },
   tasks: [
     // Add your verification tasks here
     // Example:
-    // { key: "format", run: "pnpm lint" },
-    // { key: "types", run: "pnpm typecheck" },
-    // { key: "test", run: "pnpm test" },
+    // { key: "format", run: "biome check ." },
+    // { key: "types", run: "tsc --noEmit" },
+    // { key: "test", run: "vitest run" },
   ],
 })
 `;
@@ -641,6 +650,9 @@ function generateConfigContent(tasks, format) {
   return `${importStatement}
 
 export default defineConfig({
+  env: {
+    NO_COLOR: "1",
+  },
   tasks: [
 ${taskLines.join(",\n")},
   ],
@@ -945,20 +957,36 @@ var vitestParser = {
   id: "vitest",
   parse(output, exitCode) {
     const cleanOutput = stripAnsi(output);
-    const testsMatch = cleanOutput.match(/Tests\s+(\d+)\s+passed\s*\((\d+)\)/m);
+    const testsLineMatch = cleanOutput.match(/Tests\s+(.+?)\s*\((\d+)\)/m);
     const durationMatch = cleanOutput.match(/Duration\s+([\d.]+(?:ms|s))\b/m);
-    if (!testsMatch) {
+    if (!testsLineMatch) {
       return null;
     }
-    const passed = Number.parseInt(testsMatch[1], 10);
-    const total = Number.parseInt(testsMatch[2], 10);
+    const statsStr = testsLineMatch[1];
+    const total = Number.parseInt(testsLineMatch[2], 10);
+    const passedMatch = statsStr.match(/(\d+)\s+passed/);
+    const failedMatch = statsStr.match(/(\d+)\s+failed/);
+    const skippedMatch = statsStr.match(/(\d+)\s+skipped/);
+    const passed = passedMatch ? Number.parseInt(passedMatch[1], 10) : 0;
+    const skipped = skippedMatch ? Number.parseInt(skippedMatch[1], 10) : 0;
     const duration = durationMatch ? durationMatch[1] : void 0;
+    const failed = failedMatch ? Number.parseInt(failedMatch[1], 10) : total - passed - skipped;
+    const ran = passed + failed;
+    let summary;
+    if (ran === 0 && skipped > 0) {
+      summary = `${skipped} tests skipped (no matches)`;
+    } else if (skipped > 0) {
+      summary = exitCode === 0 ? `passed ${passed}/${ran} tests (${skipped} skipped)` : `passed ${passed}/${ran} tests (${skipped} skipped, some failed)`;
+    } else {
+      summary = exitCode === 0 ? `passed ${passed}/${total} tests` : `passed ${passed}/${total} tests (some failed)`;
+    }
     return {
-      summary: exitCode === 0 ? `passed ${passed}/${total} tests` : `passed ${passed}/${total} tests (some failed)`,
+      summary,
       metrics: {
         passed,
         total,
-        failed: total - passed,
+        failed,
+        skipped,
         duration
       }
     };
@@ -1095,20 +1123,31 @@ var cursor = {
   moveToStart: "\x1B[0G",
   clearLine: "\x1B[2K"
 };
-function shouldUseColors(options) {
+function defaultTerminalContext() {
+  return { isTTY: !!process.stdout.isTTY, env: process.env };
+}
+function shouldUseColors(options, ctx) {
   if (options.noColor) return false;
   if (options.format === "json") return false;
-  if (!process.stdout.isTTY) return false;
-  if ("NO_COLOR" in process.env) return false;
-  if (process.env.TERM === "dumb") return false;
+  if (!ctx.isTTY) return false;
+  if ("NO_COLOR" in ctx.env) return false;
+  if (ctx.env.TERM === "dumb") return false;
+  return true;
+}
+function shouldUseLiveDashboard(options, ctx) {
+  if (options.noTty) return false;
+  if (ctx.env.TURBO_IS_TUI === "true") return false;
+  if (ctx.isTTY && ctx.env.TURBO_HASH != null) return false;
+  if (!ctx.isTTY) return false;
   return true;
 }
 var BaseReporter = class {
   colorEnabled;
   stream;
   taskDepths = /* @__PURE__ */ new Map();
-  constructor(options = {}) {
-    this.colorEnabled = shouldUseColors(options);
+  constructor(options = {}, ctx) {
+    const termCtx = ctx ?? defaultTerminalContext();
+    this.colorEnabled = shouldUseColors(options, termCtx);
     this.stream = options.format === "json" ? process.stderr : process.stdout;
   }
   /**
@@ -1130,10 +1169,10 @@ var BaseReporter = class {
     return this.colorEnabled ? this.c(ansi.red, "\u2717") : "FAIL";
   }
   /**
-   * Get suppressed mark (⊘ or SUPPRESSED)
+   * Get blocked mark (⊘ or BLOCK)
    */
-  suppressedMark() {
-    return this.colorEnabled ? this.c(ansi.yellow, "\u2298") : "SUPPRESSED";
+  blockedMark() {
+    return this.colorEnabled ? this.c(ansi.yellow, "\u2298") : "BLOCK";
   }
   /**
    * Get arrow symbol (→ or ->)
@@ -1161,6 +1200,22 @@ var BaseReporter = class {
       this.taskDepths.set(path, depth);
     });
   }
+  /**
+   * Format a completed task result line in name-first format.
+   * Shared by LiveDashboardReporter and SequentialReporter.
+   */
+  formatResultLine(name, result) {
+    const duration = this.c(ansi.dim, `${result.durationMs}ms`);
+    if (result.blocked) {
+      const reason = result.blockedBy ? `by ${result.blockedBy}` : "by dependency";
+      return `${this.blockedMark()} ${this.c(ansi.bold, name)} blocked ${this.c(ansi.dim, `(${reason}, ${duration})`)}`;
+    }
+    const summary = this.extractSummary(result);
+    if (result.ok) {
+      return `${this.okMark()} ${this.c(ansi.bold, name)} verified ${this.c(ansi.dim, `(${summary}, ${duration})`)}`;
+    }
+    return `${this.failMark()} ${this.c(ansi.bold, name)} failed ${this.c(ansi.dim, `(${summary}, ${duration})`)}`;
+  }
   /**
    * Extract summary from task result
    */
@@ -1196,7 +1251,7 @@ var BaseReporter = class {
     for (const r of flatResults) {
       if (r.children) continue;
       if (logsMode === "failed" && r.ok) continue;
-      if (r.suppressed) continue;
+      if (r.blocked) continue;
       const status = r.ok ? this.c(ansi.green, "OK") : this.c(ansi.red, "FAIL");
       this.stream.write(
         `
@@ -1221,8 +1276,8 @@ var LiveDashboardReporter = class extends BaseReporter {
   taskOrder = [];
   spinner;
   lineCount = 0;
-  constructor(options = {}) {
-    super(options);
+  constructor(options = {}, ctx) {
+    super(options, ctx);
     this.topLevelOnly = options.topLevelOnly ?? false;
     this.spinner = new SpinnerManager();
     const cleanup = () => {
@@ -1283,16 +1338,7 @@ var LiveDashboardReporter = class extends BaseReporter {
       return `${indent}${this.arrow()} verifying ${this.c(ansi.bold, displayKey)} ${spinnerChar}`;
     }
     if (task.status === "completed" && task.result) {
-      const duration = this.c(ansi.dim, `${task.result.durationMs}ms`);
-      if (task.result.suppressed) {
-        const reason = task.result.suppressedBy ? `${task.result.suppressedBy} failed` : "dependency failed";
-        return `${indent}${this.suppressedMark()} suppressed ${this.c(ansi.bold, displayKey)} ${this.c(ansi.dim, `(${reason}, ${duration})`)}`;
-      }
-      const summary = this.extractSummary(task.result);
-      if (task.result.ok) {
-        return `${indent}${this.okMark()}   verified ${this.c(ansi.bold, displayKey)} ${this.c(ansi.dim, `(${summary}, ${duration})`)}`;
-      }
-      return `${indent}${this.failMark()}     failed ${this.c(ansi.bold, displayKey)} ${this.c(ansi.dim, `(${summary}, ${duration})`)}`;
+      return `${indent}${this.formatResultLine(displayKey, task.result)}`;
     }
     return "";
   }
@@ -1342,8 +1388,8 @@ var LiveDashboardReporter = class extends BaseReporter {
 };
 var SequentialReporter = class extends BaseReporter {
   topLevelOnly;
-  constructor(options = {}) {
-    super(options);
+  constructor(options = {}, ctx) {
+    super(options, ctx);
     this.topLevelOnly = options.topLevelOnly ?? false;
   }
   onStart(tasks) {
@@ -1363,27 +1409,8 @@ var SequentialReporter = class extends BaseReporter {
   }
   onTaskComplete(result) {
     if (!this.shouldDisplay(result.path)) return;
-    const duration = this.c(ansi.dim, `${result.durationMs}ms`);
-    if (result.suppressed) {
-      const reason = result.suppressedBy ? `${result.suppressedBy} failed` : "dependency failed";
-      this.stream.write(
-        `${this.suppressedMark()} suppressed ${this.c(ansi.bold, result.path)} ${this.c(ansi.dim, `(${reason}, ${duration})`)}
-`
-      );
-      return;
-    }
-    const summary = this.extractSummary(result);
-    if (result.ok) {
-      this.stream.write(
-        `${this.okMark()}   verified ${this.c(ansi.bold, result.path)} ${this.c(ansi.dim, `(${summary}, ${duration})`)}
-`
-      );
-    } else {
-      this.stream.write(
-        `${this.failMark()}     failed ${this.c(ansi.bold, result.path)} ${this.c(ansi.dim, `(${summary}, ${duration})`)}
-`
-      );
-    }
+    this.stream.write(`${this.formatResultLine(result.path, result)}
+`);
   }
   onFinish() {
   }
@@ -1418,8 +1445,8 @@ var JSONReporter = class {
       code: t.code,
       durationMs: t.durationMs,
       summaryLine: t.summaryLine,
-      ...t.suppressed ? { suppressed: t.suppressed } : {},
-      ...t.suppressedBy ? { suppressedBy: t.suppressedBy } : {},
+      ...t.blocked ? { blocked: t.blocked } : {},
+      ...t.blockedBy ? { blockedBy: t.blockedBy } : {},
       ...t.children ? { children: this.serializeTasks(t.children) } : {}
     }));
   }
@@ -1442,17 +1469,22 @@ var QuietReporter = class extends BaseReporter {
   }
 };
 function createReporter(options) {
+  const ctx = defaultTerminalContext();
   if (options.format === "json") {
     return new JSONReporter();
   }
-  if (process.stdout.isTTY && !options.noTty) {
-    return new LiveDashboardReporter(options);
+  if (options.quiet) {
+    return new QuietReporter(options, ctx);
   }
-  return new SequentialReporter(options);
+  if (shouldUseLiveDashboard(options, ctx)) {
+    return new LiveDashboardReporter(options, ctx);
+  }
+  return new SequentialReporter(options, ctx);
 }
 
 // src/runner.ts
 import { spawn } from "child_process";
+import { dirname, join as join4, resolve as resolve3 } from "path";
 import treeKill2 from "tree-kill";
 
 // src/dependency-tracker.ts
@@ -1634,9 +1666,9 @@ var ReportingDependencyTracker = class {
     if (this.results.has(pathOrKey)) {
       return Promise.resolve();
     }
-    return new Promise((resolve3) => {
+    return new Promise((resolve4) => {
       const waiters = this.waiters.get(pathOrKey) ?? [];
-      waiters.push(resolve3);
+      waiters.push(resolve4);
       this.waiters.set(pathOrKey, waiters);
     });
   }
@@ -1704,17 +1736,78 @@ var ReportingDependencyTracker = class {
 };
 
 // src/runner.ts
-function normalizeCommand(run, nodeTimeout) {
+function mergeEnv(base, overlay) {
+  if (!overlay) return { ...base };
+  const result = { ...base };
+  for (const [key, value] of Object.entries(overlay)) {
+    if (value === null) {
+      result[key] = null;
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function buildFinalEnv(processEnv, path, overlay) {
+  const result = {};
+  for (const [key, value] of Object.entries(processEnv)) {
+    if (value !== void 0) {
+      result[key] = value;
+    }
+  }
+  result.PATH = path;
+  if (overlay) {
+    for (const [key, value] of Object.entries(overlay)) {
+      if (value === null) {
+        delete result[key];
+      } else {
+        result[key] = value;
+      }
+    }
+  }
+  return result;
+}
+function shellEscape(arg) {
+  if (/[\s"'`$\\!&|;<>(){}[\]*?#~]/.test(arg)) {
+    return `"${arg.replace(/"/g, '\\"')}"`;
+  }
+  return arg;
+}
+function buildNodeModulesPath(cwd) {
+  const pathSeparator = process.platform === "win32" ? ";" : ":";
+  const existingPath = process.env.PATH ?? "";
+  const binPaths = [];
+  let current = resolve3(cwd);
+  while (true) {
+    binPaths.push(join4(current, "node_modules", ".bin"));
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return [...binPaths, existingPath].join(pathSeparator);
+}
+function normalizeCommand(run, nodeTimeout, passthrough, inheritedEnv) {
   if (typeof run === "string") {
+    let cmd = run;
+    if (passthrough && passthrough.length > 0) {
+      const escapedArgs = passthrough.map(shellEscape).join(" ");
+      cmd = `${run} ${escapedArgs}`;
+    }
     return {
-      cmd: run,
+      cmd,
       args: [],
       shell: true,
-      timeout: nodeTimeout
+      timeout: nodeTimeout,
+      env: inheritedEnv
     };
   }
+  const args = passthrough ? [...run.args, ...passthrough] : run.args;
+  const env = mergeEnv(inheritedEnv ?? {}, run.env);
   return {
-    ...run,
+    cmd: run.cmd,
+    args,
+    cwd: run.cwd,
+    env: Object.keys(env).length > 0 ? env : void 0,
     shell: false,
     // Command-level timeout takes precedence over node-level timeout
     timeout: run.timeout ?? nodeTimeout
@@ -1722,12 +1815,18 @@ function normalizeCommand(run, nodeTimeout) {
 }
 async function executeCommand(command, cwd, tracker, path) {
   const start = Date.now();
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     const useShell = command.shell || process.platform === "win32";
+    const effectiveCwd = command.cwd ?? cwd;
+    const finalEnv = buildFinalEnv(
+      process.env,
+      buildNodeModulesPath(effectiveCwd),
+      command.env
+    );
     const proc = spawn(command.cmd, command.args, {
       shell: useShell,
-      cwd: command.cwd ?? cwd,
-      env: { ...process.env, NO_COLOR: "1", ...command.env }
+      cwd: effectiveCwd,
+      env: finalEnv
     });
     if (tracker && path) {
       tracker.registerProcess(path, proc);
@@ -1760,7 +1859,7 @@ async function executeCommand(command, cwd, tracker, path) {
       }
       const durationMs = Date.now() - start;
       const killed = signal === "SIGTERM" || code === 143 || (tracker?.wasKilled(path ?? "") ?? false);
-      resolve3({
+      resolve4({
         code: code ?? 1,
         output,
         durationMs,
@@ -1777,7 +1876,7 @@ async function executeCommand(command, cwd, tracker, path) {
         tracker.unregisterProcess(path);
       }
       const durationMs = Date.now() - start;
-      resolve3({
+      resolve4({
         code: 1,
         output: `Failed to execute command: ${err.message}`,
         durationMs,
@@ -1812,11 +1911,13 @@ var VerificationRunner = class {
   options;
   callbacks;
   dependencyTracker;
-  constructor(options = {}, registry = defaultRegistry, callbacks = {}) {
+  configEnv;
+  constructor(options = {}, registry = defaultRegistry, callbacks = {}, configEnv = {}) {
     this.options = options;
     this.registry = registry;
     this.callbacks = callbacks;
     this.dependencyTracker = new ReportingDependencyTracker();
+    this.configEnv = configEnv;
   }
   /**
    * Run all verification tasks
@@ -1825,7 +1926,8 @@ var VerificationRunner = class {
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
     const wallStart = Date.now();
     this.dependencyTracker.initialize(tasks);
-    const results = await this.runNodes(tasks, "");
+    const baseEnv = mergeEnv({}, this.configEnv);
+    const results = await this.runNodes(tasks, "", "parallel", baseEnv);
     const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
     const durationMs = Date.now() - wallStart;
     const allOk = results.every((r) => r.ok);
@@ -1840,7 +1942,7 @@ var VerificationRunner = class {
   /**
    * Run a list of nodes with the appropriate strategy
    */
-  async runNodes(nodes, parentPath, strategy = "parallel") {
+  async runNodes(nodes, parentPath, strategy = "parallel", inheritedEnv = {}) {
     const filteredNodes = nodes.filter(
       (node) => hasMatchingDescendant(node, parentPath, this.options.filter)
     );
@@ -1850,19 +1952,21 @@ var VerificationRunner = class {
     switch (strategy) {
       case "parallel":
         return Promise.all(
-          filteredNodes.map((node) => this.runNode(node, parentPath))
+          filteredNodes.map(
+            (node) => this.runNode(node, parentPath, inheritedEnv)
+          )
         );
       case "sequential": {
         const results = [];
         for (const node of filteredNodes) {
-          results.push(await this.runNode(node, parentPath));
+          results.push(await this.runNode(node, parentPath, inheritedEnv));
         }
         return results;
       }
       case "fail-fast": {
         const results = [];
         for (const node of filteredNodes) {
-          const result = await this.runNode(node, parentPath);
+          const result = await this.runNode(node, parentPath, inheritedEnv);
           results.push(result);
           if (!result.ok) {
             break;
@@ -1875,8 +1979,9 @@ var VerificationRunner = class {
   /**
    * Run a single node (leaf or group)
    */
-  async runNode(node, parentPath) {
+  async runNode(node, parentPath, inheritedEnv = {}) {
     const path = buildTaskPath(parentPath, node.key);
+    const nodeEnv = mergeEnv(inheritedEnv, node.env);
     this.dependencyTracker.markActive(path);
     this.callbacks.onTaskStart?.(path, node.key);
     if (node.children && node.children.length > 0) {
@@ -1884,12 +1989,13 @@ var VerificationRunner = class {
       const childResults = await this.runNodes(
         node.children,
         path,
-        node.strategy ?? "parallel"
+        node.strategy ?? "parallel",
+        nodeEnv
       );
       const durationMs2 = Date.now() - start;
-      const allOk = childResults.every((r) => r.ok || r.suppressed);
-      const allSuppressed = childResults.length > 0 && childResults.every((r) => r.suppressed);
-      const anySuppressed = childResults.some((r) => r.suppressed);
+      const allOk = childResults.every((r) => r.ok || r.blocked);
+      const allBlocked = childResults.length > 0 && childResults.every((r) => r.blocked);
+      const anyBlocked = childResults.some((r) => r.blocked);
       const result2 = {
         key: node.key,
         path,
@@ -1900,10 +2006,10 @@ var VerificationRunner = class {
         summaryLine: allOk ? node.successLabel ?? `${node.key}: all passed` : node.failureLabel ?? `${node.key}: some failed`,
         children: childResults
       };
-      if (allSuppressed) {
-        result2.suppressed = true;
-        result2.suppressedBy = childResults[0].suppressedBy;
-      } else if (anySuppressed && !allOk) {
+      if (allBlocked) {
+        result2.blocked = true;
+        result2.blockedBy = childResults[0].blockedBy;
+      } else if (anyBlocked && !allOk) {
       }
       this.dependencyTracker.recordResult(result2);
       this.callbacks.onTaskComplete?.(result2);
@@ -1923,7 +2029,13 @@ var VerificationRunner = class {
       this.callbacks.onTaskComplete?.(result2);
       return result2;
     }
-    const command = normalizeCommand(node.run, node.timeout);
+    const passthrough = this.options.passthrough;
+    const command = normalizeCommand(
+      node.run,
+      node.timeout,
+      passthrough,
+      nodeEnv
+    );
     const cwd = this.options.cwd ?? process.cwd();
     const { code, output, durationMs, killed, timedOut } = await executeCommand(
       command,
@@ -1958,8 +2070,8 @@ var VerificationRunner = class {
         durationMs,
         output,
         summaryLine: `${node.key}: terminated`,
-        suppressed: true,
-        suppressedBy: failedDep ?? "unknown"
+        blocked: true,
+        blockedBy: failedDep ?? "unknown"
       };
       this.dependencyTracker.recordResult(result2);
       this.callbacks.onTaskComplete?.(result2);
@@ -1995,8 +2107,8 @@ var VerificationRunner = class {
         if (failedDep) {
           result = {
             ...result,
-            suppressed: true,
-            suppressedBy: failedDep
+            blocked: true,
+            blockedBy: failedDep
           };
         }
       }
@@ -2021,10 +2133,15 @@ async function verify(config, cliOptions) {
   }
   const reporter = createReporter(options);
   reporter.onStart?.(config.tasks);
-  const runner = new VerificationRunner(options, void 0, {
-    onTaskStart: (path, key) => reporter.onTaskStart(path, key),
-    onTaskComplete: (result2) => reporter.onTaskComplete(result2)
-  });
+  const runner = new VerificationRunner(
+    options,
+    void 0,
+    {
+      onTaskStart: (path, key) => reporter.onTaskStart(path, key),
+      onTaskComplete: (result2) => reporter.onTaskComplete(result2)
+    },
+    config.env
+  );
   const result = await runner.run(config.tasks);
   reporter.onFinish?.();
   reporter.outputLogs(result.tasks, options.logs ?? "failed");