scint 0.1.0 → 0.7.0

data/lib/scint/progress.rb

@@ -18,15 +18,22 @@ module Scint
     }.freeze
     BUILD_TAIL_MAX = 6
     BUILD_TAIL_PREVIEW_LINES = 4
-    RENDER_HZ = 5
+    RENDER_HZ = 10
     RENDER_INTERVAL = 1.0 / RENDER_HZ
     MAX_DETAIL_ROWS_PER_PHASE = 4
     MAX_LINE_LEN = 220
     MIN_RENDER_WIDTH = 40
     MAX_PANEL_ROWS = 14
+    SLOW_OPERATION_THRESHOLD_SECONDS = 1.0
     SPINNER_FRAMES = %w[⠋ ⠙ ⠹ ⠸ ⠼ ⠴ ⠦ ⠧ ⠇ ⠏].freeze
-    IDLE_MARK = "○".freeze
-    PANEL_PHASE_ORDER = %i[download extract build_ext link].freeze
+    IDLE_MARK = "•".freeze
+    PANEL_PHASE_ORDER = %i[download extract link build_ext].freeze
+    COMPLETION_LOG_TYPES = {
+      download: true,
+      extract: true,
+      link: true,
+      build_ext: true,
+    }.freeze
 
     PHASE_LABELS = {
       fetch_index: "Fetching index",
@@ -43,6 +50,12 @@ module Scint
       link: "Installing",
       build_ext: "Compiling",
     }.freeze
+    COMPLETION_LABELS = {
+      download: "Downloaded",
+      extract: "Extracted",
+      link: "Installed",
+      build_ext: "Compiled",
+    }.freeze
 
     def initialize(output: $stderr)
       @output = output
@@ -55,6 +68,7 @@ module Scint
       @failed = Hash.new(0)
       @total = Hash.new(0)
       @active_jobs = {}
+      @job_started_at = {}
       @build_tail = []
       @build_tail_by_name = {}
       @spinner_idx = 0
@@ -67,6 +81,7 @@ module Scint
       @phase_reserved_detail_rows = Hash.new(0)
       @setup_lines_printed = false
       @setup_gap_printed = false
+      @pending_log_lines = []
       @render_stop = false
       @render_thread = nil
     end
@@ -90,8 +105,9 @@ module Scint
 
       @mutex.synchronize do
         begin
+          flush_pending_logs_locked
           mark_completed_phase_elapsed_locked
-          render_live_locked if any_stream_activity?
+          render_live_locked if any_active_stream_jobs?
           if @interactive && @live_rows.positive?
             move_cursor_down(@live_rows - 1)
             @output.print "\r\n"
@@ -119,11 +135,16 @@ module Scint
 
       @mutex.synchronize do
         @active_jobs[job_id] = { type: type, name: name }
+        @job_started_at[job_id] = Process.clock_gettime(Process::CLOCK_MONOTONIC) if completion_log_type?(type)
         @started += 1
         emit_setup_gap_if_needed(type)
         @phase_started_at[type] ||= Process.clock_gettime(Process::CLOCK_MONOTONIC) if stream_type?(type)
-        if @interactive && stream_type?(type)
+        if @interactive
           start_render_thread_locked
+          unless stream_type?(type)
+            clear_live_block_locked
+            emit_setup_or_log_line(type, name)
+          end
         else
           clear_live_block_locked
           emit_setup_or_log_line(type, name)
@@ -136,6 +157,8 @@ module Scint
         @completed[type] += 1
         active = @active_jobs.delete(job_id)
         @build_tail_by_name.delete(active[:name]) if active
+        elapsed = consume_job_elapsed(job_id)
+        emit_task_completion_locked(type, name, elapsed) if @interactive
         if !@interactive || !stream_type?(type)
           emit_phase_completion_locked(type)
         end
@@ -147,11 +170,22 @@ module Scint
 
       @mutex.synchronize do
         active = @active_jobs.delete(job_id)
+        elapsed = consume_job_elapsed(job_id)
         @build_tail_by_name.delete(active[:name]) if active
         @failed[type] += 1
-        clear_live_block_locked
         label = PHASE_LABELS[type] || type.to_s
-        @output.puts "#{RED}FAILED#{RESET} #{label} #{BOLD}#{name}#{RESET}: #{error.message}"
+        failed_timing = if elapsed && elapsed >= SLOW_OPERATION_THRESHOLD_SECONDS
+          " #{DIM}#{format_phase_elapsed(elapsed)}#{RESET}"
+        else
+          ""
+        end
+        failed_line = "#{RED}FAILED#{RESET} #{label} #{BOLD}#{name}#{RESET}: #{error.message}#{failed_timing}"
+        if @interactive
+          queue_log_line_locked(failed_line)
+        else
+          clear_live_block_locked
+          @output.puts failed_line
+        end
         if !@interactive
           emit_phase_completion_locked(type)
         end
@@ -197,9 +231,68 @@ module Scint
       HIDDEN_TYPES[type] == true
     end
 
+    def completion_log_type?(type)
+      COMPLETION_LOG_TYPES[type] == true
+    end
+
+    def consume_job_elapsed(job_id)
+      started_at = @job_started_at.delete(job_id)
+      return nil unless started_at
+
+      Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at
+    end
+
+    def emit_task_completion_locked(type, name, elapsed)
+      return unless completion_log_type?(type)
+
+      label = COMPLETION_LABELS[type] || (PHASE_LABELS[type] || type.to_s)
+      timing = if elapsed && elapsed >= SLOW_OPERATION_THRESHOLD_SECONDS
+        " #{DIM}#{format_phase_elapsed(elapsed)}#{RESET}"
+      else
+        ""
+      end
+      line = "#{GREEN}#{IDLE_MARK}#{RESET} #{DIM}#{label} #{BOLD}#{name}#{RESET}#{timing}"
+
+      queue_log_line_locked(line)
+    end
+
+    def queue_log_line_locked(line)
+      @pending_log_lines << line
+    end
+
+    def flush_pending_logs_locked
+      return if @pending_log_lines.empty?
+
+      lines = @pending_log_lines.dup
+      @pending_log_lines.clear
+      lines.each_with_index do |line, idx|
+        write_scrollback_line_locked(line, flush: idx == lines.length - 1)
+      end
+    end
+
+    def write_scrollback_line_locked(line, flush: true)
+      rendered = fit_line(line, @render_width)
+
+      unless @interactive && @live_rows.positive?
+        @output.print "\r"
+        @output.puts rendered
+        @output.flush if flush && @output.respond_to?(:flush)
+        return
+      end
+
+      # Insert one scrollback line above the active block without clearing
+      # existing rows first. This reduces visible flicker during fast updates.
+      move_cursor_up(@live_rows - 1)
+      @output.print "\e[1L"
+      @output.print "\r#{rendered}\e[K\n"
+      move_cursor_down(@live_rows - 1)
+      @output.print "\r"
+      @output.flush if flush && @output.respond_to?(:flush)
+    end
+
     def render_live_locked
       return unless @interactive
-      return unless any_stream_activity?
+      return unless any_active_stream_jobs? || any_active_setup_jobs?
 
       mark_completed_phase_elapsed_locked
 
@@ -207,7 +300,11 @@ module Scint
       spinner = SPINNER_FRAMES[@spinner_idx % SPINNER_FRAMES.length]
       @spinner_idx += 1
 
-      lines.concat(phase_lines(spinner))
+      if any_active_stream_jobs?
+        lines.concat(phase_lines(spinner))
+      else
+        lines << "#{GREEN}#{spinner}#{RESET} Processing..."
+      end
       lines = clamp_panel_rows(lines)
 
       redraw_live_block_locked(lines)
@@ -238,7 +335,8 @@ module Scint
     end
 
     def phase_lines(spinner)
-      PANEL_PHASE_ORDER.flat_map do |type|
+      active_types = PANEL_PHASE_ORDER.select { |type| !active_stream_jobs_for(type).empty? }
+      active_types.flat_map do |type|
         phase_rows_for(type, spinner)
       end
     end
@@ -252,69 +350,21 @@ module Scint
       label = PHASE_SUMMARY_LABELS[type] || (PHASE_LABELS[type] || type.to_s)
       line = phase_status_line(type, active, label, completed, total, spinner)
       detail_rows = phase_detail_rows_for(type, active)
-      [line, *reserve_phase_detail_space(type, detail_rows, total, completed, active)]
+      [line, *detail_rows.first(MAX_DETAIL_ROWS_PER_PHASE)]
     end
 
     def phase_status_line(type, active_jobs, label, completed, total, spinner)
       base = "#{label}... (#{completed}/#{total})"
-      if active_jobs.empty?
-        elapsed = @phase_elapsed[type]
-        elapsed_text = elapsed ? " · #{format_phase_elapsed(elapsed)}" : ""
-        "#{DIM}#{IDLE_MARK} #{base}#{elapsed_text}#{RESET}"
-      else
-        name = active_jobs.first[:name]
-        "#{spinner} #{base} · #{BOLD}#{name}#{RESET}"
-      end
+      name = active_jobs.first[:name]
+      "#{GREEN}#{spinner}#{RESET} #{base} · #{BOLD}#{name}#{RESET}"
     end
 
     def phase_detail_rows_for(type, active_jobs)
       return [] if active_jobs.empty?
 
-      if type == :build_ext
-        compile_tail_rows_for(active_jobs.first[:name])
-      else
-        active_rows_for(type, active_jobs)
-      end
-    end
-
-    def reserve_phase_detail_space(type, details, total, completed, active_jobs)
-      if phase_complete?(type, total, completed, active_jobs)
-        @phase_reserved_detail_rows[type] = 0
-        return []
-      end
-
-      desired = [details.length, MAX_DETAIL_ROWS_PER_PHASE].min
-      @phase_reserved_detail_rows[type] = [@phase_reserved_detail_rows[type], desired].max
-      reserved = @phase_reserved_detail_rows[type]
+      return compile_tail_rows_for(active_jobs.first[:name]) if type == :build_ext
 
-      rows = details.first(reserved)
-      while rows.length < reserved
-        rows << "#{DIM}  #{RESET}"
-      end
-      rows
-    end
-
-    def phase_complete?(type, total, completed, active_jobs)
-      return false if total.zero?
-
-      if completed >= total && active_jobs.empty?
-        mark_phase_elapsed_locked(type)
-        return true
-      end
-
-      false
-    end
-
-    def active_rows_for(_type, active_jobs)
-      return [] if active_jobs.empty?
-      if active_jobs.length <= MAX_DETAIL_ROWS_PER_PHASE
-        return active_jobs.map { |job| "  #{BOLD}#{job[:name]}#{RESET}" }
-      end
-
-      rows = active_jobs.first(MAX_DETAIL_ROWS_PER_PHASE - 1).map { |job| "  #{BOLD}#{job[:name]}#{RESET}" }
-      remaining = active_jobs.length - rows.length
-      rows << "#{DIM}  +#{remaining} more#{RESET}"
-      rows
+      []
     end
 
     def compile_tail_rows_for(name)
@@ -330,14 +380,21 @@ module Scint
       @active_jobs.values.select { |job| job[:type] == type }
     end
 
+    def any_active_stream_jobs?
+      STREAM_TYPES.keys.any? { |type| !active_stream_jobs_for(type).empty? }
+    end
+
+    def any_active_setup_jobs?
+      @active_jobs.values.any? { |job| SETUP_TYPES[job[:type]] == true }
+    end
+
     def clear_live_block_locked
       return unless @interactive
       return if @live_rows.zero?
 
       move_cursor_up(@live_rows - 1)
       @live_rows.times do |idx|
-        prev_width = @rendered_widths[idx] || 0
-        @output.print "\r#{' ' * prev_width}"
+        @output.print "\r\e[K"
         @output.print "\n" if idx < (@live_rows - 1)
       end
       move_cursor_up(@live_rows - 1)
@@ -350,7 +407,6 @@ module Scint
     def redraw_live_block_locked(lines)
       hide_cursor_locked
       previous_rows = @live_rows
-      previous_widths = @rendered_widths.dup
 
       move_cursor_up(previous_rows - 1) if previous_rows.positive?
 
@@ -359,12 +415,8 @@ module Scint
 
       max_rows.times do |idx|
         line = idx < lines.length ? fit_line(lines[idx], @render_width) : ""
-        prev_width = previous_widths[idx] || 0
         line_width = visible_width(line)
-        pad_len = prev_width > line_width ? (prev_width - line_width) : 0
-        pad = pad_len.positive? ? (" " * pad_len) : ""
-
-        @output.print "\r#{line}#{pad}"
+        @output.print "\r#{line}\e[K"
         @output.print "\n" if idx < (max_rows - 1)
         new_widths << line_width
       end
@@ -405,7 +457,8 @@ module Scint
           @mutex.synchronize do
             should_stop = @render_stop
             unless should_stop
-              render_live_locked
+              flush_pending_logs_locked
+              render_live_locked if any_active_stream_jobs?
               should_stop = render_done_locked?
             end
           end
@@ -502,7 +555,9 @@ module Scint
     end
 
     def render_done_locked?
-      any_stream_activity? && !stream_active_or_pending?
+      !any_active_stream_jobs? && !any_active_setup_jobs? &&
+        @pending_log_lines.empty? &&
+        (!any_stream_activity? || !stream_active_or_pending?)
     end
 
     def format_phase_elapsed(seconds)

data/lib/scint/resolver/provider.rb

@@ -65,8 +65,9 @@ module Scint
           else
             entries = info_for(name)
             versions = {}
-            entries.each do |_name, version, platform, _deps, _reqs|
+            entries.each do |_name, version, platform, _deps, reqs|
               next unless platform_match?(platform)
+              next unless requirements_match?(reqs)
               ver = Gem::Version.new(version)
               versions[version] ||= ver
             end
@@ -85,7 +86,7 @@ module Scint
             pg = @path_gems[name]
             deps = {}
             (pg[:dependencies] || []).each do |dep_name, dep_req_str|
-              deps[dep_name] = Gem::Requirement.new(dep_req_str || ">= 0")
+              deps[dep_name] = build_requirement(dep_req_str)
             end
             deps
           else
@@ -93,11 +94,12 @@ module Scint
             entries = info_for(name)
             deps = {}
 
-            entries.each do |_name, ver, platform, dep_hash, _reqs|
+            entries.each do |_name, ver, platform, dep_hash, reqs|
               next unless ver == version_str && platform_match?(platform)
+              next unless requirements_match?(reqs)
               dep_hash.each do |dep_name, dep_req_str|
                 # Merge constraints from all matching platform entries
-                req = Gem::Requirement.new(dep_req_str.split(", "))
+                req = build_requirement(dep_req_str)
                 deps[dep_name] = if deps[dep_name]
                   merge_requirements(deps[dep_name], req)
                 else
@@ -119,8 +121,9 @@ module Scint
         version_str = version.to_s
         entries = info_for(name)
         has_platform_specific = false
-        entries.each do |_name, ver, platform, _deps, _reqs|
+        entries.each do |_name, ver, platform, _deps, reqs|
           next unless ver == version_str
+          next unless requirements_match?(reqs)
           has_platform_specific = true if platform != "ruby"
         end
         has_platform_specific
@@ -132,8 +135,8 @@ module Scint
         return "ruby" if @path_gems.key?(name)
 
         version_str = version.to_s
-        entries = info_for(name).select do |_n, ver, platform, _deps, _reqs|
-          ver == version_str && platform_match?(platform)
+        entries = info_for(name).select do |_n, ver, platform, _deps, reqs|
+          ver == version_str && platform_match?(platform) && requirements_match?(reqs)
         end
         return "ruby" if entries.empty?
 
@@ -225,6 +228,67 @@ module Scint
         combined = req1.requirements + req2.requirements
         Gem::Requirement.new(combined.map { |op, v| "#{op} #{v}" })
       end
+
+      def requirements_match?(reqs)
+        return true unless reqs.is_a?(Hash)
+
+        ruby_req = reqs["ruby"] || reqs[:ruby]
+        return false unless requirement_satisfied?(ruby_req, Gem::Version.new(RUBY_VERSION), ignore_upper: ignore_ruby_upper_bounds?) if ruby_req
+
+        rubygems_req = reqs["rubygems"] || reqs[:rubygems]
+        return false unless requirement_satisfied?(rubygems_req, Gem::Version.new(Gem::VERSION), ignore_upper: false) if rubygems_req
+
+        true
+      rescue StandardError
+        # Keep resolver tolerant of malformed compact-index requirement fields.
+        true
+      end
+
+      def ignore_ruby_upper_bounds?
+        raw = ENV["SCINT_IGNORE_RUBY_UPPER_BOUNDS"]
+        return true if raw.nil?
+
+        !%w[0 false no off].include?(raw.strip.downcase)
+      end
+
+      def requirement_satisfied?(requirement_str, current_version, ignore_upper:)
+        req = normalize_requirement(requirement_str, ignore_upper: ignore_upper)
+        req.satisfied_by?(current_version)
+      end
+
+      def normalize_requirement(requirement_str, ignore_upper:)
+        parts = requirement_str.to_s.split(",").map(&:strip).reject(&:empty?)
+        req = Gem::Requirement.new(*(parts.empty? ? [">= 0"] : parts))
+        return req unless ignore_upper
+
+        filtered = req.requirements.filter_map do |op, version|
+          case op
+          when "<", "<="
+            nil
+          when "~>"
+            [">=", version]
+          else
+            [op, version]
+          end
+        end
+
+        return Gem::Requirement.default if filtered.empty?
+
+        Gem::Requirement.new(filtered.map { |op, version| "#{op} #{version}" })
+      end
+
+      def build_requirement(value)
+        case value
+        when Gem::Requirement
+          value
+        when Array
+          parts = value.flatten.compact.map(&:to_s).reject(&:empty?)
+          Gem::Requirement.new(*(parts.empty? ? [">= 0"] : parts))
+        else
+          parts = value.to_s.split(",").map(&:strip).reject(&:empty?)
+          Gem::Requirement.new(*(parts.empty? ? [">= 0"] : parts))
+        end
+      end
     end
   end
 end

data/lib/scint/runtime/exec.rb

@@ -2,8 +2,10 @@
 
 require_relative "setup"
 require_relative "../fs"
+require_relative "../platform"
 require "base64"
 require "pathname"
+require "rbconfig"
 
 module Scint
   module Runtime
@@ -19,40 +21,40 @@ module Scint
       # lock_path: path to .bundle/scint.lock.marshal
       def exec(command, args, lock_path)
         original_env = ENV.to_hash
-        lock_data = Setup.load_lock(lock_path)
+        Setup.load_lock(lock_path)
+        command, args = rewrite_bundle_exec(command, args)
+        passthrough_bundle = bundle_command?(command)
 
         bundle_dir = File.dirname(lock_path)
         scint_lib_dir = File.expand_path("../..", __dir__)
-        ruby_dir = File.join(bundle_dir, "ruby",
-                             RUBY_VERSION.split(".")[0, 2].join(".") + ".0")
-
-        # Collect all load paths from the runtime config
-        paths = []
-        lock_data.each_value do |info|
-          Array(info[:load_paths]).each do |p|
-            paths << p if File.directory?(p)
-          end
+        ruby_dir = Platform.ruby_install_dir(bundle_dir)
+
+        # Set RUBYLIB to make our Bundler shim loadable. We intentionally avoid
+        # injecting all gem load paths here because large apps can exceed exec
+        # argument/environment limits when RUBYLIB gets too long.
+        # Gem load paths are still activated via Scint::Runtime::Setup from
+        # `-rbundler/setup`.
+        unless passthrough_bundle
+          existing = ENV["RUBYLIB"]
+          rubylib = scint_lib_dir
+          rubylib = "#{rubylib}#{File::PATH_SEPARATOR}#{existing}" if existing && !existing.empty?
+          ENV["RUBYLIB"] = rubylib
         end
 
-        # Ensure our bundler shim wins over global bundler.
-        # Order matters: scint lib first, then gem load paths.
-        paths.unshift(scint_lib_dir)
-
-        # Set RUBYLIB so the child process inherits load paths.
-        existing = ENV["RUBYLIB"]
-        rubylib = paths.join(File::PATH_SEPARATOR)
-        rubylib = "#{rubylib}#{File::PATH_SEPARATOR}#{existing}" if existing && !existing.empty?
-        ENV["RUBYLIB"] = rubylib
-
         ENV["SCINT_RUNTIME_LOCK"] = lock_path
         ENV["GEM_HOME"] = ruby_dir
-        ENV["GEM_PATH"] = ruby_dir
+        ENV["GEM_PATH"] = build_gem_path(ruby_dir, original_env["GEM_PATH"])
         ENV["BUNDLE_PATH"] = bundle_dir
         ENV["BUNDLE_APP_CONFIG"] = bundle_dir
         ENV["BUNDLE_GEMFILE"] = find_gemfile(bundle_dir)
-        ENV["PATH"] = prepend_path(File.join(ruby_dir, "bin"), ENV["PATH"])
+        ruby_interpreter_bin = File.dirname(RbConfig.ruby)
+
+        # Keep interpreter/bin ahead of .bundle/bin so `#!/usr/bin/env ruby`
+        # resolves to the interpreter, not a gem-provided "ruby" executable.
         ENV["PATH"] = prepend_path(File.join(bundle_dir, "bin"), ENV["PATH"])
-        prepend_rubyopt("-rbundler/setup")
+        ENV["PATH"] = prepend_path(File.join(ruby_dir, "bin"), ENV["PATH"])
+        ENV["PATH"] = prepend_path(ruby_interpreter_bin, ENV["PATH"])
+        prepend_rubyopt("-rbundler/setup") unless passthrough_bundle
         export_original_env(original_env)
 
         command = resolve_command(command, bundle_dir, ruby_dir)
@@ -76,9 +78,9 @@ module Scint
 
       def prepend_path(prefix, current_path)
         return prefix unless current_path && !current_path.empty?
-        return current_path if current_path.split(File::PATH_SEPARATOR).include?(prefix)
-
-        "#{prefix}#{File::PATH_SEPARATOR}#{current_path}"
+        parts = current_path.split(File::PATH_SEPARATOR).reject(&:empty?)
+        parts.delete(prefix)
+        ([prefix] + parts).join(File::PATH_SEPARATOR)
       end
 
       def export_original_env(original_env)
@@ -87,6 +89,29 @@ module Scint
         # Non-fatal: shim can fallback to current ENV.
       end
 
+      def build_gem_path(bundle_ruby_dir, original_gem_path)
+        paths = [bundle_ruby_dir]
+        if defined?(Gem) && Gem.respond_to?(:default_path)
+          paths.concat(Array(Gem.default_path))
+        end
+        if original_gem_path && !original_gem_path.empty?
+          paths.concat(original_gem_path.split(File::PATH_SEPARATOR))
+        end
+        paths.reject(&:empty?).uniq.join(File::PATH_SEPARATOR)
+      end
+
+      def bundle_command?(command)
+        File.basename(command.to_s) == "bundle"
+      end
+
+      def rewrite_bundle_exec(command, args)
+        return [command, args] unless bundle_command?(command)
+        return [command, args] unless args.first == "exec"
+        return [command, args] if args.length < 2
+
+        [args[1], args[2..] || []]
+      end
+
       def resolve_command(command, bundle_dir, ruby_dir)
         return command if command.include?(File::SEPARATOR)
 
@@ -135,6 +160,7 @@ module Scint
       end
 
       private_class_method :find_gemfile, :prepend_rubyopt, :prepend_path, :export_original_env,
+                           :bundle_command?, :rewrite_bundle_exec, :build_gem_path,
                            :resolve_command, :find_gem_executable, :write_bundle_exec_wrapper
     end
   end

data/lib/scint/runtime/setup.rb

@@ -29,6 +29,7 @@ module Scint
         $LOAD_PATH.unshift(*paths)
 
         ENV["BUNDLE_GEMFILE"] ||= find_gemfile(File.dirname(lock_path))
+        hydrate_loaded_specs(lock_data)
 
         lock_data
       end
@@ -39,7 +40,34 @@ module Scint
         File.exist?(gemfile) ? gemfile : nil
       end
 
-      private_class_method :find_gemfile
+      def hydrate_loaded_specs(lock_data)
+        return unless defined?(Gem) && Gem.respond_to?(:loaded_specs)
+
+        lock_data.each do |name, info|
+          gem_name = name.to_s
+          next if gem_name.empty? || Gem.loaded_specs[gem_name]
+
+          version = info.is_a?(Hash) ? info[:version] : nil
+          spec = find_installed_spec(gem_name, version)
+          Gem.loaded_specs[gem_name] = spec if spec
+        end
+      rescue StandardError
+        # Best-effort compatibility with gems expecting Gem.loaded_specs.
+      end
+
+      def find_installed_spec(gem_name, version)
+        version_req = version.to_s.strip
+        if !version_req.empty?
+          exact = Gem::Specification.find_all_by_name(gem_name, version_req)
+          return exact.find { |spec| spec.version.to_s == version_req } || exact.first
+        end
+
+        Gem::Specification.find_all_by_name(gem_name).max_by(&:version)
+      rescue StandardError
+        nil
+      end
+
+      private_class_method :find_gemfile, :hydrate_loaded_specs, :find_installed_spec
     end
   end
 end

data/lib/scint/scheduler.rb

@@ -329,7 +329,12 @@ module Scint
           job.error = error
           @failed[job.id] = job
           @errors << { job_id: job.id, type: job.type, name: job.name, error: error }
-          @aborted = true if @fail_fast
+          if @fail_fast
+            @aborted = true
+            # Drop queued work immediately; wait_all will return once current
+            # in-flight jobs drain.
+            @pending.clear
+          end
         else
           job.state = :completed
           @completed[job.id] = job