rspec-mergify 0.3.0-x86_64-linux → 0.4.0-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4dabe88c5f64038181d8a4939b92178c44f3f06e8d83afdaa80a35d3683d8afd
-  data.tar.gz: 2de7f3aec3374465de5425ef58d7325f084626696b185f0e0d31011f82525c4f
+  metadata.gz: 575c4e6cb1bf916b62d8a980400b66d759f5ab93a0336f4b291c334b0fc135e3
+  data.tar.gz: 75b9c3987f3ce8f6af6b7cae5475996894ff792c9d7731c0dfdcdfefc9986a23
 SHA512:
-  metadata.gz: 0a90d80f864b1a122e576f76475f2d91e46246a175e922da180dee5bb6205b7dd3e4efba5182747341676c6bd6aec5b523c556621910a6e5a65ad0935b0aadc2
-  data.tar.gz: d67e1e86f964c57c25aaf4afc0a45636c7f8e40279eccb9f3b7c2c0f9e8ab5cfe565c4fb5f10f69d7e5af9b0ca2af61e0061aadb964a5b8d9993f2b33b5ab436
+  metadata.gz: 82c9c02a5e7cdea0cec4f4c0c72aede62fd081e530029c180b5e54f3be3561f0ea95883e4490a731a93cd897bdc6e56227724e7b44f71fdf40c6f591ed023ccb
+  data.tar.gz: c248034b68730876dc1c7dbc4725aa37ab5fb014a05c74c8c5a74de775b65334a680cc8db8a0a1b7ebe7fa1419a389554efc25d9d1ac17c47ef55d57f9c60088

data/README.md

@@ -7,6 +7,7 @@ RSpec plugin for [Mergify Test Insights](https://docs.mergify.com/ci-insights/).
 - **Test tracing** — Sends OpenTelemetry traces for every test to Mergify's API
 - **Flaky test detection** — Intelligently reruns tests to detect flakiness with budget constraints
 - **Test quarantine** — Quarantines failing tests so they don't block CI
+- **Test selection** — Runs only the previously-failing examples when Mergify's merge queue reruns a job
 
 ## Installation
 
@@ -51,6 +52,54 @@ The plugin activates automatically when running in CI (detected via the `CI` env
 | `RSPEC_MERGIFY_DEBUG` | Print spans to console | `false` |
 | `MERGIFY_TRACEPARENT` | W3C distributed trace context | — |
 | `MERGIFY_TEST_JOB_NAME` | Mergify test job name | — |
+| `MERGIFY_TEST_SELECTION_ENABLE` | Opt this job into test selection (see below) | `false` |
+
+### Test selection
+
+When Mergify's merge queue reruns a job — a retry, or a step of a batch
+bisection — only the examples that failed on the previous attempt are
+informative. The gem asks Mergify whether the current run is such a rerun and,
+if so, runs only those examples.
+
+**This is off until you turn it on, per job.** Set
+`MERGIFY_TEST_SELECTION_ENABLE=true` on the job you want reduced. Installing the
+gem is not enough — a feature that decides not to run tests starts only where
+you wrote that it should. Anything that is not a recognised yes (unset, empty,
+`false`, unparsable) means no, and a job that has not opted in never asks.
+
+Once opted in, it only ever removes work:
+
+- the answer is applied **after** RSpec's own filters — file and line
+  arguments, `--tag`, `-e`, `--only-failures` all still narrow the run, never
+  widen it;
+- examples are matched by their id (`./spec/models/user_spec.rb[1:2]`), the
+  identity RSpec itself reruns failures by;
+- if Mergify says the previous attempt already ran every one of these examples
+  and they passed, the run executes none and exits green;
+- if any example Mergify asks for is not collected here, the full suite runs;
+- any error, timeout, or unrecognised answer runs the full suite;
+- if Mergify refuses to pick a previous attempt (several runs of this job
+  report under one name), the run **fails** with Mergify's explanation: give
+  each run its own `MERGIFY_TEST_JOB_NAME`;
+- at the end of the run the gem sends Mergify what it concluded (the counts
+  and the failing examples) — unless the run failed outside any example (a
+  failing `after(:context)` or suite hook), in which case a retry runs the
+  full suite.
+
+Each parallel_tests worker, and each CI job handed a slice of the spec files,
+is matched to the same slice of the previous attempt, by the examples it
+collects. This needs the slices to be the same on both attempts, which is the
+case for a split by file size or by a committed runtime log; Knapsack Pro's
+Queue Mode hands files out dynamically and is not supported.
+
+### Parallel runs
+
+[parallel_tests](https://github.com/grosser/parallel_tests) and [turbo_tests](https://github.com/serpapi/turbo_tests) need no setup. Each worker is a separate RSpec process, and each reports to Mergify as its own session:
+
+- flaky detection sizes each worker's rerun budget from the tests that worker runs;
+- each worker prints its own Mergify report, so a report covers only that worker's tests.
+
+Suites split across CI jobs (knapsack, `circleci tests split`, Buildkite `parallelism`) behave the same way, one session per job.
 
 For detailed documentation, see the [official guide](https://docs.mergify.com/ci-insights/test-frameworks/rspec/).
 

data/lib/mergify/rspec/ci_insights.rb

@@ -5,18 +5,38 @@ require_relative 'trace'
 require_relative 'utils'
 require_relative 'native'
 require_relative 'resources/rspec'
+require_relative 'test_selection'
+require_relative 'session_verdict'
 
 module Mergify
   module RSpec
     # Central orchestrator for Mergify Test Insights: records the run's spans,
-    # uploads them, and coordinates flaky detection and quarantine.
+    # uploads them, and coordinates flaky detection, quarantine and test
+    # selection.
+    # rubocop:disable-next Metrics/ClassLength
     class CIInsights
+      # The resource attributes pytest-mergify reports, under the same keys.
+      # The fingerprint and count describe what this run collected, on every
+      # run that took one; the selection keys echo what Mergify answered, as
+      # sent, and are absent on a run it never answered.
+      TEST_COLLECTION_FINGERPRINT = 'test.collection.fingerprint'
+      TEST_COLLECTION_COUNT = 'test.collection.count'
+      TEST_SELECTION_ANSWER = 'test.selection.answer'
+      TEST_SELECTION_REASON = 'test.selection.reason'
+      TEST_SELECTION_KEPT_COUNT = 'test.selection.kept_count'
+      TEST_SELECTION_NOT_APPLIED_REASON = 'test.selection.not_applied_reason'
+
+      # The largest value the engine's counters take (a signed 32-bit int).
+      MAX_COUNT = (2**31) - 1
+
       attr_reader :token, :repo_name, :api_url, :test_run_id,
                   :recorder,
                   :branch_name,
-                  :flaky_detector, :flaky_detector_error_message, :quarantined_tests
+                  :flaky_detector, :flaky_detector_error_message, :quarantined_tests,
+                  :test_selection, :session_verdict, :session_verdict_result,
+                  :captured_session_verdict, :session_verdict_withheld
 
-      # rubocop:disable-next Metrics/MethodLength
+      # rubocop:disable-next Metrics/MethodLength,Metrics/AbcSize
       def initialize
         @token = ENV.fetch('MERGIFY_TOKEN', nil)
         @repo_name = Native.detect_repository_name
@@ -28,10 +48,110 @@ module Mergify
         @flaky_detector = nil
         @flaky_detector_error_message = nil
         @quarantined_tests = nil
+        @test_selection = nil
+        @selection_echo = nil
+        @session_verdict = SessionVerdict.new
+        @session_verdict_result = SessionVerdict::Result.new(sent: false, truncated: false)
+        @captured_session_verdict = nil
+        @session_verdict_withheld = false
 
         setup_tracing if Utils.in_ci?
       end
 
+      # Take the identity of what this run is about to execute, and ask
+      # Mergify whether part of it is enough.
+      #
+      # Called once RSpec has loaded the spec files and applied every filter
+      # of its own -- file and line arguments, `--tag`, `-e`, `--only-failures`
+      # -- so the fingerprint describes this process's examples and nothing
+      # else. A parallel_tests worker, or a CI job handed a slice of the spec
+      # files, collects its own slice and so reports its own identity: the
+      # engine matches each against the previous attempt of the same slice.
+      #
+      # The fingerprint is reported on every run that can take one, whether
+      # or not this job opted into the selection, as pytest-mergify does.
+      def on_examples_collected(example_ids)
+        return unless @recorder && Native.available?
+
+        fingerprint = Native.test_collection_fingerprint(example_ids)
+        @recorder.resource_attributes[TEST_COLLECTION_FINGERPRINT] = fingerprint
+        @recorder.resource_attributes[TEST_COLLECTION_COUNT] = example_ids.size
+        # A process with nothing to run has nothing to reduce, and asking would
+        # cost the job its next retry: every parallel worker left empty by a
+        # filter reports the same empty-set fingerprint under the same job, and
+        # Mergify refuses to choose between sessions it cannot tell apart.
+        load_test_selection(fingerprint) unless example_ids.empty?
+      end
+
+      # Report what Mergify answered and what this run made of it, once the
+      # answer has met the collection. Nothing is echoed unless Mergify
+      # actually answered: a run that never asked, or whose question went
+      # unanswered, was offered nothing.
+      # rubocop:disable-next Metrics/MethodLength
+      def on_selection_resolved(kept_count)
+        return unless @recorder && @test_selection&.served?
+
+        @selection_echo = {
+          'answer' => @test_selection.selection,
+          'reason' => @test_selection.reason,
+          'kept_count' => kept_count
+        }
+        not_applied = @test_selection.not_applied_reason
+        @selection_echo['not_applied_reason'] = not_applied if not_applied
+
+        resource = @recorder.resource_attributes
+        resource[TEST_SELECTION_ANSWER] = @selection_echo['answer']
+        resource[TEST_SELECTION_REASON] = @selection_echo['reason']
+        resource[TEST_SELECTION_KEPT_COUNT] = kept_count
+        resource[TEST_SELECTION_NOT_APPLIED_REASON] = not_applied if not_applied
+      end
+
+      # Write what this session concluded to Mergify, before the spans go.
+      #
+      # Sent exactly when the selection was asked for -- including when that
+      # request failed: the verdict is what the NEXT rerun of this job needs.
+      # Withheld when the run failed outside any example (a failing
+      # `after(:context)` or suite hook): its examples then read as passed,
+      # and a verdict naming no failure would have the retry run nothing and
+      # turn green on the same breakage. Without a verdict, the retry runs the
+      # whole suite. Never raises.
+      # rubocop:disable-next Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+      def send_session_verdict(failed_outside_examples:)
+        return if @test_selection.nil?
+
+        if failed_outside_examples
+          @session_verdict_withheld = true
+          return
+        end
+
+        body = session_verdict_body
+        return if body.nil?
+
+        if test_mode?
+          @captured_session_verdict = body
+          @session_verdict_result = SessionVerdict::Result.new(sent: true, truncated: false)
+          return
+        end
+
+        if debug_mode?
+          puts "MERGIFY SESSION VERDICT: #{body}"
+          @session_verdict_result = SessionVerdict::Result.new(sent: true, truncated: false)
+          return
+        end
+
+        receipt = api_client.send_session_verdict(body)
+        # Dormant: the feature is not enabled for this repository, which the
+        # selection block already says.
+        return if receipt.nil?
+
+        @session_verdict_result = SessionVerdict::Result.new(sent: true, truncated: receipt['truncated'])
+      rescue StandardError => e
+        # Broader than ApiError on purpose: a value the binding cannot marshal
+        # raises something else, and a verdict must never cost the run.
+        message = e.is_a?(Native::ApiError) ? e.message : "#{e.class}: #{e.message}"
+        @session_verdict_result = SessionVerdict::Result.new(sent: false, truncated: false, error: message)
+      end
+
       # Send the run, once, at the end. Failing to report a run is worth
       # saying out loud but never worth failing a suite that just passed,
       # so this answers with a message instead of raising.
@@ -56,6 +176,85 @@ module Mergify
 
       private
 
+      # Opt-in, per job, and asked for only where the run's identity is
+      # complete: the head branch and revision (a merge-queue draft branch on a
+      # rerun) and the job coordinates, the very values each uploaded example
+      # carries, so the server can match its records.
+      # rubocop:disable-next Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity
+      def load_test_selection(fingerprint)
+        return unless TestSelection.enabled?
+        # An empty token is what a fork or a bot pull request gets for a secret.
+        return if @token.to_s.empty? || @repo_name.to_s.empty?
+
+        resource = @recorder.resource_attributes
+        branch = resource['vcs.ref.head.name']
+        head_sha = resource['vcs.ref.head.revision']
+        pipeline_name = resource['cicd.pipeline.name']
+        job_name = job_name_from(resource)
+        return if [branch, head_sha, pipeline_name, job_name].any? { |value| value.to_s.empty? }
+
+        answer = api_client.fetch_test_selection(branch.to_s, head_sha.to_s, pipeline_name.to_s,
+                                                 job_name.to_s, fingerprint)
+        @test_selection = answer.nil? ? TestSelection.unanswered : TestSelection.served(answer)
+      rescue Native::ApiError, Utils::InvalidRepositoryFullNameError => e
+        @test_selection = TestSelection.unanswered(init_error_msg: e.message)
+      end
+
+      # `mergify.test.job.name` is the operator-set override; the provider's
+      # own task name is the fallback. Same precedence as the other clients.
+      def job_name_from(resource)
+        override = resource['mergify.test.job.name']
+        override.to_s.empty? ? resource['cicd.pipeline.task.name'] : override
+      end
+
+      # The verdict body, keyed on exactly what the selection call was keyed
+      # on, so a verdict is found by what the asking run knows.
+      # rubocop:disable-next Metrics/MethodLength,Metrics/AbcSize
+      def session_verdict_body
+        resource = @recorder.resource_attributes
+        fingerprint = resource[TEST_COLLECTION_FINGERPRINT]
+        head_sha = resource['vcs.ref.head.revision']
+        pipeline_name = resource['cicd.pipeline.name']
+        job_name = job_name_from(resource)
+        return nil if [fingerprint, head_sha, pipeline_name, job_name].any? { |value| value.to_s.empty? }
+
+        body = {
+          'test_run_id' => @test_run_id,
+          'head_sha' => head_sha.to_s,
+          'pipeline_name' => pipeline_name.to_s,
+          'job_name' => job_name.to_s,
+          'collection_fingerprint' => fingerprint,
+          'collection_count' => resource[TEST_COLLECTION_COUNT],
+          'total_test_runtime_ms' => @session_verdict.total_test_runtime_ms,
+          'failing_tests' => @session_verdict.failing_tests,
+          'quarantined_failing_tests' => @session_verdict.quarantined_failing_tests
+        }.merge(@session_verdict.counts)
+        head_branch = resource['vcs.ref.head.name']
+        body['head_branch'] = head_branch.to_s unless head_branch.to_s.empty?
+        add_run_identity(body, resource)
+        body['selection'] = @selection_echo.dup if @selection_echo
+        body
+      end
+
+      # `run_attempt` only next to a `run_id`: the engine refuses an attempt of
+      # nothing. An attempt the engine's counter cannot hold is left out
+      # rather than refused.
+      def add_run_identity(body, resource)
+        run_id = resource['cicd.pipeline.run.id']
+        return if run_id.to_s.empty?
+
+        body['run_id'] = run_id.to_s
+        attempt = resource['cicd.pipeline.run.attempt']
+        body['run_attempt'] = attempt if attempt.is_a?(Integer) && attempt.between?(0, MAX_COUNT)
+      end
+
+      def api_client
+        @api_client ||= begin
+          owner, repo = Utils.split_full_repo_name(@repo_name)
+          Native::Client.new(@api_url, @token, owner, repo, Mergify::RSpec::VERSION)
+        end
+      end
+
       # Recording is unconditional; whether the run is *uploaded* is what the
       # token and repository decide. Debug and test runs keep their spans and
       # send nothing, which is what they always did -- the difference is that

data/lib/mergify/rspec/configuration.rb

@@ -1,20 +1,33 @@
 # frozen_string_literal: true
 
 require 'set'
+require_relative 'test_selection'
 
 module Mergify
   module RSpec
-    # Registers RSpec hooks for quarantine and flaky detection, and adds the
+    # Registers RSpec hooks for quarantine and flaky detection, and attaches the
     # Mergify Test Insights formatter when running inside CI.
+    # rubocop:disable-next Metrics/ModuleLength
     module Configuration
+      QUARANTINE_MESSAGE = 'Test is quarantined from Mergify Test Insights'
+
       module_function
 
-      # rubocop:disable Metrics/MethodLength,Metrics/BlockLength,Metrics/AbcSize
+      # rubocop:disable-next Metrics/MethodLength,Metrics/BlockLength,Metrics/AbcSize
       # rubocop:disable-next Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
       def setup!
         ::RSpec.configure do |config|
-          # Add formatter when in CI
-          config.add_formatter(Mergify::RSpec::Formatter) if Utils.in_ci?
+          # Registered before the formatter's hook so that it runs after it --
+          # each `prepend_before` goes to the front: the formatter has to be
+          # attached already for the run's report and verdict to see what the
+          # selection did.
+          config.prepend_before(:suite) { Configuration.select_examples } if Utils.in_ci?
+
+          # Attached to the reporter once the suite starts, rather than added with
+          # `add_formatter`: RSpec only sets up its default formatter when no
+          # other was added, so adding this one took the progress output and the
+          # summary line away from every suite that had not chosen a format.
+          config.prepend_before(:suite) { Configuration.attach_formatter(config) } if Utils.in_ci?
 
           # Flaky detection: prepare session with all example IDs
           config.before(:suite) do
@@ -37,81 +50,163 @@ module Mergify
 
           # Flaky detection: rerun tests within budget
           config.around(:each) do |example|
-            ci = Mergify::RSpec.ci_insights
-            fd = ci&.flaky_detector
-
-            example.run
-
-            # Feed metrics from the initial run so the detector can evaluate
-            if fd
-              run_time = example.execution_result.run_time || 0.0
-              status = example.execution_result.status
-              fd.fill_metrics_from_report(example.id, 'setup', 0.0, status)
-              fd.fill_metrics_from_report(example.id, 'call', run_time, status)
-              fd.fill_metrics_from_report(example.id, 'teardown', 0.0, status)
-            end
-
-            next unless fd&.rerunning_test?(example.id)
+            fd = Mergify::RSpec.ci_insights&.flaky_detector
+            fd ? Configuration.run_detecting_flakiness(example, fd) : example.run
+          end
 
-            # Mark as flaky detection candidate (even if too slow to rerun)
-            example.metadata[:mergify_flaky_detection] = true
-            example.metadata[:mergify_new_test] = true if fd.mode == 'new'
+          # Quarantine: override failed quarantined test results. The failure is
+          # noted for flaky detection first, which would otherwise take a
+          # quarantined attempt that failed for one that passed.
+          config.after(:each) do |example|
+            next unless example.metadata[:mergify_quarantined] && example.exception
 
-            fd.set_test_deadline(example.id)
-            next if fd.test_too_slow?(example.id)
+            example.metadata[:mergify_quarantined_failure] = true
+            example.instance_variable_set(:@exception, nil)
+            example.execution_result.status = :pending
+            example.execution_result.pending_message = QUARANTINE_MESSAGE
+          end
+        end
+      end
 
-            distinct_outcomes = Set.new
-            distinct_outcomes.add(example.execution_result.status) if example.execution_result.status
+      # Fingerprint what this process is about to run, ask Mergify whether part
+      # of it is enough, and remove the rest.
+      #
+      # A `before(:suite)` hook, because that is the first moment RSpec has both
+      # loaded the spec files and applied its filters, and the last one before
+      # an example group starts. What each group runs is read from
+      # `RSpec.world.filtered_examples`, which RSpec memoized while counting the
+      # run; narrowing those lists is what deselects.
+      # rubocop:disable-next Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+      def select_examples
+        ci = Mergify::RSpec.ci_insights
+        return unless ci
+
+        groups = ::RSpec.world.example_groups.flat_map(&:descendants)
+        ids = groups.flat_map { |group| ::RSpec.world.filtered_examples[group] }.map(&:id)
+        ci.on_examples_collected(ids)
+
+        begin
+          keep = ci.test_selection&.resolve(ids)
+        rescue TestSelectionRefused => e
+          ci.on_selection_resolved(0)
+          return refuse(e.message)
+        end
 
-            rerun_count = 0
-            # Use a null reporter to prevent reruns from being reported as
-            # individual failures. The final outcome is set after the loop.
-            null_reporter = ::RSpec::Core::NullReporter
+        deselect(groups, keep) if keep
+        ci.on_selection_resolved(keep ? ids.count { |id| keep.include?(id) } : ids.size)
+      rescue StandardError => e
+        # This runs on every CI run, opted in or not, and RSpec would answer a
+        # raise here by running nothing: a fault of this gem must cost the run
+        # its reduction, never its tests.
+        ::RSpec.configuration.error_stream.puts(
+          "Mergify Test Selection failed, so the full suite runs: #{e.class}: #{e.message}"
+        )
+      end
 
-            until example.metadata[:is_last_rerun]
-              example.metadata[:is_last_rerun] = fd.last_rerun_for_test?(example.id)
+      # Stop the run before any example, the way RSpec stops one whose suite
+      # hook failed -- nothing runs, the exit code is red, and the summary
+      # counts an error outside of examples -- but with the server's
+      # explanation alone. Raised from the hook, the same failure is printed
+      # under a "Failure/Error:" header pointing at a line of this gem, which
+      # only buries the explanation.
+      def refuse(message)
+        ::RSpec.configuration.error_stream.puts("\n#{message}\n")
+        ::RSpec.world.wants_to_quit = true
+        reporter = ::RSpec.configuration.reporter
+        count = reporter.instance_variable_get(:@non_example_exception_count)
+        reporter.instance_variable_set(:@non_example_exception_count, count + 1) if count.is_a?(Integer)
+      end
 
-              # Reset example state for rerun
-              example.instance_variable_set(:@exception, nil)
-              if example.example_group_instance
-                memoized = example.example_group_instance.instance_variable_get(:@__memoized)
-                if memoized.respond_to?(:clear)
-                  memoized.clear
-                elsif memoized
-                  # RSpec >= 3.12 uses ThreadsafeMemoized which wraps an internal hash
-                  inner = memoized.instance_variable_get(:@memoized)
-                  inner&.clear
-                end
-              end
+      # A group left with no example runs none of its `before(:context)`
+      # hooks: RSpec decides that from these same lists, once the group starts.
+      def deselect(groups, keep)
+        groups.each do |group|
+          ::RSpec.world.filtered_examples[group] =
+            ::RSpec.world.filtered_examples[group].select { |example| keep.include?(example.id) }
+        end
+      end
 
-              example.run(example.example_group_instance, null_reporter)
+      # The reporter has sent `start` by the time suite hooks run, so the
+      # formatter is handed the same notification directly.
+      def attach_formatter(config)
+        formatter = Formatter.new(config.output_stream)
+        formatter.start(::RSpec::Core::Notifications::StartNotification.new(::RSpec.world.example_count, 0))
+        config.reporter.register_listener(formatter, *Formatter::NOTIFICATIONS)
+      end
 
-              # Feed rerun metrics so budget/deadline tracking stays accurate
-              rerun_time = example.execution_result.run_time || 0.0
-              rerun_status = example.execution_result.status
-              fd.fill_metrics_from_report(example.id, 'call', rerun_time, rerun_status)
+      # `example` is the Procsy an around hook is handed, and the example has no
+      # result yet: RSpec records its status and run time in `Example#finish`,
+      # once every around hook has returned. So each attempt is timed here, and
+      # its outcome read off the exception it left behind.
+      # rubocop:disable-next Metrics/AbcSize
+      def run_detecting_flakiness(example, detector)
+        status, duration = run_attempt(example)
+        detector.fill_metrics_from_report(example.id, 'setup', 0.0, status)
+        detector.fill_metrics_from_report(example.id, 'call', duration, status)
+        detector.fill_metrics_from_report(example.id, 'teardown', 0.0, status)
+        return unless detector.rerunning_test?(example.id)
+
+        # Mark as flaky detection candidate (even if too slow to rerun)
+        example.metadata[:mergify_flaky_detection] = true
+        example.metadata[:mergify_new_test] = true if detector.mode == 'new'
+
+        detector.set_test_deadline(example.id)
+        return if detector.test_too_slow?(example.id)
+
+        rerun(example, detector, status)
+      end
 
-              distinct_outcomes.add(rerun_status)
-              rerun_count += 1
-            end
+      # Which attempt decides the result is pytest-mergify's rule: in 'new' mode
+      # any failure fails the test, so a new flaky test cannot be merged; in
+      # 'unhealthy' mode the reruns only learn, and the first attempt stands.
+      # rubocop:disable-next Metrics/MethodLength,Metrics/AbcSize
+      def rerun(example, detector, initial_status)
+        initial_exception = example.exception
+        first_failure = initial_exception
+        outcomes = Set[initial_status]
+        rerun_count = 0
+
+        until example.metadata[:is_last_rerun]
+          example.metadata[:is_last_rerun] = detector.last_rerun_for_test?(example.id)
+          reset_for_rerun(example)
+
+          status, duration = run_attempt(example)
+          detector.fill_metrics_from_report(example.id, 'call', duration, status)
+          outcomes << status
+          first_failure ||= example.exception
+          rerun_count += 1
+        end
 
-            is_flaky = distinct_outcomes.include?(:passed) &&
-                       distinct_outcomes.include?(:failed)
-            example.metadata[:mergify_flaky] = true if is_flaky
-            example.metadata[:mergify_rerun_count] = rerun_count
-          end
+        example.metadata[:mergify_flaky] = true if outcomes.include?(:passed) && outcomes.include?(:failed)
+        example.metadata[:mergify_rerun_count] = rerun_count
+        final_exception = detector.mode == 'new' ? first_failure : initial_exception
+        example.example.instance_variable_set(:@exception, final_exception)
+      end
 
-          # Quarantine: override failed quarantined test results
-          config.after(:each) do |example|
-            next unless example.metadata[:mergify_quarantined] && example.exception
+      # Runs what the around hook wraps -- the before and after hooks included
+      # -- and answers its outcome and duration in seconds.
+      def run_attempt(example)
+        started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        example.run
+        duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started
+        failed = example.exception || example.metadata.delete(:mergify_quarantined_failure)
+        [failed ? :failed : :passed, duration]
+      end
 
-            example.instance_variable_set(:@exception, nil)
-            example.execution_result.status = :pending
-            example.execution_result.pending_message = 'Test is quarantined from Mergify Test Insights'
-          end
+      # The exception lives on the example itself, not on the Procsy: setting
+      # it there would leave RSpec to fold every attempt's failure into one.
+      def reset_for_rerun(example)
+        example.example.instance_variable_set(:@exception, nil)
+        return unless example.example_group_instance
+
+        memoized = example.example_group_instance.instance_variable_get(:@__memoized)
+        if memoized.respond_to?(:clear)
+          memoized.clear
+        elsif memoized
+          # RSpec >= 3.12 uses ThreadsafeMemoized which wraps an internal hash
+          memoized.instance_variable_get(:@memoized)&.clear
         end
       end
-      # rubocop:enable Metrics/MethodLength,Metrics/BlockLength,Metrics/AbcSize
     end
   end
 end

data/lib/mergify/rspec/flaky_detection.rb

@@ -146,11 +146,14 @@ module Mergify
         (metrics.initial_duration * min_exec) > metrics.remaining_time
       end
 
+      # Asked before the rerun it guards. `rerun_count` counts executions, the
+      # initial one included, so the rerun about to start is the last one when
+      # it is the one reaching the cap.
       def last_rerun_for_test?(test_id)
         return false unless @metrics.key?(test_id)
 
         metrics = @metrics[test_id]
-        metrics.will_exceed_deadline? || metrics.rerun_count >= @context['max_test_execution_count']
+        metrics.will_exceed_deadline? || metrics.rerun_count + 1 >= @context['max_test_execution_count']
       end
 
       def test_metrics(test_id)

data/lib/mergify/rspec/formatter.rb

@@ -2,6 +2,7 @@
 
 require 'rspec/core/formatters/base_formatter'
 require_relative 'trace'
+require_relative 'configuration'
 
 require 'mergify/rspec/native'
 
@@ -12,12 +13,17 @@ module Mergify
     # test execution.
     # rubocop:disable-next Metrics/ClassLength
     class Formatter < ::RSpec::Core::Formatters::BaseFormatter
-      ::RSpec::Core::Formatters.register self,
-                                         :start,
-                                         :example_started,
-                                         :example_finished,
-                                         :example_pending,
-                                         :stop
+      # What it listens to once attached, `start` excepted: it is attached after
+      # that notification, and handed it directly.
+      NOTIFICATIONS = %i[example_started example_finished example_pending stop].freeze
+
+      # @mergifyio/vitest's sentence, for the same withheld verdict.
+      WITHHELD_VERDICT = TestSelection.wrap(
+        "Mergify wasn't sent this run's results: it failed outside any example. If this merge-queue " \
+        'batch is retried, this job will run its full test suite.'
+      )
+
+      ::RSpec::Core::Formatters.register self, :start, *NOTIFICATIONS
 
       def start(notification)
         super
@@ -47,7 +53,7 @@ module Mergify
         @example_spans[example.id] = span
       end
 
-      # rubocop:disable-next Metrics/MethodLength
+      # rubocop:disable-next Metrics/MethodLength,Metrics/AbcSize
       def example_finished(notification)
         return unless @example_spans
 
@@ -56,6 +62,7 @@ module Mergify
         return unless span
 
         result = example.execution_result
+        @ci_insights.session_verdict.record(example.id, verdict_status(example), result.run_time)
         status = result.status.to_s
         span.set_attribute('test.case.result.status', status)
         set_flaky_attributes(span, example)
@@ -78,17 +85,50 @@ module Mergify
         return unless span
 
         span.set_attribute('test.case.result.status', 'skipped')
+        @ci_insights.session_verdict.record(example.id, verdict_status(example), example.execution_result.run_time)
         @ci_insights.recorder.record(span)
       end
 
       def stop(_notification)
         finish_session_span
+        # The verdict first, on purpose: it is what the next merge-queue rerun
+        # of this job is answered from, and it must never wait behind the
+        # trace upload's timeout and retries.
+        send_session_verdict
         print_report
         flush_and_shutdown
       end
 
       private
 
+      # The status RSpec reported, which is the one that decided the exit
+      # code. A pending example is a skip, unless it is a failure the
+      # quarantine absorbed.
+      def verdict_status(example)
+        result = example.execution_result
+        case result.status
+        when :passed then 'passed'
+        when :failed then 'failed'
+        else
+          quarantined = example.metadata[:mergify_quarantined] &&
+                        result.pending_message == Configuration::QUARANTINE_MESSAGE
+          quarantined ? 'quarantined_failed' : 'skipped'
+        end
+      end
+
+      def send_session_verdict
+        return unless @ci_insights&.recorder
+
+        @ci_insights.send_session_verdict(failed_outside_examples: failed_outside_examples?)
+      end
+
+      # RSpec flags a failure no example carries -- a failing `after(:context)`
+      # or suite hook. A load error flags it too, but stops the run before the
+      # formatter is ever attached.
+      def failed_outside_examples?
+        ::RSpec.world.non_example_failure ? true : false
+      end
+
       def build_example_attributes(example, quarantined)
         {
           'test.scope' => 'case',
@@ -149,6 +189,7 @@ module Mergify
         print_configuration_warnings
         print_flaky_report
         print_quarantine_report
+        print_test_selection_report
         output.puts "MERGIFY_TEST_RUN_ID=#{@ci_insights.test_run_id}"
         output.puts '------------------'
       end
@@ -185,6 +226,17 @@ module Mergify
         output.puts report if report
       end
 
+      # One block whatever happened, once the job asked for a selection.
+      def print_test_selection_report
+        selection = @ci_insights.test_selection
+        return unless selection
+
+        output.puts selection.report
+        output.puts WITHHELD_VERDICT if @ci_insights.session_verdict_withheld
+        verdict_report = @ci_insights.session_verdict_result.report
+        output.puts verdict_report if verdict_report
+      end
+
       # One upload, at the end. There is nothing to shut down any more: the
       # recorder holds spans in memory and the client owns the connection.
       def flush_and_shutdown

data/lib/mergify/rspec/quarantine.rb

@@ -48,13 +48,19 @@ module Mergify
         lines << "  Quarantined tests run (#{used.size}):"
         used.each { |t| lines << "    - #{t}" }
         lines << ''
-        lines << "  Unused quarantined tests (#{unused.size}):"
+        lines << "  #{unused_label} (#{unused.size}):"
         unused.each { |t| lines << "    - #{t}" }
         lines.join("\n")
       end
 
       private
 
+      # A parallel worker runs a share of the suite, so a quarantined test it
+      # did not run was most likely run by another worker, not left unused.
+      def unused_label
+        Utils.parallel_worker? ? 'Quarantined tests not run by this worker' : 'Unused quarantined tests'
+      end
+
       # A nil list means the repository has no quarantine subscription, which is
       # not an error: the session simply quarantines nothing. Anything that went
       # genuinely wrong is recorded and the suite carries on -- this plugin has

data/lib/mergify/rspec/session_verdict.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative 'test_selection'
+
+module Mergify
+  module RSpec
+    # What the session concluded about each example, folded as RSpec reports
+    # it, and written to Mergify when the session ends.
+    #
+    # Test Selection answers a merge-queue rerun from its predecessor's
+    # verdict: which examples failed, whether anything ran at all. The verdict
+    # is sent in one request before the trace upload, so the answer is there
+    # seconds after the session ends rather than whenever trace ingestion gets
+    # to it (INC-2434).
+    #
+    # One status per example, its FINAL one -- the status RSpec reported once
+    # flaky detection's reruns were over, which is what decided the exit code.
+    # A verdict that disagreed with the exit code would either replay examples
+    # that did not gate, or skip the one that did.
+    class SessionVerdict
+      # A failure the quarantine absorbed is `quarantined_failed`: it did not
+      # gate the job, so a rerun must not replay it, but it did run and fail,
+      # so it is not green either.
+      PRECEDENCE = { 'passed' => 0, 'skipped' => 1, 'quarantined_failed' => 2, 'failed' => 3 }.freeze
+
+      # How sending went, for the report. `sent` is false both when nothing
+      # had to be sent and when the request failed; `error` tells them apart.
+      Result = Struct.new(:sent, :truncated, :error, keyword_init: true) do
+        # Said only when the verdict did not reach Mergify whole. Wording
+        # validated by Alexandre on 2026-09-15 (MRGFY-9313), pytest-mergify's
+        # verbatim; a change here is a product decision.
+        def report
+          if error
+            "#{TestSelection.wrap("Mergify couldn't record this run's results. If this merge-queue batch is " \
+                                  'retried, this job will run its full test suite.')}\nError: #{error}\n"
+          elsif truncated
+            "#{TestSelection.wrap("Mergify recorded this run's counts but not its failing tests. If this " \
+                                  'merge-queue batch is retried, this job will run its full test suite.')}\n"
+          end
+        end
+      end
+
+      def initialize
+        @final = {}
+        @runtime_seconds = 0.0
+      end
+
+      def record(example_id, status, run_time)
+        @runtime_seconds += run_time.to_f
+        previous = @final[example_id]
+        @final[example_id] = status if previous.nil? || PRECEDENCE.fetch(status) > PRECEDENCE.fetch(previous)
+      end
+
+      def total_test_runtime_ms
+        (@runtime_seconds * 1000).to_i
+      end
+
+      # The engine's own definitions: `executed` counts every example that
+      # reached a status, a skipped one included, and `failed` includes the
+      # quarantined failures.
+      def counts
+        statuses = @final.values
+        {
+          'executed_count' => statuses.size,
+          'passed_count' => statuses.count('passed'),
+          'failed_count' => statuses.count { |status| %w[failed quarantined_failed].include?(status) },
+          'skipped_count' => statuses.count('skipped')
+        }
+      end
+
+      def failing_tests
+        ids_with('failed')
+      end
+
+      def quarantined_failing_tests
+        ids_with('quarantined_failed')
+      end
+
+      private
+
+      def ids_with(status)
+        @final.filter_map { |id, final| id if final == status }
+      end
+    end
+  end
+end

data/lib/mergify/rspec/test_selection.rb

@@ -0,0 +1,299 @@
+# frozen_string_literal: true
+
+require 'set'
+require_relative 'utils'
+
+module Mergify
+  module RSpec
+    # Raised by `TestSelection#resolve` when Mergify refuses to choose a
+    # selection for this run, carrying the explanation to show. The caller
+    # stops the run with it.
+    class TestSelectionRefused < StandardError; end
+
+    # Whether this run should execute only part of what it collected.
+    #
+    # A merge-queue rerun only needs to replay the examples that failed on the
+    # previous attempt of the same job. Mergify decides that server-side from
+    # the run's own identity AND from the fingerprint of what the run
+    # collected, which is why the request leaves only once RSpec has loaded
+    # and filtered its examples. The answer is one of:
+    #
+    # * `full` -- run everything;
+    # * `subset` -- run only `tests`;
+    # * `empty` -- run nothing: the previous attempt ran these examples and
+    #   they passed, so the run exits green having executed none;
+    # * `refused` -- Mergify holds several candidate sessions for this job and
+    #   will not guess between them, so the run FAILS with its explanation.
+    #
+    # Every error, and every answer outside that list, runs the whole suite:
+    # the feature can remove work, never correctness. pytest-mergify's
+    # `TestSelection`, answer for answer and sentence for sentence.
+    #
+    # When an answer cannot be honoured the run executes everything and says
+    # so in `not_applied_reason`, never by rewriting `selection` or `reason`:
+    # those two carry Mergify's word.
+    # rubocop:disable-next Metrics/ClassLength
+    class TestSelection
+      ENABLE_ENV = 'MERGIFY_TEST_SELECTION_ENABLE'
+
+      CLIENT_NAME = 'rspec-mergify'
+      DOCS_URL = 'https://docs.mergify.com/ci-insights/test-frameworks/rspec/'
+
+      # What a refusal says when the server sent no wording of its own. The
+      # copy belongs to the server; this is a fallback, not the message.
+      FALLBACK_REFUSAL_MESSAGE = <<~MESSAGE.chomp
+        Mergify Test Selection stopped this run.
+
+        Several runs of this job report to Mergify under the same name, and they run the same tests — so Mergify cannot tell which one this run repeats, and it will not guess which tests to skip.
+
+        If this job runs more than once (a build matrix, for example), give each run its own name with MERGIFY_TEST_JOB_NAME:
+        #{DOCS_URL}
+
+        If this job only runs once, this is unexpected — please contact Mergify support.
+      MESSAGE
+
+      NOT_APPLIED_SENTENCE =
+        "Mergify's answer didn't match the tests this run collected, so the full suite ran."
+
+      # One sentence per reason the full suite ran. pytest-mergify's
+      # `_FULL_RUN_SENTENCES` verbatim (validated by Alexandre on 2026-09-11,
+      # MRGFY-8978), naming this gem where they name a client. A change here is
+      # a product decision.
+      FULL_RUN_SENTENCES = {
+        'no_predecessor' => 'First attempt of this batch, so the full suite ran.',
+        'not_a_merge_queue_run' => "This job isn't part of a merge queue run, so the full suite ran.",
+        'stale_run' => 'The batch branch was updated while this job was running, so the full suite ran.',
+        'no_matching_test_session' =>
+          "The previous attempt didn't run this exact set of tests, so the full suite ran.",
+        'matched_test_session_ran_no_test' => 'The previous attempt executed no tests, so the full suite ran.',
+        'predecessor_unknown' => "Mergify couldn't tell which previous run to start from, so the full suite ran.",
+        'indeterminate_test_session' =>
+          "Mergify couldn't tell which previous run to start from, so the full suite ran.",
+        'matched_test_session_partially_processed' =>
+          "Mergify didn't have the complete results of the previous attempt, so the full suite ran.",
+        'matched_test_session_dropped_cases' =>
+          "Mergify didn't have the complete results of the previous attempt, so the full suite ran.",
+        'matched_test_session_declaration_unreadable' =>
+          "Mergify didn't have the complete results of the previous attempt, so the full suite ran.",
+        'matched_test_session_incomplete' =>
+          'The previous attempt stopped before running all of its tests, so the full suite ran.',
+        'matched_test_session_failures_truncated' =>
+          'The previous attempt had too many failures for Mergify to list, so the full suite ran.',
+        'no_collection_fingerprint' =>
+          "This version of #{CLIENT_NAME} doesn't report what it collected, so the full suite ran. " \
+          'Upgrade it to let Mergify reduce reruns.',
+        'feature_disabled' => "Test selection isn't enabled for this organization yet, so the full suite ran.",
+        'not_requested' => "Test selection isn't available for this repository, so the full suite ran.",
+        'unrecognised_selection' =>
+          "Mergify answered in a way this version of #{CLIENT_NAME} doesn't understand, so the full suite " \
+          'ran. Upgrade it to let Mergify reduce reruns.',
+        'subset_served_without_tests' => NOT_APPLIED_SENTENCE,
+        'subset_matched_no_collected_test' => NOT_APPLIED_SENTENCE,
+        'subset_partly_absent_from_collection' => NOT_APPLIED_SENTENCE
+      }.freeze
+
+      # A newer engine may serve a reason this gem predates. The block must
+      # still read as a full run, and must never show the raw identifier.
+      UNKNOWN_REASON_SENTENCE = 'Mergify served the full suite.'
+
+      HEADER = '✂️ Test selection'
+
+      # How many re-executed examples the subset block lists before counting
+      # the rest.
+      LISTED_TESTS_MAX = 10
+
+      # The width the wording was validated at.
+      WRAP_WIDTH = 80
+
+      KNOWN_ANSWERS = %w[full subset empty refused].freeze
+
+      attr_reader :selection, :reason, :tests, :message, :init_error_msg,
+                  :not_applied_reason, :kept_count, :deselected_count, :kept_tests
+
+      class << self
+        # Whether this job asked for test selection. Opt-in and per job: a job
+        # that has not opted in asks nothing, which is what lets Mergify tell
+        # a repository that never opted in from one that did (MRGFY-9172).
+        # Trimmed, and anything unrecognised is off -- the direction that runs
+        # the whole suite.
+        def enabled?
+          Utils::TRUTHY_STRINGS.include?(ENV.fetch(ENABLE_ENV, '').strip.downcase)
+        end
+
+        # What Mergify answered, as the binding hands it over.
+        def served(answer)
+          new(selection: answer['selection'], reason: answer['reason'], tests: answer['tests'] || [],
+              message: answer['message'], served: true)
+        end
+
+        # A run Mergify did not answer: the repository has no such feature, or
+        # the request failed. Both run everything, and neither was offered
+        # anything, so neither is echoed as an answer.
+        def unanswered(init_error_msg: nil)
+          new(selection: 'full', reason: 'not_requested', tests: [], message: nil,
+              served: false, init_error_msg: init_error_msg)
+        end
+      end
+
+      # rubocop:disable-next Metrics/ParameterLists,Metrics/MethodLength
+      def initialize(selection:, reason:, tests:, message:, served:, init_error_msg: nil)
+        @selection = selection
+        @reason = reason
+        @tests = tests
+        @message = message
+        @served = served
+        @init_error_msg = init_error_msg
+        @not_applied_reason = nil
+        @kept_count = nil
+        @deselected_count = 0
+        @kept_tests = []
+
+        # A subset is only honoured with a non-empty list, and an answer this
+        # gem predates is never acted on: both run everything, and say so.
+        if @selection == 'subset'
+          @not_applied_reason = 'subset_served_without_tests' if @tests.empty?
+        else
+          @not_applied_reason = 'unrecognised_selection' unless KNOWN_ANSWERS.include?(@selection)
+          @tests = []
+        end
+      end
+
+      def served?
+        @served
+      end
+
+      def refused?
+        @not_applied_reason.nil? && @selection == 'refused'
+      end
+
+      # Decide what the answer leaves of this collection to run: the ids to
+      # keep, or nil for all of them. Raises `TestSelectionRefused` on a
+      # refusal, carrying the server's explanation.
+      #
+      # Matching is by exact example id, the identity this gem uploads. A
+      # subset is honoured all or not at all: one served id this run did not
+      # collect declines the whole answer and runs everything, rather than a
+      # reduced run over an arbitrary part of what was asked for.
+      # rubocop:disable-next Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+      def resolve(ids)
+        return nil unless @not_applied_reason.nil?
+
+        raise TestSelectionRefused, @message.to_s.empty? ? FALLBACK_REFUSAL_MESSAGE : @message if refused?
+
+        if @selection == 'empty'
+          # A collection already empty is left alone: the run is then empty for
+          # a reason of its own, and announcing a skip over it would mislead.
+          return nil if ids.empty?
+
+          @deselected_count = ids.size
+          return Set.new
+        end
+
+        return nil unless @selection == 'subset'
+
+        subset = @tests.to_set
+        kept = ids.select { |id| subset.include?(id) }
+        matched = kept.to_set
+        # Identities, not counts, so a repeated id can never stand in for a
+        # missing one.
+        if matched != subset
+          @not_applied_reason =
+            matched.empty? ? 'subset_matched_no_collected_test' : 'subset_partly_absent_from_collection'
+          return nil
+        end
+
+        @kept_count = kept.size
+        @deselected_count = ids.size - kept.size
+        @kept_tests = kept
+        subset
+      end
+
+      # The block printed in the gem's "Mergify CI" report: what reduced this
+      # run, whether it was deliberate, and whether its green can be trusted.
+      # Prose, and no identifier from the API ever reaches it.
+      # rubocop:disable-next Metrics/MethodLength
+      def report
+        if @init_error_msg
+          # The error text on its own line: it is what support will ask for,
+          # and it usually carries a URL that wrapping would split.
+          return block("Mergify couldn't be asked whether this run could be reduced, so the full suite ran.") +
+                 "Error: #{@init_error_msg}\n"
+        end
+
+        if refused?
+          # The server's explanation was printed when the run stopped; the
+          # block only says where to look.
+          return block('Mergify stopped this run before any test ran; its explanation is in the error above.')
+        end
+
+        return block(FULL_RUN_SENTENCES.fetch(@not_applied_reason, UNKNOWN_REASON_SENTENCE)) if @not_applied_reason
+        return empty_block if @selection == 'empty'
+        return subset_block if @selection == 'subset' && @kept_count
+
+        block(FULL_RUN_SENTENCES.fetch(@reason, UNKNOWN_REASON_SENTENCE))
+      end
+
+      private
+
+      def empty_block
+        skipped = @deselected_count
+        # Nothing was collected: the block is the title alone, rather than a
+        # paragraph about skipping "all 0 tests".
+        return "#{HEADER}\n" if skipped.zero?
+
+        passed, them =
+          skipped == 1 ? ['its only test passed back then', 'it'] : ["all #{skipped} tests passed back then", 'them']
+        block("The code under test hasn't changed since the previous attempt of this job, and #{passed}. " \
+              "Mergify skipped #{them}: the job is green, and no test was executed.")
+      end
+
+      # rubocop:disable-next Metrics/MethodLength
+      def subset_block
+        failed = @kept_count
+        skipped = @deselected_count
+        sentence =
+          if skipped.zero?
+            which, them =
+              failed == 1 ? ['its only test failed', 'it'] : ["all #{failed} of its tests failed", 'all of them']
+            "The code under test hasn't changed since the previous attempt of this job, where #{which}. " \
+              "Mergify re-executed #{them}:"
+          else
+            those = failed == 1 ? 'that one' : "those #{failed}"
+            "The code under test hasn't changed since the previous attempt of this job, where #{failed} of its " \
+              "#{count_tests(failed + skipped)} failed. Mergify re-executed only #{those} and skipped the " \
+              "#{skipped} that had already passed:"
+          end
+
+        lines = @kept_tests.first(LISTED_TESTS_MAX).map { |id| "  #{id}" }
+        remaining = @kept_tests.size - LISTED_TESTS_MAX
+        lines << "  … and #{remaining} more" if remaining.positive?
+        "#{block(sentence)}\n#{lines.join("\n")}\n"
+      end
+
+      def count_tests(count)
+        count == 1 ? '1 test' : "#{count} tests"
+      end
+
+      def block(text)
+        "#{HEADER}\n\n#{TestSelection.wrap(text)}\n"
+      end
+
+      class << self
+        # Greedy word wrap, the way Python's `textwrap.fill` does it for this
+        # prose: words are never split, and a word longer than the width sits
+        # on a line of its own.
+        def wrap(text, width = WRAP_WIDTH)
+          lines = []
+          text.split.each do |word|
+            if lines.empty? || lines.last.length + 1 + word.length > width
+              lines << word.dup
+            else
+              lines.last << ' ' << word
+            end
+          end
+          lines.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/mergify/rspec/utils.rb

@@ -45,6 +45,13 @@ module Mergify
         env_truthy?('CI') || env_truthy?('RSPEC_MERGIFY_ENABLE')
       end
 
+      # Returns true inside one of the processes parallel_tests or turbo_tests
+      # splits a suite across. Both set TEST_ENV_NUMBER, to an empty string for
+      # parallel_tests' first worker, so it is the key that counts.
+      def parallel_worker?
+        ENV.key?('TEST_ENV_NUMBER')
+      end
+
       # Split "owner/repo" into [owner, repo].
       # Raises InvalidRepositoryFullNameError when the format is wrong.
       def split_full_repo_name(full_repo_name)

data/lib/mergify/rspec/version.rb

@@ -8,6 +8,6 @@ module Mergify
     # which resolved against whatever repository happened to be the working
     # directory at load time -- the monorepo's namespaced tags here, the user's
     # own tags once the gem was installed.
-    VERSION = '0.3.0'
+    VERSION = '0.4.0'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rspec-mergify
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: x86_64-linux
 authors:
 - Mergify
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-09-17 00:00:00.000000000 Z
+date: 2026-10-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec-core
@@ -47,6 +47,8 @@ files:
 - lib/mergify/rspec/native.rb
 - lib/mergify/rspec/quarantine.rb
 - lib/mergify/rspec/resources/rspec.rb
+- lib/mergify/rspec/session_verdict.rb
+- lib/mergify/rspec/test_selection.rb
 - lib/mergify/rspec/trace.rb
 - lib/mergify/rspec/utils.rb
 - lib/mergify/rspec/version.rb