blastproof 0.8.0 → 0.10.0

package/README.md

@@ -42,6 +42,8 @@ Before `run`, `plan` or `test` do anything, they check what they are about to sp
 
 **Your markup must be accessible — a hard requirement.** Elements are found by role, label or visible text from the accessibility tree. That is what removes selectors and survives redesigns; the cost is that an interface the accessibility tree cannot describe cannot be driven at all, and there is deliberately no CSS or XPath fallback. Icon-only buttons without accessible names, `div`-based controls and ARIA-less dropdowns simply cannot be targeted. Run an accessibility checker first — the result predicts how well this will work better than anything else.
 
+**Windows is untested.** Development and CI run on Linux and macOS. Nothing is known to be broken and reports are welcome (#8).
+
 **Not supported yet:** `iframe` content (so hosted payment widgets like Stripe Elements are invisible — an embedded checkout cannot be driven end to end), hover, scroll-to, drag and drop, file upload, multiple tabs, native `alert`/`confirm` dialogs. Page snapshots are capped at 200 lines by default, so very dense pages are truncated — raise it with `browser.max_snapshot_lines` if your pages need more; truncation is always marked in the snapshot so the model is never misled into thinking it saw the whole page.
 
 **Point it at disposable data.** Within a step, an action that commits — a click, or pressing Enter — is never performed twice: the runner refuses the repeat and tells the agent it already did that. This closes the case that used to produce duplicate records, where a submit answered by a redirect came back to a reset form and the agent, seeing no evidence of its own work, submitted again. It is not a guarantee of zero duplicate writes: an agent that reaches the same effect by a genuinely different route — another control with the same effect — is not caught. Use a seeded database, a staging environment you can reset, or a throwaway account; do not gate on a run against production data.
@@ -70,6 +72,26 @@ steps:
 
 `priority` is P0–P2 (default P1). `tags`, `setup` steps and `auth` are optional — `auth: false` runs the test signed out, which a login test needs. `routes` declares the URLs a test covers, which is what `--impacted` selects on; write route strings consistently, since they compare by exact equality (`/cart` ≠ `/cart/`).
 
+### Say what each step should produce
+
+This is the one rule that decides whether a suite works. An outside evaluation took the **same application, same suite, same version from Score 64 to Score 100 by rewriting two steps** — nothing else changed:
+
+```yaml
+# Fragile: a bare action. Nothing says what should be true afterwards.
+- submit the add-task form
+- verify the new task "Fix the flaky test" appears in the task list
+
+# Robust: the step carries its own outcome.
+- submit the add-task form and verify the task "Fix the flaky test" appears
+  in the task list with priority High and status Open
+```
+
+The bare version fails on a shape that is everywhere: the form POSTs, the server redirects back to the same page, and the form comes back empty. The agent is asked whether "submit the add-task form" happened, and is looking at a page that is indistinguishable from one where nothing did. A step that names the outcome gives it something to check that survives the action.
+
+Write steps that end in an observable result — text on the page, a count, a state change — and this class of failure does not arise.
+
+**Inline error messages should be plain visible text.** `role="alert"` is read correctly from the accessibility tree and needs no special handling, but note that an alert your page has cleared shows up as an empty element: if a verdict says an alert exists whose content is missing, the message was emptied, not hidden.
+
 ## Commands
 
 ```bash
@@ -113,7 +135,7 @@ jobs:
 
       - run: npm start &          # however your app boots
 
-      - uses: hamc/blastproof@v0.8.0
+      - uses: hamc/blastproof@v0.10.0
         with:
           version: '0.6.0'        # pin both when this gates merges
           api-key: ${{ secrets.ANTHROPIC_API_KEY }}
@@ -167,6 +189,22 @@ blastproof plan --base main --dry-run                 # affected routes no test
 
 They report affected routes, files nobody has classified, and affected routes no test covers — a coverage-gap report with an exit code, useful even on a repo whose suite is Playwright or Cypress.
 
+## Running tests at once
+
+Tests run one at a time by default. Raise it when your tests can stand it:
+
+```yaml
+concurrency: 4
+```
+
+or `blastproof run --concurrency 4` for a single invocation. On this repository's own suite that takes a run from 156s to 68s — **2.3× faster, for the same 81 model calls.** Parallelism buys wall-clock, not spend.
+
+**The default is 1 on purpose, and raising it is your call to make.** Other test runners default to parallel because their tests are isolated by construction — separate processes, separate fixtures. These are journeys driven against **one running application**, so two tests can see each other's data. A suite is safe to parallelise when its tests do not write state that another test reads.
+
+The test in this repository's own suite that could not run beside itself is a good shape to recognise: it adds a note and then asserts *"one note on file"*. It writes shared server state, and it asserts on a global count. Either alone is a warning; together they mean the test's verdict depends on nothing else touching the application at that moment.
+
+Two practical notes. Four concurrent journeys are four times the traffic against whatever you pointed at — usually fine for a development instance, worth knowing for a shared one. And with several model calls in flight, a `budget:` limit can overshoot by up to the concurrency rather than by a single call, since the calls already sent are allowed to finish.
+
 ## Bounding a run
 
 Nothing stops a run by default. `budget:` puts a ceiling on `run`, `plan` and `test` alike — every model call any of them makes is counted:
@@ -182,7 +220,18 @@ Each limit is optional; with none set, nothing binds. They count **calls and tok
 
 Exhausting a budget **stops the run; it does not fail a test.** Running out of quota says nothing about the code under review. Unreached tests are reported as `not run`, a third state excluded from the score entirely, and the process exits 1 unconditionally — `--min-score` cannot rescue it, because the tests that finished are whichever ran first, not a representative sample.
 
-`--dry-run` reports the ceiling before you spend anything.
+**Every run reports what it spent**, so you can size a limit from experience rather than guesswork:
+
+```
+Spent: 82 model call(s), 115407 token(s)
+Score: 100
+```
+
+The figures also land in the JUnit report as `llm_calls` and `llm_tokens`, beside `score`, so a pipeline can trend cost without scraping output. A run stopped by its own budget reports the spend too — that is the case where the number is least guessable. Where a provider reports no token usage, the line says so rather than showing zero.
+
+`--dry-run` reports the ceiling before you spend anything. Read it as a maximum and nothing more: for this repository's own suite it says 735 calls where a real run spends 82. Size a budget from what your runs actually report, not from the ceiling.
+
+For an order of magnitude, this repository's own suite — 7 tests, 31 steps, an authenticated demo shop, `anthropic/claude-haiku-4.5` — spends **about 82 model calls and 115k tokens**, taking 156s serially or 68s at `--concurrency 4`. That is a number you can reproduce (`node examples/demo-app/serve.mjs 4173` and `blastproof run`), not a forecast for your suite: cost scales with steps, page density and how often the agent has to retry. Run yours once and read the `Spent:` line.
 
 ## Testing behind a login
 

package/dist/cli.js

@@ -210,6 +210,7 @@ var RunBudget = class {
   startedAt;
   calls = 0;
   tokens = 0;
+  callsWithUsage = 0;
   constructor(options = {}) {
     this.maxCalls = options.maxCalls;
     this.maxTokens = options.maxTokens;
@@ -248,7 +249,25 @@ var RunBudget = class {
   /** Records what a completed model call spent. */
   record(usage) {
     this.calls += 1;
-    if (usage?.totalTokens !== void 0) this.tokens += usage.totalTokens;
+    if (usage?.totalTokens !== void 0) {
+      this.tokens += usage.totalTokens;
+      this.callsWithUsage += 1;
+    }
+  }
+  /**
+   * What this budget has been spent on, for every surface that reports it
+   * (design report-what-it-spent, D1). One method rather than four getters read
+   * separately: the console, the JUnit report and the HTML report take the same
+   * numbers from the same object, so they cannot disagree about what a run cost.
+   */
+  spend() {
+    return {
+      calls: this.calls,
+      maxCalls: this.maxCalls,
+      tokens: this.tokens,
+      callsWithUsage: this.callsWithUsage,
+      maxTokens: this.maxTokens
+    };
   }
 };
 function estimateMaxModelCalls(tests, maxIterationsPerStep, maxRetriesPerStep) {
@@ -417,7 +436,8 @@ async function performAction(page, action, ctx) {
       const url = new URL(value, ctx.baseUrl);
       assertAllowedOrigin(url, ctx);
       await page.goto(url.toString(), { timeout: ctx.resolveTimeoutMs ?? 3e4 });
-      return `ok: navigated to ${url.toString()}`;
+      const landed = page.url();
+      return landed === url.toString() ? `ok: navigated to ${url.toString()}` : `ok: navigated to ${url.toString()}, which redirected to ${landed}`;
     }
     case "click": {
       const target = requireTarget(action);
@@ -623,11 +643,21 @@ async function executeTest(page, test, options) {
         }
         if (action.action === "assert") {
           const expectation = action.expectation ?? action.reasoning;
-          let judgment = await brain.judge(mask(step), mask(expectation), mask(snap));
+          let judgment = await brain.judge(
+            mask(step),
+            mask(expectation),
+            mask(snap),
+            recovery.stepHistory()
+          );
           if (!judgment.pass) {
             await waitForSettled(page);
             const freshSnap = await takeSnapshot(page);
-            judgment = await brain.judge(mask(step), mask(expectation), mask(freshSnap));
+            judgment = await brain.judge(
+              mask(step),
+              mask(expectation),
+              mask(freshSnap),
+              recovery.stepHistory()
+            );
           }
           const result = judgment.pass ? `ok: assertion passed: ${judgment.reason}` : `assertion failed: ${judgment.reason}`;
           emitAction(index, action, result);
@@ -947,6 +977,13 @@ var configSchema = z.object({
   allowed_origins: z.array(z.string().url()).optional(),
   auth: authSchema.optional(),
   max_retries_per_step: z.number().int().min(1).default(3),
+  /**
+   * How many tests may run at once (design tests-in-parallel, D1). Defaults to
+   * 1 — tests are journeys driven against one running application, and whether
+   * two of them can run at the same time is a property of that application and
+   * those tests, not of the runner. Opted into by the person who knows.
+   */
+  concurrency: z.number().int().min(1, "concurrency must be at least 1").default(1),
   budget: budgetSchema.optional()
 });
 var ENV_OVERRIDES = {
@@ -1177,13 +1214,24 @@ A value sitting in a control that was just typed into \u2014 an open dialog's te
 
 A step that names an ACTION (submit, click, create, add, ...) is satisfied by evidence the action took effect, not by the action's own control still being on the page. A successful action ordinarily replaces or moves past exactly the form, button or field the step names, so that control's absence is normal evidence of success, not evidence the step is unverifiable \u2014 do not fail such a step only because you can no longer see the thing it names. Fail it instead when the snapshot shows the action did NOT take effect: an error message, a validation warning, or the very same pre-action page still in front of you with nothing changed. A different page, a new state, or the result the action was meant to produce counts as evidence it worked.
 
+You may also be shown the actions already performed in this step, with their results. That record tells you what was ATTEMPTED and what it produced \u2014 for instance that a navigation was performed and which URL the server ultimately served, or that a form was submitted. Use it to avoid concluding that something never happened when the page simply cannot show it any more: a navigation the server redirected does not leave the browser at the path that was requested, and that is what success looks like, not failure.
+
+The record is not evidence that the step's outcome holds. An action reported as \`ok\` establishes that it ran and what it returned; whether the thing the step describes is now TRUE is still decided by the snapshot alone. Never pass a step because the record shows an action succeeded while the snapshot does not show the outcome.
+
 Be strict about what the step asks, not about withholding a pass you can plainly see is earned. Answer with pass=true/false and a one-sentence reason.
 
 \`***\` marks a secret deliberately withheld from you \u2014 a password, token or key. Seeing it is expected. A field holding \`***\` is filled, not empty, so do not fail a step on the grounds that a value was redacted. This applies only to the redaction itself: everything else the step asks for must still be visibly satisfied by the snapshot, and a step you genuinely cannot check against what you were shown still fails.`;
 }
-function assertUserPrompt(step, expectation, snapshot) {
-  return [
-    `Step under test: ${step}`,
+function assertUserPrompt(step, expectation, snapshot, stepHistory) {
+  const parts = [`Step under test: ${step}`];
+  if (stepHistory && stepHistory.length > 0) {
+    parts.push(
+      "",
+      "Actions already performed in this step, with their results (what was DONE \u2014 not evidence of what is now true):",
+      ...stepHistory.map((entry, i) => `${i + 1}. ${entry.action} -> ${entry.result}`)
+    );
+  }
+  parts.push(
     "",
     `Model's expectation (the claim offered in support of the step, not the question itself): ${expectation}`,
     "",
@@ -1191,7 +1239,8 @@ function assertUserPrompt(step, expectation, snapshot) {
     snapshot,
     "",
     "Does the snapshot establish that the step's own outcome holds?"
-  ].join("\n");
+  );
+  return parts.join("\n");
 }
 function plannerSystemPrompt() {
   return `You are a QA engineer writing one end-to-end test for a web page, in plain English.
@@ -1280,12 +1329,12 @@ function createBrain(model, generate = generateObject, budget) {
       }
       return parsed.data;
     },
-    async judge(step, expectation, snapshot) {
+    async judge(step, expectation, snapshot, stepHistory) {
       const result = await countedGenerate(generate, budget, {
         model,
         schema: assertJudgmentSchema,
         system: assertSystemPrompt(),
-        prompt: assertUserPrompt(step, expectation, snapshot)
+        prompt: assertUserPrompt(step, expectation, snapshot, stepHistory)
       });
       const parsed = assertJudgmentSchema.safeParse(result.object);
       if (!parsed.success) {
@@ -1626,6 +1675,43 @@ function printPreflightFailures(failures) {
   for (const failure of failures) console.error(`  - ${failure}`);
 }
 
+// src/report/score.ts
+var WEIGHTS = { P0: 3, P1: 2, P2: 1 };
+var DEFAULT_WEIGHT = WEIGHTS.P1;
+function computeScore(results) {
+  let total = 0;
+  let passed = 0;
+  for (const result of results) {
+    if (result.status === "not-run") continue;
+    const weight = WEIGHTS[result.priority] ?? DEFAULT_WEIGHT;
+    total += weight;
+    if (result.status === "passed") passed += weight;
+  }
+  if (total === 0) return 100;
+  return Math.round(100 * passed / total);
+}
+function formatScoreLine(score, results, threshold) {
+  if (results.length === 0) {
+    const base = "Score: 100 (no tests executed)";
+    return threshold === void 0 ? base : `${base} \u2014 min-score ${threshold}: pass`;
+  }
+  if (threshold === void 0) return `Score: ${score}`;
+  return score >= threshold ? `Score: ${score} \u2014 min-score ${threshold}: pass` : `Score: ${score} \u2014 min-score ${threshold}: FAIL (below threshold)`;
+}
+function formatIncompleteLine(score, reason) {
+  return `Run incomplete: ${reason}
+Score over executed tests: ${score} (not a verdict \u2014 exit code 1 regardless of --min-score)`;
+}
+function formatSpendLine(spend) {
+  const calls = spend.maxCalls === void 0 ? `${spend.calls} model call(s)` : `${spend.calls} of ${spend.maxCalls} model call(s)`;
+  if (spend.callsWithUsage === 0) {
+    return `Spent: ${calls}; token usage not reported by the provider`;
+  }
+  const tokens = spend.maxTokens === void 0 ? `${spend.tokens} token(s)` : `${spend.tokens} of ${spend.maxTokens} token(s)`;
+  const coverage = spend.callsWithUsage < spend.calls ? ` (tokens reported by ${spend.callsWithUsage} of ${spend.calls} call(s))` : "";
+  return `Spent: ${calls}, ${tokens}${coverage}`;
+}
+
 // src/commands/run.ts
 import path9 from "path";
 
@@ -1770,7 +1856,7 @@ async function renderHtml(results, skipped, meta) {
 <body>
 <main>
   <h1>blastproof report</h1>
-  <p class="sub">${escapeHtml(generatedAt)} \xB7 ${seconds(meta.durationMs)}</p>
+  <p class="sub">${escapeHtml(generatedAt)} \xB7 ${seconds(meta.durationMs)}${meta.spend ? ` \xB7 ${escapeHtml(formatSpendLine(meta.spend))}` : ""}</p>
 
 ${banner}  <section class="score">
     <b>${meta.score}</b>
@@ -1824,6 +1910,11 @@ function renderJUnit(results, skipped, meta) {
     `<testsuite name="blastproof" tests="${results.length + skipped.length}" failures="${failures}" skipped="${skipped.length + notRun.length}" time="${seconds2(meta.durationMs)}">`,
     "  <properties>",
     `    <property name="score" value="${meta.score}"/>`,
+    ...meta.spend ? [`    <property name="llm_calls" value="${meta.spend.calls}"/>`] : [],
+    // Omitted rather than emitted as zero when no call reported usage: a
+    // property carrying 0 would be read by a pipeline as "this run spent no
+    // tokens", which is a different claim from "the provider did not say".
+    ...meta.spend && meta.spend.callsWithUsage > 0 ? [`    <property name="llm_tokens" value="${meta.spend.tokens}"/>`] : [],
     ...meta.incomplete !== void 0 ? [
       '    <property name="incomplete" value="true"/>',
       `    <property name="incomplete_reason" value="${escapeXml(meta.incomplete)}"/>`
@@ -1867,32 +1958,26 @@ async function writeJUnit(file, xml) {
   return file;
 }
 
-// src/report/score.ts
-var WEIGHTS = { P0: 3, P1: 2, P2: 1 };
-var DEFAULT_WEIGHT = WEIGHTS.P1;
-function computeScore(results) {
-  let total = 0;
-  let passed = 0;
-  for (const result of results) {
-    if (result.status === "not-run") continue;
-    const weight = WEIGHTS[result.priority] ?? DEFAULT_WEIGHT;
-    total += weight;
-    if (result.status === "passed") passed += weight;
-  }
-  if (total === 0) return 100;
-  return Math.round(100 * passed / total);
-}
-function formatScoreLine(score, results, threshold) {
-  if (results.length === 0) {
-    const base = "Score: 100 (no tests executed)";
-    return threshold === void 0 ? base : `${base} \u2014 min-score ${threshold}: pass`;
+// src/runner/pool.ts
+async function runWithConcurrency(items, concurrency, run) {
+  if (concurrency < 1) throw new RangeError(`concurrency must be at least 1, got ${concurrency}`);
+  const results = new Array(items.length);
+  let next = 0;
+  const worker = async () => {
+    while (true) {
+      const index = next++;
+      if (index >= items.length) return;
+      results[index] = await run(items[index], index);
+    }
+  };
+  const workers = [];
+  for (let i = 0; i < Math.min(concurrency, items.length); i++) {
+    workers.push(worker());
   }
-  if (threshold === void 0) return `Score: ${score}`;
-  return score >= threshold ? `Score: ${score} \u2014 min-score ${threshold}: pass` : `Score: ${score} \u2014 min-score ${threshold}: FAIL (below threshold)`;
-}
-function formatIncompleteLine(score, reason) {
-  return `Run incomplete: ${reason}
-Score over executed tests: ${score} (not a verdict \u2014 exit code 1 regardless of --min-score)`;
+  const settled = await Promise.allSettled(workers);
+  const failure = settled.find((outcome) => outcome.status === "rejected");
+  if (failure && failure.status === "rejected") throw failure.reason;
+  return results;
 }
 
 // src/runner/selection.ts
@@ -1983,19 +2068,19 @@ function notRunResults(tests, reason) {
     durationMs: 0
   }));
 }
-function printEvent(event) {
+function printEvent(event, write = console.log) {
   switch (event.type) {
     case "step-start":
-      console.log(`  ${event.setup ? "(setup) " : ""}step ${event.index + 1}/${event.total}: ${event.step}`);
+      write(`  ${event.setup ? "(setup) " : ""}step ${event.index + 1}/${event.total}: ${event.step}`);
       break;
     case "action": {
       const { action, result } = event;
-      console.log(`    -> ${describeAction(action)} :: ${result}`);
+      write(`    -> ${describeAction(action)} :: ${result}`);
       break;
     }
     case "step-end":
       if (event.status === "failed") {
-        console.log(`    X step failed: ${event.reason ?? "unknown reason"}`);
+        write(`    X step failed: ${event.reason ?? "unknown reason"}`);
       }
       break;
   }
@@ -2040,7 +2125,7 @@ ${notRun.length} test(s) not run (run stopped by its budget or deadline):`);
     for (const r of notRun) console.log(`  - ${r.summary} (${r.file})`);
   }
 }
-async function runOne(browser, test, config, sessionDir, session, runMask, budget) {
+async function runOne(browser, test, config, sessionDir, session, runMask, budget, write) {
   const brain = createBrain(createModel(config.llm).model, void 0, budget);
   let resolved;
   const mask = runMask;
@@ -2075,7 +2160,7 @@ async function runOne(browser, test, config, sessionDir, session, runMask, budge
       timeoutMs: config.browser.timeout_ms,
       maxSnapshotLines: config.browser.max_snapshot_lines,
       mask: (text) => mask.mask(text),
-      onEvent: printEvent
+      onEvent: (event) => printEvent(event, write)
     });
   } finally {
     await context.close();
@@ -2106,8 +2191,9 @@ function printImpactReport(impact, selection, cwd) {
   }
   console.log("---------------------------------------------------------------");
 }
-async function finalize(results, skipped, options, sessionDir, durationMs, impact, incomplete) {
+async function finalize(results, skipped, options, sessionDir, durationMs, impact, incomplete, spend) {
   if (results.length > 0) printSummary(results);
+  if (spend) console.log(formatSpendLine(spend));
   const score = computeScore(results);
   console.log(
     incomplete ? formatIncompleteLine(score, incomplete.message) : formatScoreLine(score, results, options.minScore)
@@ -2118,7 +2204,8 @@ async function finalize(results, skipped, options, sessionDir, durationMs, impac
       score,
       durationMs,
       cwd: options.cwd,
-      incomplete: incomplete?.message
+      incomplete: incomplete?.message,
+      spend
     });
     await writeJUnit(target, xml);
     console.log(`JUnit report: ${path9.relative(options.cwd, target)}`);
@@ -2130,7 +2217,8 @@ async function finalize(results, skipped, options, sessionDir, durationMs, impac
       durationMs,
       minScore: options.minScore,
       cwd: options.cwd,
-      incomplete: incomplete?.message
+      incomplete: incomplete?.message,
+      spend
     });
     await writeHtml(target, html);
     console.log(`HTML report: ${path9.relative(options.cwd, target)}`);
@@ -2317,21 +2405,38 @@ ${results.length} test file(s) could not be parsed:`);
     if (incomplete) {
       results.push(...notRunResults(selected, incomplete.message));
     } else {
-      for (let i = 0; i < selected.length; i++) {
-        const test = selected[i];
-        console.log(`
-> ${test.summary} [${test.priority}] (${path9.relative(options.cwd, test.path)})`);
+      const concurrency = options.concurrency ?? config.concurrency;
+      const streaming = concurrency === 1;
+      let stoppedBy;
+      const outcomes = await runWithConcurrency(selected, concurrency, async (test, index) => {
+        if (stoppedBy) return { index, stopped: stoppedBy };
+        const lines = [];
+        const header = `
+> ${test.summary} [${test.priority}] (${path9.relative(options.cwd, test.path)})`;
+        const write = streaming ? console.log : (line) => lines.push(line);
+        if (streaming) console.log(header);
+        else lines.push(header);
         try {
           budget.check();
-          results.push(await runOne(browser, test, config, sessionDir, session, runMask, budget));
+          const result = await runOne(browser, test, config, sessionDir, session, runMask, budget, write);
+          if (!streaming) for (const line of lines) console.log(line);
+          return { index, result };
         } catch (error) {
           if (error instanceof BudgetExhaustedError) {
-            incomplete = error;
-            results.push(...notRunResults(selected.slice(i), error.message));
-            break;
+            stoppedBy ??= error;
+            if (!streaming) for (const line of lines) console.log(line);
+            return { index, stopped: error };
           }
           throw error;
         }
+      });
+      for (const outcome of outcomes) {
+        if (outcome.result) {
+          results.push(outcome.result);
+          continue;
+        }
+        incomplete ??= outcome.stopped;
+        results.push(...notRunResults([selected[outcome.index]], outcome.stopped.message));
       }
     }
   } finally {
@@ -2344,7 +2449,13 @@ ${results.length} test file(s) could not be parsed:`);
     sessionDir,
     Date.now() - startedAt,
     impact,
-    incomplete
+    incomplete,
+    // The command that constructed the budget is the one that reports it
+    // (design report-what-it-spent, D2). `test` hands one budget to both of its
+    // phases deliberately, so reporting at the point of use rather than the
+    // point of ownership would print the running total twice for a single
+    // allowance, the second line silently including the first.
+    options.budget === void 0 ? budget.spend() : void 0
   );
 }
 
@@ -2574,6 +2685,7 @@ ${renderTestYaml(draft, { route, base })}`);
       for (const route of notAttempted) console.log(`  ${route}`);
     }
   }
+  if (options.budget === void 0) console.log(formatSpendLine(budget.spend()));
   console.log("---------------------------------------------------------------");
   return incomplete || failed.length > 0 ? EXIT_FAILED : EXIT_OK;
 }
@@ -2618,6 +2730,8 @@ async function testCommand(options) {
     budget
   });
   if (planCode === EXIT_USAGE) return EXIT_USAGE;
+  console.log(`
+${formatSpendLine(budget.spend())}`);
   console.log(
     "\nDrafts are not executed and do not affect the score \u2014 review them before they join the suite."
   );
@@ -2660,7 +2774,7 @@ function parsePositiveNumber(flag) {
   };
 }
 var program = new Command();
-program.name("blastproof").description("Open-source AI testing agent: plain-English YAML tests executed agentically on a real browser.").version("0.8.0");
+program.name("blastproof").description("Open-source AI testing agent: plain-English YAML tests executed agentically on a real browser.").version("0.10.0");
 program.command("init").description("Scaffold .blastproof/ (config, tests, sample tests) in the current directory").action(async () => {
   try {
     const result = await initProject(process.cwd());
@@ -2676,6 +2790,10 @@ program.command("run").description("Discover and run all tests under .blastproof
   "require a weighted score of at least n (0-100); replaces the all-must-pass rule",
   parseMinScore
 ).option("--junit [path]", "write a JUnit XML report (default: .blastproof/reports/<session>/junit.xml)").option("--html [path]", "write a self-contained HTML report (default: .blastproof/reports/<session>/report.html)").option("--fail-on-unmapped", "fail when a changed file matches no routes: or ignore: glob").option(
+  "--concurrency <n>",
+  "run this many tests at once (overrides config; default 1 \u2014 see the README on when this is safe)",
+  parsePositiveInt("--concurrency")
+).option(
   "--max-llm-calls <n>",
   "stop the run after this many model calls, reported as incomplete (overrides config)",
   parsePositiveInt("--max-llm-calls")
@@ -2703,6 +2821,7 @@ program.command("run").description("Discover and run all tests under .blastproof
         junit: options.junit,
         html: options.html,
         failOnUnmapped: options.failOnUnmapped,
+        concurrency: options.concurrency,
         maxLlmCalls: options.maxLlmCalls,
         maxTokens: options.maxTokens,
         maxDuration: options.maxDuration