@qawolf/cli 1.7.2 → 1.7.4

package/dist/cli.js

@@ -8514,7 +8514,7 @@ var require_BufferList = __commonJS((exports, module) => {
       this.head = this.tail = null;
       this.length = 0;
     };
-    BufferList.prototype.join = function join34(s3) {
+    BufferList.prototype.join = function join35(s3) {
       if (this.length === 0)
         return "";
       var p3 = this.head;
@@ -23070,7 +23070,7 @@ var require_BufferList2 = __commonJS((exports, module) => {
       this.head = this.tail = null;
       this.length = 0;
     };
-    BufferList.prototype.join = function join34(s3) {
+    BufferList.prototype.join = function join35(s3) {
       if (this.length === 0)
         return "";
       var p3 = this.head;
@@ -144620,19 +144620,19 @@ async function takeScreenshotBidi(filepath, options) {
     type: imageFormat,
     quality
   };
-  const clip2 = options?.clip ? {
+  const clip3 = options?.clip ? {
     type: "box",
     x: options.clip.x,
     y: options.clip.y,
     width: options.clip.width,
     height: options.clip.height
   } : undefined;
-  if (clip2) {
-    if (typeof clip2.x !== "number" || typeof clip2.y !== "number" || typeof clip2.width !== "number" || typeof clip2.height !== "number") {
+  if (clip3) {
+    if (typeof clip3.x !== "number" || typeof clip3.y !== "number" || typeof clip3.width !== "number" || typeof clip3.height !== "number") {
       throw new Error("Invalid clip, use an object with x, y, width and height properties");
     }
   }
-  const { data: data2 } = contextManager.findParentContext(context, tree.contexts) ? await browser.$("html").getElement().then((el) => this.takeElementScreenshot(el.elementId).then((data22) => ({ data: data22 }))) : await this.browsingContextCaptureScreenshot({ context, origin, format, clip: clip2 });
+  const { data: data2 } = contextManager.findParentContext(context, tree.contexts) ? await browser.$("html").getElement().then((el) => this.takeElementScreenshot(el.elementId).then((data22) => ({ data: data22 }))) : await this.browsingContextCaptureScreenshot({ context, origin, format, clip: clip3 });
   return data2;
 }
 async function saveElementScreenshot(filepath) {
@@ -155283,7 +155283,8 @@ var doctorMessages = {
   playwright: {
     notFound: (path) => toolNotInstalled("Playwright", path),
     launchFailed: "Could not launch Playwright. Try reinstalling the qawolf CLI.",
-    versionUnparseable: "Could not parse playwright version output"
+    versionUnparseable: "Could not parse playwright version output",
+    versionMismatch: (installed, pinned) => `Playwright ${installed} is installed but the flow runtime requires ${pinned}; local runs will fail to launch browsers. Run \`qawolf install\` to repair the runtime dependencies.`
   },
   appium: {
     notFound: (path) => toolNotInstalled("Appium", path),
@@ -155395,11 +155396,20 @@ var initMessages = {
   outro: "Run `qawolf auth login`, then `qawolf flows pull`, then `qawolf flows run`.",
   createPackageJsonPrompt: "Create package.json (required to run flows)?",
   skippedCreatingPackageJson: "Skipped package.json",
-  skippedAddingTestE2e: "Skipped adding test:e2e to package.json",
+  skippedUpdatingPackageJson: "Skipped updating package.json",
   createdPackageJson: "Created package.json",
-  packageJsonInvalidJson: "package.json is not valid JSON — skipped adding `test:e2e`",
-  packageJsonHasTestE2e: "package.json already has `test:e2e` — skipped",
-  addTestE2ePrompt: "Add `test:e2e: qawolf flows run` to package.json?",
+  packageJsonInvalidJson: "`package.json` contains invalid JSON. Correct the JSON syntax, then run `qawolf init` again.",
+  packageJsonNotAnObject: "`package.json` must contain a JSON object. Update it, then run `qawolf init` again.",
+  packageJsonMalformedSection: (field) => `The \`${field}\` field in \`package.json\` must be a JSON object. Update it, then run \`qawolf init\` again.`,
+  packageJsonHasTestE2e: "package.json already has `test:e2e` — leaving it as is",
+  packageJsonUpToDate: "package.json already configured — nothing to update",
+  typeChanged: (from) => `Changed "type" from "${from}" to "module" — .js files in this package now load as ES modules.`,
+  pkgChanges: {
+    script: "add `test:e2e` script",
+    type: 'set "type": "module"',
+    flowsDep: "add @qawolf/flows dependency"
+  },
+  updatePackageJsonPrompt: (changes) => `Update package.json (${changes.join(", ")})?`,
   updatedPackageJson: "Updated package.json",
   overwritePrompt: (relPath) => `Overwrite ${relPath}?`,
   skippedFile: (relPath) => `Skipped ${relPath}`,
@@ -170184,49 +170194,86 @@ function createLoggingSystem(opts) {
   };
 }
 
+// src/shell/platform/parseErrorBody.ts
+var defaultMaxLength = 1024;
+function asRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+}
+function asString(value) {
+  return typeof value === "string" ? value : undefined;
+}
+function extractMessage(parsed) {
+  const root = asRecord(parsed);
+  if (!root)
+    return;
+  const flat = asString(root["error"]);
+  if (flat !== undefined)
+    return flat;
+  const error51 = asRecord(root["error"]);
+  if (!error51)
+    return;
+  const json2 = asRecord(error51["json"]);
+  return asString(json2?.["message"]) ?? asString(error51["message"]);
+}
+function parseErrorBody(body, maxLength = defaultMaxLength) {
+  if (!body)
+    return "";
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return "";
+  }
+  const message = extractMessage(parsed)?.trim();
+  if (!message)
+    return "";
+  return clip(message, maxLength);
+}
+function clip(message, maxLength) {
+  if (message.length <= maxLength)
+    return message;
+  return maxLength < 1 ? "" : `${message.slice(0, maxLength - 1)}…`;
+}
+
 // src/shell/platform/describeErrors.ts
 var m = authMessages.errors;
+var inlineReasonMaxLength = 200;
 function describeIdentityError(err) {
   if (err.kind === "http") {
     if (err.status === 401 || err.status === 403) {
-      return m.identity.invalidOrUnauthorized;
+      return { error: m.identity.invalidOrUnauthorized };
     }
-    return m.identity.couldNotVerify(parseErrorBody(err.body), err.status);
+    return {
+      error: m.identity.couldNotVerify(parseErrorBody(err.body, inlineReasonMaxLength), err.status)
+    };
   }
   if (err.kind === "network") {
-    return m.identity.couldNotVerifyNetwork(err.cause.message);
+    return { error: m.identity.couldNotVerifyNetwork(err.cause.message) };
   }
-  if (err.kind === "timeout")
-    return m.identity.timedOut(err.timeoutMs);
-  return m.identity.unexpectedFormat;
-}
-function parseErrorBody(body) {
-  if (!body)
-    return "";
-  try {
-    const parsed = JSON.parse(body);
-    if (typeof parsed === "object" && parsed !== null && "error" in parsed && typeof parsed.error === "string") {
-      return parsed.error;
-    }
-  } catch {}
-  return "";
+  if (err.kind === "timeout") {
+    return { error: m.identity.timedOut(err.timeoutMs) };
+  }
+  return { error: m.identity.unexpectedFormat };
 }
 function describeRequestError(err, baseUrl, noun) {
   if (err.kind === "http") {
+    const reason = parseErrorBody(err.body);
+    const body = reason ? { errorBody: reason } : {};
     if (err.status === 401)
-      return m.request.rejected401(noun);
+      return { error: m.request.rejected401(noun), ...body };
     if (err.status === 403)
-      return m.request.rejected403(noun);
+      return { error: m.request.rejected403(noun), ...body };
     if (err.status === 404)
-      return m.request.notFound404(noun);
-    return m.request.failedWithStatus(err.status, noun);
+      return { error: m.request.notFound404(noun), ...body };
+    return { error: m.request.failedWithStatus(err.status, noun), ...body };
   }
   if (err.kind === "network") {
-    return m.request.networkUnreachable(baseUrl, noun);
+    return { error: m.request.networkUnreachable(baseUrl, noun) };
   }
-  if (err.kind === "timeout")
-    return m.request.timedOut(err.timeoutMs, noun);
-  return m.request.unexpectedResponse(noun);
+  if (err.kind === "timeout") {
+    return { error: m.request.timedOut(err.timeoutMs, noun) };
+  }
+  return { error: m.request.unexpectedResponse(noun) };
 }
 function describeBundleDownloadError(err) {
   if (err.kind === "http") {
@@ -170261,6 +170308,9 @@ import { setTimeout as setTimeout2 } from "node:timers/promises";
 var sleep = (ms) => setTimeout2(ms);
 
 // src/shell/platform/requestWithRetry.ts
+function failureFields(failure) {
+  return failure.errorBody ? { error: failure.error, errorBody: failure.errorBody } : { error: failure.error };
+}
 async function requestWithRetry(args) {
   const sleep2 = args.sleep ?? sleep;
   for (let attempt = 0;; attempt++) {
@@ -170270,7 +170320,7 @@ async function requestWithRetry(args) {
     const backoff = args.backoffMs[attempt];
     const retryable = result.error.kind === "network" || result.error.kind === "timeout";
     if (backoff === undefined || !retryable) {
-      return { ok: false, error: args.describe(result.error) };
+      return { ok: false, ...args.describe(result.error) };
     }
     await sleep2(backoff);
   }
@@ -171175,15 +171225,15 @@ function createTrpcClient(apiKey, deps) {
     }
   };
 }
-function clip(text) {
+function clip2(text) {
   return text.length > 200 ? text.slice(0, 200) + "…" : text;
 }
 function summarize(error51) {
   if (error51.kind === "http")
-    return `${error51.status} ${clip(error51.body)}`;
+    return `${error51.status} ${clip2(error51.body)}`;
   if (error51.kind === "timeout")
     return `timed out after ${error51.timeoutMs}ms`;
-  return clip(error51.cause.message);
+  return clip2(error51.cause.message);
 }
 
 // src/shell/platform/downloadBundle.ts
@@ -174616,7 +174666,7 @@ function startUpdateCheck(deps) {
 // package.json
 var package_default = {
   name: "@qawolf/cli",
-  version: "1.7.2",
+  version: "1.7.4",
   description: "Run and manage QA Wolf flows from the terminal, CI, or an AI agent",
   keywords: [
     "automation",
@@ -174676,7 +174726,6 @@ var package_default = {
     "@clack/prompts": "1.5.1",
     "@napi-rs/keyring": "1.3.0",
     "@oxc-node/core": "0.1.0",
-    "@playwright/test": "1.62.0",
     "@qawolf/api-contracts": "0.22.0",
     "@qawolf/emails": "1.1.1",
     "@qawolf/flow-targets": "1.0.0",
@@ -174770,7 +174819,7 @@ function withContext(signals, fn) {
     try {
       const result = await fn(ctx);
       if (result !== undefined) {
-        ctx.ui.error(result.error);
+        ctx.ui.error(result.error, result.errorBody);
         process.exitCode = result.exitCode ?? 1;
       }
     } catch (err) {
@@ -174803,7 +174852,7 @@ function withAuthContext(signals, fn, deps = {}) {
         apiKeySource: resolved.source
       });
       if (result !== undefined) {
-        ctx.ui.error(result.error);
+        ctx.ui.error(result.error, result.errorBody);
         process.exitCode = result.exitCode ?? 1;
       }
     } catch (err) {
@@ -175047,9 +175096,6 @@ function nodeModulesBinCandidates(envDir, name, platform) {
 function appiumCliCandidates(envDir, platform) {
   return nodeModulesBinCandidates(envDir, "appium", platform);
 }
-function playwrightCliCandidates(envDir, platform) {
-  return nodeModulesBinCandidates(envDir, "playwright", platform);
-}
 
 // src/domains/doctor/checks/androidAppium.ts
 function firstLine(result) {
@@ -175412,19 +175458,48 @@ async function checkNpmRegistry(deps) {
   return { name: "npm-registry", status: "pass" };
 }
 
+// src/core/playwrightCli.ts
+import { join as join13 } from "node:path";
+function playwrightCliJsPath(envDir) {
+  return join13(envDir, "node_modules", "playwright", "cli.js");
+}
+function playwrightCliInvocation(args) {
+  return {
+    cmd: args.execPath,
+    args: [playwrightCliJsPath(args.envDir), ...args.cliArgs],
+    env: { BUN_BE_BUN: "1" }
+  };
+}
+
+// src/generated/dependencyVersions.ts
+var flowsVersion = "0.1.4";
+var playwrightVersion = "1.62.0";
+var emailsVersion = "1.1.1";
+var testkitVersion = "1.1.1";
+var appiumVersion = "2.11.3";
+var appiumXcuitestDriverVersion = "9.10.5";
+var appiumUiautomator2DriverVersion = "3.7.0";
+var expectWebdriverioVersion = "5.6.5";
+
 // src/domains/doctor/checks/playwright.ts
 async function checkPlaywright(deps) {
-  const candidates = deps.envDir ? playwrightCliCandidates(deps.envDir, deps.platform) : [];
-  const cliPath = candidates.find(deps.checkExists);
-  if (cliPath === undefined) {
+  const { envDir } = deps;
+  const cliJsPath = envDir === undefined ? undefined : playwrightCliJsPath(envDir);
+  if (envDir === undefined || cliJsPath === undefined || !deps.checkExists(cliJsPath)) {
     return {
       name: "playwright",
       status: "fail",
-      detail: doctorMessages.playwright.notFound(candidates[0])
+      detail: doctorMessages.playwright.notFound(cliJsPath)
     };
   }
-  const result = await deps.spawn(cliPath, ["--version"], {
-    platform: deps.platform
+  const invocation = playwrightCliInvocation({
+    envDir,
+    execPath: deps.execPath,
+    cliArgs: ["--version"]
+  });
+  const result = await deps.spawn(invocation.cmd, invocation.args, {
+    platform: deps.platform,
+    env: invocation.env
   });
   if (result.exitCode < 0) {
     return {
@@ -175446,6 +175521,14 @@ async function checkPlaywright(deps) {
       detail: doctorMessages.playwright.versionUnparseable
     };
   }
+  if (version2 !== playwrightVersion) {
+    return {
+      name: "playwright",
+      status: "fail",
+      version: version2,
+      detail: doctorMessages.playwright.versionMismatch(version2, playwrightVersion)
+    };
+  }
   return { name: "playwright", status: "pass", version: version2 };
 }
 
@@ -175466,6 +175549,7 @@ async function runChecks(deps) {
     }),
     checkPlaywright({
       spawn: deps.spawn,
+      execPath: deps.execPath,
       envDir: deps.envDir,
       platform: deps.platform,
       checkExists: deps.checkExists
@@ -175525,11 +175609,11 @@ function renderResults(ui, results) {
 }
 
 // src/domains/flows/ensureDeps.ts
-import { dirname as dirname4, join as join13 } from "node:path";
+import { dirname as dirname4, join as join14 } from "node:path";
 function findEnvDir(flowPath, fs2) {
   let dir = dirname4(flowPath);
   while (true) {
-    if (fs2.existsSync(join13(dir, "package.json")))
+    if (fs2.existsSync(join14(dir, "package.json")))
       return dir;
     const parent = dirname4(dir);
     if (parent === dir)
@@ -175555,7 +175639,7 @@ function resolveProjectDirSafe(files, fs2) {
 }
 
 // src/domains/flows/expand.ts
-import { join as join14, resolve as resolve3 } from "node:path";
+import { join as join15, resolve as resolve3 } from "node:path";
 
 // node_modules/tinyglobby/dist/index.mjs
 import { readdir, readdirSync, realpath, realpathSync, stat, statSync } from "fs";
@@ -176446,11 +176530,11 @@ function makePeekFlowMeta(fs2) {
   };
 }
 async function resolveGlobRoots(cwd, fs2) {
-  const qawolfPath = join14(cwd, ".qawolf");
+  const qawolfPath = join15(cwd, ".qawolf");
   let envDirs = [];
   try {
     const entries = await fs2.readdirWithTypes(qawolfPath);
-    envDirs = entries.filter((e) => e.isDirectory()).map((e) => join14(qawolfPath, e.name));
+    envDirs = entries.filter((e) => e.isDirectory()).map((e) => join15(qawolfPath, e.name));
   } catch {}
   return [cwd, ...envDirs];
 }
@@ -176475,21 +176559,11 @@ async function expandPatterns(patterns, cwd, logger, fs2) {
 }
 
 // src/domains/runtimeEnv/clearRuntimeEnv.ts
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 
 // src/domains/runtimeEnv/managedEnvDir.ts
 import { createHash } from "node:crypto";
-import { join as join15, resolve as resolve4 } from "node:path";
-
-// src/generated/dependencyVersions.ts
-var flowsVersion = "0.1.4";
-var playwrightVersion = "1.62.0";
-var emailsVersion = "1.1.1";
-var testkitVersion = "1.1.1";
-var appiumVersion = "2.11.3";
-var appiumXcuitestDriverVersion = "9.10.5";
-var appiumUiautomator2DriverVersion = "3.7.0";
-var expectWebdriverioVersion = "5.6.5";
+import { join as join16, resolve as resolve4 } from "node:path";
 
 // src/domains/runtimeEnv/pinnedPackages.ts
 var pinnedPackages = [
@@ -176522,19 +176596,19 @@ function managedEnvBaseDir() {
   const override = process.env["QAWOLF_RUNTIME_DIR"]?.trim();
   if (override)
     return resolve4(override);
-  return join15(getDataDir(), "runtime");
+  return join16(getDataDir(), "runtime");
 }
 function runStagingRoot() {
   return `${managedEnvBaseDir()}-runs`;
 }
 function managedEnvDir() {
-  return join15(managedEnvBaseDir(), managedEnvHash());
+  return join16(managedEnvBaseDir(), managedEnvHash());
 }
 async function scaffoldManagedEnv(dir, fs2) {
   await fs2.mkdir(dir, { recursive: true });
   const dependencies = Object.fromEntries(pinnedPackages.map(({ name, version: version2 }) => [name, version2]));
-  await fs2.writeFile(join15(dir, "package.json"), JSON.stringify({ name: "qawolf-runtime", private: true, dependencies }, undefined, 2));
-  await fs2.writeFile(join15(dir, ".npmrc"), `@qawolf:registry=https://registry.npmjs.org/
+  await fs2.writeFile(join16(dir, "package.json"), JSON.stringify({ name: "qawolf-runtime", private: true, dependencies }, undefined, 2));
+  await fs2.writeFile(join16(dir, ".npmrc"), `@qawolf:registry=https://registry.npmjs.org/
 `);
 }
 
@@ -176556,14 +176630,14 @@ async function isManagedRuntimeBase(dir, fs2) {
   for (const entry of entries) {
     if (!entry.isDirectory())
       return false;
-    if (!await hasRuntimeSentinel(join16(dir, entry.name), fs2))
+    if (!await hasRuntimeSentinel(join17(dir, entry.name), fs2))
       return false;
   }
   return true;
 }
 async function hasRuntimeSentinel(hashDir, fs2) {
   try {
-    const pkg = JSON.parse(await fs2.readFile(join16(hashDir, "package.json")));
+    const pkg = JSON.parse(await fs2.readFile(join17(hashDir, "package.json")));
     return pkg.name === runtimeSentinel;
   } catch {
     return false;
@@ -176637,10 +176711,10 @@ function spawnNpmInstall(cwd, spawn2 = spawn) {
 }
 
 // src/domains/runtimeEnv/resolvePinned.ts
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 function readInstalledVersion(dir, pkgName, fs2) {
   try {
-    const pkgPath = join17(dir, "node_modules", ...pkgName.split("/"), "package.json");
+    const pkgPath = join18(dir, "node_modules", ...pkgName.split("/"), "package.json");
     const raw = JSON.parse(fs2.readFileSync(pkgPath));
     const { version: version2 } = raw;
     return typeof version2 === "string" ? version2 : undefined;
@@ -176649,8 +176723,18 @@ function readInstalledVersion(dir, pkgName, fs2) {
   }
 }
 var shims = [
-  { name: "playwright", candidates: playwrightCliCandidates },
-  { name: "appium", candidates: appiumCliCandidates }
+  {
+    name: "playwright",
+    display: "node_modules/playwright/cli.js",
+    candidates: (dir, _platform) => [
+      playwrightCliJsPath(dir)
+    ]
+  },
+  {
+    name: "appium",
+    display: "node_modules/.bin/appium",
+    candidates: appiumCliCandidates
+  }
 ];
 function pinnedResolutionFailures(dir, fs2, platform) {
   const failures = [];
@@ -176660,16 +176744,16 @@ function pinnedResolutionFailures(dir, fs2, platform) {
       failures.push({ kind: "package", name, pinned: version2, installed });
     }
   }
-  for (const { name, candidates } of shims) {
+  for (const { name, display, candidates } of shims) {
     if (!candidates(dir, platform).some((p2) => fs2.existsSync(p2))) {
-      failures.push({ kind: "shim", name });
+      failures.push({ kind: "shim", name, display });
     }
   }
   return failures;
 }
 function describePinnedFailure(failure) {
   if (failure.kind === "shim") {
-    return `node_modules/.bin/${failure.name} (missing)`;
+    return `${failure.display} (missing)`;
   }
   return failure.installed === undefined ? `${failure.name} (missing, pinned ${failure.pinned})` : `${failure.name} ${failure.installed} (pinned ${failure.pinned})`;
 }
@@ -176678,10 +176762,10 @@ function allPinnedResolved(dir, fs2, platform) {
 }
 
 // src/domains/runtimeEnv/shimDeps.ts
-import { join as join19 } from "node:path";
+import { join as join20 } from "node:path";
 
 // src/shell/resolveExport.ts
-import { join as join18 } from "node:path";
+import { join as join19 } from "node:path";
 function pickPath(entry, preference) {
   if (typeof entry === "string")
     return entry;
@@ -176713,28 +176797,28 @@ function resolveFromEnvDir(envDir, specifier, preference = "esm", fs2 = makeDefa
   const pkgName = parts.slice(0, pkgPartCount).join("/");
   const rest = parts.slice(pkgPartCount);
   const subpath = rest.length > 0 ? "./" + rest.join("/") : ".";
-  const pkgDir = join18(envDir, "node_modules", ...pkgName.split("/"));
+  const pkgDir = join19(envDir, "node_modules", ...pkgName.split("/"));
   let pkg;
   try {
-    pkg = JSON.parse(fs2.readFileSync(join18(pkgDir, "package.json")));
+    pkg = JSON.parse(fs2.readFileSync(join19(pkgDir, "package.json")));
   } catch (err) {
     if (isNoEntError(err))
-      throw new Error(`Package '${pkgName}' not found in ${join18(envDir, "node_modules")}`, { cause: err });
+      throw new Error(`Package '${pkgName}' not found in ${join19(envDir, "node_modules")}`, { cause: err });
     throw err;
   }
   const exportsMap = normalizeExports(pkg.exports);
   const entry = exportsMap?.[subpath];
   const relative3 = pickPath(entry, preference) ?? (subpath === "." ? pkg.module ?? pkg.main : undefined);
   if (!relative3) {
-    throw new Error(`No entry for "${subpath}" in exports of ${join18(pkgDir, "package.json")}`);
+    throw new Error(`No entry for "${subpath}" in exports of ${join19(pkgDir, "package.json")}`);
   }
-  return join18(pkgDir, relative3);
+  return join19(pkgDir, relative3);
 }
 
 // src/domains/runtimeEnv/shimDeps.ts
 function readShimMarker(shimDir, fs2) {
   try {
-    const pkg = JSON.parse(fs2.readFileSync(join19(shimDir, "package.json")));
+    const pkg = JSON.parse(fs2.readFileSync(join20(shimDir, "package.json")));
     if (pkg._qawolf_format) {
       return {
         _qawolf_version: pkg._qawolf_version ?? "",
@@ -176750,11 +176834,11 @@ function resolveBunBuild(bunBuild) {
   return bunBuild === false ? undefined : { build: bunBuild };
 }
 async function removeStaleShims(flowsDir, flowsDeps, fs2) {
-  const shimsDir = join19(flowsDir, "node_modules");
+  const shimsDir = join20(flowsDir, "node_modules");
   if (!fs2.existsSync(shimsDir))
     return;
   for (const dep of flowsDeps) {
-    const shimDepDir = join19(shimsDir, ...dep.split("/"));
+    const shimDepDir = join20(shimsDir, ...dep.split("/"));
     if (readShimMarker(shimDepDir, fs2)) {
       await fs2.rm(shimDepDir, { recursive: true, force: true });
     }
@@ -176763,17 +176847,17 @@ async function removeStaleShims(flowsDir, flowsDeps, fs2) {
 async function buildDepShim(args) {
   const { envDir, flowsDir, dep, fs: fs2, build: build2 } = args;
   const depParts = dep.split("/");
-  const depDir = join19(envDir, "node_modules", ...depParts);
+  const depDir = join20(envDir, "node_modules", ...depParts);
   if (!fs2.existsSync(depDir))
     return;
   let depVersion;
   try {
-    const pkg = JSON.parse(fs2.readFileSync(join19(depDir, "package.json")));
+    const pkg = JSON.parse(fs2.readFileSync(join20(depDir, "package.json")));
     depVersion = pkg.version ?? "unknown";
   } catch {
     depVersion = "unknown";
   }
-  const shimDir = join19(flowsDir, "node_modules", ...depParts);
+  const shimDir = join20(flowsDir, "node_modules", ...depParts);
   if (fs2.existsSync(shimDir)) {
     const marker = readShimMarker(shimDir, fs2);
     if (!marker)
@@ -176800,20 +176884,20 @@ async function buildDepShim(args) {
   }
   const shimCode = await output.text();
   await fs2.mkdir(shimDir, { recursive: true });
-  await fs2.writeFile(join19(shimDir, "package.json"), JSON.stringify({
+  await fs2.writeFile(join20(shimDir, "package.json"), JSON.stringify({
     name: dep,
     _qawolf_version: depVersion,
     _qawolf_format: "bun-build-v1"
   }));
-  await fs2.writeFile(join19(shimDir, "index.js"), shimCode);
+  await fs2.writeFile(join20(shimDir, "index.js"), shimCode);
 }
 async function shimFlowsDeps(envDir, fs2 = makeDefaultFs(), bunBuild) {
-  const flowsDir = join19(envDir, "node_modules", "@qawolf", "flows");
+  const flowsDir = join20(envDir, "node_modules", "@qawolf", "flows");
   if (!fs2.existsSync(flowsDir))
     return;
   let flowsDeps;
   try {
-    const flowsPkg = JSON.parse(fs2.readFileSync(join19(flowsDir, "package.json")));
+    const flowsPkg = JSON.parse(fs2.readFileSync(join20(flowsDir, "package.json")));
     flowsDeps = Object.keys(flowsPkg.dependencies ?? {});
   } catch {
     return;
@@ -176937,6 +177021,7 @@ async function handleDoctor(ctx, opts) {
     apiKey: resolved?.key,
     fetch: globalThis.fetch,
     spawn: defaultSpawn,
+    execPath: process.execPath,
     apiBaseUrl: ctx.apiBaseUrl,
     enginesNode: package_default.engines.node,
     processVersion: process.version,
@@ -177044,9 +177129,8 @@ async function flowsListRemote(ctx, pattern, options) {
     environmentId: options.env,
     includeDrafts: options.includeDrafts
   });
-  if (!result.ok) {
-    return { error: result.error };
-  }
+  if (!result.ok)
+    return failureFields(result);
   const matches = pattern ? import_picomatch2.default(pattern) : undefined;
   const items = result.value.flows.filter((f2) => !matches || matches(f2.path)).map((f2) => ({
     flowId: f2.flowId,
@@ -177079,11 +177163,11 @@ async function flowsListRemote(ctx, pattern, options) {
 }
 
 // src/domains/flows/pull/handler.ts
-import { dirname as dirname7, join as join24, resolve as resolve8 } from "node:path";
+import { dirname as dirname7, join as join25, resolve as resolve8 } from "node:path";
 
 // src/shell/manifest/io.ts
 import { createHash as createHash2 } from "node:crypto";
-import { join as join20 } from "node:path";
+import { join as join21 } from "node:path";
 var manifestFilename = ".manifest.json";
 var flowEntrySchema = exports_external.object({
   path: exports_external.string(),
@@ -177102,7 +177186,7 @@ var manifestSchema = exports_external.object({
 async function readManifest(envDir, fs2 = makeDefaultFs()) {
   let raw;
   try {
-    raw = await fs2.readFile(join20(envDir, manifestFilename));
+    raw = await fs2.readFile(join21(envDir, manifestFilename));
   } catch (err) {
     if (isNoEntError(err))
       return "missing";
@@ -177130,7 +177214,7 @@ async function readManifest(envDir, fs2 = makeDefaultFs()) {
 }
 async function writeManifest(envDir, manifest, fs2 = makeDefaultFs()) {
   const body = JSON.stringify(manifest, undefined, 2);
-  await fs2.writeFile(join20(envDir, manifestFilename), `${body}
+  await fs2.writeFile(join21(envDir, manifestFilename), `${body}
 `);
 }
 function hashFile(absPath, fs2 = makeDefaultFs()) {
@@ -177265,7 +177349,7 @@ async function checkSafety(args) {
 }
 
 // src/domains/flows/pull/bundle.ts
-import { join as join21, relative as relative4 } from "node:path";
+import { join as join22, relative as relative4 } from "node:path";
 async function flattenSingleWrapper(dir, fs2 = makeDefaultFs()) {
   const entries = await fs2.readdir(dir);
   if (entries.length !== 1)
@@ -177273,12 +177357,12 @@ async function flattenSingleWrapper(dir, fs2 = makeDefaultFs()) {
   const innerName = entries[0];
   if (!innerName)
     return;
-  const inner = join21(dir, innerName);
+  const inner = join22(dir, innerName);
   const innerStat = await fs2.stat(inner);
   if (!innerStat.isDirectory())
     return;
   for (const e of await fs2.readdir(inner)) {
-    await fs2.rename(join21(inner, e), join21(dir, e));
+    await fs2.rename(join22(inner, e), join22(dir, e));
   }
   const leftovers = await fs2.readdir(inner);
   if (leftovers.length > 0) {
@@ -177297,7 +177381,7 @@ async function buildManifest(args, fs2 = makeDefaultFs()) {
   const flowPaths = await walkForFlows(args.bundleDir, fs2);
   const flows = await Promise.all(flowPaths.map(async (rel) => ({
     path: rel,
-    contentHash: await hashFile(join21(args.bundleDir, rel), fs2)
+    contentHash: await hashFile(join22(args.bundleDir, rel), fs2)
   })));
   return {
     envId: args.envId,
@@ -177318,7 +177402,7 @@ async function walkForFlows(root, fs2) {
 async function walk(current, root, out, fs2) {
   const entries = await fs2.readdirWithTypes(current);
   for (const e of entries) {
-    const abs = join21(current, e.name);
+    const abs = join22(current, e.name);
     if (e.isDirectory()) {
       await walk(abs, root, out, fs2);
     } else if (e.isFile() && flowExtensions.some((ext) => e.name.endsWith(ext))) {
@@ -177331,11 +177415,11 @@ async function sampleQawolfCommittedAt(bundleDir, fs2 = makeDefaultFs()) {
   const sample = flowPaths[0];
   if (!sample)
     return;
-  return (await fs2.stat(join21(bundleDir, sample))).mtime.toISOString();
+  return (await fs2.stat(join22(bundleDir, sample))).mtime.toISOString();
 }
 
 // src/domains/flows/pull/applyTeamStorageRewrite.ts
-import { join as join22, relative as relative5 } from "node:path";
+import { join as join23, relative as relative5 } from "node:path";
 
 // src/domains/flows/pull/rewriteTeamStorage.ts
 var runnerMountPrefix = "/home/wolf/team-storage/";
@@ -177371,7 +177455,7 @@ function isFlowFile(name) {
 async function walk2(dir, out, fs2) {
   const entries = await fs2.readdirWithTypes(dir);
   for (const e of entries) {
-    const abs = join22(dir, e.name);
+    const abs = join23(dir, e.name);
     if (e.isDirectory()) {
       await walk2(abs, out, fs2);
     } else if (e.isFile() && isSourceFile(e.name)) {
@@ -177399,7 +177483,7 @@ async function applyTeamStorageRewrite(rootDir, fs2 = makeDefaultFs()) {
 }
 
 // src/domains/flows/pull/envVars.ts
-import { join as join23 } from "node:path";
+import { join as join24 } from "node:path";
 
 // src/core/dotenv.ts
 var bareKeyPattern = /^[A-Za-z_][A-Za-z0-9_]*$/;
@@ -177464,7 +177548,7 @@ function unquote(escaped) {
 async function writeEnvFile(envDir, vars, fs2 = makeDefaultFs()) {
   if (Object.keys(vars).length === 0)
     return;
-  await fs2.writeFile(join23(envDir, ".env"), serializeDotenv(vars), {
+  await fs2.writeFile(join24(envDir, ".env"), serializeDotenv(vars), {
     mode: 384
   });
 }
@@ -180837,8 +180921,8 @@ async function handleFlowsPull(ctx, opts, deps) {
     ctx.ui.error(validation.error);
     return { error: validation.error };
   }
-  const destAbs = resolve8(opts.out ?? join24(".qawolf", opts.env));
-  const assetsAbs = join24(dirname7(destAbs), "assets");
+  const destAbs = resolve8(opts.out ?? join25(".qawolf", opts.env));
+  const assetsAbs = join25(dirname7(destAbs), "assets");
   await resolvedDeps.fs.mkdir(assetsAbs, { recursive: true });
   const yes = opts.yes ?? false;
   let archive;
@@ -180904,7 +180988,7 @@ async function handleFlowsPull(ctx, opts, deps) {
         assetDownloadedCount: assetResult.downloadedCount,
         assetReusedCount: assetResult.reusedCount,
         assetSkippedCount: assetResult.skippedCount,
-        manifestPath: join24(result.envDir, manifestFilename)
+        manifestPath: join25(result.envDir, manifestFilename)
       }, "");
     }
   } finally {
@@ -180918,7 +181002,7 @@ var findContract = publicContractsV1.environment.find;
 async function pickEnvironment(deps) {
   const fetched = await fetchAllEnvironments(deps.platformClient);
   if (!fetched.ok)
-    return { kind: "error", error: fetched.error };
+    return { ...failureFields(fetched), kind: "error" };
   const environments = fetched.environments;
   if (environments.length === 0) {
     return { kind: "error", error: environmentsMessages.noEnvironments };
@@ -181011,6 +181095,7 @@ async function resolveRef2(deps, ref) {
   });
   if (!result.ok) {
     return {
+      ...failureFields(result),
       kind: "error",
       error: environmentsMessages.couldNotResolve(ref, result.error)
     };
@@ -181044,7 +181129,7 @@ function withResolvedEnv(signals, args, fn2) {
         return;
       }
       if (outcome.kind === "error") {
-        return { error: outcome.error };
+        return failureFields(outcome);
       }
       return fn2(ctx, outcome.env);
     })(opts, command);
@@ -181090,6 +181175,72 @@ function buildPatternArgs(pattern) {
   return pattern ? [pattern] : [];
 }
 
+// src/shell/reporter/createCompositeReporter.ts
+function callEach(reporters, pick2, event) {
+  for (const r2 of reporters) {
+    try {
+      pick2(r2)?.(event);
+    } catch (err) {
+      process.stderr.write(`[reporter error] ${String(err)}
+`);
+    }
+  }
+}
+function createCompositeReporter(reporters) {
+  return {
+    onFlowStart: (e) => callEach(reporters, (r2) => r2.onFlowStart, e),
+    onFlowPass: (e) => callEach(reporters, (r2) => r2.onFlowPass, e),
+    onFlowFail: (e) => callEach(reporters, (r2) => r2.onFlowFail, e),
+    onTestStart: (e) => callEach(reporters, (r2) => r2.onTestStart, e),
+    onTestResult: (e) => callEach(reporters, (r2) => r2.onTestResult, e),
+    onScreenshot: (e) => callEach(reporters, (r2) => r2.onScreenshot, e),
+    onRunComplete: (e) => callEach(reporters, (r2) => r2.onRunComplete, e)
+  };
+}
+
+// src/shell/reporter/formatErrorWithCause.ts
+function filterStack(stack) {
+  const cwd = process.cwd();
+  return stack.split(`
+`).filter((line) => {
+    if (!/^\s+at /.test(line))
+      return true;
+    return !line.includes("node_modules") && !line.includes("dist/cli.js");
+  }).map((line) => {
+    if (!/^\s+at /.test(line))
+      return line;
+    return line.replace(`file://${cwd}/`, "").replace(`${cwd}/`, "");
+  }).join(`
+`);
+}
+function renderCause(cause) {
+  if (cause instanceof Error)
+    return filterStack(cause.stack ?? cause.message);
+  if (typeof cause === "object" && cause !== null) {
+    const obj = cause;
+    if (typeof obj["message"] === "string")
+      return obj["message"];
+    try {
+      return JSON.stringify(cause);
+    } catch {
+      return String(cause);
+    }
+  }
+  return String(cause);
+}
+function formatErrorWithCause(err) {
+  const parts = [String(err)];
+  let cause = err.cause;
+  while (cause !== undefined && cause !== null) {
+    parts.push(`Caused by: ${renderCause(cause)}`);
+    if (!(cause instanceof Error))
+      break;
+    cause = cause.cause;
+  }
+  return parts.join(`
+`);
+}
+
 // src/domains/runner/runAndroidFlowUtils.ts
 import { parseExecutionTarget as parseExecutionTarget3 } from "@qawolf/flow-targets";
 
@@ -181437,9 +181588,16 @@ async function flowsRun(ctx, files, flags, deps) {
     return { error: runnerMessages.androidWorkersUnsupported, exitCode: 2 };
   }
   const { webOptions, androidOptions } = buildRunOptions(flags);
+  const failureDetails = [];
+  const reporter = ctx.outputMode === "json" ? createCompositeReporter([
+    deps.reporter,
+    {
+      onFlowFail: ({ err }) => failureDetails.push(formatErrorWithCause(err))
+    }
+  ]) : deps.reporter;
   const result = await executeFlows({
     ctx,
-    deps,
+    deps: { ...deps, reporter },
     flags,
     flows,
     webFlows,
@@ -181467,7 +181625,13 @@ async function flowsRun(ctx, files, flags, deps) {
   deps.reporter.onRunComplete?.({ summary });
   ctx.ui.gap();
   if (counts.flowsFailed > 0) {
-    return { error: runnerMessages.flowsFailed(counts.flowsFailed) };
+    const error51 = runnerMessages.flowsFailed(counts.flowsFailed);
+    if (ctx.outputMode === "json" && failureDetails.length > 0) {
+      return { error: error51, errorBody: failureDetails.join(`
+
+`) };
+    }
+    return { error: error51 };
   }
 }
 
@@ -181518,15 +181682,15 @@ async function defaultRunWebFlowDeps(envDir = process.cwd(), signals) {
 
 // src/domains/runtimeEnv/prepareRunDir.ts
 import { createHash as createHash4 } from "node:crypto";
-import { join as join31, resolve as resolve9 } from "node:path";
+import { join as join32, resolve as resolve9 } from "node:path";
 
 // src/domains/runtimeEnv/execSubpathImports.ts
-import { join as join25 } from "node:path";
+import { join as join26 } from "node:path";
 var flowSubpathImports = { "#playwright": "playwright" };
 var packageJsonSchema = exports_external.looseObject({ imports: exports_external.record(exports_external.string(), exports_external.unknown()).catch({}) }).catch({ imports: {} });
 async function writeExecSubpathImports(args) {
   const { execDir, fs: fs3 } = args;
-  const pkgPath = join25(execDir, "package.json");
+  const pkgPath = join26(execDir, "package.json");
   const pkg = packageJsonSchema.parse(await readPackageJson(pkgPath, fs3));
   const merged = { ...pkg, imports: { ...pkg.imports, ...flowSubpathImports } };
   await fs3.writeFile(pkgPath, JSON.stringify(merged, undefined, 2));
@@ -181548,10 +181712,10 @@ async function readPackageJson(pkgPath, fs3) {
 }
 
 // src/domains/runtimeEnv/innerHop.ts
-import { join as join27 } from "node:path";
+import { join as join28 } from "node:path";
 
 // src/domains/runtimeEnv/linkPinnedPackages.ts
-import { dirname as dirname8, join as join26 } from "node:path";
+import { dirname as dirname8, join as join27 } from "node:path";
 
 // src/domains/runtimeEnv/symlinkDir.ts
 import { symlink } from "node:fs/promises";
@@ -181563,16 +181727,16 @@ async function createDirSymlink(source, target) {
 // src/domains/runtimeEnv/linkPinnedPackages.ts
 async function linkPinnedPackages(args) {
   const { depsRoot, nodeModulesDir, fs: fs3 } = args;
-  const managedModules = join26(depsRoot, "node_modules");
+  const managedModules = join27(depsRoot, "node_modules");
   await fs3.mkdir(nodeModulesDir, { recursive: true });
   for (const { name } of pinnedPackages) {
     const segments = name.split("/");
-    const target = join26(nodeModulesDir, ...segments);
+    const target = join27(nodeModulesDir, ...segments);
     if (segments.length > 1) {
       await fs3.mkdir(dirname8(target), { recursive: true });
     }
     await fs3.rm(target, { recursive: true, force: true });
-    await createDirSymlink(join26(managedModules, ...segments), target);
+    await createDirSymlink(join27(managedModules, ...segments), target);
   }
 }
 
@@ -181581,14 +181745,14 @@ async function populateInnerHop(args) {
   const { depsRoot, execDir, fs: fs3 } = args;
   await linkPinnedPackages({
     depsRoot,
-    nodeModulesDir: join27(execDir, "node_modules"),
+    nodeModulesDir: join28(execDir, "node_modules"),
     fs: fs3
   });
 }
 
 // src/domains/runtimeEnv/outerHop.ts
 import { lstat } from "node:fs/promises";
-import { dirname as dirname9, join as join28 } from "node:path";
+import { dirname as dirname9, join as join29 } from "node:path";
 var executorPackageNames = new Set(pinnedPackages.map((p3) => p3.name));
 async function populateOuterHop(args) {
   const { projectDir, runDir, fs: fs3 } = args;
@@ -181598,7 +181762,7 @@ async function populateOuterHop(args) {
   const depNames = Object.keys(installableDeps);
   const { satisfying, rejected } = await findSatisfyingNodeModulesDir(projectDir, depNames, fs3);
   if (satisfying !== undefined) {
-    await createDirSymlink(satisfying, join28(runDir, "node_modules"));
+    await createDirSymlink(satisfying, join29(runDir, "node_modules"));
     return { mode: "symlink", nodeModulesDir: satisfying };
   }
   if (depNames.length === 0)
@@ -181607,7 +181771,7 @@ async function populateOuterHop(args) {
   await installOuterDeps(runDir, installableDeps, fs3, args.install ?? spawnNpmInstall);
   await linkPinnedPackages({
     depsRoot: args.depsRoot,
-    nodeModulesDir: join28(runDir, "node_modules"),
+    nodeModulesDir: join29(runDir, "node_modules"),
     fs: fs3
   });
   return { mode: "install", depCount: depNames.length, rejected };
@@ -181616,10 +181780,10 @@ async function findSatisfyingNodeModulesDir(startDir, depNames, fs3) {
   const rejected = [];
   let dir = startDir;
   while (true) {
-    const candidate = join28(dir, "node_modules");
+    const candidate = join29(dir, "node_modules");
     const stats = await lstatSafe(candidate);
     if (stats !== undefined && stats.isDirectory() && !stats.isSymbolicLink()) {
-      const missing = depNames.filter((name) => !fs3.existsSync(join28(candidate, name, "package.json")));
+      const missing = depNames.filter((name) => !fs3.existsSync(join29(candidate, name, "package.json")));
       if (missing.length === 0)
         return { satisfying: candidate, rejected };
       rejected.push({ dir: candidate, missing });
@@ -181640,7 +181804,7 @@ async function lstatSafe(path3) {
 async function readInstallableDeps(projectDir, fs3) {
   let content;
   try {
-    content = await fs3.readFile(join28(projectDir, "package.json"));
+    content = await fs3.readFile(join29(projectDir, "package.json"));
   } catch {
     return {};
   }
@@ -181658,8 +181822,8 @@ async function readInstallableDeps(projectDir, fs3) {
   return Object.fromEntries(Object.entries(rawDeps).filter(([name]) => !executorPackageNames.has(name)).filter((entry) => typeof entry[1] === "string"));
 }
 async function installOuterDeps(runDir, deps, fs3, install) {
-  await fs3.writeFile(join28(runDir, "package.json"), JSON.stringify({ name: "qawolf-run", private: true, dependencies: deps }, undefined, 2));
-  await fs3.writeFile(join28(runDir, ".npmrc"), `@qawolf:registry=https://registry.npmjs.org/
+  await fs3.writeFile(join29(runDir, "package.json"), JSON.stringify({ name: "qawolf-run", private: true, dependencies: deps }, undefined, 2));
+  await fs3.writeFile(join29(runDir, ".npmrc"), `@qawolf:registry=https://registry.npmjs.org/
 `);
   const result = await install(runDir);
   if (result.exitCode !== 0) {
@@ -181669,14 +181833,14 @@ async function installOuterDeps(runDir, deps, fs3, install) {
 
 // src/domains/runtimeEnv/stageFlowFiles.ts
 import { createHash as createHash3 } from "node:crypto";
-import { basename as basename4, dirname as dirname10, join as join30, sep as sep4 } from "node:path";
+import { basename as basename4, dirname as dirname10, join as join31, sep as sep4 } from "node:path";
 
 // src/shell/copyDir.ts
 import { cp, readdir as readdir2 } from "node:fs/promises";
-import { basename as basename3, join as join29 } from "node:path";
+import { basename as basename3, join as join30 } from "node:path";
 async function copyDirExcluding(source, destination, excludedNames) {
   const entries = await readdir2(source, { withFileTypes: true });
-  await Promise.all(entries.filter((entry) => !excludedNames.has(entry.name)).map((entry) => cp(join29(source, entry.name), join29(destination, entry.name), {
+  await Promise.all(entries.filter((entry) => !excludedNames.has(entry.name)).map((entry) => cp(join30(source, entry.name), join30(destination, entry.name), {
     recursive: true,
     filter: (path3) => !excludedNames.has(basename3(path3))
   })));
@@ -181693,14 +181857,14 @@ async function stageFlowFiles(args) {
   if (files.length > 1) {
     return Promise.all(files.map((f3) => stageOneFile(f3, execDir, fs3)));
   }
-  await Promise.all(files.map((f3) => fs3.copyFile(f3, join30(execDir, basename4(f3)))));
-  return files.map((f3) => join30(execDir, basename4(f3)));
+  await Promise.all(files.map((f3) => fs3.copyFile(f3, join31(execDir, basename4(f3)))));
+  return files.map((f3) => join31(execDir, basename4(f3)));
 }
 async function stageOneFile(file2, execDir, fs3) {
   const dirHash = createHash3("sha256").update(dirname10(file2)).digest("hex").slice(0, 8);
-  const subDir = join30(execDir, dirHash);
+  const subDir = join31(execDir, dirHash);
   await fs3.mkdir(subDir, { recursive: true });
-  const dest = join30(subDir, basename4(file2));
+  const dest = join31(subDir, basename4(file2));
   await fs3.copyFile(file2, dest);
   return dest;
 }
@@ -181708,7 +181872,7 @@ function remapPath(file2, projectDir, execDir) {
   if (file2 === projectDir)
     return execDir;
   if (file2.startsWith(projectDir + sep4)) {
-    return join30(execDir, file2.slice(projectDir.length + 1));
+    return join31(execDir, file2.slice(projectDir.length + 1));
   }
   return;
 }
@@ -181718,10 +181882,10 @@ async function prepareRunDir(args) {
   const { files, projectDir, depsRoot, runRoot } = args;
   const fs3 = args.fs ?? makeDefaultFs();
   const runId = buildRunId(projectDir, files);
-  const runDir = join31(runRoot, runId);
+  const runDir = join32(runRoot, runId);
   await fs3.rm(runDir, { recursive: true, force: true });
   await fs3.mkdir(runDir, { recursive: true });
-  const execDir = join31(runDir, "exec");
+  const execDir = join32(runDir, "exec");
   await fs3.mkdir(execDir, { recursive: true });
   await populateInnerHop({ depsRoot, execDir, fs: fs3 });
   const stagedFiles = await stageFlowFiles({ files, projectDir, execDir, fs: fs3 });
@@ -181752,17 +181916,17 @@ function buildRunId(projectDir, files) {
 }
 
 // src/shell/testkit.ts
-import { join as join32 } from "node:path";
+import { join as join33 } from "node:path";
 function notAvailableLocally(name) {
   throw new Error(runnerMessages.notAvailableLocally(name));
 }
 async function loadSdkDeps(cwd) {
-  const testkitDir = join32(cwd, "node_modules", "@qawolf", "testkit");
+  const testkitDir = join33(cwd, "node_modules", "@qawolf", "testkit");
   try {
     const clientMod = await importFromPath(resolveFromEnvDir(cwd, "@qawolf/testkit/client"));
     if (typeof clientMod.createTestkitClient !== "function")
       throw new Error("createTestkitClient is not a function");
-    const scopeMod = await importFromPath(join32(testkitDir, "dist", "clientScope.js"));
+    const scopeMod = await importFromPath(join33(testkitDir, "dist", "clientScope.js"));
     if (typeof scopeMod.configureTestkitClient !== "function")
       throw new Error("configureTestkitClient is not a function");
     return {
@@ -181820,9 +181984,9 @@ async function registerLazyEmailsClient(getInbox, cwd, deps) {
 }
 
 // src/commands/flows/envVarDeps.ts
-import { join as join33 } from "node:path";
+import { join as join34 } from "node:path";
 function envFilePath(envDir) {
-  return join33(envDir, ".env");
+  return join34(envDir, ".env");
 }
 async function readEnv(envDir, fs3) {
   try {
@@ -182319,17 +182483,21 @@ async function findFlowStamp(flowAbsPath) {
 
 // src/domains/install/browsers.ts
 async function installBrowserList(ctx, browsers, deps) {
-  const candidates = playwrightCliCandidates(deps.envDir, deps.platform);
-  const cliPath = candidates.find(deps.checkExists);
-  if (!cliPath) {
-    throw new Error(installMessages.playwrightNotFound(candidates[0] ?? deps.envDir));
+  const cliJsPath = playwrightCliJsPath(deps.envDir);
+  if (!deps.checkExists(cliJsPath)) {
+    throw new Error(installMessages.playwrightNotFound(cliJsPath));
   }
   await ctx.ui.withProgress(browsers.map((browser) => ({
     message: installMessages.installingBrowser(browser),
     task: async () => {
-      const args = buildArgs(browser, deps.platform, deps.browserDeps);
-      const result = await deps.spawn(cliPath, args, {
-        platform: deps.platform
+      const invocation = playwrightCliInvocation({
+        envDir: deps.envDir,
+        execPath: deps.execPath,
+        cliArgs: buildArgs(browser, deps.platform, deps.browserDeps)
+      });
+      const result = await deps.spawn(invocation.cmd, invocation.args, {
+        platform: deps.platform,
+        env: invocation.env
       });
       if (result.exitCode !== 0) {
         throw new Error(formatError2(browser, result));
@@ -182347,6 +182515,7 @@ async function installBrowsers(ctx, pattern, deps) {
   }
   await installBrowserList(ctx, browsers, {
     spawn: deps.spawn,
+    execPath: deps.execPath,
     platform: deps.platform,
     browserDeps: deps.browserDeps,
     envDir: await deps.resolveDepsRoot(files),
@@ -183221,14 +183390,14 @@ async function runWebFlow({
 
 // src/shell/embeddedWorkerCli.ts
 import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { basename as basename6, join as join34 } from "node:path";
+import { basename as basename6, join as join35 } from "node:path";
 var embeddedCliPathEnv = "QAWOLF_EMBEDDED_CLI_PATH";
 function extractEmbeddedWorkerCli() {
   const assetPath = process.env[embeddedCliPathEnv];
   if (assetPath === undefined || assetPath === "")
     return;
-  const dir = join34(getDataDir(), "worker");
-  const dest = join34(dir, basename6(assetPath));
+  const dir = join35(getDataDir(), "worker");
+  const dest = join35(dir, basename6(assetPath));
   if (existsSync3(dest))
     return dest;
   mkdirSync3(dir, { recursive: true });
@@ -183387,51 +183556,6 @@ import { dirname as dirname12 } from "node:path";
 
 // src/shell/reporter/createConsoleReporter.ts
 import { styleText as styleText3 } from "node:util";
-
-// src/shell/reporter/formatErrorWithCause.ts
-function filterStack(stack) {
-  const cwd = process.cwd();
-  return stack.split(`
-`).filter((line) => {
-    if (!/^\s+at /.test(line))
-      return true;
-    return !line.includes("node_modules") && !line.includes("dist/cli.js");
-  }).map((line) => {
-    if (!/^\s+at /.test(line))
-      return line;
-    return line.replace(`file://${cwd}/`, "").replace(`${cwd}/`, "");
-  }).join(`
-`);
-}
-function renderCause(cause) {
-  if (cause instanceof Error)
-    return filterStack(cause.stack ?? cause.message);
-  if (typeof cause === "object" && cause !== null) {
-    const obj = cause;
-    if (typeof obj["message"] === "string")
-      return obj["message"];
-    try {
-      return JSON.stringify(cause);
-    } catch {
-      return String(cause);
-    }
-  }
-  return String(cause);
-}
-function formatErrorWithCause(err) {
-  const parts = [String(err)];
-  let cause = err.cause;
-  while (cause !== undefined && cause !== null) {
-    parts.push(`Caused by: ${renderCause(cause)}`);
-    if (!(cause instanceof Error))
-      break;
-    cause = cause.cause;
-  }
-  return parts.join(`
-`);
-}
-
-// src/shell/reporter/createConsoleReporter.ts
 function fmtDuration(ms2) {
   return `(${(ms2 / 1000).toFixed(2)}s)`;
 }
@@ -183510,30 +183634,8 @@ ${styleText3("dim", "─".repeat(width))}
     }
   };
 }
-// src/shell/reporter/createCompositeReporter.ts
-function callEach(reporters, pick2, event) {
-  for (const r2 of reporters) {
-    try {
-      pick2(r2)?.(event);
-    } catch (err) {
-      process.stderr.write(`[reporter error] ${String(err)}
-`);
-    }
-  }
-}
-function createCompositeReporter(reporters) {
-  return {
-    onFlowStart: (e) => callEach(reporters, (r2) => r2.onFlowStart, e),
-    onFlowPass: (e) => callEach(reporters, (r2) => r2.onFlowPass, e),
-    onFlowFail: (e) => callEach(reporters, (r2) => r2.onFlowFail, e),
-    onTestStart: (e) => callEach(reporters, (r2) => r2.onTestStart, e),
-    onTestResult: (e) => callEach(reporters, (r2) => r2.onTestResult, e),
-    onScreenshot: (e) => callEach(reporters, (r2) => r2.onScreenshot, e),
-    onRunComplete: (e) => callEach(reporters, (r2) => r2.onRunComplete, e)
-  };
-}
 // src/shell/reporter/createJUnitReporter.ts
-import { join as join35 } from "node:path";
+import { join as join36 } from "node:path";
 
 // src/shell/reporter/junitXml.ts
 function escapeXml(str) {
@@ -183572,7 +183674,7 @@ ${suites}`;
 
 // src/shell/reporter/createJUnitReporter.ts
 function resolveJUnitOutputPath(junit, outputDir) {
-  return typeof junit === "string" && junit.trim() !== "" ? junit : join35(outputDir, "junit-report.xml");
+  return typeof junit === "string" && junit.trim() !== "" ? junit : join36(outputDir, "junit-report.xml");
 }
 function createJUnitReporter(deps) {
   const flows = [];
@@ -183634,6 +183736,7 @@ function buildFlowsRunDeps(args) {
     peekFlowMeta: makePeekFlowMeta(ctx.fs),
     installBrowsers: (innerCtx, browsers) => installBrowserList(innerCtx, browsers, {
       spawn: defaultSpawn,
+      execPath: process.execPath,
       platform: process.platform,
       browserDeps: flags.browserDeps,
       envDir: resolvedDir,
@@ -183661,11 +183764,11 @@ function buildFlowsRunDeps(args) {
 
 // src/commands/flows/loadEnvFile.ts
 import { readFile } from "node:fs/promises";
-import { join as join36 } from "node:path";
+import { join as join37 } from "node:path";
 async function loadEnvFile(envDir) {
   let content;
   try {
-    content = await readFile(join36(envDir, ".env"), "utf8");
+    content = await readFile(join37(envDir, ".env"), "utf8");
   } catch (err) {
     if (isNoEntError(err))
       return;
@@ -183766,7 +183869,7 @@ async function handleFlowsRun(ctx, pattern, flags, deps) {
 }
 
 // src/commands/flows/hybridRunDefaults.ts
-import { join as join37, resolve as resolve10 } from "node:path";
+import { join as join38, resolve as resolve10 } from "node:path";
 function makeDefaultHybridDeps(fs9) {
   return {
     expandPatterns: (patterns, cwd, logger) => expandPatterns(patterns, cwd, logger, fs9),
@@ -183785,7 +183888,7 @@ async function handleHybridFlowsRun(ctx, pattern, flags, deps) {
   if (validation !== "ok") {
     return { error: validation.error, exitCode: 2 };
   }
-  const envDir = resolve10(join37(".qawolf", flags.env));
+  const envDir = resolve10(join38(".qawolf", flags.env));
   const patternArgs = buildPatternArgs(pattern);
   const globFlows = () => resolvedDeps.expandPatterns(patternArgs, envDir, ctx.log("flows"));
   let files = await globFlows();
@@ -183931,7 +184034,100 @@ function registerFlowsCommand(program2, signals) {
 }
 
 // src/domains/init/init.ts
-import { dirname as dirname13, join as join38, relative as relative7 } from "node:path";
+import { dirname as dirname13, join as join40, relative as relative7 } from "node:path";
+
+// src/domains/init/ensurePackageJson.ts
+import { join as join39 } from "node:path";
+async function ensurePackageJson(ctx, yes, deps) {
+  const pkgPath = join39(deps.cwd, "package.json");
+  if (!await deps.fs.pathExists(pkgPath)) {
+    const confirmed2 = await ctx.ui.confirm(initMessages.createPackageJsonPrompt, { yes });
+    if (!confirmed2.ok || !confirmed2.value) {
+      ctx.ui.info(initMessages.skippedCreatingPackageJson);
+      return;
+    }
+    const pkg2 = {
+      private: true,
+      type: "module",
+      dependencies: { "@qawolf/flows": flowsVersion },
+      scripts: { "test:e2e": "qawolf flows run" }
+    };
+    await deps.fs.writeFile(pkgPath, JSON.stringify(pkg2, undefined, 2) + `
+`);
+    ctx.ui.step(initMessages.createdPackageJson);
+    return;
+  }
+  const raw = await deps.fs.readFile(pkgPath);
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    ctx.ui.warn(initMessages.packageJsonInvalidJson);
+    return;
+  }
+  if (!isRecord3(parsed)) {
+    ctx.ui.warn(initMessages.packageJsonNotAnObject);
+    return;
+  }
+  const pkg = parsed;
+  const scripts = readSection(ctx, pkg, "scripts");
+  const dependencies = readSection(ctx, pkg, "dependencies");
+  const devDependencies = readSection(ctx, pkg, "devDependencies");
+  const needScript = scripts !== undefined && !scripts["test:e2e"];
+  const priorType = pkg["type"];
+  const needType = priorType !== "module";
+  const needFlowsDep = dependencies !== undefined && !dependencies["@qawolf/flows"] && !devDependencies?.["@qawolf/flows"];
+  const changes = [];
+  if (needScript)
+    changes.push(initMessages.pkgChanges.script);
+  if (needType)
+    changes.push(initMessages.pkgChanges.type);
+  if (needFlowsDep)
+    changes.push(initMessages.pkgChanges.flowsDep);
+  if (changes.length === 0) {
+    ctx.ui.info(initMessages.packageJsonUpToDate);
+    return;
+  }
+  if (scripts !== undefined && scripts["test:e2e"]) {
+    ctx.ui.warn(initMessages.packageJsonHasTestE2e);
+  }
+  const confirmed = await ctx.ui.confirm(initMessages.updatePackageJsonPrompt(changes), { yes, destructive: true });
+  if (!confirmed.ok || !confirmed.value) {
+    ctx.ui.info(initMessages.skippedUpdatingPackageJson);
+    return;
+  }
+  if (needScript && scripts !== undefined) {
+    scripts["test:e2e"] = "qawolf flows run";
+    pkg["scripts"] = scripts;
+  }
+  if (needType)
+    pkg["type"] = "module";
+  if (needFlowsDep && dependencies !== undefined) {
+    dependencies["@qawolf/flows"] = flowsVersion;
+    pkg["dependencies"] = dependencies;
+  }
+  const trailingNewline = raw.endsWith(`
+`) ? `
+` : "";
+  await deps.fs.writeFile(pkgPath, JSON.stringify(pkg, undefined, 2) + trailingNewline);
+  ctx.ui.step(initMessages.updatedPackageJson);
+  if (needType && priorType !== undefined) {
+    const label = typeof priorType === "string" ? priorType : JSON.stringify(priorType);
+    ctx.ui.warn(initMessages.typeChanged(label));
+  }
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readSection(ctx, pkg, key) {
+  const value = pkg[key];
+  if (value === undefined)
+    return {};
+  if (isRecord3(value))
+    return value;
+  ctx.ui.warn(initMessages.packageJsonMalformedSection(key));
+  return;
+}
 
 // src/domains/init/templates.ts
 var qawolfConfigTs = `export default {
@@ -183969,9 +184165,9 @@ function makeDefaultInitDeps() {
 async function handleInit(ctx, opts, deps = makeDefaultInitDeps()) {
   ctx.ui.gap();
   ctx.ui.intro(initMessages.title);
-  const configPath = join38(deps.cwd, "qawolf.config.ts");
-  const flowPath = join38(deps.cwd, "src", "flows", "example.flow.ts");
-  const gitignorePath = join38(deps.cwd, ".qawolf", ".gitignore");
+  const configPath = join40(deps.cwd, "qawolf.config.ts");
+  const flowPath = join40(deps.cwd, "src", "flows", "example.flow.ts");
+  const gitignorePath = join40(deps.cwd, ".qawolf", ".gitignore");
   await writeWithPrompt(ctx, configPath, qawolfConfigTs, opts.yes, deps);
   await writeWithPrompt(ctx, flowPath, exampleFlowTs, opts.yes, deps);
   await writeWithPrompt(ctx, gitignorePath, qawolfGitignore, opts.yes, deps);
@@ -183994,54 +184190,6 @@ async function writeWithPrompt(ctx, filePath, content, yes, deps) {
   await deps.fs.writeFile(filePath, content);
   ctx.ui.step(initMessages.createdFile(relPath));
 }
-async function ensurePackageJson(ctx, yes, deps) {
-  const pkgPath = join38(deps.cwd, "package.json");
-  if (!await deps.fs.pathExists(pkgPath)) {
-    const confirmed2 = await ctx.ui.confirm(initMessages.createPackageJsonPrompt, { yes });
-    if (!confirmed2.ok || !confirmed2.value) {
-      ctx.ui.info(initMessages.skippedCreatingPackageJson);
-      return;
-    }
-    const pkg2 = {
-      private: true,
-      type: "module",
-      dependencies: { "@qawolf/flows": flowsVersion },
-      scripts: { "test:e2e": "qawolf flows run" }
-    };
-    await deps.fs.writeFile(pkgPath, JSON.stringify(pkg2, undefined, 2) + `
-`);
-    ctx.ui.step(initMessages.createdPackageJson);
-    return;
-  }
-  const raw = await deps.fs.readFile(pkgPath);
-  let pkg;
-  try {
-    pkg = JSON.parse(raw);
-  } catch {
-    ctx.ui.warn(initMessages.packageJsonInvalidJson);
-    return;
-  }
-  const scripts = pkg["scripts"] ?? {};
-  if (scripts["test:e2e"]) {
-    ctx.ui.warn(initMessages.packageJsonHasTestE2e);
-    return;
-  }
-  const confirmed = await ctx.ui.confirm(initMessages.addTestE2ePrompt, {
-    yes,
-    destructive: true
-  });
-  if (!confirmed.ok || !confirmed.value) {
-    ctx.ui.info(initMessages.skippedAddingTestE2e);
-    return;
-  }
-  scripts["test:e2e"] = "qawolf flows run";
-  pkg["scripts"] = scripts;
-  const trailingNewline = raw.endsWith(`
-`) ? `
-` : "";
-  await deps.fs.writeFile(pkgPath, JSON.stringify(pkg, undefined, 2) + trailingNewline);
-  ctx.ui.step(initMessages.updatedPackageJson);
-}
 
 // src/commands/init/index.ts
 function registerInitCommand(program2, signals) {
@@ -184057,7 +184205,7 @@ Examples:
 import { parseExecutionTarget as parseExecutionTarget4 } from "@qawolf/flow-targets";
 
 // src/domains/install/android/avd.ts
-import { join as join39 } from "node:path";
+import { join as join41 } from "node:path";
 async function installAvds(ctx, specs, deps) {
   const sdkManagerPath = sdkManagerBin(deps.androidHome, deps.platform);
   const avdManagerPath = avdManagerBin(deps.androidHome, deps.platform);
@@ -184067,7 +184215,7 @@ async function installAvds(ctx, specs, deps) {
   if (versionResult.exitCode !== 0) {
     throw new Error(installMessages.android.sdkmanagerNotFound(sdkManagerPath));
   }
-  const licenseFile = join39(deps.androidHome, "licenses", "android-sdk-license");
+  const licenseFile = join41(deps.androidHome, "licenses", "android-sdk-license");
   if (deps.checkExists(licenseFile)) {
     ctx.ui.info(installMessages.android.licensesAlreadyAccepted);
   } else {
@@ -184082,7 +184230,7 @@ async function installAvds(ctx, specs, deps) {
   for (const spec of specs) {
     if (installedImages.has(spec.systemImage))
       continue;
-    const systemImg = join39(deps.androidHome, ...spec.systemImage.split(";"), "system.img");
+    const systemImg = join41(deps.androidHome, ...spec.systemImage.split(";"), "system.img");
     if (deps.checkExists(systemImg)) {
       ctx.ui.info(installMessages.android.systemImageAlreadyInstalled(spec.systemImage));
       installedImages.add(spec.systemImage);
@@ -184236,6 +184384,7 @@ async function handleInstallBrowsers(ctx, pattern, options) {
   return installBrowsers(ctx, pattern, {
     cwd,
     spawn: defaultSpawn,
+    execPath: process.execPath,
     platform: process.platform,
     browserDeps,
     expandPatterns: (patterns, dir) => expandPatterns(patterns, dir ?? cwd, undefined, fs9),
@@ -184644,7 +184793,7 @@ async function handlePublicApiCommand(ctx, spec, options) {
     return { error: exports_external.prettifyError(parsed.error) };
   const result = await ctx.platformClient.callPublicApi(spec.contract, parsed.data);
   if (!result.ok)
-    return { error: result.error };
+    return failureFields(result);
   ctx.ui.output(result.value, renderHuman(result.value));
   return;
 }
@@ -184656,8 +184805,16 @@ var groupDescriptions = {
 var handWrittenContractNames = new Set(["flow.list"]);
 var skippedContractNames = new Set([
   ...handWrittenContractNames,
-  "issue.update"
+  "issue.update",
+  "runner.performAction"
 ]);
+var optionEnvironmentVariables = new Map([
+  ["environmentId", "QAWOLF_ENVIRONMENT"],
+  ["public.run.create.aiTaskId", "QAWOLF_AI_TASK_ID"]
+]);
+function optionEnvironmentVariable(spec, field) {
+  return optionEnvironmentVariables.get(`${spec.trpcPath}.${field}`) ?? optionEnvironmentVariables.get(field);
+}
 function resolveGroup(parent2, segment) {
   const existing = parent2.commands.find((command) => command.name() === segment);
   return existing ?? parent2.command(segment).description(groupDescriptions[segment] ?? `QA Wolf public API ${segment} commands`);
@@ -184674,7 +184831,13 @@ function registerSpec(program2, signals, spec, authDeps) {
   }
   const command = declareCommandKind(parent2.command(leafName), spec.kind).description(spec.description);
   for (const flag of spec.flags) {
-    if (flag.required) {
+    const environmentVariable = optionEnvironmentVariable(spec, flag.field);
+    if (environmentVariable) {
+      const option = new Option(flag.flag, flag.description).env(environmentVariable);
+      if (flag.required)
+        option.makeOptionMandatory();
+      command.addOption(option);
+    } else if (flag.required) {
       command.requiredOption(flag.flag, flag.description);
     } else {
       command.option(flag.flag, flag.description);
@@ -184726,4 +184889,4 @@ createProgram({ signals }).parseAsync().catch(() => {
     process.exitCode = 1;
 }).finally(() => flushAndExit(typeof process.exitCode === "number" ? process.exitCode : 0));
 
-//# debugId=F77E4418A62E284264756E2164756E21
+//# debugId=6CBE0567ED2CC02E64756E2164756E21