@@ -2,9 +2,9 @@ name: XCTest Nightly
 
 # The full iOS runner XCTest suite (#1781 A7). The PR lane (ios.yml) names a hand-written
 # subset of the target's methods in an `-only-testing:` list; everything outside that list ran
-# nowhere at all. This lane drops the filter and runs the test plan whole, skipping only
-# `testCommand` — which is the runner's server entry point rather than a test (see the step
-# below).
+# nowhere at all. This lane runs the test plan whole, except `testCommand` (the runner's
+# server entry point). The process-scoped input-preparation regression runs in isolation;
+# its result is merged with the remaining suite before checking the executed count.
 #
 # No count is quoted here on purpose. `pnpm check:xctest-selection` prints the live split
 # (declared / PR-selected / skipped / nightly-only) and is the only place those numbers are
@@ -117,8 +117,21 @@ jobs:
           runtime-version: ${{ env.IOS_RUNTIME_VERSION }}
           preferred-device-name: iPhone 17 Pro
 
-      # Same command as ios.yml's targeted step minus every `-only-testing:` flag, so the
-      # xctestrun's own test plan decides what runs — with one exception.
+      # The preparation regression needs a fresh process before any other synthesized
+      # input. Run it separately, then merge both bundles for the source-derived count.
+      - name: Run isolated synthesized-input preparation regression
+        run: |
+          set -euo pipefail
+          XCTESTRUN_PATH="$(find "$AGENT_DEVICE_IOS_RUNNER_DERIVED_PATH/Build/Products" -maxdepth 1 -name '*.xctestrun' -print -quit)"
+          test -n "$XCTESTRUN_PATH"
+          mkdir -p "$(dirname "$RESULT_BUNDLE_PATH")"
+          xcodebuild test-without-building \
+            -xctestrun "$XCTESTRUN_PATH" \
+            -destination "platform=iOS Simulator,id=${{ steps.ios-simulator.outputs.simulator-udid }}" \
+            -only-testing:AgentDeviceRunnerUITests/RunnerTests/testSynthesizedInputPreparationDoesNotDeliverContactsAndOrdersMixedRoutes \
+            -resultBundlePath "${RESULT_BUNDLE_PATH%.xcresult}-isolated.xcresult"
+
+      # The remaining suite follows the xctestrun plan, excluding the isolated test.
       #
       # `RunnerTests/testCommand` is not a test. It is the runner's server entry point: it
       # opens an NWListener and blocks in `XCTWaiter.wait(timeout: 24 * 60 * 60)` until a
@@ -144,7 +157,15 @@ jobs:
             -destination "platform=iOS Simulator,id=${{ steps.ios-simulator.outputs.simulator-udid }}" \
             -skip-testing:AgentDeviceRunnerUITests/RunnerTests/testCommand \
             -skip-testing:AgentDeviceRunnerUITests/RunnerTests/testSynthesizedInputPreparationDoesNotDeliverContactsAndOrdersMixedRoutes \
-            -resultBundlePath "$RESULT_BUNDLE_PATH"
+            -resultBundlePath "${RESULT_BUNDLE_PATH%.xcresult}-remaining.xcresult"
+
+      - name: Merge isolated and remaining XCTest results
+        if: always()
+        run: |
+          set -euo pipefail
+          xcrun xcresulttool merge --output-path "$RESULT_BUNDLE_PATH" \
+            "${RESULT_BUNDLE_PATH%.xcresult}-isolated.xcresult" \
+            "${RESULT_BUNDLE_PATH%.xcresult}-remaining.xcresult"
 
       # Best-effort and never the job's verdict on its own; the step below is what asserts.
       # `--compact` first because a red night's summary is the large one, and the job summary
 
@@ -84,13 +84,20 @@ describe('the real tree', () => {
   test('the whole-bundle lanes skip the runner server entry point, which is not a test', () => {
     // The whole reason -skip-testing: exists in this repo. `testCommand` opens an
     // NWListener and waits 24 hours; an unfiltered run would hang the lane to its timeout.
-    const skipped = loadReport(repoRoot).flagged.filter((entry) => entry.flag === 'skip-testing');
+    const report = loadReport(repoRoot);
+    const skipped = report.flagged.filter((entry) => entry.flag === 'skip-testing');
     for (const entry of LANES.filter((entry) => entry.selection === 'whole')) {
       expect(
         skipped.filter((flag) => flag.workflow === entry.workflow).map((flag) => flag.identifier),
       ).toContain(ENTRY_POINT);
     }
-    for (const entry of skipped) expect(entry.identifier).toBe(ENTRY_POINT);
+    for (const entry of skipped) {
+      if (entry.identifier === ENTRY_POINT) continue;
+      // A real test may be excluded from the shared process only if another invocation
+      // on the same lane still reaches it. Removing the isolated run must fail this.
+      const current = LANES.find((lane) => lane.workflow === entry.workflow)!;
+      expect(report.reach[current.id].has(entry.identifier)).toBe(true);
+    }
   });
 
   test('the simulator-only tests are exactly the ones the macOS build compiles out', () => {
@@ -296,6 +303,40 @@ describe('a planted guard', () => {
   });
 });
 
+describe('isolated invocations', () => {
+  const isolated = `${TARGET}/RunnerTests/testIsolated`;
+  const swift = source(`${ENTRY_SOURCE}extension RunnerTests {\n  func testIsolated() {}\n}\n`);
+  const shared = `xcodebuild test-without-building -skip-testing:${ENTRY_POINT} -skip-testing:${isolated}`;
+
+  test('a separate selected invocation restores a test skipped by the shared process', () => {
+    const report = buildReport(TARGET, swift, [
+      ...laneWorkflows().filter((entry) => entry.workflow !== NIGHTLY_WORKFLOW_FILE),
+      {
+        workflow: NIGHTLY_WORKFLOW_FILE,
+        text: `xcodebuild test-without-building -only-testing:${isolated}\n${shared}`,
+      },
+    ]);
+    expect([...report.reach.nightly]).toEqual([isolated]);
+    expect(report.entryPointReachedBy).toEqual([]);
+  });
+
+  test('removing the isolated invocation leaves that test unreachable on nightly', () => {
+    const report = buildReport(TARGET, swift, [
+      ...laneWorkflows().filter((entry) => entry.workflow !== NIGHTLY_WORKFLOW_FILE),
+      { workflow: NIGHTLY_WORKFLOW_FILE, text: shared },
+    ]);
+    expect(report.reach.nightly.has(isolated)).toBe(false);
+  });
+
+  test('a skip still wins over an only flag in the same invocation', () => {
+    const report = buildReport(TARGET, swift, [
+      ...laneWorkflows().filter((entry) => entry.workflow !== NIGHTLY_WORKFLOW_FILE),
+      { workflow: NIGHTLY_WORKFLOW_FILE, text: `${shared} -only-testing:${isolated}` },
+    ]);
+    expect(report.reach.nightly.has(isolated)).toBe(false);
+  });
+});
+
 describe('the workflow scan', () => {
   test('reads both flags on the multi-line xcodebuild invocation', () => {
     expect(
 
@@ -188,19 +188,26 @@ function identifiers(
   );
 }
 
-/** What one lane reaches: its platform's compiled set, narrowed by its flags. */
+/** Union the invocations: a skip in one process must not erase an isolated run. */
 function laneReach(
   entry: Lane,
   declaredTests: readonly DeclaredTest[],
-  flagged: readonly FlaggedTest[],
+  workflowText: string,
 ): Set<string> {
-  const only = identifiers(flagged, entry.workflow, 'only-testing');
-  const skipped = identifiers(flagged, entry.workflow, 'skip-testing');
+  const parts = workflowText.split(/^\s*(?:run:\s*)?xcodebuild\s+test(?:-without-building)?\b/m);
+  const invocations = parts.length > 1 ? parts.slice(1) : parts;
+  const compiled = declaredTests
+    .filter((test) => test.platforms.includes(entry.platform))
+    .map((test) => test.identifier);
   return new Set(
-    declaredTests
-      .filter((test) => test.platforms.includes(entry.platform))
-      .map((test) => test.identifier)
-      .filter((id) => (entry.selection === 'whole' || only.has(id)) && !skipped.has(id)),
+    invocations.flatMap((text) => {
+      const flagged = parseFlaggedTests(entry.workflow, text);
+      const only = identifiers(flagged, entry.workflow, 'only-testing');
+      const skipped = identifiers(flagged, entry.workflow, 'skip-testing');
+      // An explicit list narrows even a whole-bundle lane's isolated invocation.
+      const whole = entry.selection === 'whole' && only.size === 0;
+      return compiled.filter((id) => (whole || only.has(id)) && !skipped.has(id));
+    }),
   );
 }
 
@@ -220,7 +227,14 @@ export function buildReport(
   // and cannot speak for anything else a workflow might select.
   const owned = flagged.filter((entry) => entry.identifier.startsWith(`${target}/`));
   const reach = Object.fromEntries(
-    LANES.map((entry) => [entry.id, laneReach(entry, declaredTests, flagged)]),
+    LANES.map((entry) => [
+      entry.id,
+      laneReach(
+        entry,
+        declaredTests,
+        workflows.find((workflow) => workflow.workflow === entry.workflow)?.text ?? '',
+      ),
+    ]),
   ) as Record<LaneId, ReadonlySet<string>>;
   const entryPoint = `${target}/${ENTRY_POINT_METHOD}`;
   const reachedAnywhere = new Set(LANES.flatMap((entry) => [...reach[entry.id]]));