@piwitests/reporter 0.26.0 → 0.27.0

package/README.md

@@ -1,8 +1,8 @@
 # Piwi Dashboard Reporter
 
-A custom Playwright reporter that sends test results to a [Piwi Dashboard](https://piwitests.dev) server. It handles uploading test results, HTML reports, trace files, and performance metrics — with optional live streaming of results as tests execute.
+A custom Playwright reporter that sends your test results to a [Piwi Dashboard](https://piwitests.dev) server — run history, HTML reports, traces and performance metrics, streamed live as tests execute. With the optional capture fixtures it also unlocks locator healing, slow-endpoint analysis, Web Vitals, console capture and failure-time ARIA snapshots.
 
-📖 **[Full documentation](https://piwitests.dev/reporter)**
+📖 **[Full documentation](https://piwitests.dev/guide/reporter)** · 🎮 **[Live demo](https://piwitests.dev/demo/)**
 
 ## Installation
 
@@ -18,140 +18,27 @@ From your Playwright project, `npx @piwitests/reporter init` installs the report
 npx @piwitests/reporter init --server-url http://localhost:3000 --project my-project
 ```
 
-Every step is idempotent (safe to re-run); a config shape it will not rewrite is reported as `manual` with the exact change to make, never mangled. Add `--dry-run` to preview or `--json` for a machine-readable plan an agent can act on. It also installs the [Piwi agent skills](https://piwitests.dev/mcp#agent-skills) so your coding agent can investigate failures, heal locators, and stabilize flaky tests. Run `npx @piwitests/reporter init --help` for all options, or wire it up by hand with the steps below.
+Every step is idempotent (safe to re-run); a config shape it will not rewrite is reported as `manual` with the exact change to make, never mangled. Add `--dry-run` to preview or `--json` for a machine-readable plan an agent can act on. It also installs the [Piwi agent skills](https://piwitests.dev/features/mcp#agent-skills) so your coding agent can investigate failures, heal locators, and stabilize flaky tests. Run `npx @piwitests/reporter init --help` for all options, or wire it up by hand with the steps below.
 
 > The package is `@piwitests/reporter`; its command is `piwi`. Invoke it through the package name (`npx @piwitests/reporter <command>`) so npx resolves this package — `npx piwi` would fetch an unrelated `piwi` from npm. Once the reporter is a project dependency, `npx piwi <command>` resolves the local binary and works too.
 
 ## Quick start
 
-`wrapConfig` is the recommended setup. It injects the reporter **and** a global
-setup step (so the run shows up as "initializing" while your `globalSetup` runs),
-and forwards your options to that setup:
+`wrapConfig` is the recommended setup. It injects the reporter **and** a global setup step (so the run shows up as "initializing" while your `globalSetup` runs), and defaults `use.screenshot` / `use.trace` to `'only-on-failure'` / `'retain-on-failure'` when unset so failure evidence is captured (pass `defaultCapture: false` to opt out):
 
 ```typescript
 import { defineConfig } from '@playwright/test'
 import { wrapConfig } from '@piwitests/reporter'
 
-export default wrapConfig(
-  defineConfig({
-    use: {
-      trace: 'retain-on-failure',
-    },
-  }),
-  {
-    serverUrl: 'http://localhost:3000',
-    projectName: 'my-project',
-  },
-)
-```
-
-Run your tests — results are uploaded automatically:
-
-```bash
-npx playwright test
-```
-
-**Recommended: enable the [capture fixtures](#capture-fixtures)** — one small file unlocks the dashboard's richest features (locator healing, slow-endpoint analysis, Web Vitals, console capture, failure-time ARIA snapshots):
-
-```typescript
-// tests/fixtures.ts
-import { test as base, expect } from '@playwright/test'
-import { piwiFixtures } from '@piwitests/reporter'
-
-export const test = base.extend(piwiFixtures)
-export { expect }
-```
-
-Import `test` from this file in your specs instead of `@playwright/test` — see [Capture fixtures](#capture-fixtures) below.
-
-Prefer to wire it up by hand? Add the reporter to the `reporter` array instead:
-
-```typescript
-import { defineConfig } from '@playwright/test'
-
-export default defineConfig({
-  reporter: [
-    ['list'],
-    ['@piwitests/reporter', {
-      serverUrl: 'http://localhost:3000',
-      projectName: 'my-project',
-    }],
-  ],
-  use: {
-    trace: 'retain-on-failure',
-  },
-})
-```
-
-## Configuration Options
-
-| Option                      | Type     | Default                   | Description                                                            |
-|-----------------------------|----------|---------------------------|------------------------------------------------------------------------|
-| `serverUrl`                 | string   | `'http://localhost:3000'` | URL of the Piwi Dashboard server                                       |
-| `projectName`               | string   | `'default-project'`       | Name of the project to report results under                            |
-| `uploadTraces`              | boolean  | `true`                    | Whether to upload trace files to the dashboard                         |
-| `uploadReport`              | boolean  | `true`                    | Whether to upload the HTML report to the dashboard                     |
-| `reports`                   | array    | —                         | Additional report types to upload (html, monocart, blob, or custom)    |
-| `streaming`                 | boolean  | `true`                    | Enable live streaming of results as tests complete                     |
-| `streamingBatchSize`        | number   | `5`                       | Number of test results to batch before sending                         |
-| `streamingBatchDelay`       | number   | `2000`                    | Max delay (ms) before flushing pending events                          |
-| `projectDescription`        | string   | —                         | Description of the project                                             |
-| `environment`               | string   | —                         | Deployment environment for the run, e.g. `production`, `staging`       |
-| `relatedIssue`              | string   | —                         | Related issue reference (e.g., "PROJ-123")                             |
-| `ciInfo`                    | string   | —                         | CI job information                                                     |
-| `tags`                      | string[] | —                         | Tags to categorize the test run                                        |
-| `customData`                | object   | —                         | Additional custom metadata as key-value pairs                          |
-| `collectScmInfo`            | boolean  | `true`                    | Auto-collect git commit, branch, author                                |
-| `collectCiInfo`             | boolean  | `true`                    | Auto-collect CI environment info                                       |
-| `collectPerformanceMetrics` | boolean  | `true`                    | Collect step timings, network requests and web vitals from the fixture |
-| `outputFile`                | string   | —                         | Write a JSON file with the run URL/id/status so CI can consume it (see below) |
-| `apiKey`                    | string   | —                         | API key for authentication (preferred for CI)                          |
-| `username`                  | string   | —                         | Username for dashboard login (use `apiKey` instead when possible)      |
-| `password`                  | string   | —                         | Password for dashboard login (used with `username`)                    |
-| `verbose`                   | boolean  | `false`                   | Enable verbose logging for debugging                                   |
-
-## Live streaming
-
-By default, the reporter streams test results to the dashboard in real-time. This allows you to monitor progress live in the dashboard UI while CI is still running.
-
-To disable streaming and send all results at the end:
-
-```typescript
-['@piwitests/reporter', {
+export default wrapConfig(defineConfig({}), {
   serverUrl: 'http://localhost:3000',
   projectName: 'my-project',
-  streaming: false,
-}]
-```
-
-If the server doesn't support streaming (older versions), the reporter automatically falls back to batch mode.
-
-## Multiple reports
-
-Attach multiple report types to a single test run:
-
-```typescript
-export default defineConfig({
-  reporter: [
-    ['list'],
-    ['@playwright/test/reporter-html', { outputFolder: 'playwright-report' }],
-    ['monocart-reporter', { name: 'My Tests', outputFile: 'monocart-report/index.html' }],
-    ['@piwitests/reporter', {
-      serverUrl: 'http://localhost:3000',
-      projectName: 'my-project',
-      reports: [
-        { type: 'html' },
-        { type: 'monocart' },
-        { type: 'blob', dir: 'blob-report', label: 'Blob archive' },
-      ],
-    }],
-  ],
 })
 ```
 
-## Capture fixtures
+Run `npx playwright test` — results are uploaded automatically.
 
-The reporter works without any test-code changes, but the **capture fixtures** observe your tests from the inside and unlock the dashboard's richest features. Extend your `test` with them:
+**Recommended: enable the capture fixtures.** One small file unlocks the dashboard's richest features:
 
 ```typescript
 // tests/fixtures.ts
@@ -162,181 +49,28 @@ export const test = base.extend(piwiFixtures)
 export { expect }
 ```
 
-Or extend the base `test` in one line with `extendPiwiFixtures`:
-
-```typescript
-import { test as base } from '@playwright/test'
-import { extendPiwiFixtures } from '@piwitests/reporter'
-
-export const test = extendPiwiFixtures(base)
-export { expect } from '@playwright/test'
-```
+Import `test` from this file in your specs instead of `@playwright/test`. A spec that imports from `@playwright/test` directly still runs and reports fine — it just isn't captured. `extendPiwiFixtures(base)` is an equivalent one-line spelling. See the [capture fixtures guide](https://piwitests.dev/guide/capture-fixtures) for the full feature matrix and composition patterns.
 
-Then import `test` from your fixtures file in every spec — a spec that imports `test` from `@playwright/test` directly still runs and reports fine, it just isn't captured.
+## What you get
 
-### What gets captured
+- **Run history, statuses, errors, traces, reports and live streaming** — with no test-code changes.
+- **Capture fixtures** add slow-endpoint analysis, Web Vitals, console capture, failure-time ARIA snapshots and locator healing.
+- **AI steps** (`page.piwiLocator(...)` / `page.piwiRun(...)`) drive flows in plain English, compiled once and replayed deterministically with zero LLM calls in CI — see [AI steps](https://piwitests.dev/guide/ai-steps).
+- **CI-aware** — auto-detects the run label, branch and commit, publishes the run URL back to the pipeline, and shards into a single run. See [CI & sharding](https://piwitests.dev/guide/ci).
 
-- **Network requests** — method, URL, status, duration, resource type (API/document traffic only). Aggregated on the dashboard into a *Slow API Endpoints* table grouped by `METHOD + normalized route`.
-- **Console entries** — `warning`, `error`, and `assert` messages with their source location.
-- **Browser Web Vitals** — TTFB, DOM Interactive, DOMContentLoaded, Load Complete, First Paint, First Contentful Paint — displayed with color-coded thresholds.
-- **ARIA snapshot** — captured automatically when a test fails, shown as failure evidence and fed to the AI diagnosis.
-- **Locator snapshots** — for each element a test proves resolvable (successful actions and passing `expect(locator)` assertions alike), its attributes plus ranked alternative locators, stamped with the call site. These power locator healing; when a failing locator matches nothing, a fresh suggestion is attached as a Playwright annotation.
+## Configuration
 
-Capture works for the `page` fixture, `browser.newPage()`, `browser.newContext().newPage()`, and popups. Everything is only collected when `collectPerformanceMetrics` is `true` (the default); locator snapshots can be disabled separately with `captureLocators: false`.
-
-Without the fixtures you still get full run history, statuses, errors, traces, reports, streaming, and clustering — the fixtures add the slow-endpoint, Web Vitals, console, ARIA, and locator-healing layers. See the [capture fixtures guide](https://piwitests.dev/capture-fixtures) for the full feature matrix and composition patterns.
-
-## AI steps
-
-Locate elements and drive flows in plain English, without giving up determinism:
-
-```typescript
-await page.piwiLocator('the email address field').fill('ada@example.com')
-await page.piwiRun('sign in as {email}', { email: 'ada@example.com' })
-```
-
-The LLM is a **compiler, not a runtime**: each prompt is resolved **once** by an agent into a committed, deterministic JSON artifact, and every run after that replays that artifact with plain Playwright — **zero LLM calls and zero network** in the default `replay` mode. Add it by composing `extendPiwiAi` over your test:
-
-```typescript
-import { extendPiwiFixtures, extendPiwiAi } from '@piwitests/reporter'
-export const test = extendPiwiAi(extendPiwiFixtures(base))
-```
-
-Author missing entries once in `resolve` mode (`PIWI_AI=resolve`, pointed at a dashboard with an AI provider configured), commit the artifacts, and CI replays them offline. `{param}` placeholders are type-checked and masked out of everything sent to the model. Manage the committed entries with `piwi ai check | resolve | prune`.
-
-See the [AI steps guide](https://piwitests.dev/ai-steps) for the authoring/replay lifecycle, the safety model (allowlisted, drift-guarded, postcondition-verified), and the full option/env-var reference.
-
-## Authentication
-
-When the dashboard has authentication enabled, use an API key (recommended for CI):
-
-```typescript
-['@piwitests/reporter', {
-  serverUrl: 'https://your-dashboard.example.com',
-  projectName: 'my-project',
-  apiKey: process.env.PIWI_API_KEY,
-}]
-```
-
-Generate a key in the dashboard UI: **Settings → Users → API keys**. Store it as a CI secret.
-
-Alternatively, use `username`/`password` — the reporter will call `/api/auth/login` automatically.
-
-## Automatic Metadata Collection
-
-### SCM Information (Git)
-
-When `collectScmInfo` is enabled (default), the reporter collects:
-- Commit hash and message
-- Branch name
-- Author name
-- Remote URL
-
-### CI Information
-
-When `collectCiInfo` is enabled (default), the reporter auto-detects:
-- **GitHub Actions** — run ID, workflow, actor, repository, ref, SHA
-- **Jenkins** — build number, build URL, job name
-- **GitLab CI** — pipeline ID/URL, job ID/URL, job name
-- **CircleCI** — build number/URL, job name, workflow
-- **Travis CI** — build number/URL, job number
-- **Azure Pipelines** — build number, build ID/URL, job name
-
-## Publishing the run URL to CI
-
-After a run is submitted, the reporter surfaces the dashboard run URL so a later
-CI step (a custom email, a Slack message, a deploy gate) can pick it up without
-scraping the log. The URL is always printed as `View run: <url>`, and in
-addition:
-
-- **Any CI — JSON output file.** Set `outputFile` (or `PIWI_OUTPUT_FILE`) and the
-  reporter writes a small JSON file when the run lands:
-
-  ```json
-  { "runUrl": "https://piwi.example.com/test-runs/1234", "runId": 1234, "projectId": 5, "projectName": "checkout", "status": "passed", "ciBuildUrl": "https://ci.example.com/build/9" }
-  ```
-
-  Read it from any pipeline, e.g. `node -e "console.log(require('./piwi-run.json').runUrl)"`
-  (portable) or `cat piwi-run.json` and parse it in your email step. In Jenkins,
-  `def run = readJSON file: 'piwi-run.json'` then use `run.runUrl`.
-
-- **GitHub Actions (automatic).** When `GITHUB_ACTIONS` is set, the reporter
-  appends step outputs to `$GITHUB_OUTPUT` (`piwi_run_url`, `piwi_run_id`,
-  `piwi_project_id`, `piwi_run_status`), writes a markdown link to the job
-  summary, and prints a `::notice::` annotation. Give the test step an `id` and a
-  downstream step can read it:
-
-  ```yaml
-  - id: tests
-    run: npx playwright test
-  - run: echo "Results at ${{ steps.tests.outputs.piwi_run_url }}"
-  ```
-
-- **GitLab CI (automatic).** When `GITLAB_CI` is set, the reporter writes a
-  dotenv report (`piwi.env` by default, override with `PIWI_DOTENV_FILE`).
-  Declare it so later jobs inherit `$PIWI_RUN_URL`:
-
-  ```yaml
-  test:
-    script: npx playwright test
-    artifacts:
-      reports:
-        dotenv: piwi.env
-  email:
-    needs: [test]
-    script: ./send-email.sh "$PIWI_RUN_URL"
-  ```
-
-## How It Works
-
-1. When tests start, the reporter creates a run on the server (streaming mode) or collects results locally (batch mode)
-2. As tests complete, results are streamed in batches to the server
-3. After all tests finish, HTML reports are compressed and uploaded
-4. Trace files from test attachments are uploaded
-5. Data from the capture fixtures (network requests, console entries, web vitals, ARIA snapshots, locator snapshots) is included per test case
-6. The server stores everything and makes it available in the dashboard UI
+Every option can also be set via a `PIWI_*` environment variable (config wins over env). The full option and env-var reference lives in the [reporter documentation](https://piwitests.dev/guide/reporter); authentication for CI (API keys) is covered under [Authentication](https://piwitests.dev/operate/authentication).
 
 ## Requirements
 
-- Node.js 18 or higher (the reporter runs inside your test project — the dashboard *server* itself targets Node 22+, or use its Docker image)
-- Playwright Test 1.40 or higher
-- Running Piwi Dashboard server
-
-## Development
-
-This package is written in TypeScript. Source files live in `src/` and compile to `dist/`.
-
-```bash
-cd reporter
-npm install
-npm run reporter:build   # compile TypeScript src/ → dist/
-npm run reporter:dev     # watch mode — auto-recompile on changes
-```
-
-### Source layout
-
-The package keeps its **public API** (`src/index.ts`, `src/public/`) separate from internal plumbing (`src/internal/<domain>/`) and the type model (`src/types/`). See [`ARCHITECTURE.md`](./ARCHITECTURE.md) for the full map — the public/internal split, the collect-and-submit data flow, the fallback ladder, and the conventions.
-
-Everything public — the reporter, config helpers, and the capture fixtures — is exported from the package's single entry point (`@piwitests/reporter`).
-
-## Troubleshooting
-
-### Reporter not uploading files
-
-- Ensure an HTML reporter is configured: `['html', { outputFolder: 'playwright-report' }]`
-- Ensure traces are enabled: `use: { trace: 'retain-on-failure' }`
-- Check the dashboard server is running and accessible at `serverUrl`
-
-### Fixture data not appearing (network, Web Vitals, console, ARIA, locator healing)
-
-- Extend your `test` with `piwiFixtures` / `extendPiwiFixtures` from `@piwitests/reporter`, and import `test` from your fixtures file in every spec — not from `@playwright/test` directly
-- Verify `collectPerformanceMetrics` is not set to `false` (and `captureLocators` for locator healing)
-- Ensure tests navigate to at least one page (`await page.goto(...)`)
+- Node.js 20 or higher (the reporter runs inside your test project — the dashboard *server* itself targets Node 22+, or use its Docker image)
+- Playwright Test 1.61 or higher
+- A running Piwi Dashboard server
 
-### Connection errors
+## Contributing
 
-- Check that `serverUrl` is correct and the server is running
-- Verify network connectivity and firewall settings
+Source layout, the collect-and-submit data flow and the public/internal split are documented in [`ARCHITECTURE.md`](./ARCHITECTURE.md). Build with `npm run reporter:build` (or `reporter:dev` for watch mode) from the repository root.
 
 ## License
 

package/dist/cli/index.js

@@ -477,9 +477,9 @@ function readCount(argv, name) {
   if (!Number.isFinite(n) || n < 0) throw new Error(`${name} expects a non-negative number, got "${raw}"`);
   return Math.floor(n);
 }
-function readRunIdFromFile(path10) {
+function readRunIdFromFile(path11) {
   try {
-    const parsed = JSON.parse(fs3.readFileSync(path10, "utf-8"));
+    const parsed = JSON.parse(fs3.readFileSync(path11, "utf-8"));
     const runId = Number(parsed.runId);
     return Number.isFinite(runId) && runId > 0 ? runId : null;
   } catch {
@@ -1196,10 +1196,10 @@ Piwi setup${opts.dryRun ? " (dry run \u2014 nothing written)" : ""} for "${opts.
 }
 
 // src/cli/select.ts
-var fs7 = __toESM(require("fs"));
-var path9 = __toESM(require("path"));
+var fs8 = __toESM(require("fs"));
+var path10 = __toESM(require("path"));
 var import_node_child_process3 = require("child_process");
-var import_node_module = require("module");
+var import_node_module2 = require("module");
 
 // src/internal/support/selection-client.ts
 function authHeaders(apiKey) {
@@ -1248,6 +1248,74 @@ async function fetchImpact(options, projectId, changedFiles) {
   return await res.json();
 }
 
+// src/cli/add-reporter.ts
+var fs7 = __toESM(require("fs"));
+var path9 = __toESM(require("path"));
+var import_node_module = require("module");
+var REPORTER_PACKAGE2 = "@piwitests/reporter";
+var ADD_REPORTER_FLAG = "--add-reporter";
+var ADD_REPORTER_MIN = { major: 1, minor: 63 };
+function playwrightSupportsAddReporter(version) {
+  const match = version ? /^(\d+)\.(\d+)/.exec(version) : null;
+  if (!match) return false;
+  const major = Number(match[1]);
+  const minor = Number(match[2]);
+  return major > ADD_REPORTER_MIN.major || major === ADD_REPORTER_MIN.major && minor >= ADD_REPORTER_MIN.minor;
+}
+function configHasPiwiReporter(source) {
+  return new RegExp(REPORTER_PACKAGE2.replace(/[/\\]/g, "\\$&")).test(source);
+}
+function decideAddReporter(configSource, playwrightVersion) {
+  if (configSource === null || configHasPiwiReporter(configSource)) return { args: [], log: null };
+  if (playwrightSupportsAddReporter(playwrightVersion)) {
+    return {
+      args: [ADD_REPORTER_FLAG, REPORTER_PACKAGE2],
+      log: `piwi run: the Playwright config has no Piwi reporter \u2014 appending ${ADD_REPORTER_FLAG} ${REPORTER_PACKAGE2}`
+    };
+  }
+  return {
+    args: [],
+    log: `piwi run: the Playwright config has no Piwi reporter and Playwright ${playwrightVersion ?? "unknown"} predates ${ADD_REPORTER_FLAG} (1.63) \u2014 results will not reach the dashboard`
+  };
+}
+function resolveConfigPath(cwd, playwrightArgs) {
+  for (let i = 0; i < playwrightArgs.length; i++) {
+    const arg = playwrightArgs[i];
+    if (arg === "--config" || arg === "-c") {
+      const next = playwrightArgs[i + 1];
+      if (next) return path9.resolve(cwd, next);
+    } else if (arg.startsWith("--config=")) {
+      return path9.resolve(cwd, arg.slice("--config=".length));
+    }
+  }
+  return detectProject(cwd).configPath;
+}
+function readConfigSource(configPath) {
+  if (!configPath) return null;
+  try {
+    return fs7.readFileSync(configPath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function readInstalledPlaywrightVersion(cwd) {
+  try {
+    const require2 = (0, import_node_module.createRequire)(path9.join(cwd, "noop.js"));
+    for (const id of ["@playwright/test/package.json", "playwright/package.json"]) {
+      try {
+        return require2(id).version ?? null;
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function computeAddReporterArgs(cwd, playwrightArgs) {
+  const source = readConfigSource(resolveConfigPath(cwd, playwrightArgs));
+  return decideAddReporter(source, readInstalledPlaywrightVersion(cwd));
+}
+
 // src/cli/select.ts
 var EXIT_OK3 = 0;
 var EXIT_ERROR3 = 2;
@@ -1267,7 +1335,7 @@ Connection:
 Selection:
   --format <fmt>        args (file:line, default) | grep | files | json
   --budget <duration>   Cap total time, e.g. 5m, 90s, 300000 (ms)
-  --shard <i/n>         Keep only shard i of n, balanced by test duration
+  --shard <i/n>         Keep only shard i of n, balanced by duration, lock-aware
   --fail-fast           Order the least-reliable tests first (fail-fast)
   --base <ref>          For "impact": the ref to diff the working tree against
 
@@ -1352,13 +1420,13 @@ function parseSelectArgs(argv, env) {
     extra
   };
 }
-var CACHE_FILE = path9.join(".piwi", "selection-cache.json");
+var CACHE_FILE = path10.join(".piwi", "selection-cache.json");
 function cacheKey(projectId, args) {
   return `${projectId}:${args.key}:${args.format}:${args.budgetMs ?? 0}:${args.shard ?? ""}:${args.order ?? ""}`;
 }
 function readCache(projectId, args) {
   try {
-    const store = JSON.parse(fs7.readFileSync(CACHE_FILE, "utf-8"));
+    const store = JSON.parse(fs8.readFileSync(CACHE_FILE, "utf-8"));
     return store[cacheKey(projectId, args)] ?? null;
   } catch {
     return null;
@@ -1368,12 +1436,12 @@ function writeCache(projectId, args, resolution) {
   try {
     let store = {};
     try {
-      store = JSON.parse(fs7.readFileSync(CACHE_FILE, "utf-8"));
+      store = JSON.parse(fs8.readFileSync(CACHE_FILE, "utf-8"));
     } catch {
     }
     store[cacheKey(projectId, args)] = resolution;
-    fs7.mkdirSync(path9.dirname(CACHE_FILE), { recursive: true });
-    fs7.writeFileSync(CACHE_FILE, JSON.stringify(store, null, 2));
+    fs8.mkdirSync(path10.dirname(CACHE_FILE), { recursive: true });
+    fs8.writeFileSync(CACHE_FILE, JSON.stringify(store, null, 2));
   } catch {
   }
 }
@@ -1469,7 +1537,7 @@ async function runSelect(argv, env = process.env) {
   return EXIT_OK3;
 }
 function resolvePlaywrightCli() {
-  const require2 = (0, import_node_module.createRequire)(path9.join(process.cwd(), "noop.js"));
+  const require2 = (0, import_node_module2.createRequire)(path10.join(process.cwd(), "noop.js"));
   for (const id of ["playwright/cli", "@playwright/test/cli", "playwright/lib/cli/cli"]) {
     try {
       return require2.resolve(id);
@@ -1484,14 +1552,19 @@ function spawnPlaywright(pkgRunner, playwrightArgs, env) {
     stdio: "inherit",
     env
   });
-  return new Promise((resolve5) => {
+  return new Promise((resolve6) => {
     child.on("error", (err) => {
       console.error(`piwi run: could not start Playwright \u2014 ${err.message}`);
-      resolve5(EXIT_ERROR3);
+      resolve6(EXIT_ERROR3);
     });
-    child.on("exit", (code) => resolve5(code ?? EXIT_ERROR3));
+    child.on("exit", (code) => resolve6(code ?? EXIT_ERROR3));
   });
 }
+function spawnPlaywrightForRun(pkgRunner, playwrightArgs, env) {
+  const decision = computeAddReporterArgs(process.cwd(), playwrightArgs);
+  if (decision.log) console.error(decision.log);
+  return spawnPlaywright(pkgRunner, [...decision.args, ...playwrightArgs], env);
+}
 async function runRunImpact(args, env) {
   let projectId;
   try {
@@ -1502,7 +1575,7 @@ async function runRunImpact(args, env) {
       return EXIT_ERROR3;
     }
     console.error(`piwi run: ${e.message} \u2014 running the full suite`);
-    return spawnPlaywright(args.pkgRunner, args.extra, env);
+    return spawnPlaywrightForRun(args.pkgRunner, args.extra, env);
   }
   let impact;
   try {
@@ -1513,14 +1586,14 @@ async function runRunImpact(args, env) {
       return EXIT_ERROR3;
     }
     console.error(`piwi run: ${e.message} \u2014 running the full suite`);
-    return spawnPlaywright(args.pkgRunner, args.extra, env);
+    return spawnPlaywrightForRun(args.pkgRunner, args.extra, env);
   }
   printWarnings(impact);
   if (impact.impact.widened) {
     console.error(
       `piwi run: impact widened to the full suite (${impact.impact.unmappedSourceFiles.length} unmapped source file(s))`
     );
-    return spawnPlaywright(args.pkgRunner, args.extra, env);
+    return spawnPlaywrightForRun(args.pkgRunner, args.extra, env);
   }
   if (impact.estimate.count === 0) {
     console.error(`piwi run: no tests impacted by ${impact.impact.changedFiles} changed file(s) \u2014 nothing to run`);
@@ -1534,7 +1607,7 @@ async function runRunImpact(args, env) {
     PIWI_SELECTION_COUNT: String(impact.estimate.count)
   };
   console.error(`piwi run: impact \u2192 ${impact.estimate.count} test(s)`);
-  return spawnPlaywright(args.pkgRunner, [...impact.materialization.args, ...args.extra], runEnv);
+  return spawnPlaywrightForRun(args.pkgRunner, [...impact.materialization.args, ...args.extra], runEnv);
 }
 async function runRun(argv, env = process.env) {
   if (argv.includes("-h") || argv.includes("--help")) {
@@ -1570,7 +1643,7 @@ async function runRun(argv, env = process.env) {
       return EXIT_ERROR3;
     }
     console.error(`piwi run: ${e.message} \u2014 running the full suite`);
-    return spawnPlaywright(args.pkgRunner, args.extra, env);
+    return spawnPlaywrightForRun(args.pkgRunner, args.extra, env);
   }
   let outcome;
   try {
@@ -1581,7 +1654,7 @@ async function runRun(argv, env = process.env) {
   }
   if (!outcome) {
     console.error("piwi run: dashboard unreachable and no cached resolution \u2014 running the full suite");
-    return spawnPlaywright(args.pkgRunner, args.extra, env);
+    return spawnPlaywrightForRun(args.pkgRunner, args.extra, env);
   }
   const { resolution } = outcome;
   printWarnings(resolution);
@@ -1599,7 +1672,7 @@ async function runRun(argv, env = process.env) {
   console.error(
     `piwi run: ${args.key} \u2192 ${resolution.estimate.count} tests${resolution.materialization.format !== args.format ? ` (materialized as ${resolution.materialization.format})` : ""}`
   );
-  return spawnPlaywright(args.pkgRunner, [...resolution.materialization.args, ...args.extra], runEnv);
+  return spawnPlaywrightForRun(args.pkgRunner, [...resolution.materialization.args, ...args.extra], runEnv);
 }
 
 // src/cli/index.ts