scint 0.7.0 → 0.8.0

data/lib/scint/cli/install.rb

@@ -23,7 +23,9 @@ require_relative "../downloader/pool"
 require_relative "../gem/package"
 require_relative "../gem/extractor"
 require_relative "../cache/layout"
+require_relative "../cache/manifest"
 require_relative "../cache/metadata_store"
+require_relative "../cache/validity"
 require_relative "../installer/planner"
 require_relative "../installer/linker"
 require_relative "../installer/preparer"
@@ -41,40 +43,57 @@ module Scint
     class Install
       RUNTIME_LOCK = "scint.lock.marshal"
 
-      def initialize(argv = [])
+      def initialize(argv = [], without: nil, with: nil, output: $stderr)
         @argv = argv
         @jobs = nil
         @path = nil
         @verbose = false
         @force = false
+        @without_groups = nil
+        @with_groups = nil
+        @output = output
         @download_pool = nil
         @download_pool_lock = Thread::Mutex.new
         @gemspec_cache = {}
         @gemspec_cache_lock = Thread::Mutex.new
         parse_options
+        # Allow programmatic override (for tests)
+        @without_groups = Array(without).map(&:to_sym) if without
+        @with_groups = Array(with).map(&:to_sym) if with
+      end
+
+      def _tmark(label, t0)
+        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        @output.puts "  [timing] #{label}: #{((now - t0) * 1000).round}ms" if ENV["SCINT_TIMING"]
+        now
       end
 
       def run
         start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        _t = start_time
 
         cache = Scint::Cache::Layout.new
+        cache_telemetry = Scint::Cache::Telemetry.new
         bundle_path = @path || ENV["BUNDLER_PATH"] || ".bundle"
         bundle_display = display_bundle_path(bundle_path)
         bundle_path = File.expand_path(bundle_path)
-        worker_count = @jobs || [Platform.cpu_count * 2, 50].min
+        worker_count = [(@jobs || [Platform.cpu_count * 2, 50].min).to_i, 1].max
         compile_slots = compile_slots_for(worker_count)
-        per_type_limits = install_task_limits(worker_count, compile_slots)
-        $stdout.puts "#{GREEN}💎#{RESET} Scintellating Gemfile into #{BOLD}#{bundle_display}#{RESET} #{DIM}(scint #{VERSION}, ruby #{RUBY_VERSION})#{RESET}"
-        $stdout.puts
+        git_slots = git_slots_for(worker_count)
+        per_type_limits = install_task_limits(worker_count, compile_slots, git_slots)
+        @output.puts "#{GREEN}💎#{RESET} Scintellating Gemfile into #{BOLD}#{bundle_display}#{RESET} #{DIM}(scint #{VERSION}, ruby #{RUBY_VERSION})#{RESET}"
+        @output.puts
 
         # 0. Build credential store from config files (~/.bundle/config, XDG scint/credentials)
         @credentials = Credentials.new
 
         # 1. Start the scheduler with 1 worker — scale up dynamically
-        scheduler = Scheduler.new(max_workers: worker_count, fail_fast: true, per_type_limits: per_type_limits)
+        scheduler = Scheduler.new(max_workers: worker_count, fail_fast: true, per_type_limits: per_type_limits,
+                                  progress: Progress.new(output: @output))
         scheduler.start
 
         begin
+          _t = _tmark("startup", _t)
           # 2. Parse Gemfile
           gemfile = Scint::Gemfile::Parser.parse("Gemfile")
 
@@ -86,6 +105,7 @@ module Scint
           dep_count = gemfile.dependencies.size
           scheduler.scale_workers(dep_count)
 
+          _t = _tmark("parse_gemfile", _t)
           # 3. Enqueue index fetches for all sources immediately
           gemfile.sources.each do |source|
             scheduler.enqueue(:fetch_index, source[:uri] || source.to_s,
@@ -106,20 +126,26 @@ module Scint
                               -> { clone_git_source(source, cache) })
           end
 
+          _t = _tmark("enqueue_fetches", _t)
           # 6. Wait for index fetches, then resolve
           scheduler.wait_for(:fetch_index)
+          _t = _tmark("wait_index", _t)
           scheduler.wait_for(:git_clone)
+          _t = _tmark("wait_git", _t)
 
           resolved = resolve(gemfile, lockfile, cache)
           resolved = dedupe_resolved_specs(adjust_meta_gems(resolved))
+          resolved = filter_excluded_gems(resolved, gemfile)
           force_purge_artifacts(resolved, bundle_path, cache) if @force
 
+          _t = _tmark("resolve", _t)
           # 7. Plan: diff resolved vs installed
-          plan = Installer::Planner.plan(resolved, bundle_path, cache)
+          plan = Installer::Planner.plan(resolved, bundle_path, cache, telemetry: cache_telemetry)
           total_gems = resolved.size
           updated_gems = plan.count { |e| e.action != :skip }
           cached_gems = total_gems - updated_gems
           to_install = plan.reject { |e| e.action == :skip }
+          _t = _tmark("plan", _t)
 
           # Scale up for download/install phase based on actual work count
           scheduler.scale_workers(to_install.size)
@@ -127,6 +153,7 @@ module Scint
           # Warm-cache accelerator: pre-materialize cache-backed gem trees in
           # batches so install workers avoid one cp process per gem.
           bulk_prelink_gem_files(to_install, cache, bundle_path)
+          _t = _tmark("prelink", _t)
 
           if to_install.empty?
             # Keep lock artifacts aligned even when everything is already installed.
@@ -135,7 +162,7 @@ module Scint
             elapsed_ms = elapsed_ms_since(start_time)
             worker_count = scheduler.stats[:workers]
             warn_missing_bundle_gitignore_entry
-            $stdout.puts "\n#{GREEN}#{total_gems}#{RESET} gems installed total#{install_breakdown(cached: cached_gems, updated: updated_gems)}. #{DIM}(#{format_run_footer(elapsed_ms, worker_count)})#{RESET}"
+            @output.puts "\n#{GREEN}#{total_gems}#{RESET} gems installed total#{install_breakdown(cached: cached_gems, updated: updated_gems)}. #{DIM}(#{format_run_footer(elapsed_ms, worker_count)})#{RESET}"
             return 0
           end
 
@@ -160,14 +187,14 @@ module Scint
           errors = scheduler.errors.dup
           stats = scheduler.stats
           if errors.any?
-            $stderr.puts "#{RED}Some gems failed to install:#{RESET}"
+            @output.puts "#{RED}Some gems failed to install:#{RESET}"
             errors.each do |err|
               error = err[:error]
-              $stderr.puts "  #{BOLD}#{err[:name]}#{RESET}: #{error.message}"
+              @output.puts "  #{BOLD}#{err[:name]}#{RESET}: #{error.message}"
               emit_network_error_details(error)
             end
           elsif stats[:failed] > 0
-            $stderr.puts "#{YELLOW}Warning: #{stats[:failed]} jobs failed but no error details captured#{RESET}"
+            @output.puts "#{YELLOW}Warning: #{stats[:failed]} jobs failed but no error details captured#{RESET}"
           end
 
           elapsed_ms = elapsed_ms_since(start_time)
@@ -180,21 +207,25 @@ module Scint
 
           if has_failures
             warn_missing_bundle_gitignore_entry
-            $stdout.puts "\n#{RED}Bundle failed!#{RESET} #{installed_total}/#{total_gems} gems installed total#{install_breakdown(cached: cached_gems, updated: updated_gems, compiled: compiled_gems, failed: failed_count)}. #{DIM}(#{format_run_footer(elapsed_ms, worker_count)})#{RESET}"
+            @output.puts "\n#{RED}Bundle failed!#{RESET} #{installed_total}/#{total_gems} gems installed total#{install_breakdown(cached: cached_gems, updated: updated_gems, compiled: compiled_gems, failed: failed_count)}. #{DIM}(#{format_run_footer(elapsed_ms, worker_count)})#{RESET}"
             1
           else
             # 10. Write lockfile + runtime config only for successful installs
             write_lockfile(resolved, gemfile, lockfile)
             write_runtime_config(resolved, bundle_path)
             warn_missing_bundle_gitignore_entry
-            $stdout.puts "\n#{GREEN}#{total_gems}#{RESET} gems installed total#{install_breakdown(cached: cached_gems, updated: updated_gems, compiled: compiled_gems)}. #{DIM}(#{format_run_footer(elapsed_ms, worker_count)})#{RESET}"
+            @output.puts "\n#{GREEN}#{total_gems}#{RESET} gems installed total#{install_breakdown(cached: cached_gems, updated: updated_gems, compiled: compiled_gems)}. #{DIM}(#{format_run_footer(elapsed_ms, worker_count)})#{RESET}"
             0
           end
         ensure
           begin
-            scheduler.shutdown
+            cache_telemetry.warn_if_needed(cache_root: cache.root)
           ensure
-            close_download_pool
+            begin
+              scheduler.shutdown
+            ensure
+              close_download_pool
+            end
           end
         end
       end
@@ -233,6 +264,91 @@ module Scint
         seen.values
       end
 
+      # Determine which gem names should be excluded based on group settings.
+      # A gem is excluded if ALL of its group memberships are in excluded groups.
+      # Gems appearing in any non-excluded group are kept.
+      def excluded_gem_names(gemfile, resolved: nil)
+        excluded_groups = compute_excluded_groups(gemfile)
+        return Set.new if excluded_groups.empty?
+
+        # Build map: gem_name => set of all groups it appears in (across all declarations)
+        gem_groups = Hash.new { |h, k| h[k] = Set.new }
+        gemfile.dependencies.each do |dep|
+          dep.groups.each { |g| gem_groups[dep.name] << g }
+        end
+
+        # A gem is directly excluded if ALL its groups are excluded
+        directly_excluded = Set.new
+        gem_groups.each do |name, groups|
+          directly_excluded << name if groups.subset?(excluded_groups)
+        end
+
+        # If we have resolved specs, also exclude transitive-only deps
+        if resolved && directly_excluded.any?
+          exclude_transitive_deps(directly_excluded, resolved, gem_groups)
+        else
+          directly_excluded
+        end
+      end
+
+      # Filter resolved specs, removing gems that belong only to excluded groups.
+      def filter_excluded_gems(resolved, gemfile)
+        excluded = excluded_gem_names(gemfile, resolved: resolved)
+        return resolved if excluded.empty?
+
+        resolved.reject { |spec| excluded.include?(spec.name) }
+      end
+
+      private
+
+      def compute_excluded_groups(gemfile)
+        optional = Set.new(Array(gemfile.optional_groups))
+        without = Set.new(Array(@without_groups))
+        with = Set.new(Array(@with_groups))
+
+        # Optional groups are excluded by default unless explicitly included via --with
+        excluded = optional - with
+        # --without adds more groups to exclude
+        excluded.merge(without)
+        excluded
+      end
+
+      # Walk the dependency graph to find transitive deps that are ONLY
+      # reachable through excluded gems. Shared deps are kept.
+      def exclude_transitive_deps(directly_excluded, resolved, gem_groups)
+        # Build dependency graph: name => [dep_names]
+        dep_graph = {}
+        resolved.each do |spec|
+          dep_names = Array(spec.dependencies).filter_map do |dep|
+            if dep.is_a?(Hash)
+              dep[:name] || dep["name"]
+            elsif dep.respond_to?(:name)
+              dep.name
+            end
+          end
+          dep_graph[spec.name] = dep_names
+        end
+
+        all_names = Set.new(resolved.map(&:name))
+
+        # Start from Gemfile deps that are NOT excluded, then walk transitive deps
+        included_roots = gem_groups.keys.reject { |n| directly_excluded.include?(n) }
+
+        # BFS from included roots to find all reachable gems
+        reachable = Set.new
+        queue = included_roots.dup
+        while (name = queue.shift)
+          next if reachable.include?(name)
+          reachable << name
+          (dep_graph[name] || []).each { |dep| queue << dep }
+        end
+
+        # Everything not reachable from included roots is excluded
+        all_names - reachable
+      end
+
+      public
+
       # Install scint into the bundle by copying our own lib tree.
       # No download needed — we know exactly where we are.
       def install_builtin_gem(entry, bundle_path)
@@ -354,20 +470,20 @@ module Scint
           if opts[:git]
             git_source = find_matching_git_source(Array(lockfile&.sources), opts) || find_matching_git_source(gemfile.sources, opts)
             revision_hint = git_source&.revision || git_source&.ref || opts[:ref] || opts[:branch] || opts[:tag] || "HEAD"
-            bare_repo = cache&.git_path(opts[:git])
-            if bare_repo && !Dir.exist?(bare_repo)
-              clone_git_repo(opts[:git], bare_repo)
-            elsif bare_repo && Dir.exist?(bare_repo)
-              fetch_git_repo(bare_repo)
+            git_repo = cache&.git_path(opts[:git])
+            if git_repo && !Dir.exist?(git_repo)
+              clone_git_repo(opts[:git], git_repo)
+            elsif git_repo && Dir.exist?(git_repo)
+              fetch_git_repo(git_repo)
             end
-            if bare_repo && Dir.exist?(bare_repo)
+            if git_repo && Dir.exist?(git_repo)
               begin
-                resolved_revision = resolve_git_revision(bare_repo, revision_hint)
+                resolved_revision = resolve_git_revision(git_repo, revision_hint)
                 cache_key = "#{opts[:git]}@#{resolved_revision}"
                 git_metadata = git_source_metadata_cache[cache_key]
                 unless git_metadata
                   git_metadata = build_git_path_gems_for_revision(
-                    bare_repo,
+                    git_repo,
                     resolved_revision,
                     glob: opts[:glob],
                     source_desc: opts[:git],
@@ -429,17 +545,17 @@ module Scint
         candidates.each do |gs|
           next unless File.exist?(gs)
           begin
-            spec = Gem::Specification.load(gs)
+            spec = SpecUtils.load_gemspec(gs, isolate: true)
             return spec if spec
-          rescue StandardError
+          rescue SystemExit, StandardError
             nil
           end
         end
         nil
       end
 
-      def find_git_gemspec(bare_repo, revision, gem_name, glob: nil)
-        gemspec_paths = gemspec_paths_in_git_revision(bare_repo, revision)
+      def find_git_gemspec(git_repo, revision, gem_name, glob: nil)
+        gemspec_paths = gemspec_paths_in_git_revision(git_repo, revision)
         return nil if gemspec_paths.empty?
 
         path = gemspec_paths[gem_name.to_s]
@@ -450,23 +566,23 @@ module Scint
         path ||= gemspec_paths.values.first
         return nil if path.nil?
 
-        load_git_gemspec(bare_repo, revision, path)
+        load_git_gemspec(git_repo, revision, path)
       rescue StandardError
         nil
       end
 
-      def build_git_path_gems_for_revision(bare_repo, revision, glob: nil, source_desc: nil)
-        gemspec_paths = gemspec_paths_in_git_revision(bare_repo, revision)
+      def build_git_path_gems_for_revision(git_repo, revision, glob: nil, source_desc: nil)
+        gemspec_paths = gemspec_paths_in_git_revision(git_repo, revision)
         return {} if gemspec_paths.empty?
 
         glob_regex = glob ? git_glob_to_regex(glob) : nil
         data = {}
 
-        with_git_worktree(bare_repo, revision) do |worktree|
+        with_git_checkout(git_repo, revision) do |checkout_dir|
           gemspec_paths.each_value do |path|
             next if glob_regex && !path.match?(glob_regex)
 
-            gemspec = load_gemspec_from_worktree(worktree, path)
+            gemspec = load_gemspec_from_checkout(checkout_dir, path)
             next unless gemspec
 
             deps = gemspec.dependencies
@@ -611,19 +727,19 @@ module Scint
         by_source = git_specs.group_by { |s| s[:source] }
         by_source.each do |source, specs|
           uri, revision = git_source_ref(source)
-          bare_repo = cache.git_path(uri)
+          git_repo = cache.git_path(uri)
           # Do not invalidate an otherwise-usable lockfile just because this
           # git source has not been cached yet in the current machine/session.
-          next unless Dir.exist?(bare_repo)
+          next unless Dir.exist?(git_repo)
 
           resolved_revision = begin
-            resolve_git_revision(bare_repo, revision)
+            resolve_git_revision(git_repo, revision)
           rescue InstallError
             nil
           end
           return false unless resolved_revision
 
-          gemspec_paths = gemspec_paths_in_git_revision(bare_repo, resolved_revision)
+          gemspec_paths = gemspec_paths_in_git_revision(git_repo, resolved_revision)
           gemspec_names = gemspec_paths.keys.to_set
           return false if gemspec_names.empty?
 
@@ -635,9 +751,9 @@ module Scint
         true
       end
 
-      def gemspec_paths_in_git_revision(bare_repo, revision)
+      def gemspec_paths_in_git_revision(git_repo, revision)
         out, _err, status = git_capture3(
-          "--git-dir", bare_repo,
+          "-C", git_repo,
           "ls-tree",
           "-r",
           "--name-only",
@@ -657,8 +773,8 @@ module Scint
         {}
       end
 
-      def runtime_dependencies_for_git_gemspec(bare_repo, revision, gemspec_path)
-        spec = load_git_gemspec(bare_repo, revision, gemspec_path)
+      def runtime_dependencies_for_git_gemspec(git_repo, revision, gemspec_path)
+        spec = load_git_gemspec(git_repo, revision, gemspec_path)
         return nil unless spec
 
         spec.dependencies.select { |dep| dep.type == :runtime }
@@ -666,41 +782,32 @@ module Scint
         nil
       end
 
-      def load_git_gemspec(bare_repo, revision, gemspec_path)
+      def load_git_gemspec(git_repo, revision, gemspec_path)
         return nil if gemspec_path.to_s.empty?
 
-        with_git_worktree(bare_repo, revision) do |worktree|
-          load_gemspec_from_worktree(worktree, gemspec_path)
+        with_git_checkout(git_repo, revision) do |checkout_dir|
+          load_gemspec_from_checkout(checkout_dir, gemspec_path)
         end
       rescue StandardError
         nil
       end
 
-      def with_git_worktree(bare_repo, revision)
-        worktree = Dir.mktmpdir("scint-gemspec")
+      def with_git_checkout(git_repo, revision)
         _out, _err, status = git_capture3(
-          "--git-dir", bare_repo,
-          "--work-tree", worktree,
-          "checkout",
-          "--force",
-          revision,
+          "-C", git_repo,
+          "checkout", "-f", revision,
         )
         return nil unless status.success?
 
-        File.write(File.join(worktree, ".git"), "gitdir: #{bare_repo}\n")
-        yield worktree if block_given?
-      ensure
-        FileUtils.rm_rf(worktree) if worktree && !worktree.empty?
+        yield git_repo if block_given?
       end
 
-      def load_gemspec_from_worktree(worktree, gemspec_path)
-        absolute_gemspec = File.join(worktree, gemspec_path)
+      def load_gemspec_from_checkout(checkout_dir, gemspec_path)
+        absolute_gemspec = File.join(checkout_dir, gemspec_path)
         return nil unless File.exist?(absolute_gemspec)
 
-        Dir.chdir(File.dirname(absolute_gemspec)) do
-          Gem::Specification.load(absolute_gemspec)
-        end
-      rescue StandardError
+        SpecUtils.load_gemspec(absolute_gemspec, isolate: true)
+      rescue SystemExit, StandardError
         nil
       end
 
@@ -786,7 +893,7 @@ module Scint
         spec = entry.spec
         source = spec.source
         if git_source?(source)
-          prepare_git_checkout(spec, cache, fetch: false)
+          ensure_git_repo_for_spec(spec, cache, fetch: true)
           return
         end
         source_uri = source.to_s
@@ -827,21 +934,34 @@ module Scint
         # Git gems are extracted from the cached checkout; path gems are
         # linked directly from local source.
         if git_source?(spec.source)
-          materialize_git_spec(entry, cache)
+          assemble_git_spec(entry, cache, fetch: false)
           return
         end
         return if source_uri.start_with?("/") || !source_uri.start_with?("http")
 
-        extracted = cache.extracted_path(spec)
-        return if Dir.exist?(extracted)
+        return if Scint::Cache::Validity.cached_valid?(spec, cache)
 
         dest_path = cache.inbound_path(spec)
         raise InstallError, "Missing cached gem file for #{spec.name}: #{dest_path}" unless File.exist?(dest_path)
 
-        FS.mkdir_p(extracted)
-        pkg = GemPkg::Package.new
-        result = pkg.extract(dest_path, extracted)
-        cache_gemspec(spec, result[:gemspec], cache)
+        assembling = cache.assembling_path(spec)
+        tmp = "#{assembling}.#{Process.pid}.#{Thread.current.object_id}.tmp"
+        begin
+          FileUtils.rm_rf(assembling)
+          FileUtils.rm_rf(tmp)
+          FS.mkdir_p(File.dirname(assembling))
+
+          pkg = GemPkg::Package.new
+          result = pkg.extract(dest_path, tmp)
+          FS.atomic_move(tmp, assembling)
+          cache_gemspec(spec, result[:gemspec], cache)
+
+          unless Installer::ExtensionBuilder.needs_build?(spec, assembling)
+            promote_assembled_gem(spec, cache, assembling, result[:gemspec], extensions: false)
+          end
+        ensure
+          FileUtils.rm_rf(tmp) if tmp && File.exist?(tmp)
+        end
       end
 
       def git_source?(source)
@@ -870,113 +990,94 @@ module Scint
       def prepare_git_source(entry, cache)
         # Legacy helper used by tests/callers that expect git download+extract
         # in a single step.
-        spec = entry.spec
-        checkout_dir, resolved_revision, _uri = prepare_git_checkout(spec, cache, fetch: true)
-        materialize_git_spec(entry, cache, checkout_dir: checkout_dir, resolved_revision: resolved_revision)
+        assemble_git_spec(entry, cache, fetch: true)
       end
 
-      def prepare_git_checkout(spec, cache, fetch: false)
+      def ensure_git_repo_for_spec(spec, cache, fetch:)
         source = spec.source
-        uri, revision = git_source_ref(source)
-        submodules = git_source_submodules?(source)
-
-        bare_repo = cache.git_path(uri)
+        uri, _revision = git_source_ref(source)
+        git_repo = cache.git_path(uri)
 
-        # Serialize all git operations per bare repo — git uses index.lock
+        # Serialize all git operations per repo — git uses index.lock
         # and can't handle concurrent checkouts from the same repo.
-        git_mutex_for(bare_repo).synchronize do
-          if Dir.exist?(bare_repo)
-            fetch_git_repo(bare_repo) if fetch
+        git_mutex_for(git_repo).synchronize do
+          if Dir.exist?(git_repo)
+            fetch_git_repo(git_repo) if fetch
           else
-            clone_git_repo(uri, bare_repo)
-            fetch_git_repo(bare_repo)
+            clone_git_repo(uri, git_repo)
           end
-
-          resolved_revision = resolve_git_revision(bare_repo, revision)
-          incoming_checkout = cache.git_checkout_path(uri, resolved_revision)
-          materialize_git_checkout(
-            bare_repo,
-            incoming_checkout,
-            resolved_revision,
-            spec,
-            uri,
-            submodules: submodules,
-          )
-          [incoming_checkout, resolved_revision, uri]
         end
+
+        git_repo
       end
 
-      def materialize_git_spec(entry, cache, checkout_dir: nil, resolved_revision: nil)
+      def assemble_git_spec(entry, cache, fetch: true)
         spec = entry.spec
-        checkout_dir, resolved_revision, _uri = prepare_git_checkout(spec, cache, fetch: false) unless checkout_dir && resolved_revision
-        gem_root = resolve_git_gem_subdir(checkout_dir, spec)
-        extracted = cache.extracted_path(spec)
-        marker = git_checkout_marker_path(extracted)
-        if Dir.exist?(extracted) &&
-           File.exist?(marker) &&
-           File.read(marker).strip == resolved_revision &&
-           git_spec_layout_current?(extracted, spec)
-          return
-        end
+        return if Scint::Cache::Validity.cached_valid?(spec, cache)
 
-        tmp = "#{extracted}.#{Process.pid}.#{Thread.current.object_id}.tmp"
-        begin
-          FileUtils.rm_rf(tmp)
-          FS.clone_tree(gem_root, tmp)
+        source = spec.source
+        uri, revision = git_source_ref(source)
+        submodules = git_source_submodules?(source)
 
-          FileUtils.rm_rf(extracted)
-          FS.atomic_move(tmp, extracted)
-          FS.atomic_write(marker, "#{resolved_revision}\n")
-        ensure
-          FileUtils.rm_rf(tmp) if tmp && File.exist?(tmp)
-        end
-      end
+        git_repo = cache.git_path(uri)
 
-      def git_spec_layout_current?(extracted_path, spec)
-        File.exist?(File.join(extracted_path, "#{spec.name}.gemspec"))
-      rescue StandardError
-        false
-      end
+        # Serialize all git operations per repo — git uses index.lock
+        # and can't handle concurrent checkouts from the same repo.
+        git_mutex_for(git_repo).synchronize do
+          tmp_assembled = nil
 
-      def materialize_git_checkout(bare_repo, checkout_dir, resolved_revision, spec, uri, submodules: false)
-        marker = git_checkout_marker_path(checkout_dir)
-        if Dir.exist?(checkout_dir) && File.exist?(marker)
-          checkout_marker = parse_git_checkout_marker(marker)
-          marker_revision = checkout_marker[:revision]
-          marker_submodules = checkout_marker[:submodules]
+          begin
+            if Dir.exist?(git_repo)
+              fetch_git_repo(git_repo) if fetch
+            else
+              clone_git_repo(uri, git_repo)
+            end
 
-          # Legacy markers only recorded revision. If this source now requires
-          # submodules, force a refresh so previously incomplete checkouts are
-          # not reused.
-          return if marker_revision == resolved_revision && (!submodules || marker_submodules == true)
-        end
+            resolved_revision = resolve_git_revision(git_repo, revision)
+            assembling = cache.assembling_path(spec)
+            tmp_assembled = "#{assembling}.#{Process.pid}.#{Thread.current.object_id}.tmp"
+            promoter = cache_promoter(cache)
 
-        tmp = "#{checkout_dir}.#{Process.pid}.#{Thread.current.object_id}.tmp"
-        begin
-          FileUtils.rm_rf(tmp)
-          if submodules
-            checkout_git_tree_with_submodules(
-              bare_repo,
-              tmp,
-              resolved_revision,
-              spec,
-              uri,
-            )
-          else
-            checkout_git_tree(
-              bare_repo,
-              tmp,
-              resolved_revision,
-              spec,
-              uri,
-            )
-          end
+            FileUtils.rm_rf(assembling)
+            FileUtils.rm_rf(tmp_assembled)
+            FS.mkdir_p(File.dirname(assembling))
 
-          FileUtils.rm_rf(checkout_dir)
-          FS.atomic_move(tmp, checkout_dir)
-          FS.atomic_write(marker, format_git_checkout_marker(resolved_revision, submodules: submodules))
-        ensure
-          FileUtils.rm_rf(tmp) if tmp && File.exist?(tmp)
+            promoter.validate_within_root!(cache.root, assembling, label: "assembling")
+            promoter.validate_within_root!(cache.root, tmp_assembled, label: "git-assembled")
+
+            checkout_git_revision(git_repo, resolved_revision, spec, uri, submodules: submodules)
+
+            gem_root = resolve_git_gem_subdir(git_repo, spec)
+            gem_rel = git_relative_root(git_repo, gem_root)
+            dest_root = tmp_assembled
+            dest_path = gem_rel.empty? ? dest_root : File.join(dest_root, gem_rel)
+
+            promoter.validate_within_root!(cache.root, dest_path, label: "git-dest")
+
+            FS.clone_tree(gem_root, dest_path)
+
+            # Remove .git artifacts so assembled output is deterministic.
+            Dir.glob(File.join(tmp_assembled, "**", ".git"), File::FNM_DOTMATCH).each do |path|
+              FileUtils.rm_rf(path)
+            end
+
+            copy_gemspec_root_files(git_repo, gem_root, dest_root, spec)
+            FS.atomic_move(tmp_assembled, assembling)
+
+            gem_subdir = begin
+              resolve_git_gem_subdir(assembling, spec)
+            rescue InstallError
+              assembling
+            end
+            gemspec = read_gemspec_from_extracted(gem_subdir, spec)
+            cache_gemspec(spec, gemspec, cache) if gemspec
+
+            unless Installer::ExtensionBuilder.needs_build?(spec, assembling)
+              promote_assembled_gem(spec, cache, assembling, gemspec, extensions: false)
+            end
+          ensure
+            FileUtils.rm_rf(tmp_assembled) if tmp_assembled && File.exist?(tmp_assembled)
+          end
         end
       end
 
@@ -993,61 +1094,76 @@ module Scint
         source.respond_to?(:submodules) && !!source.submodules
       end
 
-      def checkout_git_tree(bare_repo, destination, resolved_revision, spec, uri)
-        FileUtils.mkdir_p(destination)
-        _out, err, status = git_capture3(
-          "--git-dir", bare_repo,
-          "--work-tree", destination,
-          "checkout",
-          "-f",
-          resolved_revision,
-          "--",
-          ".",
-        )
-        unless status.success?
-          raise InstallError, "Git checkout failed for #{spec.name} (#{uri}@#{resolved_revision}): #{err.to_s.strip}"
+      def copy_gemspec_root_files(repo_root, gem_root, dest_root, spec)
+        repo_root = File.expand_path(repo_root.to_s)
+        gem_root = File.expand_path(gem_root.to_s)
+        return if repo_root == gem_root
+
+        gemspec_path = git_gemspec_path_for_root(gem_root, spec)
+        return unless gemspec_path && File.exist?(gemspec_path)
+
+        content = File.read(gemspec_path) rescue nil
+        return unless content
+
+        root_files = git_root_files_from_gemspec(content)
+        root_files.each do |file|
+          source = File.join(repo_root, file)
+          next unless File.file?(source)
+
+          dest = File.join(dest_root, file)
+          next if File.exist?(dest)
+
+          FS.clonefile(source, dest)
         end
       end
 
-      def checkout_git_tree_with_submodules(bare_repo, destination, resolved_revision, spec, uri)
-        worktree = "#{destination}.worktree"
-        FileUtils.rm_rf(worktree)
+      def git_gemspec_path_for_root(gem_root, spec)
+        if spec && spec.respond_to?(:name)
+          candidate = File.join(gem_root, "#{spec.name}.gemspec")
+          return candidate if File.exist?(candidate)
+        end
+
+        Dir.glob(File.join(gem_root, "*.gemspec")).first
+      end
+
+      def git_root_files_from_gemspec(content)
+        files = ["RAILS_VERSION", "VERSION"]
+        files.select { |file| content.include?(file) }
+      end
+
+      def git_relative_root(repo_root, gem_root)
+        repo_root = File.expand_path(repo_root.to_s)
+        gem_root = File.expand_path(gem_root.to_s)
+        return "" if repo_root == gem_root
+
+        if gem_root.start_with?("#{repo_root}/")
+          return gem_root.delete_prefix("#{repo_root}/")
+        end
+
+        File.basename(gem_root)
+      end
 
+      def checkout_git_revision(git_repo, resolved_revision, spec, uri, submodules: false)
         _out, err, status = git_capture3(
-          "--git-dir", bare_repo,
-          "worktree",
-          "add",
-          "--detach",
-          "--force",
-          worktree,
-          resolved_revision,
+          "-C", git_repo,
+          "checkout", "-f", resolved_revision,
         )
         unless status.success?
-          raise InstallError, "Git worktree checkout failed for #{spec.name} (#{uri}@#{resolved_revision}): #{err.to_s.strip}"
+          raise InstallError, "Git checkout failed for #{spec.name} (#{uri}@#{resolved_revision}): #{err.to_s.strip}"
         end
 
-        begin
-          _sub_out, sub_err, sub_status = git_capture3(
-            "-C", worktree,
-            "-c", "protocol.file.allow=always",
-            "submodule",
-            "update",
-            "--init",
-            "--recursive",
-          )
-          unless sub_status.success?
-            raise InstallError, "Git submodule update failed for #{spec.name} (#{uri}@#{resolved_revision}): #{sub_err.to_s.strip}"
-          end
-
-          FS.clone_tree(worktree, destination)
+        return unless submodules
 
-          # Keep cache/extracted trees deterministic and detached from git internals.
-          Dir.glob(File.join(destination, "**", ".git"), File::FNM_DOTMATCH).each do |path|
-            FileUtils.rm_rf(path)
-          end
-        ensure
-          git_capture3("--git-dir", bare_repo, "worktree", "remove", "--force", worktree)
-          FileUtils.rm_rf(worktree)
+        _sub_out, sub_err, sub_status = git_capture3(
+          "-C", git_repo,
+          "-c", "protocol.file.allow=always",
+          "submodule",
+          "update",
+          "--init",
+          "--recursive",
+        )
+        unless sub_status.success?
+          raise InstallError, "Git submodule update failed for #{spec.name} (#{uri}@#{resolved_revision}): #{sub_err.to_s.strip}"
         end
       end
 
@@ -1059,32 +1175,35 @@ module Scint
         end
       end
 
-      def clone_git_repo(uri, bare_repo)
-        FS.mkdir_p(File.dirname(bare_repo))
-        _out, err, status = git_capture3("clone", "--bare", uri.to_s, bare_repo)
+      def clone_git_repo(uri, git_repo)
+        FS.mkdir_p(File.dirname(git_repo))
+        _out, err, status = git_capture3("clone", uri.to_s, git_repo)
         unless status.success?
           raise InstallError, "Git clone failed for #{uri}: #{err.to_s.strip}"
         end
       end
 
-      def fetch_git_repo(bare_repo)
+      def fetch_git_repo(git_repo)
         _out, err, status = git_capture3(
-          "--git-dir", bare_repo,
+          "-C", git_repo,
           "fetch",
           "--prune",
+          "--force",
           "origin",
-          "+refs/heads/*:refs/heads/*",
-          "+refs/tags/*:refs/tags/*",
         )
         unless status.success?
-          raise InstallError, "Git fetch failed for #{bare_repo}: #{err.to_s.strip}"
+          raise InstallError, "Git fetch failed for #{git_repo}: #{err.to_s.strip}"
         end
       end
 
-      def resolve_git_revision(bare_repo, revision)
-        out, err, status = git_capture3("--git-dir", bare_repo, "rev-parse", "#{revision}^{commit}")
+      def resolve_git_revision(git_repo, revision)
+        # Try origin/<revision> first so we pick up fetched branch tips.
+        out, _err, status = git_capture3("-C", git_repo, "rev-parse", "origin/#{revision}^{commit}")
+        return out.strip if status.success?
+
+        out, err, status = git_capture3("-C", git_repo, "rev-parse", "#{revision}^{commit}")
         unless status.success?
-          raise InstallError, "Unable to resolve git revision #{revision.inspect} in #{bare_repo}: #{err.to_s.strip}"
+          raise InstallError, "Unable to resolve git revision #{revision.inspect} in #{git_repo}: #{err.to_s.strip}"
         end
         out.strip
       end
@@ -1093,64 +1212,59 @@ module Scint
         Open3.capture3("git", "-c", "core.fsmonitor=false", *args)
       end
 
-      def git_checkout_marker_path(dir)
-        "#{dir}.scint_git_revision"
-      end
-
-      def parse_git_checkout_marker(path)
-        content = File.read(path)
-        revision = nil
-        submodules = nil
-
-        content.each_line do |line|
-          key, value = line.strip.split("=", 2)
-          case key
-          when "revision"
-            revision = value
-          when "submodules"
-            submodules = (value == "1" || value == "true")
-          end
-        end
-
-        if revision.nil?
-          # Legacy format: raw revision only.
-          revision = content.strip
-        end
-
-        { revision: revision, submodules: submodules }
-      rescue StandardError
-        { revision: nil, submodules: nil }
-      end
+      def compile_slots_for(worker_count)
+        # Scale compile concurrency with available CPUs.
+        # Most native extensions have 1-3 source files and don't benefit from
+        # high make -j; running more concurrent builds is more effective.
+        # Each slot gets cpu_count/slots make jobs (see adaptive_make_jobs).
+        workers = [worker_count.to_i, 1].max
+        override = positive_integer_env("SCINT_COMPILE_CONCURRENCY")
+        return [override, workers].min if override
 
-      def format_git_checkout_marker(revision, submodules:)
-        "revision=#{revision}\nsubmodules=#{submodules ? 1 : 0}\n"
+        cpus = Platform.cpu_count
+        # Aim for 8 make-jobs per slot → slots = cpus / 8, clamped.
+        slots = cpus / 8
+        slots = [[slots, 2].max, workers].min
+        slots
       end
 
-      def compile_slots_for(worker_count)
-        # Keep compile parallelism conservative: at most 2 native builds.
-        # Small pools stay single-lane; larger pools can run two builds.
-        workers = worker_count.to_i
-        return 1 if workers <= 6
-
-        2
+      def git_slots_for(worker_count)
+        workers = [worker_count.to_i, 1].max
+        override = positive_integer_env("SCINT_GIT_CONCURRENCY")
+        slots = override || workers
+        [[slots, workers].min, 1].max
       end
 
-      def install_task_limits(worker_count, compile_slots)
+      def install_task_limits(worker_count, compile_slots, git_slots = worker_count)
         # Leave headroom for compile and binstub lanes so link/download
         # throughput cannot fully starve them.
-        io_cpu_limit = [worker_count - compile_slots - 1, 1].max
+        workers = [worker_count.to_i, 1].max
+        io_cpu_limit = [workers - compile_slots - 1, 1].max
         # Keep download in-flight set bounded so fail-fast exits quickly on
         # auth/source errors instead of queueing a large burst.
         download_limit = [io_cpu_limit, 8].min
+        git_limit = [[git_slots.to_i, 1].max, workers].min
         {
           download: download_limit,
           extract: io_cpu_limit,
           link: io_cpu_limit,
+          git_clone: git_limit,
           build_ext: compile_slots,
           binstub: 1,
         }
       end
 
+      def positive_integer_env(key)
+        raw = ENV[key]
+        return nil if raw.nil? || raw.empty?
+
+        value = Integer(raw, exception: false)
+        return nil unless value
+        return nil if value <= 0
+
+        value
+      end
+
       def display_bundle_path(path)
         return path if path.start_with?("/", "./", "../")
 
@@ -1297,10 +1411,21 @@ module Scint
             source_str
           end
         else
-          base = entry.cached_path || cache.extracted_path(entry.spec)
-          if git_source?(entry.spec.source) && Dir.exist?(base)
+          cached_dir = cache.cached_path(entry.spec)
+          assembling = cache.assembling_path(entry.spec)
+          base = if entry.cached_path
+            entry.cached_path
+          elsif Scint::Cache::Validity.cached_valid?(entry.spec, cache)
+            cached_dir
+          elsif Dir.exist?(assembling)
+            assembling
+          else
+            nil
+          end
+
+          if git_source?(entry.spec.source) && base && Dir.exist?(base)
             resolve_git_gem_subdir(base, entry.spec)
-          elsif path_source?(entry.spec.source) && Dir.exist?(base)
+          elsif path_source?(entry.spec.source) && base && Dir.exist?(base)
             begin
               resolve_path_gem_subdir(base, entry.spec)
             rescue InstallError
@@ -1371,19 +1496,18 @@ module Scint
           from_cache: true,
         )
         Installer::Linker.link_files(prepared, bundle_path)
-        # If this gem has a cached native build, materialize it during link.
-        # This lets reinstalling into a fresh .bundle skip build_ext entirely.
-        Installer::ExtensionBuilder.link_cached_build(prepared, bundle_path, cache)
       end
 
       def build_extensions(entry, cache, bundle_path, progress = nil, compile_slots: 1)
+        spec = entry.spec
         extracted = extracted_path_for_entry(entry, cache)
-        gemspec = load_gemspec(extracted, entry.spec, cache)
+        gemspec = load_gemspec(extracted, spec, cache)
+        promote_after_build = assembling_path?(extracted, cache)
 
-        sync_build_env_dependencies(entry.spec, bundle_path, cache)
+        sync_build_env_dependencies(spec, bundle_path, cache)
 
         prepared = PreparedGem.new(
-          spec: entry.spec,
+          spec: spec,
           extracted_path: extracted,
           gemspec: gemspec,
           from_cache: true,
@@ -1394,8 +1518,24 @@ module Scint
           bundle_path,
           cache,
           compile_slots: compile_slots,
-          output_tail: ->(lines) { progress&.on_build_tail(entry.spec.name, lines) },
+          output_tail: ->(lines) { progress&.on_build_tail(spec.name, lines) },
         )
+
+        ruby_dir = Platform.ruby_install_dir(bundle_path)
+        bundle_gem_dir = File.join(ruby_dir, "gems", SpecUtils.full_name(spec))
+        if Dir.exist?(bundle_gem_dir)
+          Installer::ExtensionBuilder.sync_extensions_into_gem(extracted, bundle_gem_dir)
+          File.write(File.join(bundle_gem_dir, Installer::ExtensionBuilder::BUILD_MARKER), "")
+        end
+
+        return unless promote_after_build
+
+        promote_assembled_gem(spec, cache, extracted, gemspec, extensions: true)
+      rescue StandardError
+        if promote_after_build && extracted && Dir.exist?(extracted)
+          FileUtils.rm_rf(extracted)
+        end
+        raise
       end
 
       def sync_build_env_dependencies(spec, bundle_path, cache)
@@ -1460,6 +1600,12 @@ module Scint
           return cached
         end
 
+        direct = read_gemspec_from_extracted(extracted_path, spec)
+        if direct
+          @gemspec_cache_lock.synchronize { @gemspec_cache[cache_key] = direct }
+          return direct
+        end
+
         inbound = cache.inbound_path(spec)
         return nil unless File.exist?(inbound)
 
@@ -1473,49 +1619,90 @@ module Scint
         end
       end
 
+      def read_gemspec_from_extracted(extracted_dir, spec)
+        return nil unless extracted_dir && Dir.exist?(extracted_dir)
+
+        pattern = File.join(extracted_dir, "*.gemspec")
+        candidates = Dir.glob(pattern)
+        return nil if candidates.empty?
+
+        load_gemspec_file(candidates.first, spec)
+      end
+
+      # Load a .gemspec file, temporarily injecting VERSION env var for gems
+      # like kgio/unicorn that use `ENV["VERSION"] or abort` in their gemspec.
+      def load_gemspec_file(path, spec = nil)
+        version = spec.respond_to?(:version) ? spec.version.to_s : nil
+        old_version = ENV["VERSION"]
+        begin
+          ENV["VERSION"] = version if version && !ENV["VERSION"]
+          SpecUtils.load_gemspec(path, isolate: true)
+        rescue SystemExit, StandardError
+          nil
+        ensure
+          ENV["VERSION"] = old_version
+        end
+      end
+
       def bulk_prelink_gem_files(entries, cache, bundle_path)
-        # Keep small installs simple; batching is for large warm-path runs.
         return if entries.length < 32
 
         ruby_dir = File.join(bundle_path, "ruby", RUBY_VERSION.split(".")[0, 2].join(".") + ".0")
         gems_dir = File.join(ruby_dir, "gems")
+        cache_abi_dir = cache.cached_abi_dir
 
-        sources = entries.filter_map do |entry|
+        gem_names = []
+        entries.each do |entry|
           next unless entry.action == :link || entry.action == :build_ext
 
-          extracted = cache.extracted_path(entry.spec)
+          source_dir = entry.cached_path
+          next unless source_dir
+
           full_name = cache.full_name(entry.spec)
-          next unless File.basename(extracted) == full_name
-          next unless Dir.exist?(extracted)
+          next unless File.basename(source_dir) == full_name
+          next unless Dir.exist?(source_dir)
           next if Dir.exist?(File.join(gems_dir, full_name))
 
-          extracted
+          gem_names << full_name
+        end
+
+        return if gem_names.empty?
+
+        if ENV["SCINT_TIMING"]
+          @output.puts "  [timing] prelink: #{gem_names.size} gems via linker"
         end
-        return if sources.empty?
 
-        FS.clone_many_trees(sources, gems_dir)
+        FS.bulk_link_gems(cache_abi_dir, gems_dir, gem_names)
       rescue StandardError => e
-        $stderr.puts("bulk prelink warning: #{e.message}") if ENV["SCINT_DEBUG"]
+        @output.puts("bulk prelink warning: #{e.message}") if ENV["SCINT_DEBUG"]
       end
 
       def load_cached_gemspec(spec, cache, extracted_path)
-        path = cache.spec_cache_path(spec)
-        return nil unless File.exist?(path)
+        paths = [cache.cached_spec_path(spec)]
 
-        data = File.binread(path)
-        gemspec = if data.start_with?("---")
-          Gem::Specification.from_yaml(data)
-        else
-          begin
-            Marshal.load(data)
-          rescue StandardError
+        paths.each do |path|
+          next unless File.exist?(path)
+
+          data = File.binread(path)
+          gemspec = if data.start_with?("# -*- encoding")
+            # Ruby format (to_ruby output) — most reliable, preserves require_paths
+            Gem::Specification.load(path)
+          elsif data.start_with?("---")
+            data.force_encoding("UTF-8") if data.encoding != Encoding::UTF_8
             Gem::Specification.from_yaml(data)
+          else
+            begin
+              Marshal.load(data)
+            rescue StandardError
+              data.force_encoding("UTF-8") if data.encoding != Encoding::UTF_8
+              Gem::Specification.from_yaml(data)
+            end
           end
+          return gemspec if cached_gemspec_valid?(gemspec, extracted_path)
         end
-        return gemspec if cached_gemspec_valid?(gemspec, extracted_path)
 
         nil
-      rescue StandardError
+      rescue SystemExit, StandardError
         nil
       end
 
@@ -1549,12 +1736,108 @@ module Scint
       end
 
       def cache_gemspec(spec, gemspec, cache)
-        path = cache.spec_cache_path(spec)
-        FS.atomic_write(path, gemspec.to_yaml)
+        path = cache.cached_spec_path(spec)
+        content = if gemspec.respond_to?(:to_ruby)
+          gemspec.to_ruby
+        else
+          gemspec.to_yaml
+        end
+        FS.atomic_write(path, content)
       rescue StandardError
         # Non-fatal: we'll read metadata from .gem next time.
       end
 
+      def cache_promoter(cache)
+        @cache_promoter ||= Installer::Promoter.new(root: cache.root)
+      end
+
+      def assembling_path?(path, cache)
+        return false if path.nil? || path.empty?
+
+        root = File.expand_path(cache.assembling_dir)
+        candidate = File.expand_path(path)
+        candidate == root || candidate.start_with?("#{root}/")
+      end
+
+      def promote_assembled_gem(spec, cache, assembling_path, gemspec, extensions:)
+        return unless assembling_path && Dir.exist?(assembling_path)
+
+        cached_dir = cache.cached_path(spec)
+        promoter = cache_promoter(cache)
+        lock_key = "#{Platform.abi_key}-#{cache.full_name(spec)}"
+
+        promoter.validate_within_root!(cache.root, assembling_path, label: "assembling")
+        promoter.validate_within_root!(cache.root, cached_dir, label: "cached")
+
+        begin
+          result = nil
+          promoter.with_staging_dir(prefix: "cached") do |staging|
+            FS.clone_tree(assembling_path, staging)
+            manifest = build_cached_manifest(spec, cache, staging, extensions: extensions)
+            Scint::Cache::Manifest.write_dotfiles(staging, manifest)
+            spec_payload = gemspec ? gemspec.to_ruby : nil
+            result = promoter.promote_tree(
+              staging_path: staging,
+              target_path: cached_dir,
+              lock_key: lock_key,
+            )
+            if result == :promoted
+              write_cached_metadata(spec, cache, spec_payload, manifest)
+            end
+            FileUtils.rm_rf(assembling_path) if Dir.exist?(assembling_path)
+          end
+          result
+        rescue StandardError
+          FileUtils.rm_rf(cached_dir) if Dir.exist?(cached_dir)
+          raise
+        end
+      end
+
+      def write_cached_metadata(spec, cache, spec_payload, manifest)
+        spec_path = cache.cached_spec_path(spec)
+        manifest_path = cache.cached_manifest_path(spec)
+        FS.mkdir_p(File.dirname(spec_path))
+
+        FS.atomic_write(spec_path, spec_payload) if spec_payload
+        Scint::Cache::Manifest.write(manifest_path, manifest)
+      end
+
+      def build_cached_manifest(spec, cache, gem_dir, extensions:)
+        Scint::Cache::Manifest.build(
+          spec: spec,
+          gem_dir: gem_dir,
+          abi_key: Platform.abi_key,
+          source: manifest_source_for(spec),
+          extensions: extensions,
+        )
+      end
+
+      def manifest_source_for(spec)
+        source = spec.source
+        if source.is_a?(Source::Git)
+          {
+            "type" => "git",
+            "uri" => source.uri.to_s,
+            "revision" => source.revision || source.ref || source.branch || source.tag,
+          }.compact
+        elsif source.is_a?(Source::Path)
+          {
+            "type" => "path",
+            "path" => File.expand_path(source.path.to_s),
+            "uri" => source.path.to_s,
+          }
+        else
+          source_str = source.to_s
+          if source_str.start_with?("http://", "https://")
+            { "type" => "rubygems", "uri" => source_str }
+          elsif path_source?(source)
+            { "type" => "path", "path" => File.expand_path(source_str), "uri" => source_str }
+          else
+            { "type" => "rubygems", "uri" => source_str }
+          end
+        end
+      end
+
       # --- Lockfile + runtime config ---
 
       def write_lockfile(resolved, gemfile, lockfile = nil)
@@ -1963,10 +2246,10 @@ module Scint
       def read_require_paths(spec_file)
         return ["lib"] unless File.exist?(spec_file)
 
-        gemspec = Gem::Specification.load(spec_file)
+        gemspec = SpecUtils.load_gemspec(spec_file)
         paths = Array(gemspec&.require_paths).reject(&:empty?)
         paths.empty? ? ["lib"] : paths
-      rescue StandardError
+      rescue SystemExit, StandardError
         ["lib"]
       end
 
@@ -2020,8 +2303,12 @@ module Scint
 
           # Global cache artifacts.
           FileUtils.rm_f(cache.inbound_path(spec))
-          FileUtils.rm_rf(cache.extracted_path(spec))
+          FileUtils.rm_rf(cache.assembling_path(spec))
+          FileUtils.rm_rf(cache.cached_path(spec))
+          FileUtils.rm_f(cache.cached_spec_path(spec))
+          FileUtils.rm_f(cache.cached_manifest_path(spec))
           FileUtils.rm_f(cache.spec_cache_path(spec))
+          FileUtils.rm_rf(cache.extracted_path(spec))
           FileUtils.rm_rf(cache.ext_path(spec))
 
           # Local bundle artifacts.
@@ -2056,17 +2343,17 @@ module Scint
         return if (headers.nil? || headers.empty?) && body.empty?
 
         if headers && !headers.empty?
-          $stderr.puts "    headers:"
+          @output.puts "    headers:"
           headers.sort.each do |key, value|
-            $stderr.puts "      #{key}: #{value}"
+            @output.puts "      #{key}: #{value}"
           end
         end
 
         return if body.empty?
 
-        $stderr.puts "    body:"
+        @output.puts "    body:"
         body.each_line do |line|
-          $stderr.puts "      #{line.rstrip}"
+          @output.puts "      #{line.rstrip}"
         end
       end
 
@@ -2075,7 +2362,7 @@ module Scint
         return unless File.file?(path)
         return if gitignore_has_bundle_entry?(path)
 
-        $stderr.puts "#{YELLOW}Warning: .gitignore exists but does not ignore .bundle (add `.bundle/`).#{RESET}"
+        @output.puts "#{YELLOW}Warning: .gitignore exists but does not ignore .bundle (add `.bundle/`).#{RESET}"
       end
 
       def gitignore_has_bundle_entry?(path)
@@ -2111,6 +2398,12 @@ module Scint
           when "--path"
             @path = @argv[i + 1]
             i += 2
+          when "--without"
+            @without_groups = @argv[i + 1]&.split(/[\s:,]+/)&.map(&:to_sym) || []
+            i += 2
+          when "--with"
+            @with_groups = @argv[i + 1]&.split(/[\s:,]+/)&.map(&:to_sym) || []
+            i += 2
           when "--verbose"
             @verbose = true
             i += 1
@@ -2121,6 +2414,32 @@ module Scint
             i += 1
           end
         end
+
+        # Also read BUNDLE_WITHOUT / BUNDLE_WITH env vars (Bundler compat)
+        if !@without_groups && ENV["BUNDLE_WITHOUT"]
+          @without_groups = ENV["BUNDLE_WITHOUT"].split(/[\s:,]+/).map(&:to_sym)
+        end
+        if !@with_groups && ENV["BUNDLE_WITH"]
+          @with_groups = ENV["BUNDLE_WITH"].split(/[\s:,]+/).map(&:to_sym)
+        end
+
+        # Read from .bundle/config if present
+        load_bundle_config_groups if !@without_groups && !@with_groups
+      end
+
+      def load_bundle_config_groups
+        config_path = File.join(".bundle", "config")
+        return unless File.exist?(config_path)
+
+        config = YAML.safe_load(File.read(config_path)) rescue nil
+        return unless config.is_a?(Hash)
+
+        if config["BUNDLE_WITHOUT"] && !@without_groups
+          @without_groups = config["BUNDLE_WITHOUT"].to_s.split(/[\s:]+/).map(&:to_sym)
+        end
+        if config["BUNDLE_WITH"] && !@with_groups
+          @with_groups = config["BUNDLE_WITH"].to_s.split(/[\s:]+/).map(&:to_sym)
+        end
       end
     end
   end