prowl-tools 0.1.8 → 0.1.10

package/README.md

@@ -145,23 +145,33 @@ prowl init
 
 <!-- ILLUSTRATION: Terminal screenshot showing `prowl init` output with raccoon mascot and file listing -->
 
-This creates a `.prowl/` directory with a config file and two starter hunts:
+This creates a `.prowl/` directory with a config file and four starter hunts:
 
 ```text
 .prowl/
-├── config.yml         # Target URL, browser settings, guardrails
-├── .gitignore         # Keeps runs/, auth-state.json, and .env out of git
+├── config.yml          # Target URL, browser settings, guardrails
+├── .gitignore          # Keeps runs/, auth-state.json, and .env out of git
 └── hunts/
-    ├── hello.yml       # Minimal smoke test — verifies the app loads
-    └── login-flow.yml  # Fuller example — auth, secrets, assertions
+    ├── hello.yml        # Minimal smoke test — verifies the app loads
+    ├── login-flow.yml   # Auth example — fill credentials, verify redirect
+    ├── form.yml         # Forms example — fill, select, submit, assert
+    └── macos-hello.yml  # Desktop starter — drive TextEdit (macOS, experimental)
 ```
 
+The web starters (`hello`, `login-flow`, `form`) run against the default web
+target as soon as you point `config.yml` at your app. `macos-hello` is the
+desktop-first first-run hunt: it drives TextEdit through the Accessibility API,
+and its inline comments walk you through switching the target to `macos` and the
+one-time setup (`prowl macdriver install`, Accessibility permission). The macOS
+target is experimental — see [macOS Target](#macos-target-experimental).
+
 `prowl init` finishes by pointing you at the first hunt:
 
 ```text
   Initialized .prowl directory.
   Run prowl run hello to get started.
-  See .prowl/hunts/login-flow.yml for a fuller example.
+  See .prowl/hunts/login-flow.yml (auth) and .prowl/hunts/form.yml (web forms) for fuller examples.
+  Desktop-first? .prowl/hunts/macos-hello.yml is a macOS starter (experimental — see its comments to enable).
 ```
 
 ### 3. Configure
@@ -379,7 +389,7 @@ macOS target (with a clear error), and `prowl login` / URL guardrails do not app
 
 | Portable (web + macOS) | Web-only (rejected on macOS) |
 |---|---|
-| `click`, `fill`, `type`, `press` | `navigate`, `waitForUrl`, `waitForNetworkIdle` |
+| `click`, `fill`, `type`, `press` | `navigate`, `waitForUrl`, `waitForNetworkIdle`, `waitForResponse` |
 | `wait`, `waitForSelector` | `mockRoute` / `unmockRoute` |
 | `assert: visible` / `notVisible` | `evalScript`, `runScript` |
 | `screenshot`, `assertScreenshot` | `onDialog`, `select` / `selectOption` |
@@ -655,6 +665,21 @@ Wait for all network requests to complete.
     timeout: 5000
 ```
 
+### waitForResponse
+
+Wait for a specific network response before continuing — more precise than `waitForNetworkIdle`, which waits for *all* traffic to settle.
+
+```yaml
+- waitForResponse:
+    url: "**/api/orders"
+    status: 200
+    timeout: 10000
+```
+
+- `url` (required) is matched against each response URL as a glob: `*`/`**` match any run of characters (including `/`) and `?` matches a single character. Matching is unanchored, so a pattern with no wildcards behaves as a substring match (e.g. `/api/orders` matches `https://shop.test/api/orders?page=2`).
+- `status` (optional) resolves the step only on a response with that exact HTTP status.
+- `timeout` (optional, milliseconds) fails the step with a clear message if no matching response arrives in time.
+
 ### onDialog
 
 Handle browser-native dialogs (alert, confirm, prompt). Register the handler **before** the action that triggers the dialog.
@@ -1004,6 +1029,39 @@ tracing:
 This is a correlation bridge only — Prowl does not generate or propagate its own
 spans. When the app emits no trace headers, nothing is recorded (no noise).
 
+### Retry Diagnostics (why a retried hunt passed)
+
+When a hunt sets a `retry` block and eventually passes — or exhausts its
+attempts — Prowl records what each attempt did instead of retrying silently:
+
+```yaml
+# In a hunt file
+retry:
+  maxRetries: 2   # up to 2 extra attempts (3 total)
+  delay: 500      # optional ms to wait between attempts
+```
+
+The final attempt's `result.json` (and the returned run result) then carries:
+
+- `retryHistory` — one record per attempt: its `attempt` number, `status`,
+  `durationMs`, the first `failedStep` (`index` + `type`), and the `error`.
+- `retrySummary` — a one-line headline, e.g.
+  `Passed on attempt 2 of 3 — first failure: navigate (timeout)`, or
+  `Failed after 3 attempts — first failure: …` when the retries were exhausted.
+
+Both fields appear **only** when more than one attempt ran, so a hunt that passes
+on the first try (and any run artifact written before this feature) stays
+unchanged and keeps parsing. `summary.md` gains a matching **Retries** section
+with the headline and a per-attempt breakdown, and the `prowl run` summary prints
+the headline. JUnit continues to report the final attempt's outcome — the
+per-attempt history lives in `result.json`, not the XML — so a retried-and-passed
+hunt is a green testcase for CI while the diagnostics remain available alongside
+it.
+
+This is what lets you distinguish a **flaky test** (passes on retry, intermittent
+first-attempt failures) from a **slow environment** (retries needed but the same
+step lags) from a **real regression** (all attempts fail the same way).
+
 ---
 
 ## CLI Reference
@@ -1035,6 +1093,10 @@ prowl login
 prowl init
 prowl init --force                      # Overwrite existing
 
+# Doctor — check the environment is ready to run hunts
+prowl doctor
+prowl doctor --fix                      # Install Chromium / scaffold .prowl if missing
+
 # List available hunts
 prowl list
 
@@ -1058,13 +1120,36 @@ prowl mcp --projects ~/.prowl/projects.yml   # Drive multiple repos via a regist
 - Must be a positive integer (`>= 1`).
 - Invalid values (for example `0` or `1.5`) fail fast with an argument error.
 
+### Environment Check (`prowl doctor`)
+
+`prowl doctor` verifies your machine is ready to run hunts and prints a
+color-coded report (green ✓ pass, yellow ⚠ warning, red ✗ failure, gray ○
+skipped) with a one-line summary. It checks:
+
+- **Node.js** is version 20 or newer.
+- **Playwright** is installed, and its **Chromium** browser is available.
+- A **`.prowl/` directory** exists with a **valid `config.yml`**.
+- **Target tooling for your configured target only** (desktop-first): the macOS
+  target reuses `prowl macdriver status` to report which helper binary resolved;
+  the iOS target checks that `xcrun simctl` is reachable (macOS only); the
+  Android target checks that `adb` is reachable. Missing native tooling prints
+  the install command — `doctor` never installs system tools for you.
+
+Warnings do not fail the command; only real failures do (exit code `1`, so it
+slots into CI). `prowl doctor --fix` performs just the two safe repairs —
+installing Chromium through Prowl's resolved Playwright dependency and
+scaffolding a missing `.prowl/` (the same templates `prowl init` writes) — then
+re-runs the checks and reports the new status. Everything else prints a manual
+remedy.
+
 ### Run History
 
 Every `prowl run` and `prowl ci` appends an entry to `.prowl/history.json`
-with the hunt name, status, start time, duration, and run directory. Retention
-is capped per hunt by `history.maxRuns` (default 100) — once a hunt exceeds the
-cap, its oldest entries are dropped on the next write. Other hunts are not
-affected.
+with the hunt name, status, start time, duration, run directory, and — when the
+run used `retry` — a `retries` count (the number of extra attempts beyond the
+first; omitted when the run passed on its first attempt). Retention is capped
+per hunt by `history.maxRuns` (default 100) — once a hunt exceeds the cap, its
+oldest entries are dropped on the next write. Other hunts are not affected.
 
 ```yaml
 # In .prowl/config.yml
@@ -1073,7 +1158,11 @@ history:
 ```
 
 Use `prowl history <hunt-name>` for a quick status/duration table, or
-`--json` to feed the entries into dashboards, flake detectors, or agents.
+`--json` to feed the entries into dashboards, flake detectors, or agents. The
+table includes a **Retries** column and a retry-frequency line
+(`Retried in N of M runs`) so you can tell a flaky hunt apart from a slow
+environment or a real regression at a glance. History from before retry
+tracking (entries without a `retries` field) still loads and reads as `0`.
 
 ### Failure Clustering
 
@@ -1359,7 +1448,7 @@ Portable steps run on the Android target; web-only steps are rejected up front
 
 | Portable (Android) | Not supported on Android |
 |---|---|
-| `click`, `fill`, `type`, `press` | `navigate`, `waitForUrl`, `waitForNetworkIdle` |
+| `click`, `fill`, `type`, `press` | `navigate`, `waitForUrl`, `waitForNetworkIdle`, `waitForResponse` |
 | `wait`, `waitForSelector` | `mockRoute` / `unmockRoute`, `evalScript`, `runScript` |
 | `assert: visible` / `notVisible` | `onDialog`, `select` / `selectOption`, `setInputFiles` |
 | `screenshot`, `assertScreenshot` | `waitForDownload`, `scroll`, `assert: urlIncludes` / `urlEquals` |
@@ -1509,7 +1598,7 @@ clear error), and URL guardrails do not apply.
 
 | Portable (iOS) | Not supported on iOS |
 |---|---|
-| `click`, `fill`, `type`, `press` | `navigate`, `waitForUrl`, `waitForNetworkIdle` |
+| `click`, `fill`, `type`, `press` | `navigate`, `waitForUrl`, `waitForNetworkIdle`, `waitForResponse` |
 | `wait`, `waitForSelector` | `mockRoute` / `unmockRoute`, `evalScript`, `runScript` |
 | `assert: visible` / `notVisible` | `onDialog`, `select` / `selectOption`, `setInputFiles` |
 | `screenshot`, `assertScreenshot` | `waitForDownload`, `scroll`, `assert: urlIncludes` / `urlEquals` |

package/dist/{chunk-CWLRDV5P.js → chunk-SRWAF2RI.js}

@@ -8,7 +8,7 @@ import {
   loadHunt,
   loadHuntTags,
   resolveViewport
-} from "./chunk-JFJQNJSJ.js";
+} from "./chunk-TTZ2IL3P.js";
 
 // src/config/target.ts
 import { execFileSync } from "child_process";
@@ -18,6 +18,7 @@ var WEB_ONLY_STEP_TYPES = /* @__PURE__ */ new Set([
   "navigate",
   "waitForUrl",
   "waitForNetworkIdle",
+  "waitForResponse",
   "mockRoute",
   "unmockRoute",
   "evalScript",
@@ -372,6 +373,9 @@ function createMacDriver(client, options = {}) {
     waitForNetworkIdle() {
       return rejectUnsupported("waitForNetworkIdle");
     },
+    waitForResponse() {
+      return rejectUnsupported("waitForResponse");
+    },
     // scripting & artifacts ------------------------------------------------
     evaluate() {
       return rejectUnsupported("evalScript");
@@ -499,10 +503,15 @@ ${macdriverBuildInstructions()}`
 ${macdriverBuildInstructions()}`);
 }
 var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
 var SpawnMacHelperClient = class {
   child;
   pending = /* @__PURE__ */ new Map();
   requestTimeoutMs;
+  onEvent;
+  onEventError;
   stdoutBuffer = "";
   stderrBuffer = "";
   nextId = 1;
@@ -510,6 +519,9 @@ var SpawnMacHelperClient = class {
   terminalError;
   constructor(binaryPath, options = {}) {
     this.requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+    this.onEvent = options.onEvent;
+    this.onEventError = options.onEventError ?? ((message) => process.stderr.write(`${message}
+`));
     this.child = spawn(binaryPath, ["serve"], { stdio: ["pipe", "pipe", "pipe"] });
     this.child.stdout?.setEncoding("utf-8");
     this.child.stderr?.setEncoding("utf-8");
@@ -546,6 +558,10 @@ var SpawnMacHelperClient = class {
     } catch {
       return;
     }
+    if (typeof message.event === "string" && typeof message.id !== "number") {
+      this.handleEvent(message);
+      return;
+    }
     const id = typeof message.id === "number" ? message.id : void 0;
     if (id === void 0) {
       return;
@@ -562,6 +578,18 @@ var SpawnMacHelperClient = class {
       pending.reject(new Error(typeof message.error === "string" ? message.error : "prowl-macdriver error"));
     }
   }
+  handleEvent(event) {
+    try {
+      this.onEvent?.(event);
+    } catch (error) {
+      try {
+        this.onEventError(
+          `prowl-macdriver event sink failed for event "${event.event}": ${errorMessage(error)}`
+        );
+      } catch {
+      }
+    }
+  }
   failAll(error) {
     for (const pending of this.pending.values()) {
       clearTimeout(pending.timer);
@@ -1270,6 +1298,9 @@ function createAndroidDriver(client, options = {}) {
     waitForNetworkIdle() {
       return rejectUnsupported("waitForNetworkIdle");
     },
+    waitForResponse() {
+      return rejectUnsupported("waitForResponse");
+    },
     // scripting & artifacts ------------------------------------------------
     evaluate() {
       return rejectUnsupported("evalScript");
@@ -2132,6 +2163,9 @@ function createIosDriver(client, options) {
     waitForNetworkIdle() {
       return rejectUnsupported("waitForNetworkIdle");
     },
+    waitForResponse() {
+      return rejectUnsupported("waitForResponse");
+    },
     // scripting & artifacts ------------------------------------------------
     evaluate() {
       return rejectUnsupported("evalScript");
@@ -3056,7 +3090,8 @@ function isHistoryEntry(value) {
     return false;
   }
   const entry = value;
-  return typeof entry.hunt === "string" && (entry.status === "pass" || entry.status === "fail") && typeof entry.durationMs === "number" && Number.isFinite(entry.durationMs) && typeof entry.startedAt === "string" && (entry.runDir === void 0 || typeof entry.runDir === "string");
+  return typeof entry.hunt === "string" && (entry.status === "pass" || entry.status === "fail") && typeof entry.durationMs === "number" && Number.isFinite(entry.durationMs) && typeof entry.startedAt === "string" && (entry.runDir === void 0 || typeof entry.runDir === "string") && // Optional (PROWL-033): older history.json files predate `retries`.
+  (entry.retries === void 0 || typeof entry.retries === "number" && Number.isInteger(entry.retries) && entry.retries >= 0);
 }
 function readHistory(configDir) {
   const filePath = historyPath(configDir);
@@ -3327,6 +3362,9 @@ function createPlaywrightDriver(page) {
     async waitForNetworkIdle(options) {
       await page.waitForLoadState("networkidle", { timeout: options?.timeout });
     },
+    async waitForResponse(predicate, options) {
+      await page.waitForResponse((response) => predicate(response), { timeout: options?.timeout });
+    },
     evaluate(pageFunction, arg) {
       const raw = page.evaluate;
       const result = arg === void 0 ? raw.call(page, pageFunction) : raw.call(page, pageFunction, arg);
@@ -3734,6 +3772,7 @@ function getStepType(step) {
   if ("waitForSelector" in step) return "waitForSelector";
   if ("waitForUrl" in step) return "waitForUrl";
   if ("waitForNetworkIdle" in step) return "waitForNetworkIdle";
+  if ("waitForResponse" in step) return "waitForResponse";
   if ("hover" in step) return "hover";
   if ("scroll" in step) return "scroll";
   if ("scrollTo" in step) return "scrollTo";
@@ -3750,6 +3789,11 @@ function getStepType(step) {
   if ("waitForDownload" in step) return "waitForDownload";
   return "step";
 }
+function compileResponseUrlMatcher(pattern) {
+  const regexBody = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/\\\*/g, ".*").replace(/\\\?/g, ".");
+  const regex = new RegExp(regexBody);
+  return (url) => regex.test(url);
+}
 var RUNTIME_VAR_PATTERN = /\{\{([A-Z0-9_]+)\}\}/g;
 function substituteRuntimeVars(input, vars) {
   return input.replace(RUNTIME_VAR_PATTERN, (match, name) => {
@@ -3788,6 +3832,15 @@ function applyRuntimeVars(step, vars) {
   if ("waitForSelector" in step) {
     return { waitForSelector: { selector: sub(step.waitForSelector.selector), timeout: step.waitForSelector.timeout } };
   }
+  if ("waitForResponse" in step) {
+    return {
+      waitForResponse: {
+        url: sub(step.waitForResponse.url),
+        ...step.waitForResponse.status !== void 0 ? { status: step.waitForResponse.status } : {},
+        ...step.waitForResponse.timeout !== void 0 ? { timeout: step.waitForResponse.timeout } : {}
+      }
+    };
+  }
   if ("evalScript" in step) {
     if (typeof step.evalScript === "string") return { evalScript: sub(step.evalScript) };
     return {
@@ -4397,6 +4450,32 @@ var STEP_HANDLERS = {
       };
     }
   },
+  waitForResponse: {
+    capabilities: ["response", "wait"],
+    run: async (h) => {
+      if (!("waitForResponse" in h.step)) unknownStep();
+      const { url: pattern, status, timeout } = h.step.waitForResponse;
+      const matchesResponseUrl = compileResponseUrlMatcher(pattern);
+      try {
+        await h.driver.waitForResponse(
+          (response) => matchesResponseUrl(response.url()) && (status === void 0 || response.status() === status),
+          { timeout }
+        );
+      } catch (err) {
+        const isTimeout = err instanceof Error && (err.name === "TimeoutError" || /timeout/i.test(err.message));
+        if (!isTimeout) throw err;
+        const statusPart = status !== void 0 ? ` with status ${status}` : "";
+        const timeoutPart = timeout !== void 0 ? ` within ${timeout}ms` : "";
+        throw new Error(
+          `waitForResponse: no response matching "${pattern}"${statusPart} was received${timeoutPart}.`
+        );
+      }
+      return {
+        kind: "result",
+        result: { type: "waitForResponse", status: "pass", durationMs: Date.now() - h.stepStart, value: pattern }
+      };
+    }
+  },
   waitForNetworkIdle: {
     capabilities: ["wait"],
     run: async (h) => {
@@ -5187,6 +5266,15 @@ function formatStep(step) {
   const error = step.error ? ` error=${escapeMd(step.error)}` : "";
   return `${base}${selector}${healed}${value}${error}`;
 }
+function formatRetryAttempt(attempt) {
+  const base = `- attempt ${attempt.attempt}: ${attempt.status.toUpperCase()} (${attempt.durationMs}ms)`;
+  if (attempt.status === "pass") {
+    return base;
+  }
+  const step = attempt.failedStep ? ` failed-step=[${attempt.failedStep.index}] ${escapeMd(attempt.failedStep.type)}` : "";
+  const error = attempt.error ? ` error=${escapeMd(attempt.error)}` : "";
+  return `${base}${step}${error}`;
+}
 function formatAssertion(assertion) {
   const value = assertion.value !== void 0 ? ` value=${typeof assertion.value === "string" ? escapeMd(assertion.value) : assertion.value}` : "";
   const error = assertion.error ? ` error=${escapeMd(assertion.error)}` : "";
@@ -5201,6 +5289,16 @@ function writeSummary(runDir, result) {
   lines.push(`Target: ${result.targetUrl}`);
   lines.push(`Started: ${result.startedAt}`);
   lines.push(`Duration: ${result.durationMs}ms`);
+  if (result.retryHistory && result.retryHistory.length > 1) {
+    lines.push("");
+    lines.push("## Retries");
+    if (result.retrySummary) {
+      lines.push(escapeMd(result.retrySummary));
+    }
+    for (const attempt of result.retryHistory) {
+      lines.push(formatRetryAttempt(attempt));
+    }
+  }
   lines.push("");
   lines.push("## Steps");
   for (const step of result.steps) {
@@ -5511,6 +5609,60 @@ async function executeHuntAttempt(options, config, configDir, interpolatedHunt,
 function delay3(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function toRetryAttempt(attempt, result) {
+  const record = {
+    attempt,
+    status: result.status,
+    durationMs: result.durationMs
+  };
+  if (result.status === "fail") {
+    const failedIndex = result.steps.findIndex((step) => step.status === "fail");
+    if (failedIndex >= 0) {
+      const failed = result.steps[failedIndex];
+      record.failedStep = { index: failedIndex, type: failed.type };
+      if (failed.error) {
+        record.error = failed.error;
+      }
+    }
+    if (!record.error) {
+      const failedAssertion = result.assertions.find((assertion) => assertion.status === "fail");
+      if (failedAssertion?.error) {
+        record.error = failedAssertion.error;
+      }
+    }
+  }
+  return record;
+}
+function describeAttemptFailure(attempt) {
+  if (attempt.status !== "fail") {
+    return void 0;
+  }
+  const step = attempt.failedStep?.type;
+  if (step && attempt.error) {
+    return `${step} (${attempt.error})`;
+  }
+  return step ?? attempt.error;
+}
+function buildRetrySummary(attempts, maxRetries) {
+  const final = attempts[attempts.length - 1];
+  const firstFailure = describeAttemptFailure(attempts[0]);
+  const suffix = firstFailure ? ` \u2014 first failure: ${firstFailure}` : "";
+  if (final.status === "pass") {
+    return `Passed on attempt ${final.attempt} of ${maxRetries + 1}${suffix}`;
+  }
+  return `Failed after ${attempts.length} attempts${suffix}`;
+}
+function finalizeRetryOutcome(outcome, attempts, maxRetries, junit) {
+  outcome.result = writeReports(
+    outcome.runDir,
+    {
+      ...outcome.result,
+      retryHistory: attempts,
+      retrySummary: buildRetrySummary(attempts, maxRetries)
+    },
+    { junit }
+  );
+}
 async function runHunt(options) {
   const { config, configDir } = loadConfig(options.configPath);
   if (config.target.type === "macos") {
@@ -5540,7 +5692,9 @@ async function runHunt(options) {
   }
   const maxRetries = hunt.retry?.maxRetries ?? 0;
   const retryDelay = hunt.retry?.delay ?? 0;
+  const junit = options.junit ?? config.artifacts.junit;
   let lastResult;
+  const attempts = [];
   for (let attempt = 0; attempt <= maxRetries; attempt++) {
     if (attempt > 0 && retryDelay > 0) {
       await delay3(retryDelay);
@@ -5556,19 +5710,20 @@ async function runHunt(options) {
       targetUrl,
       allowedDomains
     );
+    attempts.push(toRetryAttempt(attempt + 1, lastResult.result));
     if (lastResult.result.status === "pass") {
-      if (attempt > 0) {
-        lastResult.result.artifacts.summary = `Passed on attempt ${attempt + 1} of ${maxRetries + 1}`;
+      if (attempts.length > 1) {
+        finalizeRetryOutcome(lastResult, attempts, maxRetries, junit);
       }
-      recordHistory(configDir, lastResult, config.history.maxRuns);
+      recordHistory(configDir, lastResult, config.history.maxRuns, attempts.length - 1);
       return lastResult;
     }
   }
-  if (maxRetries > 0 && lastResult) {
-    lastResult.result.artifacts.summary = `Failed after ${maxRetries + 1} attempts`;
-  }
   if (lastResult) {
-    recordHistory(configDir, lastResult, config.history.maxRuns);
+    if (attempts.length > 1) {
+      finalizeRetryOutcome(lastResult, attempts, maxRetries, junit);
+    }
+    recordHistory(configDir, lastResult, config.history.maxRuns, attempts.length - 1);
   }
   return lastResult;
 }
@@ -5772,7 +5927,9 @@ async function runNativeHunt(options, config, configDir, target, native) {
   }
   const maxRetries = hunt.retry?.maxRetries ?? 0;
   const retryDelay = hunt.retry?.delay ?? 0;
+  const junit = options.junit ?? config.artifacts.junit;
   let lastResult;
+  const attempts = [];
   for (let attempt = 0; attempt <= maxRetries; attempt++) {
     if (attempt > 0 && retryDelay > 0) {
       await delay3(retryDelay);
@@ -5787,23 +5944,24 @@ async function runNativeHunt(options, config, configDir, target, native) {
       randomVars,
       config.guardrails.allowedApps
     );
+    attempts.push(toRetryAttempt(attempt + 1, lastResult.result));
     if (lastResult.result.status === "pass") {
-      if (attempt > 0) {
-        lastResult.result.artifacts.summary = `Passed on attempt ${attempt + 1} of ${maxRetries + 1}`;
+      if (attempts.length > 1) {
+        finalizeRetryOutcome(lastResult, attempts, maxRetries, junit);
       }
-      recordHistory(configDir, lastResult, config.history.maxRuns);
+      recordHistory(configDir, lastResult, config.history.maxRuns, attempts.length - 1);
       return lastResult;
     }
   }
-  if (maxRetries > 0 && lastResult) {
-    lastResult.result.artifacts.summary = `Failed after ${maxRetries + 1} attempts`;
-  }
   if (lastResult) {
-    recordHistory(configDir, lastResult, config.history.maxRuns);
+    if (attempts.length > 1) {
+      finalizeRetryOutcome(lastResult, attempts, maxRetries, junit);
+    }
+    recordHistory(configDir, lastResult, config.history.maxRuns, attempts.length - 1);
   }
   return lastResult;
 }
-function recordHistory(configDir, outcome, maxRuns) {
+function recordHistory(configDir, outcome, maxRuns, retries = 0) {
   try {
     const relativeRunDir = path13.relative(configDir, outcome.runDir);
     appendEntry(
@@ -5813,7 +5971,9 @@ function recordHistory(configDir, outcome, maxRuns) {
         status: outcome.result.status,
         durationMs: outcome.result.durationMs,
         startedAt: outcome.result.startedAt,
-        runDir: relativeRunDir || void 0
+        runDir: relativeRunDir || void 0,
+        // Omit when no retry ran so entries stay additive/backward-compatible.
+        retries: retries > 0 ? retries : void 0
       },
       maxRuns
     );
@@ -6915,6 +7075,7 @@ var STEP_REFERENCE = `
 - waitForSelector: { selector: "#el", timeout: 5000 }
 - waitForUrl: { value: "/path", timeout: 5000 }
 - waitForNetworkIdle: { timeout: 5000 }
+- waitForResponse: { url: "**/api/orders", status: 200, timeout: 10000 } \u2014 wait for a matching network response (url is a glob/substring; status is optional)
 
 ### Interaction
 - click: "Button Text" \u2014 click by text (tries role=button first)
@@ -7482,4 +7643,4 @@ export {
   collectMacdriverStatus,
   tccGuidance
 };
-//# sourceMappingURL=chunk-CWLRDV5P.js.map
+//# sourceMappingURL=chunk-SRWAF2RI.js.map