ace-test-runner 0.28.0 → 0.28.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4626e822d15950006f1df84000e1e964163355052b9e4167bcccb963202bbd02
-  data.tar.gz: cd10d616e61501c57556f3227ec5f635ddd34534fc31ee7a7cbe4e1a6667e869
+  metadata.gz: 8fc2c5132ba01f77ad703fc44426139e83ae2f930eb95a3ab26293f237bd13c7
+  data.tar.gz: b998e891eeecc4dd6ff6be3cdfcfb15c5d14a17333b306febecbd1db4dee4532
 SHA512:
-  metadata.gz: 5f6bb28ba6b56c6a84cb1b4dfda1f3d6cea951d204333a31ef8ed8fc57af97494c247e81f907a23ec295fa6f5a4cb517721bbdf6ad01fcf3ba495fdd3e2f461b
-  data.tar.gz: 15d0a4980512f6007f1468525111875826a8a57b5251bcd5fe53455552402b51cb776138c7a0426143c082e0fa0cb20052cf36947aad7d5ed72cd1dd11cbabdd
+  metadata.gz: d70486feda75375aaf8e5057adc1c6b9a10cf2692a7b2b7cd5d337c6375ba53a894c353de62b3178ca33e95460a208b367a9c283256b9ae8ee8127891f18e2bb
+  data.tar.gz: 2545709874b877010ad45bb538d05d03167b0a994a81119503a85c9f8666a13c689a2b971c738d8107d9f312785ec5a329de40718ac796baebb975f13f8421fa

data/.ace-defaults/test-runner/config.yml

@@ -26,6 +26,7 @@ patterns:
   core: "test/{fast/,}core/**/*_test.rb"
   lifecycle: "test/{fast/,}lifecycle/**/*_test.rb"
   edge: "test/{fast/,}edge/**/*_test.rb"
+  fast_tests: "test/fast/**/*_test.rb"
   feat_tests: "test/feat/**/*_test.rb"
 
 # Test targets that combine multiple patterns
@@ -45,6 +46,7 @@ targets:
     - contract
     - core
     - lifecycle
+    - fast_tests
   feat:
     - feat_tests
     - edge

data/CHANGELOG.md

@@ -7,6 +7,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.28.1] - 2026-10-08
+
+### Fixed
+
+- Reject missing explicit Ruby test files before loading tests or running selectors. Preserve exact unambiguous file-line selection.
+
+### Fixed
+
+- Refuse invalid or ambiguous file-line selections and execute exact class/method identities in direct and subprocess modes. Reject mixed whole-file/line selections before loading tests.
+
+- Include uncategorized fast test directories in default fast/all selection without executing overlapping matches twice or widening explicit target overrides.
+- Exclude undispatched groups from sequential execution reports after target fail-fast.
+
 ## [0.28.0] - 2026-10-05
 
 ### Fixed

data/lib/ace/test_runner/atoms/command_builder.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require_relative "line_number_resolver"
+require_relative "../molecules/selection_resolver"
+require "shellwords"
 
 module Ace
   module TestRunner
@@ -13,6 +15,8 @@ module Ace
         end
 
         def build_test_command(files, options = {})
+          selection = options[:selection_plan] || Molecules::SelectionResolver.resolve(Array(files))
+          return exact_selection_command(selection, options) if selection.qualified?
           cmd_parts = []
 
           # Use bundler if available and requested
@@ -29,39 +33,28 @@ module Ace
 
           # Add the test files
           if files.is_a?(Array)
-            # Check if any file has a line number (file:line format)
-            has_line_numbers = files.any? { |f| f.match?(/:\d+$/) }
-
-            if has_line_numbers
-              # For files with line numbers, resolve to test names and filter
-              build_line_number_command(cmd_parts, files, options)
-            else
-              # Build a Ruby script that requires each file and fails on LoadError
-              requires_script = files.map do |f|
-                # Add ./ prefix if it's a relative path without one
-                path = f.start_with?("/", "./") ? f : "./#{f}"
-                # Escape the path for shell safety
-                escaped_path = path.gsub("'", "\\\\'")
-                "begin; require '#{escaped_path}'; rescue LoadError => e; STDERR.puts \\\"Failed to load #{escaped_path}: \\\" + e.message; exit(1); end"
-              end.join("; ")
-
-              # Build the script parts
-              script_parts = []
-              # Inject ARGV with --verbose for Minitest if profile is requested
-              # (Ruby's --verbose flag only sets $VERBOSE, doesn't enable Minitest verbose mode)
-              script_parts << "ARGV.replace(['--verbose'])" if options[:profile]
-              script_parts << requires_script
-              script_parts << "exit_code = Minitest.autorun"
-              script_parts << "exit(exit_code)"
-
-              # Execute the requires and then run Minitest
-              cmd_parts << "-e"
-              # Use double quotes to wrap the entire script
-              cmd_parts << "\"#{script_parts.join("; ")}\""
-            end
-          elsif files.match?(/:\d+$/)
-            # Check if single file has line number
-            build_line_number_command(cmd_parts, [files], options)
+            # Build a Ruby script that requires each file and fails on LoadError
+            requires_script = files.map do |f|
+              # Add ./ prefix if it's a relative path without one
+              path = f.start_with?("/", "./") ? f : "./#{f}"
+              # Escape the path for shell safety
+              escaped_path = path.gsub("'", "\\\\'")
+              "begin; require '#{escaped_path}'; rescue LoadError => e; STDERR.puts \\\"Failed to load #{escaped_path}: \\\" + e.message; exit(1); end"
+            end.join("; ")
+
+            # Build the script parts
+            script_parts = []
+            # Inject ARGV with --verbose for Minitest if profile is requested
+            # (Ruby's --verbose flag only sets $VERBOSE, doesn't enable Minitest verbose mode)
+            script_parts << "ARGV.replace(['--verbose'])" if options[:profile]
+            script_parts << requires_script
+            script_parts << "exit_code = Minitest.autorun"
+            script_parts << "exit(exit_code)"
+
+            # Execute the requires and then run Minitest
+            cmd_parts << "-e"
+            # Use double quotes to wrap the entire script
+            cmd_parts << "\"#{script_parts.join("; ")}\""
           elsif options[:profile]
             # Single file without line number
             cmd_parts << "-e"
@@ -100,60 +93,41 @@ module Ace
 
         private
 
-        def build_line_number_command(cmd_parts, files, options = {})
-          # For files with line numbers, we need to:
-          # 1. Load each file
-          # 2. Resolve line numbers to test names
-          # 3. Filter using --name option
-
-          file_requires = []
-          test_names = []
-
-          files.each do |file_with_line|
-            parsed = LineNumberResolver.parse_file_with_line(file_with_line)
-            file_path = parsed[:file]
-            line_number = parsed[:line]
-
-            # Add ./ prefix if it's a relative path without one
-            path = file_path.start_with?("/", "./") ? file_path : "./#{file_path}"
-            escaped_path = path.gsub("'", "\\\\'")
-
-            # Always require the file
-            file_requires << "require '#{escaped_path}'"
-
-            # If there's a line number, resolve it to a test name
-            if line_number
-              test_name = LineNumberResolver.resolve_test_at_line(file_path, line_number)
-              if test_name
-                test_names << test_name
-              end
+        def exact_selection_command(plan, options)
+          argv = []
+          argv.concat(["bundle", "exec"]) if @bundler && bundler_available?
+          argv.concat(Shellwords.split(@ruby_command))
+          argv << "-Ilib:test" unless options[:no_load_path]
+          model = File.expand_path("../models/test_selection_plan", __dir__)
+          verifier = File.expand_path("../molecules/selection_verifier", __dir__)
+          script = <<~RUBY
+            begin
+              require #{model.inspect}
+              require #{verifier.inspect}
+              plan = Ace::TestRunner::Models::TestSelectionPlan.new(
+                files: #{plan.files.inspect}, identities: #{plan.identities.inspect},
+                source_digests: #{plan.source_digests.inspect})
+              verifier = Ace::TestRunner::Molecules::SelectionVerifier
+              verifier.verify_sources!(plan)
+              require "minitest/autorun"
+              plan.files.each { |file| require file }
+              pattern = verifier.verify_loaded!(plan)
+              args = ["--name", "/" + pattern + "/"]
+              args << "--verbose" if #{!!options[:profile]}
+              Minitest::Reporters.use! Minitest::Reporters::DefaultReporter.new
+              success = verifier.verify_execution!(plan) { Minitest.run(args) }
+              STDOUT.flush
+              STDERR.flush
+              exit!(success ? 0 : 1)
+            rescue Exception => error
+              STDERR.puts(error.message)
+              STDERR.flush
+              exit!(1)
             end
-          end
-
-          # Build the command
-          script_parts = []
-
-          # Require all files
-          script_parts << file_requires.join("; ")
-
-          # Set up ARGV with --name filter and --verbose if needed
-          argv_args = []
-          argv_args << "--verbose" if options[:profile]
-          if test_names.any?
-            # Create a regex pattern that matches any of the test names
-            pattern = test_names.map { |name| Regexp.escape(name) }.join("|")
-            argv_args << "--name"
-            argv_args << "/#{pattern}/"
-          end
-          script_parts << "ARGV.replace([#{argv_args.map { |a| "'#{a}'" }.join(", ")}])" if argv_args.any?
-
-          # Run Minitest
-          script_parts << "exit_code = Minitest.autorun"
-          script_parts << "exit(exit_code)"
-
-          # Add to command
-          cmd_parts << "-e"
-          cmd_parts << "\"#{script_parts.join("; ")}\""
+          RUBY
+          argv.concat(["-e", script])
+          argv.concat(Array(options[:args])) if options[:args]
+          argv
         end
 
         def bundler_available?

data/lib/ace/test_runner/atoms/line_number_resolver.rb

@@ -1,85 +1,92 @@
 # frozen_string_literal: true
 
+require "prism"
+
 module Ace
   module TestRunner
     module Atoms
-      # Resolves line numbers to test method names
       module LineNumberResolver
+        class SelectionError < ArgumentError; end
         module_function
 
-        # Given a file and line number, find the test method name
-        # Returns the test name or nil if not found
-        def resolve_test_at_line(file_path, line_number)
-          return nil unless File.exist?(file_path)
-
-          content = File.read(file_path)
-          lines = content.split("\n")
-
-          # Find all test methods and their line ranges
-          test_methods = extract_test_methods(lines)
-
-          # Find the test that contains the specified line
-          test_methods.find do |test|
-            line_number >= test[:start_line] && line_number <= test[:end_line]
-          end&.fetch(:name)
+        def parse_file_with_line(selector)
+          if (match = /\A(.+\.rb):(.+)\z/.match(selector))
+            unless match[2].match?(/\A[1-9]\d*\z/)
+              raise SelectionError, "Invalid test selector: #{selector}"
+            end
+            {file: match[1], line: Integer(match[2], 10)}
+          else
+            {file: selector, line: nil}
+          end
         end
 
-        # Extract test method names and their line ranges from file content
-        def extract_test_methods(lines)
-          test_methods = []
-          current_test = nil
-
-          lines.each_with_index do |line, index|
-            line_number = index + 1
-
-            # Match test method definitions: def test_something or test "something"
-            if line =~ /^\s*(def\s+(test_\w+)|test\s+["'](.+)["']\s+do)/
-              test_name = $2 || $3 # Either def test_name or test "name"
-
-              # Convert test "name" to test_name format for minitest --name option
-              test_name = test_name.gsub(/\s+/, "_") if test_name && test_name.include?(" ")
-
-              # Close previous test if any
-              if current_test
-                current_test[:end_line] = line_number - 1
-                test_methods << current_test
-              end
-
-              current_test = {
-                name: test_name,
-                start_line: line_number,
-                end_line: lines.size  # Default to end of file
-              }
-            elsif line =~ /^\s*end\s*(#.*)?$/ && current_test
-              # Found an end keyword - could be end of test method
-              # Simple heuristic: if we're at the same or less indentation level, close the test
-              current_indent = line[/^\s*/].length
+        def resolve_test_at_line(file_path, line_number)
+          resolve_identity(file_path, line_number).fetch(:name)
+        end
 
-              if current_indent <= 2 # Assuming test methods are indented at most 2 spaces
-                current_test[:end_line] = line_number
-                test_methods << current_test
-                current_test = nil
-              end
-            end
+        def resolve_identity(file_path, line_number, source: nil)
+          selector = "#{file_path}:#{line_number}"
+          source ||= File.read(file_path)
+          unless line_number.is_a?(Integer) && line_number.positive? && line_number <= source.lines.size
+            raise SelectionError, "Invalid test selector: #{selector}"
           end
+          parsed = Prism.parse(source)
+          raise SelectionError, "Malformed Ruby in test selector: #{selector}" unless parsed.success?
 
-          # Close last test if still open
-          if current_test
-            current_test[:end_line] = lines.size
-            test_methods << current_test
-          end
+          declarations = []
+          scopes = Hash.new(0)
+          collect(parsed.value, [], false, true, declarations, scopes)
+          matches = declarations.select { |entry| (entry[:start_line]..entry[:end_line]).cover?(line_number) }
+          selected = matches.one? && matches.first
+          valid = selected && selected[:supported] && scopes[selected[:class_name]] == 1 &&
+            declarations.count { |entry| entry.values_at(:class_name, :name) == selected.values_at(:class_name, :name) } == 1
+          raise SelectionError, "Unmatched or ambiguous test selector: #{selector}" unless valid
 
-          test_methods
+          selected.reject { |key, _| key == :supported }.merge(file: File.expand_path(file_path)).freeze
+        rescue Errno::ENOENT, Errno::EACCES, Errno::EISDIR => error
+          raise SelectionError, "Cannot read test selector #{selector}: #{error.class}"
         end
 
-        # Given "file.rb:123", split into file and line number
-        def parse_file_with_line(file_with_line)
-          if file_with_line =~ /^(.+):(\d+)$/
-            {file: $1, line: $2.to_i}
+        def collect(node, namespace, in_class, supported, declarations, scopes)
+          return unless node
+          case node
+          when Prism::ProgramNode
+            collect(node.statements, namespace, in_class, supported, declarations, scopes)
+          when Prism::StatementsNode
+            node.body.each { |child| collect(child, namespace, in_class, supported, declarations, scopes) }
+          when Prism::ClassNode, Prism::ModuleNode
+            text = node.constant_path.location.slice
+            static = text.match?(/\A(?:::)?[A-Z]\w*(?:::[A-Z]\w*)*\z/)
+            parts = static ? text.delete_prefix("::").split("::") : []
+            path = text.start_with?("::") ? parts : namespace + parts
+            scopes[path.join("::")] += 1
+            collect(node.body, path, node.is_a?(Prism::ClassNode), supported && static, declarations, scopes)
+          when Prism::DefNode
+            if node.name.to_s.start_with?("test_")
+              add_declaration(node, node.name.to_s, namespace, supported && in_class && node.receiver.nil?,
+                node.def_keyword_loc.start_line, declarations)
+            end
+            # Nested declarations cannot acquire the surrounding static class's identity.
+            collect(node.body, namespace, in_class, false, declarations, scopes)
+          when Prism::CallNode
+            if node.name == :test && node.block.is_a?(Prism::BlockNode)
+              arguments = node.arguments&.arguments || []
+              literal = arguments.one? && arguments.first.is_a?(Prism::StringNode)
+              name = literal ? "test_#{arguments.first.unescaped.gsub(/\s+/, '_')}" : nil
+              static = supported && in_class && node.receiver.nil? && literal && node.block.opening_loc.slice == "do"
+              add_declaration(node, name, namespace, static, node.block.opening_loc.start_line, declarations)
+            end
+            node.compact_child_nodes.each { |child| collect(child, namespace, in_class, false, declarations, scopes) }
           else
-            {file: file_with_line, line: nil}
+            node.compact_child_nodes.each { |child| collect(child, namespace, in_class, false, declarations, scopes) }
           end
         end
+
+        def add_declaration(node, name, namespace, supported, method_line, declarations)
+          declarations << {name: name, class_name: namespace.join("::"), start_line: node.location.start_line,
+            end_line: node.location.end_line, method_line: method_line, supported: supported}
+        end
+        private_class_method :collect, :add_declaration
       end
     end
   end

data/lib/ace/test_runner/atoms/result_parser.rb

@@ -15,7 +15,7 @@ module Ace
           # Pattern for inline errors - same structure as failures but with ERROR marker
           inline_error: /^\s+(test_[\w_]+).*?ERROR.*?\([\d.]+s\)\n(.*?)(?=^\s+test_[\w_]+.*?(?:PASS|FAIL|ERROR|SKIP)|^Finished in|\z)/m,
           location: /\[(.*?):(\d+)\]/,
-          duration: /Finished in ([\d.]+)s/,
+          duration: /Finished(?: tests)? in ([\d.]+)s/,
           deprecation: /DEPRECATION WARNING: (.+)/,
           # Pattern to capture individual test times from verbose output
           # Matches Minitest::Reporters DefaultReporter format:

data/lib/ace/test_runner/cli/commands/test.rb

@@ -90,6 +90,7 @@ module Ace
           # Execution mode options
           option :parallel, type: :boolean, desc: "Run tests in parallel (experimental)"
           option :per_file, type: :boolean, desc: "Execute each test file separately (slower, for debugging)"
+          # File-line selectors resolve exact declarations; mixed whole-file/line input refuses.
           option :direct, type: :boolean, desc: "Force in-process execution (faster, less isolation)"
           option :subprocess, type: :boolean, desc: "Force subprocess execution (slower, full isolation)"
           option :run_in_sequence, type: :boolean, aliases: %w[--ris], desc: "Run test targets sequentially (default)"

data/lib/ace/test_runner/models/test_selection_plan.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Ace
+  module TestRunner
+    module Models
+      class TestSelectionPlan
+        attr_reader :files, :identities, :source_digests
+
+        def initialize(files:, identities:, source_digests:)
+          @files = freeze_values(files)
+          @identities = freeze_values(identities)
+          @source_digests = freeze_values(source_digests)
+          freeze
+        end
+
+        def qualified?
+          !identities.empty?
+        end
+
+        def for_file(file)
+          path = File.expand_path(file.sub(/:\d+$/, ""))
+          self.class.new(files: [path],
+            identities: identities.select { |identity| identity.fetch(:file) == path },
+            source_digests: source_digests.select { |key, _| key == path })
+        end
+
+        private
+
+        def freeze_values(value)
+          case value
+          when Hash
+            value.to_h { |key, entry| [freeze_values(key), freeze_values(entry)] }.freeze
+          when Array
+            value.map { |entry| freeze_values(entry) }.freeze
+          when String
+            value.dup.freeze
+          else
+            value.freeze
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/test_runner/molecules/cli_argument_parser.rb

@@ -38,6 +38,8 @@ module Ace
         #
         # @return [Hash] Parsed options with :package_dir, :target, :files keys
         def parse
+          require_relative "../atoms/line_number_resolver"
+          @argv.each { |argument| Atoms::LineNumberResolver.parse_file_with_line(argument) }
           parse_first_argument
           parse_remaining_arguments
 
@@ -125,6 +127,8 @@ module Ace
               @test_files << arg
             elsif package_relative_ruby_file?(arg)
               @test_files << arg
+            elsif literal_ruby_file?(arg)
+              raise ArgumentError, "File not found: #{arg}"
             elsif known_target?(arg)
               @target = arg
             elsif @target.nil? && !File.exist?(arg)
@@ -210,7 +214,7 @@ module Ace
         # Check if an argument could be a package name (not a target, file, or file:line)
         def potential_package?(arg)
           !known_target?(arg) &&
-            !(arg.end_with?(".rb") && File.file?(arg)) &&
+            !literal_ruby_file?(arg) &&
             !file_with_line?(arg)
         end
 
@@ -236,6 +240,10 @@ module Ace
           @test_files << (@package_dir ? format_file_with_line(file_part, line_part) : arg)
         end
 
+        def literal_ruby_file?(arg)
+          arg.end_with?(".rb") && !arg.match?(/[\*?\[\]{}]/)
+        end
+
         def existing_ruby_file?(arg)
           File.exist?(arg) && arg.end_with?(".rb")
         end

data/lib/ace/test_runner/molecules/in_process_runner.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "stringio"
+require "timeout"
 require "ostruct"
 require "minitest"
 
@@ -62,30 +63,11 @@ module Ace
               require "minitest/autorun"
             end
 
-            # First pass: check for line numbers and resolve test names
-            # This must be done before loading files
-            test_names_to_run = []
-            files_to_load = []
-
-            files.each do |file|
-              # Check if file has line number (file:line format)
-              if file =~ /^(.+):(\d+)$/
-                actual_file = $1
-                line_number = $2.to_i
-
-                # Resolve line number to test name
-                require_relative "../atoms/line_number_resolver"
-                test_name = Ace::TestRunner::Atoms::LineNumberResolver.resolve_test_at_line(actual_file, line_number)
-                test_names_to_run << test_name if test_name
-
-                files_to_load << actual_file
-              else
-                files_to_load << file
-              end
-            end
-
-            # Store test names in options to pass to run_minitest_with_args
-            options = options.merge(test_names_filter: test_names_to_run) if test_names_to_run.any?
+            require_relative "selection_resolver"
+            require_relative "selection_verifier"
+            selection = options[:selection_plan] || SelectionResolver.resolve(files)
+            SelectionVerifier.verify_sources!(selection)
+            files_to_load = selection.files
 
             # Clear previously loaded test classes to avoid accumulation between groups
             # This is crucial for in-process execution where tests from previous groups
@@ -128,14 +110,23 @@ module Ace
               end
             end
 
+            if selection.qualified?
+              options = options.merge(selection_pattern: SelectionVerifier.verify_loaded!(selection))
+            end
+
             # Run Minitest with captured output
             # Suppress Minitest's own output by using null reporter
-            exit_code = if @timeout
-              Timeout.timeout(@timeout, ExecutionTimeout) do
+            execution = lambda do
+              if @timeout
+                Timeout.timeout(@timeout, ExecutionTimeout) { run_minitest_silent(options) }
+              else
                 run_minitest_silent(options)
               end
+            end
+            exit_code = if selection.qualified?
+              SelectionVerifier.verify_execution!(selection, &execution)
             else
-              run_minitest_silent(options)
+              execution.call
             end
 
             success = exit_code == true || exit_code == 0
@@ -242,9 +233,8 @@ module Ace
           args << "--verbose" if options[:verbose]
 
           # Add test name filter if line numbers were provided
-          if options[:test_names_filter] && options[:test_names_filter].any?
-            pattern = options[:test_names_filter].map { |name| Regexp.escape(name) }.join("|")
-            args << "--name" << "/#{pattern}/"
+          if options[:selection_pattern]
+            args << "--name" << "/#{options[:selection_pattern]}/"
           end
 
           # Run Minitest
@@ -261,9 +251,8 @@ module Ace
           args << "--seed" << options[:seed].to_s if options[:seed]
 
           # Add test name filter if line numbers were provided
-          if options[:test_names_filter] && options[:test_names_filter].any?
-            pattern = options[:test_names_filter].map { |name| Regexp.escape(name) }.join("|")
-            args << "--name" << "/#{pattern}/"
+          if options[:selection_pattern]
+            args << "--name" << "/#{options[:selection_pattern]}/"
           end
 
           # Minitest swallows Interrupt and returns a normal failure. Preserve

data/lib/ace/test_runner/molecules/pattern_resolver.rb

@@ -5,7 +5,8 @@ module Ace
     module Molecules
       class PatternResolver
         INTERNAL_PATTERN_LABELS = {
-          "feat_tests" => "feat"
+          "feat_tests" => "feat",
+          "fast_tests" => "fast"
         }.freeze
 
         attr_reader :using_catch_all
@@ -42,7 +43,7 @@ module Ace
           targets.flat_map { |target| resolve_target(target) }.uniq
         end
 
-        def resolve_target_sequential(target_name, seen = [])
+        def resolve_target_sequential(target_name, seen = [], selected = {})
           target_key = target_name.to_s
           if seen.include?(target_key)
             raise ArgumentError, "Cyclic test target definition detected: #{(seen + [target_key]).join(' -> ')}"
@@ -55,12 +56,14 @@ module Ace
             member_key = member.to_s
 
             if @targets.key?(member_key)
-              resolve_target_sequential(member_key, seen + [target_key])
+              resolve_target_sequential(member_key, seen + [target_key], selected)
             elsif @patterns.key?(member_key)
-              files = expand_pattern(@patterns[member_key])
+              files = expand_pattern(@patterns[member_key]).reject { |file| selected.key?(file) }
+              files.each { |file| selected[file] = true }
               files.empty? ? [] : [{name: display_name_for(member_key), files: files}]
             else
-              files = expand_pattern(member)
+              files = expand_pattern(member).reject { |file| selected.key?(file) }
+              files.each { |file| selected[file] = true }
               files.empty? ? [] : [{name: "other", files: files}]
             end
           end

data/lib/ace/test_runner/molecules/selection_resolver.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "digest"
+require_relative "../atoms/line_number_resolver"
+require_relative "../models/test_selection_plan"
+
+module Ace
+  module TestRunner
+    module Molecules
+      module SelectionResolver
+        module_function
+
+        def resolve(files)
+          parsed = Array(files).map { |selector| Atoms::LineNumberResolver.parse_file_with_line(selector) }
+          qualified = parsed.count { |entry| entry[:line] }
+          if qualified.positive? && qualified != parsed.size
+            raise Atoms::LineNumberResolver::SelectionError,
+              "Mixed whole-file and file:line selectors are unsupported: #{files.join(', ')}"
+          end
+          if qualified.zero?
+            return Models::TestSelectionPlan.new(files: Array(files), identities: [], source_digests: {})
+          end
+
+          sources = {}
+          identities = parsed.map do |entry|
+            path = File.expand_path(entry.fetch(:file))
+            source = sources[path] ||= File.read(path)
+            Atoms::LineNumberResolver.resolve_identity(path, entry.fetch(:line), source: source)
+          rescue SystemCallError => error
+            raise Atoms::LineNumberResolver::SelectionError,
+              "Cannot read test selector #{entry[:file]}:#{entry[:line]}: #{error.class}"
+          end
+          identities = identities.uniq { |entry| entry.values_at(:file, :class_name, :name) }
+          identities.group_by { |entry| entry.values_at(:class_name, :name) }.each_value do |matches|
+            next if matches.size == 1
+            selectors = matches.map { |entry| "#{entry[:file]}:#{entry[:start_line]}" }.join(", ")
+            raise Atoms::LineNumberResolver::SelectionError, "Ambiguous test identity across files: #{selectors}"
+          end
+          Models::TestSelectionPlan.new(files: sources.keys, identities: identities,
+            source_digests: sources.transform_values { |source| Digest::SHA256.hexdigest(source) })
+        end
+      end
+    end
+  end
+end

data/lib/ace/test_runner/molecules/selection_verifier.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+require "digest"
+require "minitest/reporters"
+require_relative "../atoms/line_number_resolver"
+
+module Ace
+  module TestRunner
+    module Molecules
+      module SelectionVerifier
+        class ExecutionCollector < Minitest::Reporters::BaseReporter
+          attr_reader :identities
+
+          def initialize
+            super
+            @identities = []
+            @mutex = Mutex.new
+          end
+
+          def record(result)
+            @mutex.synchronize do
+              super
+              @identities << [result.class_name, result.name]
+            end
+          end
+        end
+
+        module_function
+
+        def verify_execution!(plan)
+          previous = Minitest::Reporters.reporters
+          collector = ExecutionCollector.new
+          Minitest::Reporters.reporters = Array(previous) + [collector]
+          result = yield
+          expected = plan.identities.map { |identity| identity.values_at(:class_name, :name) }.sort
+          unless collector.identities.sort == expected
+            raise Atoms::LineNumberResolver::SelectionError,
+              "Executed test identities do not match selected identities"
+          end
+          result
+        ensure
+          Minitest::Reporters.reporters = previous
+        end
+
+        def verify_sources!(plan)
+          plan.source_digests.each do |file, digest|
+            unless Digest::SHA256.file(file).hexdigest == digest
+              raise Atoms::LineNumberResolver::SelectionError, "Selected test source changed: #{file}"
+            end
+          end
+        end
+
+        def verify_loaded!(plan, runnables: Minitest::Runnable.runnables)
+          verify_sources!(plan)
+          # Minitest's default randomized enumeration requires a seed even before run.
+          Minitest.seed ||= Random.new_seed
+          plan.identities.each do |identity|
+            matches = runnables.select { |klass| klass.name == identity.fetch(:class_name) }
+            klass = matches.first
+            valid = matches.size == 1 && klass < Minitest::Test && klass.public_instance_methods.include?(identity.fetch(:name).to_sym)
+            valid &&= klass.runnable_methods.count(identity.fetch(:name)) == 1
+            if valid
+              method = klass.instance_method(identity.fetch(:name))
+              source = method.source_location
+              valid = method.owner == klass && source &&
+                File.expand_path(source.first) == identity.fetch(:file) && source.last == identity.fetch(:method_line)
+            end
+            unless valid
+              raise Atoms::LineNumberResolver::SelectionError,
+                "Selected test identity does not match loaded runnable: #{identity[:class_name]}##{identity[:name]}"
+            end
+          end
+          names = plan.identities.map { |identity| Regexp.escape("#{identity[:class_name]}##{identity[:name]}") }
+          "\\A(?:#{names.join('|')})\\z"
+        end
+      end
+    end
+  end
+end

data/lib/ace/test_runner/molecules/smart_test_executor.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "test_executor"
+require_relative "selection_resolver"
 require_relative "in_process_runner"
 require_relative "../atoms/test_type_detector"
 
@@ -20,6 +21,7 @@ module Ace
           return empty_result if files.empty?
 
           # Determine execution mode
+          options = options.merge(selection_plan: options[:selection_plan] || SelectionResolver.resolve(files))
           mode = determine_execution_mode(files, options)
 
           # Execute with appropriate runner
@@ -31,6 +33,7 @@ module Ace
         end
 
         def execute_single_file(file, options = {})
+          options = options.merge(selection_plan: options[:selection_plan] || SelectionResolver.resolve([file]))
           mode = determine_execution_mode([file], options)
 
           if mode == :direct
@@ -46,6 +49,7 @@ module Ace
         end
 
         def execute_with_progress(files, options = {}, &block)
+          options = options.merge(selection_plan: options[:selection_plan] || SelectionResolver.resolve(files))
           mode = determine_execution_mode(files, options)
 
           # Add mode information to progress callback

data/lib/ace/test_runner/molecules/test_executor.rb

@@ -3,6 +3,7 @@
 require "open3"
 require "timeout"
 require "ostruct"
+require_relative "selection_resolver"
 
 module Ace
   module TestRunner
@@ -39,15 +40,15 @@ module Ace
           # environment (Process.spawn merges onto the parent by default).
           # MT_NO_AUTORUN is part of the fixture environment.
           env = @launch_env
-          command = command.sub(/^MT_NO_AUTORUN=1\s+/, "")
+          command = command.sub(/^MT_NO_AUTORUN=1\s+/, "") if command.is_a?(String)
 
           begin
             if @timeout
               Timeout.timeout(@timeout) do
-                stdout, stderr, status = Open3.capture3(env, command, unsetenv_others: true)
+                stdout, stderr, status = Open3.capture3(env, *Array(command), unsetenv_others: true)
               end
             else
-              stdout, stderr, status = Open3.capture3(env, command, unsetenv_others: true)
+              stdout, stderr, status = Open3.capture3(env, *Array(command), unsetenv_others: true)
             end
           rescue Timeout::Error
             stderr = "Test execution timed out after #{@timeout} seconds"
@@ -69,6 +70,7 @@ module Ace
         end
 
         def execute_with_progress(files, options = {}, &block)
+          options = options.merge(selection_plan: options[:selection_plan] || SelectionResolver.resolve(files))
           # Fail-fast requires per-file execution to stop on first failure
           # For performance, execute all files together unless explicitly disabled or fail-fast enabled
           if options[:per_file] == true || options[:fail_fast]
@@ -93,12 +95,16 @@ module Ace
         end
 
         def execute_per_file_with_progress(files, options = {}, &block)
+          options = options.merge(selection_plan: options[:selection_plan] || SelectionResolver.resolve(files))
           results = []
+          plan = options.fetch(:selection_plan)
+          files = plan.files if plan.qualified?
 
           files.each do |file|
             yield({type: :start, file: file}) if block_given?
 
-            result = execute_single_file(file, options)
+            file_options = plan.qualified? ? options.merge(selection_plan: plan.for_file(file)) : options
+            result = execute_single_file(file, file_options)
             results << result
 
             if block_given?

data/lib/ace/test_runner/organisms/sequential_target_executor.rb

@@ -173,6 +173,7 @@ module Ace
               duration: total_duration,
               test_times: all_test_times
             },
+            files: all_files.uniq,
             stopped_at_target: stopped
           }
         end

data/lib/ace/test_runner/organisms/test_orchestrator.rb

@@ -265,6 +265,9 @@ module Ace
             end
           end
 
+          # Only dispatched targets belong in the execution report after an early stop.
+          all_files = execution_result.fetch(:files)
+
           # Use the parsed result from sequential executor
           @parsed_result = execution_result[:parsed_result]
 

data/lib/ace/test_runner/version.rb

@@ -2,6 +2,6 @@
 
 module Ace
   module TestRunner
-    VERSION = "0.28.0"
+    VERSION = "0.28.1"
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ace-test-runner
 version: !ruby/object:Gem::Version
-  version: 0.28.0
+  version: 0.28.1
 platform: ruby
 authors:
 - Michal Czyz
 bindir: exe
 cert_chain: []
-date: 2026-10-05 00:00:00.000000000 Z
+date: 2026-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ace-support-fs
@@ -121,6 +121,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: prism
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
 - !ruby/object:Gem::Dependency
   name: ostruct
   requirement: !ruby/object:Gem::Requirement
@@ -207,6 +221,7 @@ files:
 - lib/ace/test_runner/models/test_failure.rb
 - lib/ace/test_runner/models/test_report.rb
 - lib/ace/test_runner/models/test_result.rb
+- lib/ace/test_runner/models/test_selection_plan.rb
 - lib/ace/test_runner/models/test_target.rb
 - lib/ace/test_runner/molecules/cli_argument_parser.rb
 - lib/ace/test_runner/molecules/config_loader.rb
@@ -220,6 +235,8 @@ files:
 - lib/ace/test_runner/molecules/pattern_resolver.rb
 - lib/ace/test_runner/molecules/rake_integration.rb
 - lib/ace/test_runner/molecules/report_storage.rb
+- lib/ace/test_runner/molecules/selection_resolver.rb
+- lib/ace/test_runner/molecules/selection_verifier.rb
 - lib/ace/test_runner/molecules/smart_test_executor.rb
 - lib/ace/test_runner/molecules/test_executor.rb
 - lib/ace/test_runner/organisms/agent_reporter.rb