ace-test-runner 0.27.0 → 0.28.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 737b47ec80d9081b78036ca433c88b8a98ce7c7fbcb42dc44317c9143130745c
-  data.tar.gz: f572472d8569456a2a5296c70daa674125c72dfc2a9a19ad1753cb47712e96eb
+  metadata.gz: 4626e822d15950006f1df84000e1e964163355052b9e4167bcccb963202bbd02
+  data.tar.gz: cd10d616e61501c57556f3227ec5f635ddd34534fc31ee7a7cbe4e1a6667e869
 SHA512:
-  metadata.gz: bba645e19d66f65b131a4c13ad0b7674c461797a8b88157d3e38a4ca4d768c32ffa32baadc1eb120d27eefb67f625bb73bc5b21e422eb41e381399cd3a1cb9c3
-  data.tar.gz: fa9ba7f05016bac56e7d99daab178b1550603c48e1f2454cbe7fb5f37ce4c72c25b9973efafff370ab2ab0d1fd65527f9af0a3bc5183ed016a8b01c22c497bc4
+  metadata.gz: 5f6bb28ba6b56c6a84cb1b4dfda1f3d6cea951d204333a31ef8ed8fc57af97494c247e81f907a23ec295fa6f5a4cb517721bbdf6ad01fcf3ba495fdd3e2f461b
+  data.tar.gz: 15d0a4980512f6007f1468525111875826a8a57b5251bcd5fe53455552402b51cb776138c7a0426143c082e0fa0cb20052cf36947aad7d5ed72cd1dd11cbabdd

data/CHANGELOG.md

@@ -7,6 +7,25 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.28.0] - 2026-10-05
+
+### Fixed
+
+- Honor explicit `ace-test-suite --config FILE` without merging the default cascade, and refuse unreadable or malformed selected files. Default namespace discovery remains unchanged.
+
+- Bind suite verdicts, counts and report links to each exact child invocation; preserve duplicate entries and no-save completion evidence during concurrent runs.
+
+- Preserve unsuccessful execution through target aggregation and saved/CLI verdicts even after passing partial output; distinguish operator interruption from completed test errors.
+
+### Changed
+
+- Declare the required direct dependencies and minimum producer versions for this coordinated release: `ace-support-fs ~> 0.3`.
+
+## [0.27.1] - 2026-09-29
+
+### Fixed
+- Suite children now launch with the suite's own Ruby binary plus `-rbundler/setup`, so bundler discovers the checkout Gemfile by walking up from each package directory. This gives hermetic children a deterministic source-of-truth dependency surface instead of silently relying on PATH-resolved interpreters (which can fail through manager shims under fixture HOME/XDG overrides) or on globally installed ace gems. Closes the runner-level workspace LOAD_PATH follow-up from the hermetic-tests line.
+
 ## [0.27.0] - 2026-09-28
 
 ### Added

data/exe/ace-test-suite

@@ -7,7 +7,7 @@ require "ace/test_runner"
 require "ace/test_runner/suite"
 
 options = {
-  config: ".ace/test/suite.yml",
+  config: nil,
   parallel: nil,
   group: nil,
   verbose: false,
@@ -87,11 +87,20 @@ rescue OptionParser::InvalidArgument => e
   exit 1
 end
 
-# Load the config using namespace method
-config = Ace::Core.get("test", file: "suite")
+# Explicit files replace the cascade; omitting --config keeps namespace discovery.
+begin
+  config = if options[:config]
+    Ace::Support::Config::Molecules::YamlLoader.load_file(options[:config]).data
+  else
+    Ace::Core.get("test", file: "suite")
+  end
+rescue Ace::Support::Config::Error, Psych::Exception => e
+  puts "Error: Configuration file #{options[:config] || '.ace/test/suite.yml'}: #{e.message}"
+  exit 1
+end
 
 unless config.is_a?(Hash) && config["test_suite"].is_a?(Hash)
-  puts "Error: Configuration file not found: .ace/test/suite.yml"
+  puts "Error: Invalid or missing test suite configuration: #{options[:config] || '.ace/test/suite.yml'}"
   puts
   puts "Create a test suite configuration at .ace/test/suite.yml in your project root"
   puts

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

@@ -221,10 +221,8 @@ module Ace
             config_data = config_loader.load(options[:config_path])
             config = config_loader.merge_with_options(config_data, options)
 
-            timestamp_generator = Atoms::TimestampGenerator.new
             storage = Molecules::ReportStorage.new(
-              base_dir: config[:defaults][:report_dir] || ".ace-local/test/reports",
-              timestamp_generator: timestamp_generator
+              base_dir: config[:defaults][:report_dir] || ".ace-local/test/reports"
             )
 
             keep = options[:cleanup_keep] || 10

data/lib/ace/test_runner/formatters/json_formatter.rb

@@ -53,7 +53,9 @@ module Ace
               assertions: result.assertions,
               duration: result.duration,
               pass_rate: result.pass_rate,
-              success: result.success?
+              success: result.success?,
+              execution_success: result.execution_success,
+              execution_error: result.execution_error
             },
             timing: {
               start_time: result.start_time&.iso8601,

data/lib/ace/test_runner/formatters/progress_file_formatter.rb

@@ -24,8 +24,8 @@ module Ace
           # Report directory - use actual report path if available
           if @report_path
             lines << "Details: #{@report_path}/"
-          elsif @configuration && @configuration[:save_reports]
-            lines << "Details: #{@configuration[:report_dir] || ".ace-local/test/reports"}/latest/"
+          else
+            lines << "No saved report"
           end
 
           # Compact single-line summary with emoji status
@@ -42,7 +42,9 @@ module Ace
           lines << summary
 
           # Add failure details if there are any
-          if result.has_failures?
+          lines << "Execution failed: #{result.execution_error}" unless result.execution_success
+
+          if result.failed > 0 || result.errors > 0
             lines << ""
             total_failures = result.failed + result.errors
 
@@ -51,8 +53,8 @@ module Ace
 
             # Show failure count header with reference to full report if needed
             if total_failures > @max_failures_to_display
-              report_path = @report_path || "#{@configuration[:report_dir] || ".ace-local/test/reports"}/latest"
-              lines << "FAILURES (#{failures_to_show.size}/#{total_failures}) → #{report_path}/failures.json:"
+              reference = @report_path ? "→ #{@report_path}/failures.json" : "(no saved report)"
+              lines << "FAILURES (#{failures_to_show.size}/#{total_failures}) #{reference}:"
             else
               lines << "FAILURES (#{total_failures}):"
             end
@@ -87,8 +89,9 @@ module Ace
             # If there are more failures than displayed
             if result.failures_detail.size > @max_failures_to_display
               remaining = result.failures_detail.size - @max_failures_to_display
-              report_path = @report_path || "#{@configuration[:report_dir] || ".ace-local/test/reports"}/latest"
-              lines << "  ... and #{remaining} more #{(remaining == 1) ? "failure" : "failures"}. See full report: #{report_path}/failures.json"
+              reference = @report_path ? "See full report: #{@report_path}/failures.json" : "No saved report"
+              noun = remaining == 1 ? "failure" : "failures"
+              lines << "  ... and #{remaining} more #{noun}. #{reference}"
             end
           end
 

data/lib/ace/test_runner/formatters/progress_formatter.rb

@@ -29,8 +29,8 @@ module Ace
           # Report directory - use actual report path if available
           if @report_path
             lines << "Details: #{@report_path}/"
-          elsif @configuration && @configuration[:save_reports]
-            lines << "Details: #{@configuration[:report_dir] || ".ace-local/test/reports"}/latest/"
+          else
+            lines << "No saved report"
           end
 
           # Compact single-line summary with emoji status
@@ -43,7 +43,9 @@ module Ace
           lines << summary
 
           # Add failure details if there are any
-          if result.has_failures?
+          lines << "Execution failed: #{result.execution_error}" unless result.execution_success
+
+          if result.failed > 0 || result.errors > 0
             lines << ""
             total_failures = result.failed + result.errors
 
@@ -64,8 +66,8 @@ module Ace
 
             # Show failure count header with reference to full report if needed
             if total_failures > @max_failures_to_display
-              report_path = @report_path || "#{@configuration[:report_dir] || ".ace-local/test/reports"}/latest"
-              lines << "#{label} (#{failures_to_show.size}/#{total_failures}) → #{report_path}/failures.json:"
+              reference = @report_path ? "→ #{@report_path}/failures.json" : "(no saved report)"
+              lines << "#{label} (#{failures_to_show.size}/#{total_failures}) #{reference}:"
             else
               lines << "#{label} (#{total_failures}):"
             end
@@ -100,8 +102,9 @@ module Ace
             # If there are more failures than displayed
             if result.failures_detail.size > @max_failures_to_display
               remaining = result.failures_detail.size - @max_failures_to_display
-              report_path = @report_path || "#{@configuration[:report_dir] || ".ace-local/test/reports"}/latest"
-              lines << "  ... and #{remaining} more #{(remaining == 1) ? "failure" : "failures"}. See full report: #{report_path}/failures.json"
+              reference = @report_path ? "See full report: #{@report_path}/failures.json" : "No saved report"
+              noun = remaining == 1 ? "failure" : "failures"
+              lines << "  ... and #{remaining} more #{noun}. #{reference}"
             end
           end
 

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

@@ -76,6 +76,7 @@ module Ace
           lines << ""
           lines << "**Generated:** #{timestamp.strftime("%Y-%m-%d %H:%M:%S")}"
           lines << "**Status:** #{success? ? "✅ Success" : "❌ Failed"}"
+          lines << "**Execution failure:** #{result.execution_error}" unless result.execution_success
           lines << ""
 
           lines << "## Summary"

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

@@ -7,7 +7,7 @@ module Ace
       class TestResult
         attr_accessor :passed, :failed, :skipped, :errors, :assertions,
           :duration, :start_time, :end_time, :failures_detail,
-          :deprecations, :raw_output, :stderr
+          :deprecations, :raw_output, :stderr, :execution_success
 
         def initialize(attributes = {})
           @passed = attributes[:passed] || 0
@@ -22,6 +22,7 @@ module Ace
           @deprecations = attributes[:deprecations] || []
           @raw_output = attributes[:raw_output] || ""
           @stderr = attributes[:stderr] || ""
+          @execution_success = attributes.fetch(:execution_success, true) == true
         end
 
         def total_tests
@@ -29,11 +30,16 @@ module Ace
         end
 
         def success?
-          failed == 0 && errors == 0
+          execution_success && failed == 0 && errors == 0
         end
 
         def has_failures?
-          failed > 0 || errors > 0
+          !success?
+        end
+
+        def execution_error
+          return nil if execution_success
+          stderr.to_s.strip.empty? ? "Test execution did not complete successfully" : stderr.to_s.strip
         end
 
         def has_skips?
@@ -55,6 +61,7 @@ module Ace
           parts << "❌ #{failed} failed" if failed > 0
           parts << "💥 #{errors} errors" if errors > 0
           parts << "⚠️ #{skipped} skipped" if skipped > 0
+          parts << "❌ execution failed" unless execution_success
 
           parts.empty? ? "No tests executed" : parts.join(", ")
         end
@@ -70,6 +77,8 @@ module Ace
             duration: duration,
             pass_rate: pass_rate,
             success: success?,
+            execution_success: execution_success,
+            execution_error: execution_error,
             start_time: start_time&.iso8601,
             end_time: end_time&.iso8601,
             failures: failures_detail.map(&:to_h),

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "json"
+require "fileutils"
+
+module Ace
+  module TestRunner
+    module Molecules
+      # The completion file is published last, after the optional report is complete.
+      # A suite reads this exact file once; latest is only a navigation convenience.
+      class ExecutionEvidence
+        CHANNEL = "ACE_TEST_EXECUTION"
+        COUNTS = %w[total passed failed errors skipped assertions].freeze
+        attr_reader :identity, :path, :package, :entry_id, :package_path
+
+        def initialize(package_path:, package: nil, entry_id: nil, identity: SecureRandom.uuid, path: nil)
+          @identity = identity
+          @package_path = File.realpath(package_path)
+          @package = package || File.basename(@package_path)
+          @entry_id = entry_id || identity
+          @path = path || File.join(@package_path, ".ace-local/test/completions", "#{identity}.json")
+        end
+
+        def self.for_invocation(package_path)
+          channel = ENV[CHANNEL]
+          return new(package_path: package_path) unless channel
+
+          data = JSON.parse(channel, symbolize_names: true)
+          raise Error, "Execution package path mismatch" unless File.realpath(package_path) == data[:package_path]
+
+          new(**data)
+        end
+
+        def channel
+          JSON.generate(identity: identity, path: path, package: package, entry_id: entry_id, package_path: package_path)
+        end
+
+        def publish(result, files:, report_dir: nil)
+          data = {
+            execution_id: identity, entry_id: entry_id, package: package, package_path: package_path,
+            pid: Process.pid, completed: true, selected_files: files, report_dir: report_dir,
+            total: result.total_tests, passed: result.passed, failed: result.failed, errors: result.errors,
+            skipped: result.skipped, assertions: result.assertions, duration: result.duration,
+            success: result.success?, error: result.execution_error
+          }
+          FileUtils.mkdir_p(File.dirname(path))
+          temporary = "#{path}.#{SecureRandom.uuid}.tmp"
+          File.write(temporary, JSON.generate(data))
+          # Exclusive publication: a completed invocation may never be replaced.
+          File.link(temporary, path)
+          data
+        ensure
+          FileUtils.rm_f(temporary) if temporary
+        end
+
+        def read(pid:, save_reports:)
+          data = JSON.parse(File.read(path))
+          valid = data.is_a?(Hash) && data["completed"] == true &&
+            data["execution_id"] == identity && data["entry_id"] == entry_id &&
+            data["package"] == package && data["package_path"] == package_path && data["pid"] == pid &&
+            data["selected_files"].is_a?(Array) && data["selected_files"].all? { |file| file.is_a?(String) } &&
+            COUNTS.all? { |key| data[key].is_a?(Integer) && data[key] >= 0 } &&
+            [true, false].include?(data["success"]) && data["duration"].is_a?(Numeric) &&
+            data["duration"].finite? && data["duration"] >= 0 &&
+            data["total"] == data.values_at("passed", "failed", "errors", "skipped").sum &&
+            (!data["success"] || data["failed"] + data["errors"] == 0) &&
+            (!data["selected_files"].empty? || data["total"] == 0) &&
+            (!data["success"] || data["total"] > 0 || data["selected_files"].empty?)
+          raise Error, "Invalid or mismatched execution completion evidence" unless valid
+
+          if save_reports
+            validate_report!(data)
+          elsif data["report_dir"]
+            raise Error, "Unexpected saved report in no-save execution"
+          end
+          data.transform_keys(&:to_sym)
+        rescue SystemCallError, JSON::ParserError, TypeError => e
+          raise Error, "Unverifiable execution completion evidence: #{e.message}"
+        end
+
+        private
+
+        def validate_report!(data)
+          directory = data["report_dir"]
+          raise Error, "Missing concrete execution report directory" unless directory.is_a?(String) &&
+            File.absolute_path(directory) == directory && File.basename(directory) == identity && !File.symlink?(directory)
+
+          summary = JSON.parse(File.read(File.join(directory, "summary.json")))
+          report = JSON.parse(File.read(File.join(directory, "report.json")))
+          raise Error, "Mismatched execution summary/report" unless summary.is_a?(Hash) && report.is_a?(Hash) &&
+            summary["execution_id"] == identity && report.dig("metadata", "execution_id") == identity &&
+            report["report_path"] == directory && report["files_tested"] == data["selected_files"] &&
+            report.dig("result", "total_tests") == data["total"] &&
+            COUNTS.all? { |key| summary[key] == data[key] } && summary["success"] == data["success"] &&
+            summary["duration"] == data["duration"] &&
+            %w[passed failed errors skipped assertions duration success].all? { |key| report.dig("result", key) == data[key] }
+        end
+      end
+    end
+  end
+end

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

@@ -10,79 +10,18 @@ module Ace
         module_function
 
         def format_for_display(package)
-          path = extract_path(package)
-          report_root = extract_report_root(package)
-          package_name = extract_name(package) || File.basename(path)
-          report_path = Atoms::ReportPathResolver.call(
-            path,
-            report_root: report_root,
-            package_name: package_name
-          )
-
-          if report_path
-            begin
-              relative_path = Pathname.new(report_path).relative_path_from(Dir.pwd)
-              "    → See #{relative_path}"
-            rescue => e
-              warn "Failed to calculate relative path: #{e.message}" if debug_mode?
-              "    → See #{report_path}"
-            end
-          else
-            reports_path = fallback_reports_path(path, report_root, package_name)
-            begin
-              relative_path = Pathname.new(reports_path).relative_path_from(Dir.pwd)
-              "    → Check #{relative_path}/ for details"
-            rescue => e
-              warn "Failed to calculate relative path: #{e.message}" if debug_mode?
-              "    → Check #{reports_path}/ for details"
-            end
-          end
+          directory = package[:report_dir] || package["report_dir"]
+          directory ? "    → See #{relative_or_absolute(directory)}" : "    → No saved report"
         end
 
         def format_for_markdown(package)
-          path = extract_path(package)
-          report_root = extract_report_root(package)
-          package_name = extract_name(package) || File.basename(path)
-          report_path = Atoms::ReportPathResolver.call(
-            path,
-            report_root: report_root,
-            package_name: package_name
-          )
-
-          if report_path
-            relative_report_path = relative_or_absolute(report_path)
-            "- Report: `#{relative_report_path}`"
-          else
-            reports_path = fallback_reports_path(path, report_root, package_name)
-            relative_reports_path = relative_or_absolute(reports_path)
-            "- Report: Check `#{relative_reports_path}/` for details"
-          end
+          directory = package[:report_dir] || package["report_dir"]
+          directory ? "- Report: `#{relative_or_absolute(directory)}`" : "- No saved report"
         end
 
         class << self
           private
 
-          def extract_path(package)
-            package[:path] || package["path"]
-          end
-
-          def extract_name(package)
-            package[:name] || package["name"]
-          end
-
-          def extract_report_root(package)
-            package[:report_root] || package["report_root"]
-          end
-
-          def fallback_reports_path(path, report_root, package_name)
-            if report_root
-              short_name = package_name.to_s.sub(/\Aace-/, "")
-              return File.join(report_root, short_name) unless short_name.empty?
-            end
-
-            File.join(path, "test-reports")
-          end
-
           def debug_mode?
             ENV["DEBUG"]
           end

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

@@ -10,6 +10,16 @@ module Ace
       # Runs tests directly in the current Ruby process without spawning subprocesses
       # This provides significantly faster execution for unit tests that don't need isolation
       class InProcessRunner
+        # Minitest converts ordinary timeout exceptions into completed test
+        # errors. Its pass-through SystemExit boundary preserves execution
+        # deadlines; this owner catches the private control-flow exception.
+        class ExecutionTimeout < SystemExit
+          def initialize(*)
+            super(124)
+          end
+        end
+        private_constant :ExecutionTimeout
+
         def initialize(timeout: nil, launch_env:)
           @timeout = timeout
           @launch_env = launch_env  # Hermetic fixture environment applied for the test run
@@ -121,7 +131,7 @@ module Ace
             # Run Minitest with captured output
             # Suppress Minitest's own output by using null reporter
             exit_code = if @timeout
-              Timeout.timeout(@timeout) do
+              Timeout.timeout(@timeout, ExecutionTimeout) do
                 run_minitest_silent(options)
               end
             else
@@ -129,7 +139,7 @@ module Ace
             end
 
             success = exit_code == true || exit_code == 0
-          rescue Timeout::Error
+          rescue ExecutionTimeout, Timeout::Error
             stderr_io.puts "Test execution timed out after #{@timeout} seconds"
             success = false
             exit_code = 124
@@ -256,9 +266,21 @@ module Ace
             args << "--name" << "/#{pattern}/"
           end
 
-          # Reporter already set up before loading test files
-          # Run Minitest
-          Minitest.run(args)
+          # Minitest swallows Interrupt and returns a normal failure. Preserve
+          # operator SIGINT as interruption so the owner never writes a completed
+          # report for this invocation.
+          interrupted = false
+          previous_handler = Signal.trap("INT") do
+            interrupted = true
+            raise Interrupt
+          end
+          begin
+            result = Minitest.run(args)
+            raise Interrupt if interrupted
+            result
+          ensure
+            Signal.trap("INT", previous_handler)
+          end
         end
       end
     end

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

@@ -1,22 +1,33 @@
 # frozen_string_literal: true
 
+require "securerandom"
+
 module Ace
   module TestRunner
     module Molecules
       # Handles storage of test reports to filesystem
       class ReportStorage
-        def initialize(base_dir: ".ace-local/test/reports", timestamp_generator: nil)
+        def initialize(base_dir: ".ace-local/test/reports")
           @base_dir = base_dir
-          @timestamp_generator = timestamp_generator || Atoms::TimestampGenerator.new
         end
 
-        def save_report(report, format: :json)
+        def reserve(execution_id = SecureRandom.uuid)
+          ensure_base_directory
+          directory = File.join(File.expand_path(@base_dir), execution_id)
+          Dir.mkdir(directory)
+          directory
+        end
+
+        def save_report(report, format: :json, report_dir: nil)
           ensure_base_directory
-          report_dir = create_report_directory
+          report_dir ||= reserve
+          report.report_path = report_dir
+          report.metadata[:execution_id] = File.basename(report_dir)
 
           case format
           when :json
             save_json_report(report, report_dir)
+            save_summary(report.result, report_dir)
           when :markdown
             save_markdown_report(report, report_dir)
           when :all
@@ -50,6 +61,8 @@ module Ace
           summary_file = File.join(report_dir, "summary.json")
 
           summary_data = {
+            execution_id: File.basename(report_dir),
+            assertions: result.assertions,
             passed: result.passed,
             failed: result.failed,
             errors: result.errors,
@@ -61,7 +74,7 @@ module Ace
             timestamp: Time.now.iso8601
           }
 
-          File.write(summary_file, JSON.pretty_generate(summary_data))
+          File.open(summary_file, "wx") { |file| file.write(JSON.pretty_generate(summary_data)) }
           summary_file
         end
 
@@ -211,27 +224,18 @@ module Ace
           FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
         end
 
-        def create_report_directory
-          ensure_base_directory
-          timestamp = @timestamp_generator.directory_name
-          report_dir = File.join(@base_dir, timestamp)
-          FileUtils.mkdir_p(report_dir)
-          report_dir
-        end
-
         def create_latest_symlink(report_dir)
           latest_link = File.join(@base_dir, "latest")
-
-          # Remove existing symlink if present
-          FileUtils.rm_f(latest_link) if File.exist?(latest_link)
-
-          # Create new symlink to the latest report
-          FileUtils.ln_s(File.basename(report_dir), latest_link)
+          temporary = "#{latest_link}.#{SecureRandom.uuid}"
+          File.symlink(File.basename(report_dir), temporary)
+          File.rename(temporary, latest_link)
+        ensure
+          FileUtils.rm_f(temporary) if temporary
         end
 
         def save_json_report(report, report_dir)
           report_file = File.join(report_dir, "report.json")
-          File.write(report_file, report.to_json)
+          File.open(report_file, "wx") { |file| file.write(report.to_json) }
           report_file
         end
 

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

@@ -139,6 +139,7 @@ module Ace
             stdout: results.map { |r| r[:stdout] }.join("\n"),
             stderr: results.map { |r| r[:stderr] }.join("\n"),
             commands: results.map { |r| r[:command] },
+            execution_outputs: results.map { |r| r[:stdout] },
             start_time: results.first[:start_time],
             end_time: results.last[:end_time],
             duration: results.sum { |r| r[:duration] },

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

@@ -37,7 +37,7 @@ module Ace
             # Parse result
             parsed = if result[:commands] && result[:commands].is_a?(Array)
               # Multiple commands executed (per-file)
-              aggregate_results(result[:stdout], @result_parser)
+              aggregate_results(result.fetch(:execution_outputs), @result_parser)
             else
               @result_parser.parse_output(result[:stdout])
             end
@@ -81,10 +81,8 @@ module Ace
 
         private
 
-        def aggregate_results(combined_output, parser)
-          # Split output by test file executions
-          individual_outputs = combined_output.split(/^Started with run options/)
-          individual_outputs.shift if individual_outputs.first && individual_outputs.first.empty?
+        def aggregate_results(individual_outputs, parser)
+          # Preserve exact executor boundaries, including headerless partial output.
 
           aggregated = {
             summary: {
@@ -102,7 +100,6 @@ module Ace
           }
 
           individual_outputs.each do |output|
-            output = "Started with run options" + output
             parsed = parser.parse_output(output)
 
             aggregated[:summary][:runs] += parsed[:summary][:runs]
@@ -160,7 +157,8 @@ module Ace
           combined_stderr = all_results.map { |r| r[:stderr] }.join("\n")
 
           # Determine success
-          success = total_summary[:failures] == 0 && total_summary[:errors] == 0
+          success = all_results.all? { |result| result[:success] == true } &&
+            total_summary[:failures] == 0 && total_summary[:errors] == 0
 
           {
             stdout: combined_stdout,