tryouts 3.3.1 → 3.4.0

data/lib/tryouts/cli/formatters/token_budget.rb

@@ -0,0 +1,157 @@
+# lib/tryouts/cli/formatters/token_budget.rb
+
+class Tryouts
+  class CLI
+    # Token budget tracking for agent-optimized output
+    class TokenBudget
+      DEFAULT_LIMIT = 5000
+      BUFFER_PERCENT = 0.05  # 5% buffer to avoid going over
+
+      attr_reader :limit, :used, :remaining
+
+      def initialize(limit = DEFAULT_LIMIT)
+        @limit = limit
+        @used = 0
+        @buffer_size = (@limit * BUFFER_PERCENT).to_i
+      end
+
+      # Estimate tokens in text (rough approximation: 1 token ≈ 4 characters)
+      def estimate_tokens(text)
+        return 0 if text.nil? || text.empty?
+
+        (text.length / 4.0).ceil
+      end
+
+      # Check if text would exceed budget
+      def would_exceed?(text)
+        token_count = estimate_tokens(text)
+        (@used + token_count) > (@limit - @buffer_size)
+      end
+
+      # Add text to budget if within limits
+      def consume(text)
+        return false if would_exceed?(text)
+
+        @used += estimate_tokens(text)
+        true
+      end
+
+      # Force consume (for critical information that must be included)
+      def force_consume(text)
+        @used += estimate_tokens(text)
+        true
+      end
+
+      # Get remaining budget
+      def remaining
+        [@limit - @used - @buffer_size, 0].max
+      end
+
+      # Check if we have budget remaining
+      def has_budget?
+        remaining > 0
+      end
+
+      # Get utilization percentage
+      def utilization
+        (@used.to_f / @limit * 100).round(1)
+      end
+
+      # Try to fit text within remaining budget by truncating
+      def fit_text(text, preserve_suffix: nil)
+        token_count = estimate_tokens(text)
+
+        return text if token_count <= remaining
+        return '' unless has_budget?
+
+        # Calculate how many characters we can fit
+        max_chars = remaining * 4
+
+        if preserve_suffix
+          suffix_chars = preserve_suffix.length
+          return preserve_suffix if max_chars <= suffix_chars
+
+          available_chars = max_chars - suffix_chars - 3  # 3 for "..."
+          return "#{text[0, available_chars]}...#{preserve_suffix}"
+        else
+          return text[0, max_chars - 3] + '...' if max_chars > 3
+          return ''
+        end
+      end
+
+      # Smart truncate for different data types
+      def smart_truncate(value, max_tokens: nil)
+        max_tokens ||= [remaining / 2, 50].min  # Use half remaining or 50, whichever is smaller
+        max_chars = [max_tokens.to_i * 4, 0].max
+
+        case value
+        when String
+          return value if value.length <= max_chars
+          return '...' if max_chars <= 3
+          "#{value[0, max_chars - 3]}..."
+        when Array
+          if estimate_tokens(value.inspect) <= max_tokens
+            value.inspect
+          else
+            # Show first few elements
+            truncated = []
+            char_count = 2  # for "[]"
+
+            value.each do |item|
+              item_str = item.inspect
+              if char_count + item_str.length + 2 <= max_chars - 10  # 10 chars for ", ..."
+                truncated << item
+                char_count += item_str.length + 2  # +2 for ", "
+              else
+                break
+              end
+            end
+
+            "[#{truncated.map(&:inspect).join(', ')}, ...#{value.size - truncated.size} more]"
+          end
+        when Hash
+          if estimate_tokens(value.inspect) <= max_tokens
+            value.inspect
+          else
+            # Show first few key-value pairs
+            truncated = {}
+            char_count = 2  # for "{}"
+
+            value.each do |key, val|
+              pair_str = "#{key.inspect}=>#{val.inspect}"
+              if char_count + pair_str.length + 2 <= max_chars - 10
+                truncated[key] = val
+                char_count += pair_str.length + 2
+              else
+                break
+              end
+            end
+
+            "{#{truncated.map { |k, v| "#{k.inspect}=>#{v.inspect}" }.join(', ')}, ...#{value.size - truncated.size} more}"
+          end
+        else
+          smart_truncate(value.to_s, max_tokens: max_tokens)
+        end
+      end
+
+      # Distribution strategy for budget allocation
+      def allocate_budget
+        {
+          summary: (@limit * 0.20).to_i,      # 20% for file summaries
+          failures: (@limit * 0.60).to_i,     # 60% for failure details
+          context: (@limit * 0.15).to_i,      # 15% for additional context
+          buffer: (@limit * 0.05).to_i        # 5% buffer
+        }
+      end
+
+      # Reset budget
+      def reset
+        @used = 0
+      end
+
+      def to_s
+        "TokenBudget[#{@used}/#{@limit} tokens (#{utilization}%)]"
+      end
+    end
+  end
+end

data/lib/tryouts/cli/formatters/verbose.rb

@@ -12,6 +12,7 @@ class Tryouts
         @show_passed    = options.fetch(:show_passed, true)
         @show_debug     = options.fetch(:debug, false)
         @show_trace     = options.fetch(:trace, false)
+        @show_stack_traces = options.fetch(:stack_traces, false) || options.fetch(:debug, false)
       end
 
       # Phase-level output
@@ -244,11 +245,11 @@ class Tryouts
         error_msg = Console.color(:red, "ERROR: #{message}")
         puts indent_text(error_msg, 1)
 
-        return unless backtrace && @show_debug
+        return unless backtrace && @show_stack_traces
 
         puts indent_text('Details:', 2)
         # Show first 10 lines of backtrace to avoid overwhelming output
-        backtrace.first(10).each do |line|
+        Console.pretty_backtrace(backtrace, limit: 10).each do |line|
           puts indent_text(line, 3)
         end
         puts indent_text("... (#{backtrace.length - 10} more lines)", 3) if backtrace.length > 10

data/lib/tryouts/cli/formatters.rb

@@ -6,4 +6,6 @@ require_relative 'formatters/quiet'
 require_relative 'formatters/verbose'
 require_relative 'formatters/test_run_state'
 require_relative 'formatters/tty_status_display'
+require_relative 'formatters/token_budget'
+require_relative 'formatters/agent'
 require_relative 'formatters/factory'

data/lib/tryouts/cli/opts.rb

@@ -15,19 +15,72 @@ class Tryouts
         try --direct --shared-context test_try.rb # Explicit shared context
         try --generate-rspec test_try.rb         # Output RSpec code only
         try --inspect test_try.rb                # Inspect file structure and validation
-
-      File Format:
-        ## Test description       # Test case marker
-        code_to_test              # Ruby code
-        #=> expected_result       # Expectation (various types available)
+        try --agent test_try.rb                  # Agent-optimized structured output
+        try --agent --agent-limit 10000 tests/  # Agent mode with 10K token limit
+
+      Agent Output Modes:
+        --agent                                  # Structured, token-efficient output
+        --agent-focus summary                    # Show counts and problem files only
+        --agent-focus first-failure              # Show first failure per file
+        --agent-focus critical                   # Show errors/exceptions only
+        --agent-limit 1000                      # Limit output to 1000 tokens
+
+      File Naming & Organization:
+        Files must end with '_try.rb' or '.try.rb' (e.g., auth_service_try.rb, user_model.try.rb)
+        Auto-discovery searches: ./try/, ./tryouts/, ./*_try.rb, ./*.try.rb patterns
+        Organize by feature/module: try/models/, try/services/, try/api/
+
+      Testcase Structure (3 required parts)
+        ## This is the description
+        echo 'This is ruby code under test'
+        true
+        #=> true  # this is the expected result
+
+      File Structure (3 sections):
+        # Setup section (optional) - runs once before all tests
+        @shared_var = "available to all test cases"
+
+        ## TEST: Feature description
+        # Test case body with plain Ruby code
+        result = some_operation()
+        #=> expected_value
+
+        # Teardown section (optional) - runs once after all tests
+
+      Context Guidelines:
+        Shared Context (default): Instance variables persist across test cases
+          - Use for: Integration testing, stateful scenarios, realistic workflows
+          - Caution: Test order matters, state accumulates
+
+        Fresh Context (--rspec/--minitest): Each test gets isolated environment
+          - Use for: Unit testing, independent test cases
+          - Setup variables copied to each test, but changes don't persist
+
+      Writing Quality Tryouts:
+        - Use realistic, plain Ruby code (avoid mocks, test harnesses)
+        - Test descriptions start with ##, be specific about what's being tested
+        - One result per test case (last expression is the result)
+        - Use appropriate expectation types for clarity (#==> for boolean, #=:> for types)
+        - Keep tests focused and readable - they serve as documentation
 
       Great Expectations System:
-        Multiple expectation types are supported for different testing needs.
-
         #=>   Value equality        #==> Must be true         #=/=> Must be false
         #=|>  True OR false         #=!>  Must raise error    #=:>  Type matching
-        #=~>  Regex matching        #=%>  Time constraints    #=1>  STDOUT content
-        #=2>  STDERR content        #=<>  Intentional failure
+        #=~>  Regex matching        #=%>  Time constraints    #=*>  Non-nil result
+        #=1>  STDOUT content        #=2>  STDERR content      #=<>  Intentional failure
+
+      Exception Testing:
+        # Method 1: Rescue and test exception
+        begin
+          risky_operation
+        rescue StandardError => e
+          e.class
+        end
+        #=> StandardError
+
+        # Method 2: Let it raise and test with #=!>
+        risky_operation
+        #=!> error.is_a?(StandardError)
     HELP
 
     class << self
@@ -65,6 +118,24 @@ class Tryouts
           opts.on('-q', '--quiet', 'Minimal output (dots and summary only)') { options[:quiet]            = true }
           opts.on('-c', '--compact', 'Compact single-line output') { options[:compact]                    = true }
           opts.on('-l', '--live', 'Live status display') { options[:live_status]                          = true }
+          opts.on('-j', '--parallel [THREADS]', 'Run test files in parallel (optional thread count)') do |threads|
+            options[:parallel] = true
+            options[:parallel_threads] = threads.to_i if threads && threads.to_i > 0
+          end
+
+          opts.separator "\nAgent-Optimized Output:"
+          opts.on('-a', '--agent', 'Agent-optimized structured output for LLM context management') do
+            options[:agent] = true
+          end
+          opts.on('--agent-limit TOKENS', Integer, 'Limit total output to token budget (default: 5000)') do |limit|
+            options[:agent] = true
+            options[:agent_limit] = limit
+          end
+          opts.on('--agent-focus TYPE', %w[failures first-failure summary critical],
+                  'Focus mode: failures, first-failure, summary, critical (default: failures)') do |focus|
+            options[:agent] = true
+            options[:agent_focus] = focus.to_sym
+          end
 
           opts.separator "\nParser Options:"
           opts.on('--enhanced-parser', 'Use enhanced parser with inhouse comment extraction (default)') { options[:parser] = :enhanced }
@@ -74,10 +145,16 @@ class Tryouts
           opts.on('-i', '--inspect', 'Inspect file structure without running tests') { options[:inspect] = true }
 
           opts.separator "\nGeneral Options:"
+          opts.on('-s', '--stack-traces', 'Show stack traces for exceptions') do
+            options[:stack_traces] = true
+            Tryouts.stack_traces = true
+          end
           opts.on('-V', '--version', 'Show version') { options[:version] = true }
           opts.on('-D', '--debug', 'Enable debug mode') do
             options[:debug] = true
+            options[:stack_traces] = true  # Debug mode auto-enables stack traces
             Tryouts.debug   = true
+            Tryouts.stack_traces = true
           end
           opts.on('-h', '--help', 'Show this help') do
             puts opts

data/lib/tryouts/console.rb

@@ -161,12 +161,40 @@ class Tryouts
       # directory. This simplifies logging and error reporting by showing
       # only the relevant parts of file paths instead of lengthy absolute paths.
       #
-      def pretty_path(file)
-        return nil if file.nil?
+      def pretty_path(filepath)
+        return nil if filepath.nil? || filepath.empty?
 
-        file     = File.expand_path(file) # be absolutely sure
         basepath = Dir.pwd
-        Pathname.new(file).relative_path_from(basepath).to_s
+        begin
+          relative_path = Pathname.new(filepath).relative_path_from(basepath)
+          if relative_path.to_s.start_with?('..')
+            File.basename(filepath)
+          else
+            relative_path.to_s
+          end
+        rescue ArgumentError
+          # Handle cases where filepath cannot be relativized (e.g., empty paths, different roots)
+          File.basename(filepath)
+        end
+      end
+
+      # Format backtrace entries with pretty file paths
+      def pretty_backtrace(backtrace, limit: 10)
+        return [] unless backtrace&.any?
+
+        backtrace.first(limit).map do |frame|
+          # Split the frame to get file path and line info
+          # Use non-greedy match and more specific pattern to prevent ReDoS
+          if frame.match(/^([^:]+(?::[^:0-9][^:]*)*):(\d+):(.*)$/)
+            file_part = $1
+            line_part = $2
+            method_part = $3
+            pretty_file = pretty_path(file_part) || File.basename(file_part)
+            "#{pretty_file}:#{line_part}#{method_part}"
+          else
+            frame
+          end
+        end
       end
     end
   end

data/lib/tryouts/expectation_evaluators/exception.rb

@@ -9,8 +9,14 @@ class Tryouts
         expectation_type == :exception
       end
 
-      def evaluate(_actual_result = nil)
-        execute_test_code_and_evaluate_exception
+      def evaluate(_actual_result = nil, caught_exception: nil)
+        if caught_exception
+          # Use the pre-caught exception to avoid double execution
+          evaluate_exception_condition(caught_exception)
+        else
+          # Fallback for direct calls - shouldn't happen in normal flow
+          execute_test_code_and_evaluate_exception
+        end
       end
 
       private

data/lib/tryouts/expectation_evaluators/non_nil.rb

@@ -0,0 +1,77 @@
+# lib/tryouts/expectation_evaluators/non_nil.rb
+
+require_relative 'base'
+
+class Tryouts
+  module ExpectationEvaluators
+    # Evaluator for non-nil expectations using syntax: #=*>
+    #
+    # PURPOSE:
+    # - Validates that the test result is not nil and no exception occurred
+    # - Provides a simple "anything goes" expectation for existence checks
+    # - Useful for API responses, object creation, method return values
+    #
+    # SYNTAX: #=*>
+    # Examples:
+    #   user = User.create(name: "test")
+    #   #=*>                              # Pass: user object exists (not nil)
+    #
+    #   response = api_call()
+    #   #=*>                              # Pass: got some response (not nil)
+    #
+    #   nil
+    #   #=*>                              # Fail: result is nil
+    #
+    #   raise StandardError.new("error")
+    #   #=*>                              # Fail: exception occurred
+    #
+    # VALIDATION LOGIC:
+    # - Passes when result is not nil AND no exception was raised during execution
+    # - Fails when result is nil OR an exception occurred
+    # - Does not evaluate any additional expression (unlike other expectation types)
+    #
+    # IMPLEMENTATION DETAILS:
+    # - Simple existence check without complex evaluation
+    # - No expression parsing needed - syntax is just #=*>
+    # - Expected display shows "non-nil result with no exception"
+    # - Actual display shows the actual result value or exception
+    #
+    # DESIGN DECISIONS:
+    # - Uses #=*> syntax where * represents "anything"
+    # - Part of unified #= prefix convention for all expectation types
+    # - Complements existing boolean and equality expectations
+    # - Provides simple alternative to complex conditional expressions
+    # - Useful for integration tests where exact values are unpredictable
+    #
+    # VARIABLE ACCESS:
+    # - No special variables needed since no expression is evaluated
+    # - Works purely on the actual test result value
+    class NonNil < Base
+      def self.handles?(expectation_type)
+        expectation_type == :non_nil
+      end
+
+      def evaluate(actual_result = nil, caught_exception: nil)
+        # Check if an exception occurred during test execution
+        if caught_exception
+          return build_result(
+            passed: false,
+            actual: "(#{caught_exception.class}) #{caught_exception.message}",
+            expected: 'non-nil result with no exception',
+          )
+        end
+
+        # Check if result is nil
+        passed = !actual_result.nil?
+
+        build_result(
+          passed: passed,
+          actual: actual_result,
+          expected: 'non-nil result',
+        )
+      rescue StandardError => ex
+        handle_evaluation_error(ex, actual_result)
+      end
+    end
+  end
+end

data/lib/tryouts/expectation_evaluators/registry.rb

@@ -12,6 +12,7 @@ require_relative 'regex_match'
 require_relative 'performance_time'
 require_relative 'intentional_failure'
 require_relative 'output'
+require_relative 'non_nil'
 
 class Tryouts
   module ExpectationEvaluators
@@ -61,6 +62,7 @@ class Tryouts
       register(PerformanceTime)
       register(IntentionalFailure)
       register(Output)
+      register(NonNil)
     end
   end
 end

data/lib/tryouts/file_processor.rb

@@ -20,7 +20,7 @@ class Tryouts
 
     def process
       testrun                     = create_parser(@file, @options).parse
-      @global_tally[:file_count] += 1
+      @global_tally[:aggregator].increment_total_files
       @output_manager.file_parsed(@file, testrun.total_tests)
 
       if @options[:inspect]
@@ -76,7 +76,11 @@ class Tryouts
     end
 
     def handle_general_error(ex)
-      @global_tally[:total_errors] += 1 if @global_tally
+      if @global_tally
+        @global_tally[:aggregator].add_infrastructure_failure(
+          :file_processing, @file, ex.message, ex
+        )
+      end
       @output_manager.file_failure(@file, ex.message, ex.backtrace)
       1
     end

data/lib/tryouts/parsers/enhanced_parser.rb

@@ -86,6 +86,8 @@ class Tryouts
         { type: :false_expectation, content: $1.strip, line: line_number - 1, ast: parse_expectation($1.strip) }
       when /^#\s*=\|>\s*(.*)$/
         { type: :boolean_expectation, content: $1.strip, line: line_number - 1, ast: parse_expectation($1.strip) }
+      when /^#\s*=\*>\s*(.*)$/
+        { type: :non_nil_expectation, content: $1.strip, line: line_number - 1 }
       when /^#\s*=:>\s*(.*)$/
         { type: :result_type_expectation, content: $1.strip, line: line_number - 1, ast: parse_expectation($1.strip) }
       when /^#\s*=~>\s*(.*)$/

data/lib/tryouts/parsers/prism_parser.rb

@@ -39,6 +39,8 @@ class Tryouts
                   { type: :false_expectation, content: $1.strip, line: index, ast: parse_expectation($1.strip) }
                 in /^#\s*=\|>\s*(.*)$/ # Boolean (true or false) expectation
                   { type: :boolean_expectation, content: $1.strip, line: index, ast: parse_expectation($1.strip) }
+                in /^#\s*=\*>\s*(.*)$/ # Non-nil expectation
+                  { type: :non_nil_expectation, content: $1.strip, line: index }
                 in /^#\s*=:>\s*(.*)$/ # Result type expectation
                   { type: :result_type_expectation, content: $1.strip, line: index, ast: parse_expectation($1.strip) }
                 in /^#\s*=~>\s*(.*)$/ # Regex match expectation

data/lib/tryouts/parsers/shared_methods.rb

@@ -86,6 +86,9 @@ class Tryouts
           in [_, { type: :boolean_expectation }]
             current_block[:expectations] << token
 
+          in [_, { type: :non_nil_expectation }]
+            current_block[:expectations] << token
+
           in [_, { type: :result_type_expectation }]
             current_block[:expectations] << token
 
@@ -192,7 +195,7 @@ class Tryouts
           :expectation, :exception_expectation, :intentional_failure_expectation,
           :true_expectation, :false_expectation, :boolean_expectation,
           :result_type_expectation, :regex_match_expectation,
-          :performance_time_expectation, :output_expectation
+          :performance_time_expectation, :output_expectation, :non_nil_expectation
         ].include?(type)
       end
 
@@ -368,6 +371,7 @@ class Tryouts
                      when :regex_match_expectation then :regex_match
                      when :performance_time_expectation then :performance_time
                      when :output_expectation then :output
+                     when :non_nil_expectation then :non_nil
                      else :regular
                      end
 

data/lib/tryouts/test_batch.rb

@@ -244,7 +244,7 @@ class Tryouts
         end
 
         expectations_result = execute_with_timeout(test_timeout, test_case) do
-          evaluate_expectations(test_case, caught_exception, container)
+          evaluate_expectations(test_case, caught_exception, container, nil, nil, nil, caught_exception)
         end
         build_test_result(test_case, caught_exception, expectations_result)
       else
@@ -330,7 +330,7 @@ class Tryouts
     end
 
     # Evaluate expectations using new object-oriented evaluation system
-    def evaluate_expectations(test_case, actual_result, context, execution_time_ns = nil, stdout_content = nil, stderr_content = nil)
+    def evaluate_expectations(test_case, actual_result, context, execution_time_ns = nil, stdout_content = nil, stderr_content = nil, caught_exception = nil)
       return { passed: true, actual_results: [], expected_results: [] } if test_case.expectations.empty?
 
       evaluation_results = test_case.expectations.map do |expectation|
@@ -341,6 +341,9 @@ class Tryouts
           evaluator.evaluate(actual_result, execution_time_ns)
         elsif expectation.output? && (stdout_content || stderr_content)
           evaluator.evaluate(actual_result, stdout_content, stderr_content)
+        elsif expectation.exception? && caught_exception
+          # Pass caught exception to avoid double execution
+          evaluator.evaluate(actual_result, caught_exception: caught_exception)
         else
           evaluator.evaluate(actual_result)
         end
@@ -385,13 +388,14 @@ class Tryouts
     def process_test_result(result)
       @results << result
 
+      # Add all test results to the aggregator for centralized counting
+      if @global_tally && @global_tally[:aggregator]
+        @global_tally[:aggregator].add_test_result(@testrun.source_file, result)
+      end
+
+      # Update local batch counters for batch-level logic
       if result.failed? || result.error?
         @failed_count += 1
-
-        # Collect failure details for end-of-run summary
-        if @global_tally && @global_tally[:failure_collector]
-          @global_tally[:failure_collector].add_failure(@testrun.source_file, result)
-        end
       end
 
       show_test_result(result)
@@ -418,7 +422,11 @@ class Tryouts
       end
     rescue StandardError => ex
       @setup_failed                 = true
-      @global_tally[:total_errors] += 1 if @global_tally
+      if @global_tally && @global_tally[:aggregator]
+        @global_tally[:aggregator].add_infrastructure_failure(
+          :setup, @testrun.source_file, ex.message, ex
+        )
+      end
 
       # Classify error and handle appropriately
       error_type = Tryouts.classify_error(ex)
@@ -455,7 +463,11 @@ class Tryouts
       end
     rescue StandardError => ex
       @setup_failed                 = true
-      @global_tally[:total_errors] += 1 if @global_tally
+      if @global_tally && @global_tally[:aggregator]
+        @global_tally[:aggregator].add_infrastructure_failure(
+          :setup, @testrun.source_file, ex.message, ex
+        )
+      end
 
       # Classify error and handle appropriately
       error_type = Tryouts.classify_error(ex)
@@ -488,7 +500,11 @@ class Tryouts
         @output_manager&.teardown_output(captured_output) if captured_output && !captured_output.empty?
       end
     rescue StandardError => ex
-      @global_tally[:total_errors] += 1 if @global_tally
+      if @global_tally && @global_tally[:aggregator]
+        @global_tally[:aggregator].add_infrastructure_failure(
+          :teardown, @testrun.source_file, ex.message, ex
+        )
+      end
 
       # Classify error and handle appropriately
       error_type = Tryouts.classify_error(ex)

data/lib/tryouts/test_case.rb

@@ -154,9 +154,9 @@ class Tryouts
     def self.from_error(test_case, error, captured_output: nil, elapsed_time: nil, metadata: {})
       error_message = error ? error.message : '<exception is nil>'
 
-      # Include backtrace in error message when in debug/verbose mode
-      error_display = if error && Tryouts.debug?
-        backtrace_preview = error.backtrace&.first(3)&.join("\n    ")
+      # Include backtrace in error message when stack traces are enabled
+      error_display = if error && Tryouts.stack_traces?
+        backtrace_preview = Console.pretty_backtrace(error.backtrace, limit: 3).join("\n    ")
         "(#{error.class}) #{error_message}\n    #{backtrace_preview}"
       else
         "(#{error.class}) #{error_message}"

data/lib/tryouts/test_executor.rb

@@ -53,10 +53,12 @@ class Tryouts
       file_failed_count                 = test_results.count { |r| r.failed? }
       file_error_count                  = test_results.count { |r| r.error? }
       executed_test_count               = test_results.size
-      @global_tally[:total_tests]      += executed_test_count
-      @global_tally[:total_failed]     += file_failed_count
-      @global_tally[:total_errors]     += file_error_count
-      @global_tally[:successful_files] += 1 if success
+
+      # Note: Individual test results are added to the aggregator in TestBatch
+      # Here we just update the file success count atomically
+      if success
+        @global_tally[:aggregator].increment_successful_files
+      end
 
       duration = Time.now.to_f - @file_start.to_f
       @output_manager.file_success(@file, executed_test_count, file_failed_count, file_error_count, duration)