coatepec 0.6.0 → 0.8.0

data/lib/coatepec/mcp/tools.rb

@@ -2,67 +2,73 @@
 
 module Coatepec
   module MCP
-    # The `rails_spec_run` MCP tool: runs targeted RSpec examples against
-    # the warm test worker and returns a structured pass/fail result.
+    # The `rails_spec_run` MCP tool: runs targeted RSpec examples or Minitest
+    # tests (chosen from the selector paths) against the warm test worker and
+    # returns a structured pass/fail result.
     class SpecRunTool < ::MCP::Tool
-      tool_name "rails_spec_run"
-      description "Run targeted RSpec examples against a warm, isolated Rails test worker"
-      annotations(read_only_hint: false, destructive_hint: true, idempotent_hint: false, open_world_hint: true)
-      input_schema(
+      INPUT_SCHEMA = {
         properties: {
           paths: { type: "array", items: { type: "string" }, minItems: 1, maxItems: 100 },
           example: { type: %w[string null] },
           seed: { type: %w[integer null], minimum: 0, maximum: 65_535 },
           fail_fast: { type: "boolean" },
-          timeout_seconds: { type: "integer", minimum: 1, maximum: 900 }
+          timeout_seconds: { type: "integer", minimum: 1, maximum: 900 },
+          include_passing: { type: "boolean" },
+          include_stdout: { type: "string", enum: %w[failures always never] }
         },
         required: ["paths"],
         additionalProperties: false
-      )
+      }.freeze
+
+      # Kept a constant so the vocabulary clause stays readable next to the rest of the description.
+      RSPEC_VOCABULARY =
+        "; results use RSpec vocabulary for both frameworks: a Minitest error is status failed and is " \
+        "counted in summary.failure_count (so it can exceed the failures number Minitest prints in " \
+        "stdout; summary.error_count says how many of those were errors) and a skip is pending" \
+        "; summary.assertion_count is Minitest's assertion total, null for RSpec, as is error_count"
+
+      tool_name "rails_spec_run"
+      description "Run targeted RSpec examples (spec/**/*_spec.rb) or Minitest tests (test/**/*_test.rb) " \
+                  "against a warm, isolated Rails test worker; the framework is chosen from the selector " \
+                  "paths; there is no separate Minitest tool#{RSPEC_VOCABULARY}" \
+                  "; returns only failed and pending examples unless include_passing is true" \
+                  "; failure blocks in stdout that repeat an earlier error are rolled up into one line" \
+                  "; stdout is returned only for failing runs unless include_stdout is \"always\" or \"never\""
+      annotations(read_only_hint: false, destructive_hint: true, idempotent_hint: false, open_world_hint: true)
+      input_schema(**INPUT_SCHEMA)
 
       class << self
-        # rubocop:disable Metrics/ParameterLists -- mirrors the tool's own input_schema
-        # (paths/example/seed/fail_fast/timeout_seconds) plus the MCP-framework-injected
-        # server_context; splitting it would fight the ::MCP::Tool#call contract.
-        def call(paths:, server_context:, example: nil, seed: nil, fail_fast: false, timeout_seconds: 120)
-          # rubocop:enable Metrics/ParameterLists
+        def call(paths:, server_context:, example: nil, seed: nil, fail_fast: false, timeout_seconds: 120,
+                 include_passing: false, include_stdout: "failures")
           started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
           data = server_context[:worker_manager].run_spec(
-            paths: paths, example: example, seed: seed, fail_fast: fail_fast, timeout_seconds: timeout_seconds
+            paths: paths, example: example, seed: seed, fail_fast: fail_fast, timeout_seconds: timeout_seconds,
+            include_passing: include_passing, include_stdout: include_stdout
           )
-          Response.ok(data: data, meta: meta_for(server_context, started_at))
+          Response.ok(data: data, meta: Response.meta(started_at))
         rescue Coatepec::Error => e
           Response.error(e)
         end
-
-        private
-
-        def meta_for(server_context, started_at)
-          duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at) * 1000).round
-          { project_root: server_context[:project_root], environment: "test", duration_ms: duration_ms }
-        end
       end
     end
 
-    # The `rails_runtime_status` MCP tool: reports the test worker's Ruby/Rails
-    # versions, PID, boot_id, and lifecycle state. Worker::Server#handle boots
-    # the Rails runtime before dispatching any command, so the first call to
-    # this tool starts (and blocks on) a full Rails boot just like a spec run.
+    # The `rails_runtime_status` MCP tool: reports the test worker's
+    # Ruby/Rails versions, PID, boot_id, lifecycle state and the project
+    # root. Worker::Server#handle boots the Rails runtime before dispatching
+    # any command, so the first call to this tool starts (and blocks on) a
+    # full Rails boot just like a spec run.
     class RuntimeStatusTool < ::MCP::Tool
       tool_name "rails_runtime_status"
       description "Report the Coatepec test worker's identity and boot status " \
-                  "(boots the warm worker if it is not up yet)"
+                  "(boots the warm worker if it is not up yet); includes the project root as project_root"
       annotations(read_only_hint: true, destructive_hint: false, idempotent_hint: true, open_world_hint: false)
       input_schema(properties: {}, required: [], additionalProperties: false)
 
       class << self
         def call(server_context:)
           started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          data = server_context[:worker_manager].status
-          duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at) * 1000).round
-          Response.ok(data: data,
-                      meta: { project_root: server_context[:project_root], environment: "test",
-                              duration_ms: duration_ms })
+          data = server_context[:worker_manager].status.merge(project_root: server_context[:project_root])
+          Response.ok(data: data, meta: Response.meta(started_at))
         rescue Coatepec::Error => e
           Response.error(e)
         end
@@ -84,27 +90,20 @@ module Coatepec
         def call(server_context:)
           started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
           data = server_context[:worker_manager].restart!
-          duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at) * 1000).round
-          Response.ok(data: data,
-                      meta: { project_root: server_context[:project_root], environment: "test",
-                              duration_ms: duration_ms })
+          Response.ok(data: data, meta: Response.meta(started_at))
         rescue Coatepec::Error => e
           Response.error(e)
         end
       end
     end
 
-    # The `rails_spec_flaky_check` MCP tool: runs targeted RSpec examples
-    # multiple times with independently random seeds and reports which
-    # examples' pass/fail status was inconsistent across rounds. Separate
-    # tool from rails_spec_run for the same reason rails_spec_profile is --
-    # see docs/superpowers/specs/2026-08-13-flaky-spec-detection-design.md.
+    # The `rails_spec_flaky_check` MCP tool: runs targeted RSpec examples or
+    # Minitest tests multiple times with independently random seeds and
+    # reports which tests' pass/fail status was inconsistent across rounds.
+    # Separate tool from rails_spec_run for the same reason rails_spec_profile
+    # is -- see docs/superpowers/specs/2026-08-13-flaky-spec-detection-design.md.
     class FlakyCheckTool < ::MCP::Tool
-      tool_name "rails_spec_flaky_check"
-      description "Run targeted RSpec examples multiple times with random seeds to detect order-dependent or " \
-                  "intermittent flakiness, reporting which examples' status was inconsistent across runs"
-      annotations(read_only_hint: false, destructive_hint: true, idempotent_hint: false, open_world_hint: true)
-      input_schema(
+      INPUT_SCHEMA = {
         properties: {
           paths: { type: "array", items: { type: "string" }, minItems: 1, maxItems: 100 },
           example: { type: %w[string null] },
@@ -113,7 +112,14 @@ module Coatepec
         },
         required: ["paths"],
         additionalProperties: false
-      )
+      }.freeze
+
+      tool_name "rails_spec_flaky_check"
+      description "Run targeted RSpec examples or Minitest tests multiple times with random seeds to detect " \
+                  "order-dependent or intermittent flakiness, reporting which tests' status was inconsistent " \
+                  "across runs; the framework is chosen from the selector paths"
+      annotations(read_only_hint: false, destructive_hint: true, idempotent_hint: false, open_world_hint: true)
+      input_schema(**INPUT_SCHEMA)
 
       class << self
         def call(paths:, server_context:, example: nil, timeout_seconds: 120, runs: 5)
@@ -121,17 +127,10 @@ module Coatepec
           data = server_context[:worker_manager].check_flaky(
             paths: paths, example: example, timeout_seconds: timeout_seconds, runs: runs
           )
-          Response.ok(data: data, meta: meta_for(server_context, started_at))
+          Response.ok(data: data, meta: Response.meta(started_at))
         rescue Coatepec::Error => e
           Response.error(e)
         end
-
-        private
-
-        def meta_for(server_context, started_at)
-          duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at) * 1000).round
-          { project_root: server_context[:project_root], environment: "test", duration_ms: duration_ms }
-        end
       end
     end
 
@@ -139,65 +138,94 @@ module Coatepec
     # Rails app's routes.
     class RoutesTool < ::MCP::Tool
       tool_name "rails_routes"
-      description "Return a bounded, filterable list of the Rails app's routes"
+      description "Return a bounded, filterable list of the Rails app's routes, application routes only by " \
+                  "default: mounted-engine routes (for example admin scaffolding) are withheld and the response's " \
+                  "engines_excluded says how many routes matching the query the engines filter held back " \
+                  "(application routes, under \"only\"); pass " \
+                  "engines: \"include\" to list both or \"only\" for engine routes alone. Engine routes are " \
+                  "expanded one level deep, carry the mount point in their path, and name their engine in the " \
+                  "engine field (null for an application route; query also matches that field); returns columns " \
+                  "(name, verb, path, controller, action, engine) and up to limit rows (default 100) in that " \
+                  "order, paths without the (.:format) suffix Rails appends, with next_offset -- the offset to " \
+                  "pass back for the next page, null on the last one"
       annotations(read_only_hint: true, destructive_hint: false, idempotent_hint: true, open_world_hint: false)
       input_schema(
         properties: {
           query: { type: %w[string null] },
           limit: { type: "integer", minimum: 1, maximum: 200 },
-          offset: { type: "integer", minimum: 0 }
+          offset: { type: "integer", minimum: 0 },
+          engines: { type: "string", enum: %w[include exclude only] }
         },
         required: [],
         additionalProperties: false
       )
 
       class << self
-        def call(server_context:, query: nil, limit: 50, offset: 0)
+        def call(server_context:, query: nil, limit: 100, offset: 0, engines: Introspection::Routes::DEFAULT_ENGINES)
           started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          data = server_context[:worker_manager].routes(query: query, limit: limit, offset: offset)
-          Response.ok(data: data, meta: meta_for(server_context, started_at))
+          data = server_context[:worker_manager].routes(query: query, limit: limit, offset: offset, engines: engines)
+          Response.ok(data: data, meta: Response.meta(started_at))
         rescue Coatepec::Error => e
           Response.error(e)
         end
-
-        private
-
-        def meta_for(server_context, started_at)
-          duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at) * 1000).round
-          { project_root: server_context[:project_root], environment: "test", duration_ms: duration_ms }
-        end
       end
     end
 
-    # The `rails_model` MCP tool: returns an ActiveRecord model's schema,
-    # associations, validators, and enums.
+    # The `rails_model` MCP tool: returns an ActiveRecord model's table
+    # metadata and list counts, plus any lists named in fields.
     class ModelTool < ::MCP::Tool
       tool_name "rails_model"
-      description "Return bounded ActiveRecord schema, associations, validators, and enums for a model, " \
-                  "without row data"
+      description "Return an ActiveRecord model's name, table, primary key, abstract_class and counts by default " \
+                  "(the size of its columns, associations, validators and enums lists, each capped at 200), without " \
+                  "row data; pass fields (any of columns, associations, validators, enums) to include those lists -- " \
+                  "an omitted or empty fields returns no lists, only counts; validators are de-duplicated by class, " \
+                  "attributes and options, so the list holds distinct validators and can be shorter than " \
+                  "klass.validators; an array-valued validator option longer than 20 entries keeps its first 20 with " \
+                  "<option>_count and <option>_truncated beside it"
       annotations(read_only_hint: true, destructive_hint: false, idempotent_hint: true, open_world_hint: false)
       input_schema(
         properties: {
-          name: { type: "string", pattern: '^[A-Z]\w*(?:::[A-Z]\w*)*$' }
+          name: { type: "string", pattern: '^[A-Z]\w*(?:::[A-Z]\w*)*$' },
+          fields: { type: "array", items: { type: "string", enum: %w[columns associations validators enums] },
+                    uniqueItems: true }
         },
         required: ["name"],
         additionalProperties: false
       )
 
       class << self
-        def call(name:, server_context:)
+        def call(name:, server_context:, fields: nil)
           started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          data = server_context[:worker_manager].model(name: name)
-          Response.ok(data: data, meta: meta_for(server_context, started_at))
+          data = server_context[:worker_manager].model(name: name, fields: fields)
+          Response.ok(data: data, meta: Response.meta(started_at))
         rescue Coatepec::Error => e
           Response.error(e)
         end
+      end
+    end
 
-        private
+    # The `rails_controller` MCP tool: returns a controller's actions, action
+    # callbacks, included concerns, and the routes reaching each action.
+    class ControllerTool < ::MCP::Tool
+      tool_name "rails_controller"
+      description "Return a Rails controller's actions, action callbacks, concerns, and the routes " \
+                  "reaching each action, including unroutable actions and routes with no matching action"
+      annotations(read_only_hint: true, destructive_hint: false, idempotent_hint: true, open_world_hint: false)
+      input_schema(
+        properties: {
+          name: { type: "string", pattern: '^[A-Z]\w*(?:::[A-Z]\w*)*$' }
+        },
+        required: ["name"],
+        additionalProperties: false
+      )
 
-        def meta_for(server_context, started_at)
-          duration_ms = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at) * 1000).round
-          { project_root: server_context[:project_root], environment: "test", duration_ms: duration_ms }
+      class << self
+        def call(name:, server_context:)
+          started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          data = server_context[:worker_manager].controller(name: name)
+          Response.ok(data: data, meta: Response.meta(started_at))
+        rescue Coatepec::Error => e
+          Response.error(e)
         end
       end
     end

data/lib/coatepec/mcp.rb

@@ -13,14 +13,15 @@ require_relative "mcp/tools"
 
 module Coatepec
   # Wires the `rails_spec_run`, `rails_runtime_status`, `rails_runtime_restart`,
-  # `rails_spec_flaky_check`, `rails_routes`, and `rails_model` tools into an
-  # `::MCP::Server` instance backed by the given project's worker manager.
+  # `rails_spec_flaky_check`, `rails_routes`, `rails_model`, and `rails_controller`
+  # tools into an `::MCP::Server` instance backed by the given project's worker manager.
   module MCP
     def self.build_server(project:, worker_manager:)
       ::MCP::Server.new(
         name: "coatepec",
         version: Coatepec::VERSION,
-        tools: [SpecRunTool, RuntimeStatusTool, RuntimeRestartTool, FlakyCheckTool, RoutesTool, ModelTool],
+        tools: [SpecRunTool, RuntimeStatusTool, RuntimeRestartTool, FlakyCheckTool,
+                RoutesTool, ModelTool, ControllerTool],
         server_context: { worker_manager: worker_manager, project_root: project.root }
       )
     end

data/lib/coatepec/project.rb

@@ -2,7 +2,8 @@
 
 module Coatepec
   # A Rails application checkout rooted at an absolute path (must contain a
-  # Gemfile); knows where its own and pack/engine/gem spec directories live.
+  # Gemfile); knows where its own and pack/engine/gem spec and test
+  # directories live.
   class Project
     attr_reader :root
 
@@ -23,6 +24,15 @@ module Coatepec
       ].select { |path| File.directory?(path) }
     end
 
+    def test_root_candidates
+      [
+        File.join(root, "test"),
+        *Dir.glob(File.join(root, "packs/*/test")),
+        *Dir.glob(File.join(root, "engines/*/test")),
+        *Dir.glob(File.join(root, "gems/*/test"))
+      ].select { |path| File.directory?(path) }
+    end
+
     def config
       @config ||= ProjectConfig.new(root)
     end

data/lib/coatepec/spec/failure_collapser.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Coatepec
+  module Spec
+    # Collapses failure blocks that repeat one error verbatim (a broken layout erroring every controller
+    # test, say) into the first block plus a roll-up line naming the other tests. Unrecognised text is kept.
+    module FailureCollapser
+      MINITEST_START = /\A(?:Error|Failure):\z/
+      MINITEST_ID = /\A(\S+#\S+?)(?: \[[^\]]*\])?:\z/
+      MINITEST_END = /\A\S*\brails test \S+:\d+\z/
+      RSPEC_START = /\A  \d+\) (.+)\z/
+      RSPEC_END = /\A(?:  \d+\) |Finished in |Failed examples:)/
+      # Backtrace frames and RSpec's "Failure/Error: <source line>" differ per test; the error text is what must match.
+      IGNORED = %r{\A\s+(?:# )?\S+:\d+(?::in .*)?\z|\A\s+Failure/Error: }
+
+      module_function
+
+      def call(text)
+        # read_bounded's tail byteslice can sever a multibyte character, and matching a regexp on that raises.
+        return text unless text.valid_encoding?
+
+        lines = text.lines
+        blocks = minitest_blocks(lines)
+        blocks = rspec_blocks(lines) if blocks.empty?
+        return text if blocks.size < 2
+
+        rewrite(lines, blocks)
+      end
+
+      # A block runs from the Error:/Failure: line through Rails' "bin/rails test path:LINE" rerun line.
+      def minitest_blocks(lines)
+        blocks = []
+        i = 0
+        while i < lines.size
+          id, stop = minitest_block_end(lines, i)
+          blocks << block(i, stop, id, lines[(i + 2)...stop]) if stop
+          i = (stop || i) + 1
+        end
+        blocks
+      end
+
+      def minitest_block_end(lines, index)
+        id = lines[index].chomp.match?(MINITEST_START) && lines[index + 1]&.chomp&.[](MINITEST_ID, 1)
+        return [nil, nil] unless id
+
+        [id, ((index + 2)...lines.size).find { |j| lines[j].chomp.match?(MINITEST_END) }]
+      end
+
+      # A block runs from "  N) description" (after the Failures: heading only) to the next such line or the summary.
+      def rspec_blocks(lines)
+        rspec_starts(lines).map do |i|
+          last = rspec_block_end(lines, i)
+          block(i, last, lines[i].chomp[RSPEC_START, 1], lines[(i + 1)..last])
+        end
+      end
+
+      # Only the numbered entries under the Failures: heading, never RSpec's Pending: section.
+      def rspec_starts(lines)
+        failures_at = lines.index { |line| line.chomp == "Failures:" }
+        return [] unless failures_at
+
+        ((failures_at + 1)...lines.size).select { |i| lines[i].chomp.match?(RSPEC_START) }
+      end
+
+      # Stops before the next failure or the summary, then backs over the blank lines in between.
+      def rspec_block_end(lines, start)
+        stop = ((start + 1)...lines.size).find { |j| lines[j].chomp.match?(RSPEC_END) } || lines.size
+        stop -= 1 while stop > start + 1 && lines[stop - 1].strip.empty?
+        stop - 1
+      end
+
+      def block(first, last, id, body)
+        key = body.map(&:chomp).reject { |line| line.strip.empty? || line.match?(IGNORED) }
+        { first: first, last: last, id: id, key: key }
+      end
+
+      def rewrite(lines, blocks)
+        skipped = {}
+        notes = {}
+        blocks.group_by { |b| b[:key] }.each_value do |kept, *dropped|
+          next if dropped.empty?
+
+          dropped.each { |b| skip_block(lines, b, skipped) }
+          notes[kept[:last]] = note_for(dropped)
+        end
+        render(lines, skipped, notes)
+      end
+
+      def render(lines, skipped, notes)
+        lines.each_with_index.reject { |_, j| skipped[j] }.map { |line, j| attach_note(line, notes[j]) }.join
+      end
+
+      # The blank line that separates the dropped block from the next one goes with it.
+      def skip_block(lines, dropped, skipped)
+        (dropped[:first]..dropped[:last]).each { |j| skipped[j] = true }
+        skipped[dropped[:last] + 1] = true if lines[dropped[:last] + 1]&.strip&.empty?
+      end
+
+      def note_for(dropped)
+        noun = dropped.size == 1 ? "test" : "tests"
+        "#{dropped.size} more #{noun} failed with this same error: #{dropped.map { |b| b[:id] }.join(", ")}"
+      end
+
+      def attach_note(line, note)
+        return line unless note
+
+        "#{line.chomp}\n#{note}\n"
+      end
+    end
+  end
+end

data/lib/coatepec/spec/flaky_checker.rb

@@ -44,9 +44,11 @@ module Coatepec
 
       def run_one_round(paths, example, timeout_seconds)
         seed = SecureRandom.random_number(65_536)
+        # Every round needs the full roster: a pass in one round is what makes a later failure flaky.
+        # stdout is never read from a round, so it is not captured into the result.
         result = @runner.run(
           paths: paths, example: example, seed: seed, fail_fast: false,
-          timeout_seconds: timeout_seconds
+          timeout_seconds: timeout_seconds, include_passing: true, include_stdout: "never"
         )
         { seed: seed, status: result[:status], examples: result[:examples] }
       end

data/lib/coatepec/spec/fork_strategy.rb

@@ -2,29 +2,20 @@
 
 module Coatepec
   module Spec
-    # Runs RSpec in a `Process.fork`ed child (Linux only): cheap and reuses
+    # Runs the test framework in a `Process.fork`ed child (Linux only): cheap and reuses
     # the warm worker's loaded Rails boot, but isolated from the parent's
     # ActiveRecord connections and global state.
     class ForkStrategy < ProcessStrategy
       private
 
-      def start(full_args, out_w, err_w)
+      def start(full_args, out_w, err_w, json_path)
         Process.fork do
           Process.setpgid(0, 0)
           redirect_output(out_w, err_w)
           # Forked children must not share the parent's live DB sockets.
           ActiveRecord::Base.connection_handler.clear_all_connections! if defined?(ActiveRecord::Base)
-          # RSpec freezes its own "load started at" timestamp once, at the moment
-          # rspec/core.rb is first required -- in this architecture, that's when
-          # the long-lived warm worker booted, not when THIS run started. Every
-          # forked child inherits that frozen timestamp via copy-on-write, so
-          # RSpec's own "(files took N seconds to load)" reporting would
-          # otherwise measure "time since the worker booted" and grow across
-          # every run for as long as the worker stays warm. Reset it fresh
-          # before each run.
-          RSpec.configuration.start_time = RSpec::Core::Time.now
 
-          status = RSpec::Core::Runner.run(full_args, $stderr, $stdout)
+          status = @adapter.run_in_process(full_args, json_path)
           $stdout.flush
           $stderr.flush
           Kernel.exit!(status)

data/lib/coatepec/spec/guarded_fork_strategy.rb

@@ -36,13 +36,14 @@ module Coatepec
       # along with a whole second result inside MCP::Response's 1 MiB cap.
       MAX_CRASH_STDERR_BYTES = 4 * 1024
 
-      def initialize(project_root, project: nil, rails_runtime: nil)
+      def initialize(project_root, adapter: nil, project: nil, rails_runtime: nil)
         super
-        @spawn_strategy = SpawnStrategy.new(project_root)
+        @spawn_strategy = SpawnStrategy.new(project_root, adapter: @adapter)
       end
 
-      def run(args, timeout_seconds)
-        return fallback_result(args, timeout_seconds, "spawn_fallback") unless guard_passes?
+      def run(args, timeout_seconds, include_passing: false, include_stdout: "failures")
+        result_options = { include_passing: include_passing, include_stdout: include_stdout }
+        return fallback_result(args, timeout_seconds, "spawn_fallback", result_options) unless guard_passes?
 
         started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         begin
@@ -53,20 +54,20 @@ module Coatepec
           # caller's side that is indistinguishable from a failed guard, hence
           # the same mode. Opting into macos_fork must never surface an error
           # that plain SpawnStrategy wouldn't have.
-          return fallback_result(args, timeout_seconds, "spawn_fallback")
+          return fallback_result(args, timeout_seconds, "spawn_fallback", result_options)
         end
         return result.merge(execution_mode: "fork") unless crashed?(result)
 
-        retry_after_crash(args, timeout_seconds, started_at, result)
+        retry_after_crash(args, timeout_seconds, started_at, result, result_options)
       end
 
       private
 
-      def retry_after_crash(args, timeout_seconds, started_at, crashed)
+      def retry_after_crash(args, timeout_seconds, started_at, crashed, result_options)
         elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at
         remaining = [timeout_seconds - elapsed, MIN_RETRY_TIMEOUT_SECONDS].max
 
-        fallback_result(args, remaining, "spawn_after_crash")
+        fallback_result(args, remaining, "spawn_after_crash", result_options)
           .merge(crashed_fork_stderr: crash_diagnostics(crashed))
       end
 
@@ -79,8 +80,8 @@ module Coatepec
         text.byteslice(-MAX_CRASH_STDERR_BYTES, MAX_CRASH_STDERR_BYTES)
       end
 
-      def fallback_result(args, timeout_seconds, mode)
-        @spawn_strategy.run(args, timeout_seconds).merge(execution_mode: mode)
+      def fallback_result(args, timeout_seconds, mode, result_options)
+        @spawn_strategy.run(args, timeout_seconds, **result_options).merge(execution_mode: mode)
       end
 
       def guard_passes?

data/lib/coatepec/spec/path_policy.rb

@@ -3,23 +3,32 @@
 module Coatepec
   module Spec
     # Validates rails_spec_run's `paths` selectors against the allowed spec
-    # roots before any RSpec process is started, rejecting absolute paths,
-    # `..` traversal, symlink escapes, non-`_spec.rb` files, and oversized
-    # selector lists.
+    # and test roots before any test process is started, rejecting absolute
+    # paths, `..` traversal, symlink escapes, files that are neither
+    # `_spec.rb` under a spec root nor `_test.rb` under a test root, and
+    # oversized selector lists. Also classifies the whole list as RSpec or
+    # Minitest from the selectors' shape: a list may not mix the two.
     class PathPolicy
       MAX_SELECTORS = 100
 
+      KINDS = {
+        rspec: { roots: :spec_root_candidates, suffix: "_spec.rb" },
+        minitest: { roots: :test_root_candidates, suffix: "_test.rb" }
+      }.freeze
+
       def initialize(project)
         @project = project
       end
 
+      # Returns { selectors: [...], framework: :rspec | :minitest }.
       def validate!(selectors)
         raise Coatepec::Error.new(:invalid_spec_path, "No spec paths given") if selectors.nil? || selectors.empty?
         if selectors.size > MAX_SELECTORS
           raise Coatepec::Error.new(:invalid_spec_path, "At most #{MAX_SELECTORS} spec paths are allowed")
         end
 
-        selectors.map { |selector| validate_one(selector) }
+        classified = selectors.map { |selector| validate_one(selector) }
+        { selectors: classified.map { |c| c[:selector] }, framework: single_framework!(classified) }
       end
 
       private
@@ -31,9 +40,24 @@ module Coatepec
 
         real_path = resolve_real_path!(selector, path_part)
         reject_escape!(selector, real_path)
-        reject_wrong_kind!(selector, real_path)
+        framework = framework_for!(selector, real_path)
+
+        { selector: line_part ? "#{path_part}:#{line_part}" : path_part, framework: framework }
+      end
+
+      def single_framework!(classified)
+        frameworks = classified.map { |c| c[:framework] }.uniq
+        return frameworks.first if frameworks.size == 1
 
-        line_part ? "#{path_part}:#{line_part}" : path_part
+        raise Coatepec::Error.new(:mixed_test_frameworks, mixed_frameworks_message(classified))
+      end
+
+      # Names the minority selectors: the ones an agent most likely added by
+      # mistake to an otherwise single-framework call.
+      def mixed_frameworks_message(classified)
+        majority = classified.group_by { |c| c[:framework] }.max_by { |_, list| list.size }.first
+        odd = classified.reject { |c| c[:framework] == majority }.map { |c| c[:selector] }
+        "A single call may not mix RSpec and Minitest selectors; these do not match the others: #{odd.join(", ")}"
       end
 
       def resolve_real_path!(selector, path_part)
@@ -74,15 +98,24 @@ module Coatepec
         raise Coatepec::Error.new(:invalid_spec_path, "Spec path escapes the project root: #{selector}")
       end
 
-      def reject_wrong_kind!(selector, real_path)
-        return if under_allowed_root?(real_path) && (File.directory?(real_path) || real_path.end_with?("_spec.rb"))
+      # A directory under a root is that root's kind; a file must also carry
+      # the kind's suffix. The two root sets never overlap (spec/ vs test/),
+      # so the iteration order does not matter.
+      def framework_for!(selector, real_path)
+        KINDS.each do |framework, kind|
+          next unless under_any_root?(real_path, @project.public_send(kind[:roots]))
+          return framework if File.directory?(real_path) || real_path.end_with?(kind[:suffix])
+        end
 
-        raise Coatepec::Error.new(:invalid_spec_path,
-                                  "Spec path is not an allowed spec root or _spec.rb file: #{selector}")
+        raise Coatepec::Error.new(
+          :invalid_spec_path,
+          "Spec path is not an allowed spec/test root, a _spec.rb file under spec/, " \
+          "or a _test.rb file under test/: #{selector}"
+        )
       end
 
-      def under_allowed_root?(real_path)
-        @project.spec_root_candidates.any? do |candidate|
+      def under_any_root?(real_path, roots)
+        roots.any? do |candidate|
           real_candidate = File.realpath(candidate)
           real_path == real_candidate || real_path.start_with?("#{real_candidate}/")
         end