@@ -279,6 +279,12 @@ pnpm bench:playwright-readiness --no-ingest
 pnpm bench:playwright-throughput --no-ingest
 ```
 
+The default commands require credentials for both providers and fail before any
+provider request if either is unavailable. For an explicit single-provider
+diagnostic, pass `--provider momentic` or `--provider azure`. Raw diagnostic
+outputs are labeled `provider-diagnostic` and list unavailable participants
+separately from attempted-session denominators.
+
 Store credentials in your shell or the ignored `benchmarks/.env`, never in Git:
 
 - `MOMENTIC_BROWSER_FLEET_URL`: the Browser Fleet API base URL.
@@ -346,8 +352,10 @@ cleanup is recorded as uncertain and further allocations stop for that
 participant; the implementation does not claim it released an unknown resource.
 Provisioning has a 120-second bound;
 connection, context/page creation, and navigation have 30-second bounds; each
-cleanup operation has a 15-second bound. After uncertain cleanup, the process
-refuses further allocations for that participant and records unstarted tasks
+cleanup operation has a 15-second bound. Timed-out context creation is retained
+and reconciled within that cleanup bound; late contexts are explicitly closed.
+Unresolved context ownership makes cleanup uncertain. After uncertain cleanup,
+the process refuses further allocations for that participant and records unstarted tasks
 separately from attempted-session reliability denominators.
 
 No real credentials are used by fixture tests. Local fixture credentials and
 
@@ -8,12 +8,13 @@ import { promisify } from 'node:util';
 import { mkdtempSync, readFileSync, writeFileSync, readdirSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
-import { chromium } from 'playwright-native-core';
+import { chromium, type BrowserContext, type BrowserContextOptions } from 'playwright-native-core';
+import { withTimeout } from '../src/util/timeout.js';
 import { runBenchmark, type BenchmarkRunOutcome } from '@benchsdk/runner';
-import { distribution } from './results.js';
-import { articleUrl } from './workload.js';
+import { distribution } from './playwright-results.js';
+import { articleUrl } from './playwright-workload.js';
 
-test('native suites use real Playwright connections and preserve reliability records', { timeout: 120_000 }, async () => {
+test('native suites use real Playwright connections and preserve reliability records', { timeout: 180_000 }, async t => {
   const directory = mkdtempSync(path.join(tmpdir(), 'native-bench-'));
   const envNames = ['MOMENTIC_BROWSER_FLEET_URL', 'MOMENTIC_BROWSER_FLEET_API_KEY', 'AZURE_PLAYWRIGHT_SERVICE_URL', 'AZURE_PLAYWRIGHT_ACCESS_TOKEN', 'PLAYWRIGHT_NATIVE_ENVIRONMENT_FILE', 'PLAYWRIGHT_NATIVE_URLS_FILE', 'PLAYWRIGHT_NATIVE_RESULTS_DIR'];
   const previous = new Map(envNames.map(key => [key, process.env[key]]));
@@ -76,7 +77,7 @@ test('native suites use real Playwright connections and preserve reliability rec
       const sessionId = sessions.get(key);
       if (mode === 'lost-response' && !lost) { lost = true; req.socket.destroy(); return; }
       if (mode === 'malformed-json') { res.end('{"connectToken":"local-unpublished-credential'); return; }
-      res.end(JSON.stringify({ id: sessionId, status: 'READY', playwrightVersion: '1.60.0', wsEndpoint: mode === 'refused-connection' ? 'ws://127.0.0.1:1/refused?token=private-query' : `ws://127.0.0.1:${apiPort}/connect/momentic/${sessionId}`, ...(mode !== 'malformed-ready' ? { connectToken: 'local-connect-credential' } : {}) }));
+      res.end(JSON.stringify({ id: sessionId, status: 'READY', playwrightVersion: mode === 'compatible-patch' ? '1.60.1' : mode === 'incompatible-version' ? '1.61.0' : '1.60.0', wsEndpoint: mode === 'refused-connection' ? 'ws://127.0.0.1:1/refused?token=private-query' : `ws://127.0.0.1:${apiPort}/connect/momentic/${sessionId}`, ...(mode !== 'malformed-ready' ? { connectToken: 'local-connect-credential' } : {}) }));
     } else if (req.method === 'DELETE') {
       if (mode === 'cleanup-failure') { res.writeHead(500); res.end('{}'); return; }
       if (id) terminated.add(id);
@@ -122,8 +123,8 @@ test('native suites use real Playwright connections and preserve reliability rec
     writeFileSync(environmentFile, JSON.stringify(environment));
     writeFileSync(urlsFile, JSON.stringify(urls));
     Object.assign(process.env, { MOMENTIC_BROWSER_FLEET_URL: `http://127.0.0.1:${apiPort}`, MOMENTIC_BROWSER_FLEET_API_KEY: 'local-momentic-credential', AZURE_PLAYWRIGHT_SERVICE_URL: `http://127.0.0.1:${apiPort}/browsers`, AZURE_PLAYWRIGHT_ACCESS_TOKEN: 'local-azure-credential', PLAYWRIGHT_NATIVE_ENVIRONMENT_FILE: environmentFile, PLAYWRIGHT_NATIVE_URLS_FILE: urlsFile, PLAYWRIGHT_NATIVE_RESULTS_DIR: directory });
-    const readiness = await import('../playwright-readiness.bench.js');
-    const throughput = await import('../playwright-throughput.bench.js');
+    const readiness = await import('./playwright-readiness.bench.js');
+    const throughput = await import('./playwright-throughput.bench.js');
     const records = (outcome: BenchmarkRunOutcome) => outcome.participants.flatMap(p => p.records);
     const ready = await runBenchmark({ ...readiness.config, iterations: 2 }, readiness.task, ['--no-ingest']);
     assert.deepEqual(order, ['momentic', 'azure', 'momentic', 'azure']);
@@ -173,7 +174,7 @@ test('native suites use real Playwright connections and preserve reliability rec
       assert.equal(summary.metrics.actionsPerSecond.count, 2);
       assert.equal(summary.perActionType.screenshot.count, 20);
     }
-    for (const failureMode of ['lost-response', 'malformed-ready', 'refused-connection', 'cleanup-failure']) {
+    for (const failureMode of ['lost-response', 'malformed-ready', 'refused-connection', 'incompatible-version', 'cleanup-failure']) {
       mode = failureMode;
       order.length = 0;
       const participants = readiness.config.participants.filter(p => p.name === 'momentic').map(p => ({ ...p }));
@@ -187,6 +188,10 @@ test('native suites use real Playwright connections and preserve reliability rec
         assert.deepEqual(order, ['momentic'], 'uncertain cleanup stops new allocations');
       } else assert.equal(terminated.size, sessions.size);
     }
+    mode = 'compatible-patch';
+    const compatible = await runBenchmark({ ...readiness.config, participants: readiness.config.participants.filter(p => p.name === 'momentic').map(p => ({ ...p })), iterations: 1 }, readiness.task, ['--no-ingest']);
+    assert.equal(records(compatible)[0].status, 'success');
+    assert.equal(records(compatible)[0].data?.serverPlaywrightVersion, '1.60.1');
     mode = 'refused-connection';
     const azureFailure = await runBenchmark({ ...readiness.config, participants: readiness.config.participants.filter(p => p.name === 'azure').map(p => ({ ...p })), iterations: 2 }, readiness.task, ['--no-ingest']);
     assert.equal(records(azureFailure)[0].data?.cleanupSuccess, false);
@@ -215,6 +220,60 @@ test('native suites use real Playwright connections and preserve reliability rec
       assert.ok(stdout.includes('All done. No platform run created.'));
       assert.ok(!stdout.includes('FAILED'));
     }
+    // Missing credentials must fail the comparison before any allocation.
+    const diagnosticEnv = { ...process.env };
+    delete diagnosticEnv.AZURE_PLAYWRIGHT_ACCESS_TOKEN;
+    for (const entry of ['playwright-readiness', 'playwright-throughput']) {
+      const command = ['node_modules/tsx/dist/cli.mjs', 'packages/benchsdk-runner/dist/bin.js', 'run', `benchmarks/browser/${entry}.bench.ts`, '--no-ingest', '--iterations=1'];
+      order.length = 0;
+      await assert.rejects(promisify(execFile)(process.execPath, command, { env: diagnosticEnv }), /Unavailable Playwright participant\(s\): azure: AZURE_PLAYWRIGHT_ACCESS_TOKEN/);
+      assert.deepEqual(order, []);
+      const { stdout } = await promisify(execFile)(process.execPath, [...command, '--provider=momentic'], { env: diagnosticEnv });
+      assert.deepEqual(order, ['momentic']);
+      const match = stdout.match(/Raw Playwright-native records and untrimmed summaries: (.+)/);
+      assert.ok(match);
+      const diagnostic = JSON.parse(readFileSync(match[1].trim(), 'utf8'));
+      assert.equal(diagnostic.mode, 'provider-diagnostic');
+      assert.deepEqual(diagnostic.unavailableParticipants, [{ name: 'azure', missing: ['AZURE_PLAYWRIGHT_ACCESS_TOKEN'] }]);
+    }
+    // Delay returning an actual remote context beyond the 30-second deadline.
+    // Cover reconciliation within cleanup, and ownership still unresolved at its bound.
+    for (const delayMs of [31_000, 46_000]) {
+      const client = await chromium.connect(endpoint);
+      const newContext = client.newContext.bind(client);
+      let pending: Promise<BrowserContext> | undefined;
+      let closed: Promise<void> | undefined;
+      const contextMock = t.mock.method(client, 'newContext', (options: BrowserContextOptions) => {
+        pending = newContext(options).then(async created => {
+          closed = new Promise<void>(resolve => created.once('close', () => resolve()));
+          await new Promise(resolve => setTimeout(resolve, delayMs));
+          return created;
+        });
+        return pending;
+      });
+      const connectMock = t.mock.method(chromium, 'connect', async () => client);
+      const closeMock = delayMs === 46_000 ? t.mock.method(client, 'close', async () => { throw new Error('fixture disconnect failed'); }) : undefined;
+      try {
+        order.length = 0;
+        const participants = readiness.config.participants.filter(p => p.name === 'momentic').map(p => ({ ...p }));
+        const late = await runBenchmark({ ...readiness.config, participants, iterations: delayMs === 46_000 ? 2 : 1 }, readiness.task, ['--no-ingest']);
+        const [first, second] = records(late);
+        assert.equal(first.status, 'error');
+        assert.match(String(first.data?.errorMessage), /Context creation timed out/);
+        assert.equal(first.data?.cleanupSuccess, delayMs === 31_000);
+        if (delayMs === 46_000) {
+          assert.equal(second.data?.attemptStarted, false);
+          assert.deepEqual(order, ['momentic'], 'unresolved context ownership stops allocations');
+        }
+        assert.ok(pending && closed);
+        await pending;
+        await withTimeout(closed, 5_000, 'Late context was not closed');
+        assert.equal(client.contexts().length, 0);
+      } finally {
+        contextMock.mock.restore(); connectMock.mock.restore(); closeMock?.mock.restore();
+        await client.close();
+      }
+    }
     const audit = await chromium.connect(endpoint);
     assert.equal(audit.contexts().length, 0, 'all benchmark contexts were closed');
     await audit.close();
 
@@ -1,9 +1,9 @@
 /** Resolve and DOM-validate shared Wikipedia inputs before measured sessions. */
 import { chromium } from 'playwright-native-core';
 import { writeFileSync } from 'node:fs';
-import { articleUrl, firstArticleLink } from './workload.js';
-import { withTimeout } from '../../src/util/timeout.js';
-import { VIEWPORT } from './providers.js';
+import { articleUrl, firstArticleLink } from './playwright-workload.js';
+import { withTimeout } from '../src/util/timeout.js';
+import { VIEWPORT } from './playwright-providers.js';
 
 const count = Number(process.argv[2] ?? '100');
 const filename = process.argv[3] ?? 'playwright-native-urls.json';
 
@@ -1,23 +1,29 @@
 import { setTimeout as delay } from 'node:timers/promises';
 import { readFileSync } from 'node:fs';
 import type { JsonObject } from '@benchsdk/api';
+import { parseCliArgs, selectParticipants, filterParticipantsByEnv } from '@benchsdk/runner';
+import type { PlaywrightProviderConfig } from './playwright-types.js';
 
 export const PLAYWRIGHT_VERSION = '1.60.0';
 export const PROVISION_TIMEOUT_MS = 120_000;
 export const CONNECT_TIMEOUT_MS = 30_000;
 export const CLEANUP_TIMEOUT_MS = 15_000;
 export const VIEWPORT = { width: 1920, height: 1080 };
 
-export interface NativeSession {
-  metadata: JsonObject;
-  provision(): Promise<{ endpoint: string; headers: Record<string, string> }>;
-  cleanup(options: { connected: boolean }): Promise<void>;
-}
+// Parse only flags owned by the suites; the runner handles the rest of the CLI.
+export const playwrightArgs = parseCliArgs(process.argv.flatMap((arg, index) => {
+  if (/^--(?:provider|iterations)=/.test(arg)) return [arg];
+  if (arg === '--provider' || arg === '--iterations') return [arg, process.argv[index + 1] ?? ''];
+  return [];
+}));
 
-export interface NativeParticipant {
-  name: string;
-  requiredEnvVars: string[];
-  session(identity: string): NativeSession;
+export function requireProviderCredentials(): void {
+  const selected = selectParticipants(playwrightProviders, playwrightArgs.providers);
+  const { skipped } = filterParticipantsByEnv(selected);
+  if (skipped.length) {
+    const missing = skipped.map(({ name, missing }) => `${name}: ${missing.join(', ')}`).join('; ');
+    throw new Error(`Unavailable Playwright participant(s): ${missing}. Supply credentials for every selected provider; use --provider for an explicit diagnostic run.`);
+  }
 }
 
 export function requiredEnv(name: string): string {
@@ -88,7 +94,7 @@ async function sessionResponse(response: Response): Promise<Record<string, unkno
   catch { throw new Error('Provider returned invalid session JSON'); }
 }
 
-export const nativeParticipants: NativeParticipant[] = [
+export const playwrightProviders: PlaywrightProviderConfig[] = [
   {
     name: 'momentic',
     requiredEnvVars: ['MOMENTIC_BROWSER_FLEET_URL', 'MOMENTIC_BROWSER_FLEET_API_KEY', 'PLAYWRIGHT_NATIVE_ENVIRONMENT_FILE'],
@@ -129,7 +135,7 @@ export const nativeParticipants: NativeParticipant[] = [
             data = await retrieve(signal);
           }
           if (data.status !== 'READY') throw new Error('Momentic session did not become READY');
-          if (data.playwrightVersion !== PLAYWRIGHT_VERSION) throw new Error('Momentic returned an incompatible Playwright version');
+          if (typeof data.playwrightVersion !== 'string' || !/^1\.60\.\d+$/.test(data.playwrightVersion)) throw new Error('Momentic returned an incompatible Playwright version');
           metadata.serverPlaywrightVersion = string(data.playwrightVersion);
           metadata.serverPlaywrightVersionSource = 'Momentic session response';
           return { endpoint: string(data.wsEndpoint), headers: { Authorization: `Bearer ${string(data.connectToken)}` } };
 
@@ -1,24 +1,41 @@
 /** First per-session request → example.com load; cleanup is measured separately. */
 import '../src/env.js';
 import { defineBenchmarkConfig, defineTask } from '@benchsdk/runner';
-import { nativeConfig, runSession } from './playwright-native/session.js';
-import { writeNativeResults } from './playwright-native/results.js';
+import { runSession } from './playwright-session.js';
+import { playwrightProviders, requireProviderCredentials } from './playwright-providers.js';
+import type { PlaywrightProviderConfig } from './playwright-types.js';
+import { writeNativeResults } from './playwright-results.js';
+
+requireProviderCredentials();
 
 export const config = defineBenchmarkConfig({
-  ...nativeConfig,
   benchmarkSlug: 'playwright-native-readiness',
   benchmarkName: 'Playwright-native Browser Readiness',
+  iterations: 100,
+  concurrency: 1,
+  groupBy: 'round',
+  participants: playwrightProviders,
   display: {
     metrics: [
       { key: 'readinessMs', label: 'Browser readiness', unit: 'ms', direction: 'lower-better' },
       { key: 'cleanupMs', label: 'Cleanup', unit: 'ms', direction: 'lower-better' },
     ],
+    steps: [
+      { key: 'provision', label: 'Provision session' },
+      { key: 'connect', label: 'Connect Playwright' },
+      { key: 'page', label: 'Create context and page' },
+      { key: 'navigate', label: 'Navigate page' },
+      { key: 'reconcile-context', label: 'Reconcile pending context' },
+      { key: 'close-context', label: 'Close context' },
+      { key: 'close-browser', label: 'Close browser' },
+      { key: 'release', label: 'Release session' },
+    ],
     overview: { defaultMetric: 'readinessMs', defaultLayout: 'chart' },
   },
   onComplete: outcome => writeNativeResults(outcome, 'readiness'),
 });
 
-export const task = defineTask<typeof nativeConfig.participants[number]>(ctx => runSession(ctx, async (page, startedAt, data) => {
+export const task = defineTask<PlaywrightProviderConfig>(ctx => runSession(ctx, async (page, startedAt, data) => {
   await ctx.step('navigate', async () => {
     await page.goto('https://www.example.com', { waitUntil: 'load' });
     data.readinessMs = performance.now() - startedAt;
 
@@ -1,8 +1,9 @@
 import { mkdirSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
 import { randomUUID } from 'node:crypto';
-import type { BenchmarkRunOutcome } from '@benchsdk/runner';
-import { ACTION_TYPES } from '../throughput-types.js';
+import { filterParticipantsByEnv, type BenchmarkRunOutcome } from '@benchsdk/runner';
+import { playwrightProviders } from './playwright-providers.js';
+import { ACTION_TYPES } from './throughput-types.js';
 
 /** Untrimmed nearest-rank percentiles; missing observations are not zeroes. */
 export function distribution(values: number[]) {
@@ -19,6 +20,8 @@ export function distribution(values: number[]) {
 }
 
 export function writeNativeResults(outcome: BenchmarkRunOutcome, suite: 'readiness' | 'throughput', articleUrls?: string[]): void {
+  const comparison = playwrightProviders.every(provider => outcome.participants.some(p => p.participant === provider.name));
+  const { skipped: unavailableParticipants } = filterParticipantsByEnv(playwrightProviders);
   const summaries = outcome.participants.map(({ participant, records }) => {
     const attempted = records.filter(record => record.data?.attemptStarted === true);
     const complete = attempted.filter(record => record.data?.workloadSuccess === true);
@@ -46,6 +49,6 @@ export function writeNativeResults(outcome: BenchmarkRunOutcome, suite: 'readine
   const directory = path.resolve(process.env.PLAYWRIGHT_NATIVE_RESULTS_DIR ?? 'results/playwright-native', suite);
   mkdirSync(directory, { recursive: true });
   const filename = path.join(directory, `${randomUUID()}.json`);
-  writeFileSync(filename, JSON.stringify({ suite, runId: outcome.runId, createdAt: new Date().toISOString(), config: outcome.config, ...(articleUrls ? { articleUrls } : {}), summaries, participants: outcome.participants }, null, 2));
+  writeFileSync(filename, JSON.stringify({ suite, mode: comparison ? 'comparison' : 'provider-diagnostic', unavailableParticipants, runId: outcome.runId, createdAt: new Date().toISOString(), config: outcome.config, ...(articleUrls ? { articleUrls } : {}), summaries, participants: outcome.participants }, null, 2));
   console.log(`Raw Playwright-native records and untrimmed summaries: ${filename}`);
 }