branchproof 0.9.0 → 0.11.0

data/lib/branchproof/rspec_adapter.rb

@@ -0,0 +1,423 @@
+# frozen_string_literal: true
+
+require_relative "records" unless defined?(Branchproof::Records)
+
+module Branchproof
+  # Bridges one serial RSpec run to Runtime lifecycle ownership.
+  class RSpecAdapter
+    # Identifies runner capabilities that cannot produce supported evidence.
+    class UnsupportedRunner < ArgumentError
+      def diagnostic_code = "unsupported_runner"
+    end
+
+    # Restores CLI directory discovery when RSpec runs inside the worker.
+    module DefaultDiscovery
+      def configure(configuration)
+        options[:files_or_directories_to_run] = [options[:default_path] || configuration.default_path].compact
+        super
+      end
+    end
+
+    # Rejects additional class-level runner entry points.
+    module ClassRunnerGuard
+      def run(*args, &)
+        RSpecAdapter.runner_adapter&.reject_execution!("nested or repeated RSpec runs are unsupported")
+        super
+      end
+    end
+
+    # Allows only the worker-owned native runner instance.
+    module RunnerGuard
+      def run(*args, &)
+        RSpecAdapter.runner_adapter&.enter_runner!(self)
+        super
+      end
+    end
+
+    # Assigns observation phases while the reporter owns test registration.
+    module ExampleLifecycle
+      def run(*args, &)
+        adapter = RSpecAdapter.active_adapter
+        return super unless adapter
+
+        adapter.send(:begin_example, self)
+        super
+      ensure
+        adapter&.send(:unattributed)
+      end
+
+      private
+
+      def run_before_example(*args, &)
+        adapter = RSpecAdapter.active_adapter
+        adapter&.send(:begin_attempt, self)
+        result = super
+        adapter&.send(:phase, self, "body")
+        result
+      end
+
+      def run_after_example(*args, &)
+        RSpecAdapter.active_adapter&.send(:phase, self, "teardown")
+        super
+      end
+    end
+
+    # Keeps group-level hooks outside individual example ownership.
+    module ContextLifecycle
+      def run_before_context_hooks(*args, &)
+        adapter = RSpecAdapter.active_adapter
+        return super unless adapter
+
+        adapter.send(:without_owner) { super }
+      end
+
+      def run_after_context_hooks(*args, &)
+        adapter = RSpecAdapter.active_adapter
+        return super unless adapter
+
+        adapter.send(:without_owner) { super }
+      end
+    end
+
+    class << self
+      attr_accessor :active_adapter, :runner_adapter
+    end
+
+    FORBIDDEN_OPTIONS = {
+      dry_run: "dry-run",
+      bisect: "bisect",
+      drb: "DRb",
+      runner: "custom runner"
+    }.freeze
+
+    attr_reader :tests, :late_execution_error
+
+    def initialize(runtime:)
+      @runtime = runtime
+      @tests = {}
+      @example_records = {}.compare_by_identity
+      @file_digests = {}
+      @running = false
+      @completed = false
+      @completion_started = false
+      @registered = false
+      @current_context = nil
+    end
+
+    # rubocop:disable-next Metrics/ParameterLists
+    def run(test_files:, runner_args:, on_complete:, before_load: nil, after_load: nil,
+            test_selection_explicit: false)
+      raise ArgumentError, "test_files must be an Array" unless test_files.is_a?(Array)
+      raise ArgumentError, "runner_args must be an Array" unless runner_args.is_a?(Array)
+      raise ArgumentError, "on_complete must respond to call" unless on_complete.respond_to?(:call)
+      raise UnsupportedRunner, "RSpec adapter cannot run more than once" if @running || @registered
+      raise UnsupportedRunner, "nested RSpec runs are unsupported" if self.class.active_adapter
+      raise UnsupportedRunner, "TEST_ENV_NUMBER is unsupported" if ENV.key?("TEST_ENV_NUMBER")
+
+      require "rspec/core"
+      require "rspec/core/runner"
+      unless Gem::Requirement.new("~> 3.13.0").satisfied_by?(Gem::Version.new(RSpec::Core::Version::STRING))
+        raise UnsupportedRunner, "unsupported RSpec version #{RSpec::Core::Version::STRING}; use 3.13.x"
+      end
+
+      RSpec::Core::Runner.disable_autorun!
+      options = RSpec::Core::ConfigurationOptions.new(runner_args)
+      configured_files = Array(options.options[:files_or_directories_to_run]).map(&:to_s)
+      if test_selection_explicit && configured_files.any?
+        raise ArgumentError, "explicit test selection conflicts with configured RSpec selectors"
+      end
+
+      options.options[:files_or_directories_to_run] = test_files.map(&:to_s) if test_selection_explicit
+      options.singleton_class.prepend(DefaultDiscovery) if !test_selection_explicit && configured_files.empty?
+      reject_options!(options)
+
+      @running = true
+
+      @registered = true
+      @completion_callback = on_complete
+      @unmatched_test_selection = test_selection_explicit && test_files.empty?
+      if @unmatched_test_selection
+        complete(status: 0, finalized: true)
+        return 0
+      end
+      self.class.active_adapter = self
+      self.class.runner_adapter = self
+      install_lifecycle_hooks
+      install_runner_guard
+      runner = RSpec::Core::Runner.new(options)
+      @native_runner = runner
+      adapter = self
+      runner.define_singleton_method(:setup) do |*setup_args|
+        super(*setup_args)
+        return if world.wants_to_quit
+
+        adapter.validate_runner!
+        after_load&.call
+        adapter.send(:install_reporter_listener, configuration.reporter)
+      end
+      before_load&.call
+      status = runner.run($stderr, $stdout)
+      capture_runner_state(runner)
+      complete(status: status, finalized: true)
+      status
+    rescue StandardError => e
+      raise unless @running
+      raise if @completion_started
+
+      @run_error = e
+      capture_runner_state(runner) if runner
+      status = 2
+      complete(status: status, finalized: false)
+      status
+    ensure
+      if self.class.active_adapter.equal?(self)
+        unattributed
+        self.class.active_adapter = nil
+      end
+      @running = false
+    end
+
+    def validate_runner!
+      return nil unless defined?(RSpec.configuration)
+
+      configuration = RSpec.configuration
+      reject_configuration!(configuration)
+      if configuration.respond_to?(:parallelize) && configuration.parallelize
+        raise UnsupportedRunner,
+              "parallel test scheduling is unsupported"
+      end
+
+      nil
+    end
+
+    def example_started(notification)
+      example = notification.example
+      record = test_record(example)
+      record[:status] = "running"
+      register_test(record)
+    end
+
+    def example_finished(notification)
+      example = notification.example
+      record = test_record(example)
+      record[:name] = example.full_description.to_s
+      record[:status] = status_for(example)
+      register_test(record)
+    end
+
+    def reject_execution!(message)
+      @run_error ||= UnsupportedRunner.new(message)
+      @late_execution_error = @run_error if @completion_started
+      raise @run_error
+    end
+
+    def enter_runner!(runner)
+      unless runner.equal?(@native_runner) && !@runner_entered
+        reject_execution!("nested or repeated RSpec runs are unsupported")
+      end
+      @runner_entered = true
+    end
+
+    private
+
+    def capture_runner_state(runner)
+      @selected_test_files = runner.configuration.loaded_spec_files.map { |path| File.expand_path(path.to_s) }
+      @selected_example_ids = runner.world.filtered_examples.values.flatten.map(&:id)
+      @seed = runner.configuration.seed
+      @non_example_failure = runner.world.non_example_failure
+    end
+
+    def reject_options!(options)
+      FORBIDDEN_OPTIONS.each do |key, label|
+        value = options.options[key]
+        next unless value && value != false && value != []
+
+        raise UnsupportedRunner, "#{label} is unsupported"
+      end
+    end
+
+    def reject_configuration!(configuration)
+      if configuration.respond_to?(:dry_run?) && configuration.dry_run?
+        raise UnsupportedRunner,
+              "dry-run is unsupported"
+      end
+      raise UnsupportedRunner, "bisect is unsupported" if configuration.respond_to?(:bisect) && configuration.bisect
+      raise UnsupportedRunner, "DRb is unsupported" if defined?(DRb) && RSpec::Core::Runner.send(:running_in_drb?)
+    end
+
+    def install_reporter_listener(reporter)
+      @defined_example_count = RSpec.world.filtered_examples.keys.sum { |group| group.examples.length }
+      listener = self
+      reporter.register_listener(listener, :example_started, :example_finished)
+    end
+
+    def install_runner_guard
+      return if RSpec::Core::Runner.singleton_class.instance_variable_defined?(:@branchproof_runner_guard)
+
+      RSpec::Core::Runner.singleton_class.prepend(ClassRunnerGuard)
+      RSpec::Core::Runner.prepend(RunnerGuard)
+      RSpec::Core::Runner.singleton_class.instance_variable_set(:@branchproof_runner_guard, true)
+    end
+
+    def install_lifecycle_hooks
+      return if RSpec::Core::Example.instance_variable_defined?(:@branchproof_lifecycle_hooks)
+
+      RSpec::Core::Example.prepend(ExampleLifecycle)
+      RSpec::Core::ExampleGroup.singleton_class.prepend(ContextLifecycle)
+      RSpec::Core::Example.instance_variable_set(:@branchproof_lifecycle_hooks, true)
+    end
+
+    def begin_example(example)
+      validate_runner!
+      seen = (@seen_examples ||= {}.compare_by_identity)
+      reject_execution!("repeated RSpec example attempts are unsupported") if seen[example]
+
+      seen[example] = true
+      phase(example, "setup")
+    rescue ArgumentError => e
+      reject_execution!(e.message)
+    end
+
+    def begin_attempt(example)
+      @attempts ||= {}
+      id = test_id(example)
+      if @attempts[id]
+        @run_error ||= UnsupportedRunner.new("repeated RSpec example attempts are unsupported")
+        raise @run_error
+      end
+      @attempts[id] = true
+    end
+
+    def without_owner
+      previous = @current_context
+      unattributed
+      yield
+    ensure
+      @current_context = previous
+      @runtime.context(test_id: previous&.first, phase: previous&.last || "unattributed")
+    end
+
+    def status_for(example)
+      result = example.execution_result
+      status = result.status&.to_sym
+      return "failed" if (result.respond_to?(:pending_fixed?) && result.pending_fixed?) ||
+                         (example.respond_to?(:pending?) && example.pending? && status == :failed)
+      return "failed" if status == :failed
+      return "skipped" if example.respond_to?(:skipped?) && example.skipped?
+      return "skipped" if status == :pending
+
+      status == :passed ? "passed" : "running"
+    end
+
+    def test_record(example)
+      @example_records[example] ||= begin
+        source = source_for(example)
+        id = Branchproof::Records.id(adapter: "rspec", example_id: example.id.to_s, source: source)
+        @tests[id] = {
+          id: id, adapter: "rspec", name: example.full_description.to_s,
+          example_id: example.id.to_s, class_name: nil, method_name: nil,
+          spec_digest: file_digest(example.id.to_s.sub(/\[[\d:]+\]\z/, "")),
+          source_digest: file_digest(source[:path]),
+          source: source, status: "running", phase_counts: {}
+        }
+      end
+    end
+
+    def test_id(example)
+      test_record(example)[:id]
+    end
+
+    def file_digest(path)
+      expanded = File.expand_path(path)
+      return @file_digests[expanded] if @file_digests.key?(expanded)
+
+      @file_digests[expanded] = File.file?(expanded) ? Digest::SHA256.file(expanded).hexdigest : nil
+    end
+
+    def source_for(example)
+      path = example.metadata[:absolute_file_path] || example.file_path
+      { path: File.expand_path(path.to_s), line: example.metadata[:line_number].to_i }
+    end
+
+    def phase(example, name)
+      id = test_id(example)
+      @current_context = [id, name]
+      @runtime.context(test_id: id, phase: name)
+    end
+
+    def unattributed
+      @current_context = nil
+      @runtime.context(test_id: nil, phase: "unattributed")
+    end
+
+    def register_test(test)
+      @runtime.register_test(test: test)
+    end
+
+    def complete(status:, finalized:)
+      return if @completed || @completion_started
+
+      @completion_started = true
+      apply_canonical_phase_counts
+      tests = @tests.values
+      failed = tests.count { |test| test[:status] == "failed" }
+      skipped = tests.count { |test| test[:status] == "skipped" }
+      diagnostics = completion_diagnostics(status)
+      errored = diagnostics.any? { |diagnostic| diagnostic[:severity] == "error" }
+      result = {
+        status: if errored
+                  "ERROR"
+                elsif tests.empty?
+                  "INCOMPLETE"
+                elsif failed.zero?
+                  "PASSED"
+                else
+                  "FAILED"
+                end,
+        executed_tests: tests.length, failed_tests: failed, skipped_tests: skipped,
+        exit_status: status.to_i, finalized: finalized && !errored, seed: @seed, diagnostics: diagnostics,
+        selected_test_files: @selected_test_files || [], selected_example_ids: @selected_example_ids || [], tests: tests
+      }
+      @completion_callback.call(result)
+      @completed = true
+    end
+
+    def completion_diagnostics(native_status)
+      if @run_error
+        code = if defined?(Branchproof::RailsSupport::Error) && @run_error.is_a?(Branchproof::RailsSupport::Error)
+                 "rails_boot"
+               elsif @run_error.respond_to?(:diagnostic_code)
+                 @run_error.diagnostic_code
+               else
+                 "rspec_run"
+               end
+        return [{ code: code, severity: "error", message: "#{@run_error.class}: #{@run_error.message}" }]
+      end
+      if @non_example_failure || @tests.values.any? { |test| test[:status] == "running" } ||
+         (native_status.to_i != 0 && @tests.values.none? { |test| test[:status] == "failed" })
+        return [{ code: "rspec_run", severity: "error",
+                  message: "RSpec failed outside examples; see runner output" }]
+      end
+
+      return [] unless @tests.empty?
+
+      code, message = if @unmatched_test_selection
+                        ["unmatched_test_selection", "No files matched --test; check the path or glob"]
+                      elsif @defined_example_count.to_i.positive?
+                        ["empty_example_selection",
+                         "RSpec filters selected zero examples; check tags, descriptions, and selectors"]
+                      else
+                        ["empty_suite", "RSpec discovered no examples; check the default path and configured patterns"]
+                      end
+      [{ code: code, severity: "warning", message: message }]
+    end
+
+    def apply_canonical_phase_counts
+      canonical_by_id = @runtime.test_phase_counts
+      @tests.each do |id, test|
+        counts = canonical_by_id[id]
+        test[:phase_counts] = counts unless counts.nil?
+      end
+    end
+  end
+end

data/lib/branchproof/runtime.rb

@@ -107,6 +107,10 @@ module Branchproof
         nil
       end
 
+      def test_phase_counts
+        @evidence.test_phase_counts
+      end
+
       def snapshot
         if @evidence.respond_to?(:snapshot)
           result = @evidence.snapshot

data/lib/branchproof/saved_report.rb

@@ -7,13 +7,14 @@
 require "json"
 # rubocop:disable-next Lint/RedundantRequireStatement -- supports standalone core entry
 require "set"
+require_relative "coverage_policy"
 require_relative "decision_table"
 
 module Branchproof
   # Reads and validates a persisted JSON report without loading the project.
   class SavedReport
-    SUPPORTED_SCHEMAS = %w[1.0 1.1 1.2 1.3].freeze
-    STRICT_FLOW_SCHEMAS = %w[1.2 1.3].freeze
+    SUPPORTED_SCHEMAS = %w[1.0 1.1 1.2 1.3 1.4].freeze
+    STRICT_FLOW_SCHEMAS = %w[1.2 1.3 1.4].freeze
     DECISION_TABLE_STATUSES = %w[calculated not_calculated].freeze
     RULE_CONDITION_VALUES = DecisionTable::CONDITION_VALUES
     RULE_COVERAGE_STATUSES = DecisionTable::COVERAGE_STATUSES
@@ -60,6 +61,7 @@ module Branchproof
       validate_completeness(@document["completeness"])
       validate_completeness(@document.dig("observations", "completeness"))
       validate_completeness(@document.dig("analysis", "completeness")) if @document["analysis"]
+      validate_coverage_policy
       validate_optional_sections
       validate_analysis_coverage
       @document
@@ -218,7 +220,9 @@ module Branchproof
           fail_with("nonboolean condition results must be empty") unless results.empty?
           validate_nonboolean_analysis(decision, inventory_decision)
         elsif decision.key?("decision_table")
-          fail_with("decision tables are unsupported in legacy report schemas") unless @schema_version == "1.3"
+          unless %w[1.3 1.4].include?(@schema_version)
+            fail_with("decision tables are unsupported in legacy report schemas")
+          end
           validate_decision_table(decision["decision_table"], inventory_decision)
         end
         seen_conditions = {}
@@ -626,6 +630,28 @@ module Branchproof
       fail_with("document contains non-string object keys") unless all_hashes_have_string_keys?(@document)
     end
 
+    def validate_coverage_policy
+      policy = @document["coverage_policy"]
+      fail_with("missing field: coverage_policy") if @schema_version == "1.4" && !policy
+      return if policy.nil?
+
+      fail_with("coverage_policy must be an object") unless hash_with_string_keys?(policy)
+      minimum = policy["minimum"]
+      fail_with("coverage_policy minimum must be an object") unless hash_with_string_keys?(minimum)
+      normalized = CoveragePolicy.normalize(minimum)
+      fail_with("coverage_policy status must be a string") unless policy["status"].is_a?(String)
+      fail_with("coverage_policy gates must be an array") unless policy["gates"].is_a?(Array)
+      expected = CoveragePolicy.new(minimum: normalized).call(
+        document: { baseline: @document["baseline"], completeness: @document["completeness"],
+                    observations: @document["observations"], analysis: @document["analysis"] }
+      )
+      actual = JSON.parse(JSON.generate(policy))
+      expected = JSON.parse(JSON.generate(expected))
+      fail_with("coverage_policy does not match report coverage") unless actual == expected
+    rescue ArgumentError => e
+      fail_with(e.message.sub(/\Ainvalid saved report: /, ""))
+    end
+
     def validate_phases(vector)
       phases = vector["phases_by_test"]
       return if phases.nil?
@@ -638,7 +664,9 @@ module Branchproof
     end
 
     def validate_test(test)
-      %w[name class_name method_name source_path].each { |field| validate_string_field(test, field, nullable: true) }
+      %w[adapter name class_name method_name source_path example_id].each do |field|
+        validate_string_field(test, field, nullable: true)
+      end
       validate_integer_field(test, "line", nullable: true)
       phase_counts = test["phase_counts"]
       if phase_counts
@@ -726,7 +754,12 @@ module Branchproof
       string_fields.each do |field|
         fail_with("run_metadata #{field} must be a string") if metadata.key?(field) && !metadata[field].is_a?(String)
       end
-      array_fields = %w[source_patterns test_patterns test_files runner_args]
+      nullable_string_fields = %w[framework framework_version rspec_rails_version rails_version]
+      nullable_string_fields.each do |field|
+        fail_with("run_metadata #{field} must be a string") if metadata.key?(field) &&
+                                                               !metadata[field].nil? && !metadata[field].is_a?(String)
+      end
+      array_fields = %w[source_patterns test_patterns test_files runner_args selected_test_files selected_example_ids]
       array_fields.each do |field|
         if metadata.key?(field) && !strings?(metadata[field])
           fail_with("run_metadata #{field} must be an array of strings")

data/lib/branchproof/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Branchproof
-  VERSION = "0.9.0"
+  VERSION = "0.11.0"
 end

data/lib/branchproof/worker.rb

@@ -8,19 +8,18 @@ require "stringio"
 require "fileutils"
 
 module Branchproof
-  # Runs one isolated Minitest worker and atomically exports its result.
+  # Runs one isolated test worker and atomically exports its result.
   module Worker
     module_function
 
     def child_process(config_path)
+      $stdout.sync = true
+      $stderr.sync = true
       payload = JSON.parse(File.binread(config_path))
       project = symbolize(payload.fetch("project"))
       prepend_load_paths(project)
       inventory = symbolize(payload.fetch("inventory"))
       limits = symbolize(payload.fetch("limits"))
-      require "minitest"
-      require "minitest/test"
-      require_relative "minitest_adapter"
       evidence = Branchproof::Evidence.new(inventory: inventory, limits: limits, run_id: payload.fetch("run_id"))
       runtime = Branchproof::Runtime
       runtime.boot(evidence: evidence)
@@ -28,23 +27,38 @@ module Branchproof
       status = loader.install
       return write_failure(payload, "loader", status) unless status[:status].to_sym == :installed
 
-      adapter = Branchproof::MinitestAdapter.new(runtime: runtime)
+      adapter = adapter_for(project, runtime)
+      guard_late_rspec_execution(adapter, payload) if project[:framework].to_s == "rspec"
       rails_metadata = nil
       ARGV.replace(payload.fetch("runner_args"))
-      adapter.run(test_files: payload.fetch("test_files"), runner_args: payload.fetch("runner_args"),
-                  before_load: lambda {
-                    rails_metadata = boot_project(project)
-                  }, on_complete: lambda { |baseline|
-                    result = completion_result(baseline: baseline, project: project, rails_metadata: rails_metadata,
-                                               evidence: runtime.snapshot, tests: adapter.tests.values,
-                                               diagnostics: loader.diagnostics)
-                    write_completion(payload, result)
-                  })
+      callbacks = if project[:framework].to_s == "rspec"
+                    { test_selection_explicit: payload.fetch("test_selection_explicit", false), after_load: lambda {
+                      require_relative "rails_support"
+                      rails_metadata = Branchproof::RailsSupport.validate_rspec!(project: project)
+                    } }
+                  else
+                    {}
+                  end
+      before_load = lambda do
+        rails_metadata = boot_project(project) unless project[:framework].to_s == "rspec"
+      end
+      on_complete = lambda do |baseline|
+        result = completion_result(baseline: baseline, project: project, rails_metadata: rails_metadata,
+                                   evidence: runtime.snapshot, tests: adapter.tests.values,
+                                   diagnostics: loader.diagnostics)
+        write_completion(payload, result)
+      end
+      exit_status = adapter.run(test_files: payload.fetch("test_files"), runner_args: payload.fetch("runner_args"),
+                                before_load: before_load, on_complete: on_complete, **callbacks)
+      return exit_status if project[:framework].to_s == "rspec"
+
       adapter.validate_runner!
       Minitest.autorun
       nil
     rescue StandardError => e
-      code = if e.message.include?("parallel")
+      code = if e.respond_to?(:diagnostic_code)
+               e.diagnostic_code
+             elsif e.message.match?(/parallel|runner|bisect|DRb|dry.run/)
                "unsupported_runner"
              elsif defined?(Branchproof::RailsSupport::Error) && e.is_a?(Branchproof::RailsSupport::Error)
                "rails_boot"
@@ -55,6 +69,44 @@ module Branchproof
       2
     end
 
+    def adapter_for(project, runtime)
+      if project[:framework].to_s == "rspec"
+        begin
+          require "rspec/core"
+        rescue LoadError => e
+          raise unless e.path == "rspec/core"
+
+          error = ArgumentError.new("RSpec is not available; add rspec to the application's test bundle")
+          def error.diagnostic_code = "rspec_missing"
+          raise error
+        end
+        require_relative "rspec_adapter"
+        Branchproof::RSpecAdapter.new(runtime: runtime)
+      else
+        require "minitest"
+        require "minitest/test"
+        require_relative "minitest_adapter"
+        Branchproof::MinitestAdapter.new(runtime: runtime)
+      end
+    end
+
+    # Installed before application hooks, so this runs after their at_exit work.
+    # A rescued second runner must still invalidate the already-exported result.
+    def guard_late_rspec_execution(adapter, payload)
+      at_exit do
+        error = adapter.late_execution_error
+        if error
+          result = symbolize(JSON.parse(File.binread(payload.fetch("result_path"))))
+          diagnostic = { code: "unsupported_runner", severity: "error", message: error.message }
+          result.merge!(status: "ERROR", finalized: false, exit_status: 2,
+                        diagnostics: Array(result[:diagnostics]) + [diagnostic])
+          result[:evidence] = incomplete_evidence(result[:evidence], [diagnostic]) if result[:evidence]
+          write_completion(payload, result)
+          exit(2)
+        end
+      end
+    end
+
     def legacy_project
       { "kind" => "ruby", "root" => Dir.pwd,
         "load_paths" => [File.join(Dir.pwd, "lib"), File.join(Dir.pwd, "test")],
@@ -76,7 +128,14 @@ module Branchproof
     end
 
     def project_metadata(project, rails_metadata)
+      framework = project[:framework].to_s.empty? ? "minitest" : project[:framework].to_s
+      version = if framework == "rspec" && defined?(RSpec::Core::Version::STRING)
+                  RSpec::Core::Version::STRING
+                elsif framework == "minitest" && defined?(Minitest::VERSION)
+                  Minitest::VERSION
+                end
       metadata = { kind: project[:kind].to_s, root: project[:root].to_s,
+                   framework: framework, framework_version: version,
                    load_paths: Array(project[:load_paths]).map(&:to_s), serial_policy: { mode: "single_process", workers: 1 } }
       metadata.merge!(rails_metadata) if rails_metadata
       metadata
@@ -85,6 +144,7 @@ module Branchproof
     # This result boundary intentionally carries the complete worker payload.
     # rubocop:disable-next Metrics/ParameterLists
     def completion_result(baseline:, project:, rails_metadata:, evidence:, tests:, diagnostics:)
+      diagnostics = Array(baseline[:diagnostics]) + diagnostics
       result = baseline.merge(project: project_metadata(project, rails_metadata), evidence: evidence,
                               tests: tests, diagnostics: diagnostics)
       return result unless diagnostics.any? { |diagnostic| diagnostic[:severity].to_s == "error" }

data/lib/branchproof.rb

@@ -9,11 +9,15 @@ require_relative "branchproof/project"
 # Public namespace for source inventory and one-run MC/DC reporting.
 module Branchproof
   class Error < StandardError; end
+  autoload :Configuration, "branchproof/configuration"
+  autoload :CoveragePolicy, "branchproof/coverage_policy"
+  autoload :ReportSelection, "branchproof/report_selection"
   autoload :CLI, "branchproof/cli"
   autoload :Instrumenter, "branchproof/instrumenter"
   autoload :Loader, "branchproof/loader"
   autoload :Runtime, "branchproof/runtime"
   autoload :MinitestAdapter, "branchproof/minitest_adapter"
+  autoload :RSpecAdapter, "branchproof/rspec_adapter"
   autoload :Evidence, "branchproof/evidence"
   autoload :Analyzer, "branchproof/analyzer"
   autoload :Constraints, "branchproof/constraints"