From 4b08167789b1ba4119401fc1089aa59fc7d3a1eb Mon Sep 17 00:00:00 2001
From: ScriptedAlchemy <zackary.l.jackson@gmail.com>
Date: Sat, 29 Aug 2026 02:24:40 +0000
Subject: [PATCH 1/5] test: derive integration worker count from cores and
 split shared-artifact writers into a serial pool

The parallel pool runs mkdtemp-fixture, ephemeral-port files on
min(4, cores/2) workers (still 1 on two-core CI, overridable via
AGENT_BUNDLE_INTEGRATION_MAX_WORKERS); the six files that rewrite shared
package dists stay on one worker in a chained serial config.
---
 package.json                        |  2 +-
 rstest.integration-serial.config.ts | 16 ++++++++++++
 rstest.integration-tests.ts         | 38 +++++++++++++++++++++++++++++
 rstest.integration.config.ts        | 28 ++++++++++++++++++---
 4 files changed, 79 insertions(+), 5 deletions(-)
 create mode 100644 rstest.integration-serial.config.ts

diff --git a/package.json b/package.json
index 7b3db36df..6deb835cf 100644
--- a/package.json
+++ b/package.json
@@ -13,7 +13,7 @@
     "test": "pnpm test:unit && pnpm test:integration",
     "test:unit": "rstest --config rstest.unit.config.ts",
     "test:integration": "pnpm --filter agent-bundle-workbench build && pnpm test:integration:run",
-    "test:integration:run": "AGENT_BUNDLE_WORKBENCH_PREBUILT=1 rstest --config rstest.integration.config.ts --pool.maxWorkers 1",
+    "test:integration:run": "AGENT_BUNDLE_WORKBENCH_PREBUILT=1 rstest --config rstest.integration.config.ts && AGENT_BUNDLE_WORKBENCH_PREBUILT=1 rstest --config rstest.integration-serial.config.ts",
     "test:watch": "rstest --config rstest.config.ts --watch",
     "lint": "rslint .",
     "typecheck": "tsc --noEmit && tsc --project packages/workbench/tsconfig.json",
diff --git a/rstest.integration-serial.config.ts b/rstest.integration-serial.config.ts
new file mode 100644
index 000000000..448277c11
--- /dev/null
+++ b/rstest.integration-serial.config.ts
@@ -0,0 +1,16 @@
+import { defineConfig } from '@rstest/core';
+
+import { serialIntegrationTestFiles } from './rstest.integration-tests.ts';
+import { withAgentBundleRslibConfig } from './rstest.rslib.ts';
+
+/**
+ * Integration files that rewrite workspace-shared artifacts (see the
+ * serialIntegrationTestFiles doc in rstest.integration-tests.ts). One worker
+ * only: they rebuild or repack shared package dist directories that every
+ * other file in this group also reads.
+ */
+export default defineConfig({
+  extends: withAgentBundleRslibConfig(),
+  include: [...serialIntegrationTestFiles],
+  pool: { maxWorkers: 1 },
+});
diff --git a/rstest.integration-tests.ts b/rstest.integration-tests.ts
index 78e0cc619..d40ca8b5e 100644
--- a/rstest.integration-tests.ts
+++ b/rstest.integration-tests.ts
@@ -66,6 +66,44 @@ export const integrationTestFiles: readonly string[] = [
   'packages/workbench/tests/workbench-dev-command.test.ts',
 ];
 
+/**
+ * Integration files that WRITE to workspace-shared locations and therefore
+ * cannot run alongside other integration files:
+ *
+ * - inspector-shell.e2e rewrites `packages/workbench/dist` with an explicit
+ *   development-mode artifact (the build itself is under test).
+ * - packed-release.e2e runs a root `pnpm build` (rewriting
+ *   `packages/{agent-bundle,rsc-runtime,workbench}/dist`) and `npm pack`.
+ * - cli.test runs a root `pnpm build` and `npm pack` against the shared
+ *   package dist.
+ * - overview.e2e, mcp-app-real.e2e, and playground-real.e2e rebuild
+ *   `packages/workbench/dist` with local build helpers that ignore
+ *   AGENT_BUNDLE_WORKBENCH_PREBUILT.
+ *
+ * They run on one worker via rstest.integration-serial.config.ts after the
+ * parallel pool finishes (rstest orders files alphabetically, so
+ * inspector-shell's development artifact lands after cli.test has used the
+ * production CLI dist, and packed-release packs the agent-bundle dist copy
+ * that is unaffected by the workbench dist rewrite).
+ */
+export const serialIntegrationTestFiles: readonly string[] = [
+  'packages/agent-bundle/tests/cli.test.ts',
+  'packages/workbench/tests/inspector-shell.e2e.test.ts',
+  'packages/workbench/tests/mcp-app-real.e2e.test.ts',
+  'packages/workbench/tests/overview.e2e.test.ts',
+  'packages/workbench/tests/packed-release.e2e.test.ts',
+  'packages/workbench/tests/playground-real.e2e.test.ts',
+];
+
+/**
+ * Integration files safe on parallel workers: they create per-test fixtures
+ * with `mkdtemp`, bind servers on ephemeral ports (`port: 0` or rsbuild's
+ * silent free-port fallback), and only READ the prebuilt shared artifacts
+ * (`packages/workbench/dist`, `packages/agent-bundle/dist`).
+ */
+export const parallelIntegrationTestFiles: readonly string[] =
+  integrationTestFiles.filter((file) => !serialIntegrationTestFiles.includes(file));
+
 /**
  * Pack-and-install tests: each one runs `npm pack` (and usually a clean
  * `npm install` of the tarball), which dominates the serialized integration
diff --git a/rstest.integration.config.ts b/rstest.integration.config.ts
index 47c0a4043..ee1394b83 100644
--- a/rstest.integration.config.ts
+++ b/rstest.integration.config.ts
@@ -1,13 +1,33 @@
+import { availableParallelism } from 'node:os';
+
 import { defineConfig } from '@rstest/core';
 
-import { integrationTestFiles } from './rstest.integration-tests.ts';
+import { parallelIntegrationTestFiles } from './rstest.integration-tests.ts';
 import { withAgentBundleRslibConfig } from './rstest.rslib.ts';
 
-/** Build- and process-running tests: Rslib/Rsbuild caches and output paths are process-shared, so one worker only. */
+/**
+ * Worker count for the parallel integration pool. Half the cores keeps
+ * browser + dev-server pairs from starving each other, the cap of 4 bounds
+ * memory on large machines, and two-core CI still resolves to one worker.
+ * AGENT_BUNDLE_INTEGRATION_MAX_WORKERS overrides the computed value (e.g. to
+ * force a serial run when measuring or bisecting).
+ */
+const overrideWorkers = Number(process.env['AGENT_BUNDLE_INTEGRATION_MAX_WORKERS'] ?? '');
+const maxWorkers = Number.isSafeInteger(overrideWorkers) && overrideWorkers >= 1
+  ? overrideWorkers
+  : Math.max(1, Math.min(4, Math.floor(availableParallelism() / 2)));
+
+/**
+ * Build- and process-running tests that only read workspace-shared artifacts;
+ * files that WRITE shared locations run serialized afterwards through
+ * rstest.integration-serial.config.ts (rstest has no per-project pool or
+ * isolate settings, so the split lives in two configs chained by
+ * `test:integration:run`).
+ */
 export default defineConfig({
   extends: withAgentBundleRslibConfig(),
-  include: [...integrationTestFiles],
-  pool: { maxWorkers: 1 },
+  include: [...parallelIntegrationTestFiles],
+  pool: { maxWorkers },
   // isolate: false would cut Playwright startup cost, but the log pipeline
   // suites rely on per-file module isolation (verified: logs-real.e2e fails
   // when sharing a worker with the other log suites).

From e42702a42d7ba7f0df95a12ac6c108cb9093a030 Mon Sep 17 00:00:00 2001
From: ScriptedAlchemy <zackary.l.jackson@gmail.com>
Date: Sat, 29 Aug 2026 02:28:28 +0000
Subject: [PATCH 2/5] test: stop rebuilding shared artifacts inside the
 integration pool

overview.e2e, mcp-app-real.e2e, and playground-real.e2e now use the shared
memoized buildWorkbench (which honors AGENT_BUNDLE_WORKBENCH_PREBUILT)
instead of local copies that rebuilt packages/workbench/dist up to ten
times per run; cli.test and the packed-release harness honor a new
AGENT_BUNDLE_PACKAGE_PREBUILT flag, with `test:integration` building the
whole workspace once up front. With those writes gone, the four files
move from the serial pool to the parallel one.
---
 package.json                                  |  4 ++--
 packages/agent-bundle/tests/cli.test.ts       |  1 +
 .../workbench/tests/mcp-app-real.e2e.test.ts  | 13 +-----------
 packages/workbench/tests/overview.e2e.test.ts | 12 +----------
 .../tests/playground-real.e2e.test.ts         | 15 +-------------
 .../tests/support/packed-release-harness.ts   |  1 +
 rstest.integration-tests.ts                   | 20 ++++++-------------
 7 files changed, 13 insertions(+), 53 deletions(-)

diff --git a/package.json b/package.json
index 6deb835cf..04a871f2a 100644
--- a/package.json
+++ b/package.json
@@ -12,8 +12,8 @@
     "lint:package": "publint packages/agent-bundle",
     "test": "pnpm test:unit && pnpm test:integration",
     "test:unit": "rstest --config rstest.unit.config.ts",
-    "test:integration": "pnpm --filter agent-bundle-workbench build && pnpm test:integration:run",
-    "test:integration:run": "AGENT_BUNDLE_WORKBENCH_PREBUILT=1 rstest --config rstest.integration.config.ts && AGENT_BUNDLE_WORKBENCH_PREBUILT=1 rstest --config rstest.integration-serial.config.ts",
+    "test:integration": "pnpm build && pnpm test:integration:run",
+    "test:integration:run": "AGENT_BUNDLE_WORKBENCH_PREBUILT=1 AGENT_BUNDLE_PACKAGE_PREBUILT=1 rstest --config rstest.integration.config.ts && AGENT_BUNDLE_WORKBENCH_PREBUILT=1 AGENT_BUNDLE_PACKAGE_PREBUILT=1 rstest --config rstest.integration-serial.config.ts",
     "test:watch": "rstest --config rstest.config.ts --watch",
     "lint": "rslint .",
     "typecheck": "tsc --noEmit && tsc --project packages/workbench/tsconfig.json",
diff --git a/packages/agent-bundle/tests/cli.test.ts b/packages/agent-bundle/tests/cli.test.ts
index 9fe2f5436..a858d0b64 100644
--- a/packages/agent-bundle/tests/cli.test.ts
+++ b/packages/agent-bundle/tests/cli.test.ts
@@ -15,6 +15,7 @@ const cliPath = join(packageRoot, 'dist/cli.js');
 let buildPackage: Promise<void> | undefined;
 
 const buildCliPackage = async (): Promise<void> => {
+  if (process.env['AGENT_BUNDLE_PACKAGE_PREBUILT'] === '1') return;
   buildPackage ??= execFile('pnpm', ['build'], { cwd: workspaceRoot }).then(() => undefined);
   await buildPackage;
 };
diff --git a/packages/workbench/tests/mcp-app-real.e2e.test.ts b/packages/workbench/tests/mcp-app-real.e2e.test.ts
index f2b5c235e..4ba1a8ec6 100644
--- a/packages/workbench/tests/mcp-app-real.e2e.test.ts
+++ b/packages/workbench/tests/mcp-app-real.e2e.test.ts
@@ -1,7 +1,5 @@
-import { execFile as executeFile } from 'node:child_process';
 import { access, mkdir, readFile, symlink, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { promisify } from 'node:util';
 
 import { expect, test, type PlaywrightOptions } from '@rstest/playwright';
 import type { Page, WebSocketRoute } from 'playwright';
@@ -12,12 +10,11 @@ import { startDevServer } from '../../agent-bundle/src/dev/workbench-server.ts';
 import { createProjectFixture, removeProjectFixture } from '../../agent-bundle/tests/helpers/project-fixture.ts';
 import { startRuntimePlaygroundFixture } from './helpers/runtime-playground-fixture.ts';
 import { timeScale } from '../../agent-bundle/tests/support/time-scale.ts';
-import { workbenchUrl } from './support/workbench-e2e.ts';
+import { buildWorkbench, workbenchUrl } from './support/workbench-e2e.ts';
 
 const workspaceRoot = process.cwd();
 const workbenchAssets = join(workspaceRoot, 'packages', 'workbench', 'dist');
 const browserTimeout = 8_000 * timeScale;
-const execFile = promisify(executeFile);
 
 const e2e = test.extend({
   playwright: {
@@ -26,14 +23,6 @@ const e2e = test.extend({
   } satisfies PlaywrightOptions,
 });
 
-const buildWorkbench = async (): Promise<void> => {
-  const { RSTEST: _rstest, ...environment } = process.env;
-  await execFile('pnpm', ['--filter', 'agent-bundle-workbench', 'build'], {
-    cwd: workspaceRoot,
-    env: { ...environment, NODE_ENV: 'production' },
-  });
-};
-
 const appFixtureHtml = [
   '<!doctype html><html><body><main data-testid="app-state">waiting</main>',
   '<script>',
diff --git a/packages/workbench/tests/overview.e2e.test.ts b/packages/workbench/tests/overview.e2e.test.ts
index 95ac98113..413fdfb44 100644
--- a/packages/workbench/tests/overview.e2e.test.ts
+++ b/packages/workbench/tests/overview.e2e.test.ts
@@ -1,7 +1,5 @@
-import { execFile as executeFile } from 'node:child_process';
 import { mkdir, readFile, rename, symlink, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { promisify } from 'node:util';
 
 import { expect, test, type PlaywrightOptions } from '@rstest/playwright';
 import type { Locator, Page } from 'playwright';
@@ -20,8 +18,8 @@ import { createWorkbenchAssetSource } from '../../agent-bundle/src/dev/workbench
 import { startDevServer } from '../../agent-bundle/src/dev/workbench-server.ts';
 import { createProjectFixture, removeProjectFixture } from '../../agent-bundle/tests/helpers/project-fixture.ts';
 import { startRuntimePlaygroundFixture } from './helpers/runtime-playground-fixture.ts';
+import { buildWorkbench } from './support/workbench-e2e.ts';
 
-const execFile = promisify(executeFile);
 const workspaceRoot = process.cwd();
 const workbenchAssets = join(workspaceRoot, 'packages', 'workbench', 'dist');
 const browserTimeout = 15_000;
@@ -54,14 +52,6 @@ const e2e = test.extend({
   } satisfies PlaywrightOptions,
 });
 
-const buildWorkbench = async (): Promise<void> => {
-  const { RSTEST: _rstest, ...environment } = process.env;
-  await execFile('pnpm', ['--filter', 'agent-bundle-workbench', 'build'], {
-    cwd: workspaceRoot,
-    env: { ...environment, NODE_ENV: 'production' },
-  });
-};
-
 const startFrozenEpochServer = async (root: string) => {
   const registry = createDefaultRegistry();
   const epochStore = new EpochStore({ projectRoot: root });
diff --git a/packages/workbench/tests/playground-real.e2e.test.ts b/packages/workbench/tests/playground-real.e2e.test.ts
index 84fa5d905..45853ea07 100644
--- a/packages/workbench/tests/playground-real.e2e.test.ts
+++ b/packages/workbench/tests/playground-real.e2e.test.ts
@@ -1,7 +1,5 @@
-import { execFile as executeFile } from 'node:child_process';
 import { chmod, mkdir, symlink, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
-import { promisify } from 'node:util';
 
 import { expect, test, type PlaywrightOptions } from '@rstest/playwright';
 
@@ -9,9 +7,8 @@ import { agentBundleNodeModules, workbenchNodeModules } from '../../agent-bundle
 import { createWorkbenchAssetSource } from '../../agent-bundle/src/dev/workbench-assets.ts';
 import { startDevServer } from '../../agent-bundle/src/dev/workbench-server.ts';
 import { createProjectFixture, removeProjectFixture } from '../../agent-bundle/tests/helpers/project-fixture.ts';
-import { workbenchUrl } from './support/workbench-e2e.ts';
+import { buildWorkbench, workbenchUrl } from './support/workbench-e2e.ts';
 
-const execFile = promisify(executeFile);
 const workspaceRoot = process.cwd();
 const workbenchAssets = join(workspaceRoot, 'packages', 'workbench', 'dist');
 const browserTimeout = 8_000;
@@ -24,16 +21,6 @@ const e2e = test.extend({
   } satisfies PlaywrightOptions,
 });
 
-let workbenchBuild: Promise<void> | undefined;
-
-const buildWorkbench = (): Promise<void> => workbenchBuild ??= (async (): Promise<void> => {
-  const { RSTEST: _rstest, ...environment } = process.env;
-  await execFile('pnpm', ['--filter', 'agent-bundle-workbench', 'build'], {
-    cwd: workspaceRoot,
-    env: { ...environment, NODE_ENV: 'production' },
-  });
-})();
-
 const writeFakeClaude = async (directory: string): Promise<void> => {
   const executable = join(directory, 'claude');
   const implementation = join(directory, 'claude.mjs');
diff --git a/packages/workbench/tests/support/packed-release-harness.ts b/packages/workbench/tests/support/packed-release-harness.ts
index 41b7ae989..c1f8cc806 100644
--- a/packages/workbench/tests/support/packed-release-harness.ts
+++ b/packages/workbench/tests/support/packed-release-harness.ts
@@ -31,6 +31,7 @@ export const availablePort = async (): Promise<number> => {
 };
 
 export const buildPackage = (): Promise<void> => builtPackage ??= (async (): Promise<void> => {
+  if (process.env['AGENT_BUNDLE_PACKAGE_PREBUILT'] === '1') return;
   const { RSTEST: _rstest, ...environment } = process.env;
   await execFile('pnpm', ['build'], {
     cwd: workspaceRoot,
diff --git a/rstest.integration-tests.ts b/rstest.integration-tests.ts
index d40ca8b5e..71ddf9074 100644
--- a/rstest.integration-tests.ts
+++ b/rstest.integration-tests.ts
@@ -72,27 +72,19 @@ export const integrationTestFiles: readonly string[] = [
  *
  * - inspector-shell.e2e rewrites `packages/workbench/dist` with an explicit
  *   development-mode artifact (the build itself is under test).
- * - packed-release.e2e runs a root `pnpm build` (rewriting
- *   `packages/{agent-bundle,rsc-runtime,workbench}/dist`) and `npm pack`.
- * - cli.test runs a root `pnpm build` and `npm pack` against the shared
- *   package dist.
- * - overview.e2e, mcp-app-real.e2e, and playground-real.e2e rebuild
- *   `packages/workbench/dist` with local build helpers that ignore
- *   AGENT_BUNDLE_WORKBENCH_PREBUILT.
+ * - packed-release.e2e can run a root `pnpm build` (rewriting
+ *   `packages/{agent-bundle,rsc-runtime,workbench}/dist`) when
+ *   AGENT_BUNDLE_PACKAGE_PREBUILT is unset, and always runs `npm pack`
+ *   plus a packed dev server on a pre-reserved (not ephemeral) port.
  *
  * They run on one worker via rstest.integration-serial.config.ts after the
  * parallel pool finishes (rstest orders files alphabetically, so
- * inspector-shell's development artifact lands after cli.test has used the
- * production CLI dist, and packed-release packs the agent-bundle dist copy
- * that is unaffected by the workbench dist rewrite).
+ * packed-release packs the agent-bundle dist copy that is unaffected by
+ * inspector-shell's workbench dist rewrite).
  */
 export const serialIntegrationTestFiles: readonly string[] = [
-  'packages/agent-bundle/tests/cli.test.ts',
   'packages/workbench/tests/inspector-shell.e2e.test.ts',
-  'packages/workbench/tests/mcp-app-real.e2e.test.ts',
-  'packages/workbench/tests/overview.e2e.test.ts',
   'packages/workbench/tests/packed-release.e2e.test.ts',
-  'packages/workbench/tests/playground-real.e2e.test.ts',
 ];
 
 /**

From 6d2dab4495bad078bef99e01c207d8f91e63e71e Mon Sep 17 00:00:00 2001
From: ScriptedAlchemy <zackary.l.jackson@gmail.com>
Date: Sat, 29 Aug 2026 02:30:51 +0000
Subject: [PATCH 3/5] test(rsc-agent-runtime): inject the terminal-run
 retention window into the eviction suite

The session accepts a test-only maximumRunHistory through its start
testing seam; the consolidated eviction test drives a five-run window
instead of fifty real invocations and asserts the production default is
still fifty.
---
 .../src/dev/rsbuild-runtime-session.ts        | 17 +++++++++++----
 .../tests/dev-invocation.integration.test.ts  | 21 ++++++++++++-------
 2 files changed, 26 insertions(+), 12 deletions(-)

diff --git a/examples/rsc-agent-runtime/src/dev/rsbuild-runtime-session.ts b/examples/rsc-agent-runtime/src/dev/rsbuild-runtime-session.ts
index e7cc886c2..d447d9744 100644
--- a/examples/rsc-agent-runtime/src/dev/rsbuild-runtime-session.ts
+++ b/examples/rsc-agent-runtime/src/dev/rsbuild-runtime-session.ts
@@ -93,7 +93,8 @@ const maximumInvocationWorkers = 4;
 const maximumInvocationStdoutBytes = 4 * 1024 * 1024;
 const maximumInvocationFlightBytes = 4 * 1024 * 1024;
 const maximumInvocationStderrBytes = 256 * 1024;
-const maximumRunHistory = 50;
+/** Production terminal-run retention window; tests may shrink it through the start testing seam. */
+export const defaultMaximumRunHistory = 50;
 const invocationTimeoutMs = 10_000;
 const invocationTerminationGraceMs = 100;
 const flightPreviewBytes = 32 * 1024;
@@ -603,6 +604,12 @@ export interface RsbuildRuntimeSessionStartTesting {
   }>) => Promise<void> | void;
   /** Windows-only Job owner fault injection; never used by the public provider. */
   readonly windowsJobOwnerMode?: 'close-control' | 'hang-ready' | 'ignore-stop' | 'nonzero-after-drain' | 'normal';
+  /**
+   * Test-only terminal-run retention override so eviction suites do not need
+   * fifty real invocations; the public provider always keeps
+   * `defaultMaximumRunHistory` runs.
+   */
+  readonly maximumRunHistory?: number;
 }
 
 /**
@@ -633,6 +640,7 @@ export class RsbuildRuntimeSession implements DevRuntimeSession {
   readonly #surfaceAssetApps = new Map<string, DevRuntimePreparedProject['apps'][number]>();
   readonly #surfaces = new Map<string, DevRuntimeSurface>();
   readonly #testing: RsbuildRuntimeSessionStartTesting;
+  readonly #maximumRunHistory: number;
   readonly #attempts = new Map<string, AttemptBarrier>();
   readonly #workers = new Map<string, InvocationWorker>();
   readonly #failedAttempts = new Set<string>();
@@ -669,6 +677,7 @@ export class RsbuildRuntimeSession implements DevRuntimeSession {
     this.#mcpRegistry = input.mcpRegistry;
     this.#latestPreparedRuntime = input.preparedRuntime;
     this.#testing = input.testing;
+    this.#maximumRunHistory = input.testing.maximumRunHistory ?? defaultMaximumRunHistory;
     this.#ownedRunsRoot = input.ownedRunsRoot;
     this.#runRoot = input.ownedRunsRoot.root;
     this.#stateFile = join(resolve(input.context.storageRoot), 'state', `${stateStoreId}.jsonl`);
@@ -1035,8 +1044,8 @@ export class RsbuildRuntimeSession implements DevRuntimeSession {
 
   runs(limit: number): readonly DevRuntimeRun[] {
     if (this.#closed) return Object.freeze([]);
-    if (!Number.isSafeInteger(limit) || limit < 1 || limit > maximumRunHistory) {
-      throw new RangeError(`Runtime run history limit must be an integer from 1 through ${maximumRunHistory}.`);
+    if (!Number.isSafeInteger(limit) || limit < 1 || limit > this.#maximumRunHistory) {
+      throw new RangeError(`Runtime run history limit must be an integer from 1 through ${String(this.#maximumRunHistory)}.`);
     }
     return Object.freeze([...this.#terminalRuns.values()].reverse().slice(0, limit));
   }
@@ -1333,7 +1342,7 @@ export class RsbuildRuntimeSession implements DevRuntimeSession {
   }
 
   async #evictTerminalRuns(): Promise<void> {
-    while (this.#terminalRuns.size > maximumRunHistory) {
+    while (this.#terminalRuns.size > this.#maximumRunHistory) {
       const oldestId = this.#terminalRuns.keys().next().value as string | undefined;
       if (oldestId === undefined) return;
       this.#evictingTerminalRuns.add(oldestId);
diff --git a/examples/rsc-agent-runtime/tests/dev-invocation.integration.test.ts b/examples/rsc-agent-runtime/tests/dev-invocation.integration.test.ts
index be1c11c07..a13490dc8 100644
--- a/examples/rsc-agent-runtime/tests/dev-invocation.integration.test.ts
+++ b/examples/rsc-agent-runtime/tests/dev-invocation.integration.test.ts
@@ -13,7 +13,7 @@ import { createElement, type ReactNode } from 'react';
 import { ProjectService } from '../../../packages/agent-bundle/src/dev/index.ts';
 import { createRscRuntimeRsbuildConfig } from '../rsbuild.config.js';
 import { createDevRuntimeProvider } from '../src/dev/provider.js';
-import { RsbuildRuntimeSession } from '../src/dev/rsbuild-runtime-session.js';
+import { defaultMaximumRunHistory, RsbuildRuntimeSession } from '../src/dev/rsbuild-runtime-session.js';
 import { serializeInspection } from '../src/dev/serialize-inspection.js';
 
 const readChildOutput = (stream: NodeJS.ReadableStream): Promise<Buffer> =>
@@ -1703,7 +1703,11 @@ process.stdout.end(JSON.stringify({
   }
 }, 30_000);
 
-test('drives the fifty-run eviction window through its happy, held-reader, failed-removal, and failed-release paths', async () => {
+test('drives the run-eviction window through its happy, held-reader, failed-removal, and failed-release paths', async () => {
+  // The retention window is injected small so the suite does not need fifty
+  // real invocations; production keeps the fifty-run default.
+  expect(defaultMaximumRunHistory).toBe(50);
+  const retentionWindow = 5;
   const storageRoot = await mkdtemp(join(tmpdir(), 'rsc-agent-runtime-session-eviction-'));
   const projectRoot = process.cwd();
   const prepared = await new ProjectService({ includeDevRuntime: true, mode: 'development', root: projectRoot }).prepare('dev');
@@ -1752,6 +1756,7 @@ test('drives the fifty-run eviction window through its happy, held-reader, faile
       readerEntered.resolve();
       await releaseReader.promise;
     },
+    maximumRunHistory: retentionWindow,
   });
 
   try {
@@ -1780,17 +1785,17 @@ test('drives the fifty-run eviction window through its happy, held-reader, faile
     await session.resetState({ expectedGenerationId: generationId, stateStoreId: 'playground' });
     expect(session.run(happyVictim.id)).toEqual(happyVictim);
 
-    for (let index = 0; index < 46; index += 1) await invokeSucceeded();
-    expect(session.runs(50)).toHaveLength(50);
+    for (let index = 0; index < retentionWindow - 4; index += 1) await invokeSucceeded();
+    expect(session.runs(retentionWindow)).toHaveLength(retentionWindow);
 
-    // Happy path: the fifty-first run evicts the oldest completed Flight.
+    // Happy path: the run beyond the window evicts the oldest completed Flight.
     await invokeSucceeded();
     expect(session.run(happyVictim.id)).toBeUndefined();
     await expect(session.readRunFlight(happyVictim.id)).resolves.toBeUndefined();
     await expect(session.readRunFlight('../flight.bin')).resolves.toBeUndefined();
-    expect(session.runs(50)).toHaveLength(50);
-    expect(session.runs(50)[0]!.id).not.toBe(happyVictim.id);
-    expect((await readdir(join(storageRoot, 'runs'))).filter((entry) => entry !== '.agent-bundle-runtime-owner')).toHaveLength(50);
+    expect(session.runs(retentionWindow)).toHaveLength(retentionWindow);
+    expect(session.runs(retentionWindow)[0]!.id).not.toBe(happyVictim.id);
+    expect((await readdir(join(storageRoot, 'runs'))).filter((entry) => entry !== '.agent-bundle-runtime-owner')).toHaveLength(retentionWindow);
 
     // Held reader: eviction reserves the terminal run before draining its admitted Flight reader.
     heldRunId = readerVictim.id;

From 076ff39b4166101f7c6b6ef9f108236b692004da Mon Sep 17 00:00:00 2001
From: ScriptedAlchemy <zackary.l.jackson@gmail.com>
Date: Sat, 29 Aug 2026 02:54:19 +0000
Subject: [PATCH 4/5] test: scale browser polling budgets when the integration
 pool runs parallel workers

Concurrent Chrome + dev-server + rsbuild pairs contend for cores, so the
parallel config doubles timeScale for its workers and the e2e suites with
previously unscaled budgets now honor it (same mechanism CI already uses
on two-core runners).
---
 packages/agent-bundle/tests/support/time-scale.ts       | 9 ++++++++-
 packages/workbench/tests/evals-real.e2e.test.ts         | 3 ++-
 packages/workbench/tests/examples-real.e2e.test.ts      | 3 ++-
 packages/workbench/tests/logs-real.e2e.test.ts          | 3 ++-
 packages/workbench/tests/overview.e2e.test.ts           | 3 ++-
 packages/workbench/tests/playground-real.e2e.test.ts    | 3 ++-
 packages/workbench/tests/runtime-playground.e2e.test.ts | 3 ++-
 rstest.integration.config.ts                            | 3 +++
 8 files changed, 23 insertions(+), 7 deletions(-)

diff --git a/packages/agent-bundle/tests/support/time-scale.ts b/packages/agent-bundle/tests/support/time-scale.ts
index cf6e3d663..7ba558ada 100644
--- a/packages/agent-bundle/tests/support/time-scale.ts
+++ b/packages/agent-bundle/tests/support/time-scale.ts
@@ -4,5 +4,12 @@
  * processes, and rsbuild compiles inside a single test. Scaling the budgets
  * costs nothing on green runs - polling assertions return on success - and
  * the workflow-level timeout-minutes still bounds real hangs.
+ *
+ * AGENT_BUNDLE_TEST_TIME_SCALE (set by rstest.integration.config.ts when the
+ * pool runs multiple workers) covers the same contention on development
+ * machines, where concurrent Chrome + dev-server + rsbuild pairs share cores.
  */
-export const timeScale = process.env['CI'] === undefined ? 1 : 4;
+const localScale = Number(process.env['AGENT_BUNDLE_TEST_TIME_SCALE'] ?? '');
+export const timeScale = process.env['CI'] !== undefined
+  ? 4
+  : Number.isSafeInteger(localScale) && localScale >= 1 ? localScale : 1;
diff --git a/packages/workbench/tests/evals-real.e2e.test.ts b/packages/workbench/tests/evals-real.e2e.test.ts
index e26107228..55b2c6951 100644
--- a/packages/workbench/tests/evals-real.e2e.test.ts
+++ b/packages/workbench/tests/evals-real.e2e.test.ts
@@ -13,11 +13,12 @@ import { startDevServer } from '../../agent-bundle/src/dev/workbench-server.ts';
 import { createProjectFixture, removeProjectFixture } from '../../agent-bundle/tests/helpers/project-fixture.ts';
 import { seedEvalProject, writeEvalSuite } from '../../agent-bundle/tests/support/eval-project.ts';
 import { closeServer } from './support/http.ts';
+import { timeScale } from '../../agent-bundle/tests/support/time-scale.ts';
 import { workbenchBrowserAliases } from './support/workbench-browser-modules.ts';
 import { buildWorkbench, e2e, workbenchAssets, workspaceRoot, workbenchUrl } from './support/workbench-e2e.ts';
 
 const evalsPage = join(workspaceRoot, 'packages', 'workbench', 'src', 'evals', 'evals-page.tsx');
-const browserTimeout = 12_000;
+const browserTimeout = 12_000 * timeScale;
 const runCompletionTimeout = 60_000;
 
 const listen = async (server: Server): Promise<string> => {
diff --git a/packages/workbench/tests/examples-real.e2e.test.ts b/packages/workbench/tests/examples-real.e2e.test.ts
index 7699d2451..44c13dd80 100644
--- a/packages/workbench/tests/examples-real.e2e.test.ts
+++ b/packages/workbench/tests/examples-real.e2e.test.ts
@@ -14,9 +14,10 @@ import {
   waitForSettledWorkbench,
   writeExampleReport,
 } from './support/example-acceptance.ts';
+import { timeScale } from '../../agent-bundle/tests/support/time-scale.ts';
 import { buildWorkbench, e2e, workbenchAssets, workbenchUrl } from './support/workbench-e2e.ts';
 
-const browserTimeout = 15_000;
+const browserTimeout = 15_000 * timeScale;
 
 const waitForExampleValue = async <Value>(
   page: Parameters<typeof captureExampleState>[0],
diff --git a/packages/workbench/tests/logs-real.e2e.test.ts b/packages/workbench/tests/logs-real.e2e.test.ts
index 43aa86789..8ad816c69 100644
--- a/packages/workbench/tests/logs-real.e2e.test.ts
+++ b/packages/workbench/tests/logs-real.e2e.test.ts
@@ -5,9 +5,10 @@ import { expect } from '@rstest/playwright';
 import { createWorkbenchAssetSource } from '../../agent-bundle/src/dev/workbench-assets.ts';
 import { startDevServer } from '../../agent-bundle/src/dev/workbench-server.ts';
 import { createProjectFixture, removeProjectFixture } from '../../agent-bundle/tests/helpers/project-fixture.ts';
+import { timeScale } from '../../agent-bundle/tests/support/time-scale.ts';
 import { buildWorkbench, e2e, workbenchAssets, workbenchUrl } from './support/workbench-e2e.ts';
 
-const browserTimeout = 12_000;
+const browserTimeout = 12_000 * timeScale;
 
 e2e('shows real producer logs with replay, filters, redaction, responsive layout, and no browser errors', { timeout: 90_000 }, async ({ page }) => {
   await buildWorkbench();
diff --git a/packages/workbench/tests/overview.e2e.test.ts b/packages/workbench/tests/overview.e2e.test.ts
index 413fdfb44..9c66f2cb5 100644
--- a/packages/workbench/tests/overview.e2e.test.ts
+++ b/packages/workbench/tests/overview.e2e.test.ts
@@ -18,11 +18,12 @@ import { createWorkbenchAssetSource } from '../../agent-bundle/src/dev/workbench
 import { startDevServer } from '../../agent-bundle/src/dev/workbench-server.ts';
 import { createProjectFixture, removeProjectFixture } from '../../agent-bundle/tests/helpers/project-fixture.ts';
 import { startRuntimePlaygroundFixture } from './helpers/runtime-playground-fixture.ts';
+import { timeScale } from '../../agent-bundle/tests/support/time-scale.ts';
 import { buildWorkbench } from './support/workbench-e2e.ts';
 
 const workspaceRoot = process.cwd();
 const workbenchAssets = join(workspaceRoot, 'packages', 'workbench', 'dist');
-const browserTimeout = 15_000;
+const browserTimeout = 15_000 * timeScale;
 
 interface RuntimeAppOperation {
   readonly body: unknown;
diff --git a/packages/workbench/tests/playground-real.e2e.test.ts b/packages/workbench/tests/playground-real.e2e.test.ts
index 45853ea07..cbf6af609 100644
--- a/packages/workbench/tests/playground-real.e2e.test.ts
+++ b/packages/workbench/tests/playground-real.e2e.test.ts
@@ -7,11 +7,12 @@ import { agentBundleNodeModules, workbenchNodeModules } from '../../agent-bundle
 import { createWorkbenchAssetSource } from '../../agent-bundle/src/dev/workbench-assets.ts';
 import { startDevServer } from '../../agent-bundle/src/dev/workbench-server.ts';
 import { createProjectFixture, removeProjectFixture } from '../../agent-bundle/tests/helpers/project-fixture.ts';
+import { timeScale } from '../../agent-bundle/tests/support/time-scale.ts';
 import { buildWorkbench, workbenchUrl } from './support/workbench-e2e.ts';
 
 const workspaceRoot = process.cwd();
 const workbenchAssets = join(workspaceRoot, 'packages', 'workbench', 'dist');
-const browserTimeout = 8_000;
+const browserTimeout = 8_000 * timeScale;
 const nativePathFallback = `${dirname(process.execPath)}:/usr/bin:/bin`;
 
 const e2e = test.extend({
diff --git a/packages/workbench/tests/runtime-playground.e2e.test.ts b/packages/workbench/tests/runtime-playground.e2e.test.ts
index 151a67c03..c93b3aa9b 100644
--- a/packages/workbench/tests/runtime-playground.e2e.test.ts
+++ b/packages/workbench/tests/runtime-playground.e2e.test.ts
@@ -1,9 +1,10 @@
 import { expect, test, type PlaywrightOptions } from '@rstest/playwright';
 
 import { startRuntimePlaygroundFixture } from './helpers/runtime-playground-fixture.ts';
+import { timeScale } from '../../agent-bundle/tests/support/time-scale.ts';
 import { workbenchUrl } from './support/workbench-e2e.ts';
 
-const browserTimeout = 12_000;
+const browserTimeout = 12_000 * timeScale;
 
 const e2e = test.extend({
   playwright: {
diff --git a/rstest.integration.config.ts b/rstest.integration.config.ts
index ee1394b83..88bfc6d03 100644
--- a/rstest.integration.config.ts
+++ b/rstest.integration.config.ts
@@ -28,6 +28,9 @@ export default defineConfig({
   extends: withAgentBundleRslibConfig(),
   include: [...parallelIntegrationTestFiles],
   pool: { maxWorkers },
+  // Concurrent Chrome + dev-server + rsbuild pairs contend for cores, so
+  // parallel runs double the polling budgets (see tests/support/time-scale.ts).
+  env: { AGENT_BUNDLE_TEST_TIME_SCALE: maxWorkers > 1 ? '2' : '1' },
   // isolate: false would cut Playwright startup cost, but the log pipeline
   // suites rely on per-file module isolation (verified: logs-real.e2e fails
   // when sharing a worker with the other log suites).

From bfed7558e411ad6d6da907e46af9ead2bb6f8694 Mon Sep 17 00:00:00 2001
From: ScriptedAlchemy <zackary.l.jackson@gmail.com>
Date: Sat, 29 Aug 2026 02:59:05 +0000
Subject: [PATCH 5/5] test: raise the default test timeout for the parallel
 integration pool

Real in-process example builds can exceed the 5s rstest default when four
workers share the machine; explicit per-test timeouts are unaffected.
---
 rstest.integration.config.ts | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/rstest.integration.config.ts b/rstest.integration.config.ts
index 88bfc6d03..5b010cba8 100644
--- a/rstest.integration.config.ts
+++ b/rstest.integration.config.ts
@@ -29,8 +29,11 @@ export default defineConfig({
   include: [...parallelIntegrationTestFiles],
   pool: { maxWorkers },
   // Concurrent Chrome + dev-server + rsbuild pairs contend for cores, so
-  // parallel runs double the polling budgets (see tests/support/time-scale.ts).
+  // parallel runs double the polling budgets (see tests/support/time-scale.ts)
+  // and raise the 5s default test timeout, which real in-process builds can
+  // exceed when workers share the machine. Explicit per-test timeouts win.
   env: { AGENT_BUNDLE_TEST_TIME_SCALE: maxWorkers > 1 ? '2' : '1' },
+  testTimeout: 30_000,
   // isolate: false would cut Playwright startup cost, but the log pipeline
   // suites rely on per-file module isolation (verified: logs-real.e2e fails
   // when sharing a worker with the other log suites).