polyrun 2.2.4 → 2.2.6

data/lib/polyrun/cli/run_shards_worker_interrupt.rb

@@ -19,33 +19,38 @@ module Polyrun
       # Best-effort worker teardown then exit. Does not return.
       def run_shards_shutdown_on_signal!(pids, code)
         run_shards_log_interrupt_workers(pids, nil)
-        Polyrun::WorkerOutput.shutdown_all!
         run_shards_terminate_children!(pids)
         exit(code)
       rescue Interrupt
         run_shards_signal_workers_kill(pids)
         run_shards_reap_worker_pids_interruptible(pids.map { |h| h[:pid] })
+        Polyrun::WorkerOutput.shutdown_all!
         exit(code)
       end
 
-      # Send SIGTERM to each worker PID and wait so Ctrl+C / SIGTERM does not leave orphans.
+      # Signal workers first so pipe readers see EOF; join forwarders only after children exit.
       def run_shards_terminate_children!(pids)
-        Polyrun::WorkerOutput.shutdown_all!
         run_shards_signal_workers_term(pids)
         run_shards_reap_worker_pids_interruptible(pids.map { |h| h[:pid] })
+        Polyrun::WorkerOutput.shutdown_all!
       end
 
       def run_shards_signal_workers_term(pids)
-        pids.each do |h|
-          Process.kill(:TERM, h[:pid])
-        rescue Errno::ESRCH
-        end
+        pids.each { |h| run_shards_kill_process_group!(:TERM, h[:pid]) }
       end
 
       def run_shards_signal_workers_kill(pids)
-        pids.each do |h|
-          Process.kill(:KILL, h[:pid])
-        rescue Errno::ESRCH
+        pids.each { |h| run_shards_kill_process_group!(:KILL, h[:pid]) }
+      end
+
+      # Negative PID signals the process group (workers spawn with +pgroup: true+).
+      def run_shards_kill_process_group!(signal, pid)
+        Process.kill(signal, -Integer(pid))
+      rescue Errno::ESRCH, Errno::EPERM
+        begin
+          Process.kill(signal, Integer(pid))
+        rescue Errno::ESRCH, Errno::EPERM
+          nil
         end
       end
 
@@ -71,10 +76,7 @@ module Polyrun
               force_note = true
               Polyrun::Log.orchestration_warn "polyrun run-shards: repeated SIGINT during worker cleanup — SIGKILL to #{pending.size} process(es)"
             end
-            pending.each do |pid|
-              Process.kill(:KILL, pid)
-            rescue Errno::ESRCH
-            end
+            pending.each { |pid| run_shards_kill_process_group!(:KILL, pid) }
           end
         end
       end

data/lib/polyrun/cli/start_bootstrap.rb

@@ -12,24 +12,30 @@ module Polyrun
           return code if code != 0
         end
 
-        if start_run_database_provision?(cfg) && !truthy_env?("POLYRUN_START_SKIP_DATABASES")
-          workers = parse_workers_from_start_argv(argv)
-          Polyrun::Log.warn "polyrun start: provisioning test DBs (template + shards 0..#{workers - 1})" if @verbose
-          begin
-            Polyrun::Database::CloneShards.provision!(
-              cfg.databases,
-              workers: workers,
-              rails_root: Dir.pwd,
-              migrate: true,
-              replace: true,
-              force_drop: truthy_env?("POLYRUN_PG_DROP_FORCE"),
-              dry_run: false,
-              silent: !@verbose
-            )
-          rescue Polyrun::Error => e
-            Polyrun::Log.warn "polyrun start: #{e.message}"
-            return 1
-          end
+        return 0 unless start_databases_provision_wanted?(cfg) && !truthy_env?("POLYRUN_START_SKIP_DATABASES")
+
+        dh = cfg.databases
+        adapter = Polyrun::Database::UrlBuilder::ConnectionInfer.infer_adapter_name(dh)
+        unless adapter == "postgresql"
+          return start_non_postgresql_databases_outcome(cfg, adapter)
+        end
+
+        workers = parse_workers_from_start_argv(argv)
+        Polyrun::Log.warn "polyrun start: provisioning test DBs (template + shards 0..#{workers - 1})" if @verbose
+        begin
+          Polyrun::Database::CloneShards.provision!(
+            dh,
+            workers: workers,
+            rails_root: Dir.pwd,
+            migrate: true,
+            replace: true,
+            force_drop: truthy_env?("POLYRUN_PG_DROP_FORCE"),
+            dry_run: false,
+            silent: !@verbose
+          )
+        rescue Polyrun::Error => e
+          Polyrun::Log.warn "polyrun start: #{e.message}"
+          return 1
         end
         0
       end
@@ -53,7 +59,7 @@ module Polyrun
         false
       end
 
-      def start_run_database_provision?(cfg)
+      def start_databases_provision_wanted?(cfg)
         st = cfg.start_config
         dh = cfg.databases
         return false unless dh.is_a?(Hash)
@@ -61,14 +67,33 @@ module Polyrun
         template = (dh["template_db"] || dh[:template_db]).to_s
         return false if template.empty?
 
-        if st["databases"] == true || st[:databases] == true
-          return true
-        end
         return false if st["databases"] == false || st[:databases] == false
 
         true
       end
 
+      def start_databases_explicitly_enabled?(cfg)
+        st = cfg.start_config
+        st["databases"] == true || st[:databases] == true
+      end
+
+      def start_non_postgresql_databases_outcome(cfg, adapter)
+        if start_databases_explicitly_enabled?(cfg)
+          Polyrun::Log.warn(
+            "polyrun start: start.databases is true but databases adapter is #{adapter}; " \
+            "CloneShards auto provision is PostgreSQL-only. Set start.databases: false and provision " \
+            "shards yourself (for example in prepare), or use a postgresql: connection block."
+          )
+          return 1
+        end
+
+        Polyrun::Log.warn(
+          "polyrun start: skipping database provision (adapter=#{adapter}; CloneShards is PostgreSQL-only). " \
+          "Provision shards in prepare, or set start.databases: false to silence this message."
+        )
+        0
+      end
+
       def parse_workers_from_start_argv(argv)
         sep = argv.index("--")
         head = sep ? argv[0...sep] : argv
@@ -79,6 +104,10 @@ module Polyrun
             w = Integer(head[i + 1], exception: false)
             workers = w if w && w >= 1
             i += 2
+          elsif head[i].start_with?("--workers=")
+            w = Integer(head[i].split("=", 2).last, exception: false)
+            workers = w if w && w >= 1
+            i += 1
           else
             i += 1
           end

data/lib/polyrun/cli.rb

@@ -35,7 +35,7 @@ module Polyrun
     DISPATCH_SUBCOMMAND_NAMES = %w[
       plan prepare merge-coverage merge-failures merge-spec-quality report-coverage report-junit report-timing report-spec-quality report-benchmark bench
       env config merge-timing db:setup-template db:setup-shard db:clone-shards
-      run-shards parallel-rspec start build-paths init queue run-queue quick hook
+      run-shards parallel-rspec parallel-minitest parallel-quick start build-paths init queue run-queue quick hook
     ].freeze
 
     # First argv token that is a normal subcommand (not a path); if argv[0] is not here but looks like paths, run implicit parallel.
@@ -108,6 +108,9 @@ module Polyrun
       )
 
       dispatch_cli_command(command, argv, config_path)
+    rescue Polyrun::Error => e
+      Polyrun::Log.warn "polyrun: #{e.message}"
+      2
     end
 
     private
@@ -187,6 +190,10 @@ module Polyrun
         cmd_run_shards(argv, config_path)
       when "parallel-rspec"
         cmd_parallel_rspec(argv, config_path)
+      when "parallel-minitest"
+        cmd_parallel_minitest(argv, config_path)
+      when "parallel-quick"
+        cmd_parallel_quick(argv, config_path)
       when "start"
         cmd_start(argv, config_path)
       when "build-paths"

data/lib/polyrun/config.rb

@@ -12,14 +12,19 @@ module Polyrun
     attr_reader :path, :raw
 
     def self.load(path: nil)
-      path = resolve_path(path)
+      explicit = path && !path.to_s.strip.empty?
+      resolved = resolve_path(path)
+      if explicit && !(resolved && File.file?(resolved))
+        raise Polyrun::Error, "polyrun config not found: #{path}"
+      end
+
       raw =
-        if path && File.file?(path)
-          YAML.safe_load_file(path, permitted_classes: [Symbol], aliases: true) || {}
+        if resolved && File.file?(resolved)
+          YAML.safe_load_file(resolved, permitted_classes: [Symbol], aliases: true) || {}
         else
           {}
         end
-      new(path: path, raw: raw)
+      new(path: resolved, raw: raw)
     end
 
     def self.resolve_path(explicit)

data/lib/polyrun/coverage/example_diff.rb

@@ -131,14 +131,13 @@ module Polyrun
       end
 
       def collect_diff_paths(before_blob, after_blob, filter: nil)
-        keys = before_blob.keys.dup
-        after_blob.each_key do |path|
-          string_path = path.to_s
-          keys << string_path unless keys.include?(string_path)
-        end
-        return keys unless filter
+        keys = {}
+        before_blob.each_key { |path| keys[path.to_s] = true }
+        after_blob.each_key { |path| keys[path.to_s] = true }
+        list = keys.keys
+        return list unless filter
 
-        keys.select { |path| filter.include_path?(path) }
+        list.select { |path| filter.include_path?(path) }
       end
 
       def accumulate_line_delta(before_entry, after_lines)

data/lib/polyrun/coverage/merge/formatters_html.rb

@@ -23,7 +23,7 @@ module Polyrun
         )
         file_list_html = render_html_partial("file_list", file_rows_html: files.map { |file| html_file_list_row(file) }.join("\n"))
         file_sections_html = files.map { |file| render_html_partial("file_section", file: file) }.join("\n")
-        ERB.new(File.read(html_template_path, encoding: Encoding::UTF_8), trim_mode: "-").result_with_hash(
+        html_root_template_erb.result_with_hash(
           title: CGI.escapeHTML(title.to_s),
           generated_label: html_generated_label(generated_at),
           overview_html: overview_html,
@@ -56,9 +56,27 @@ module Polyrun
       end
 
       def render_html_partial(name, locals = {})
-        ERB.new(File.read(html_partial_path(name), encoding: Encoding::UTF_8), trim_mode: "-").result_with_hash(locals)
+        html_partial_erb(name).result_with_hash(locals)
       end
 
+      # rubocop:disable ThreadSafety/ClassInstanceVariable -- template cache keyed by partial name; process-local
+      def html_partial_erb(name)
+        @html_partial_erbs ||= {}
+        @html_partial_erbs[name] ||= ERB.new(
+          File.read(html_partial_path(name), encoding: Encoding::UTF_8),
+          trim_mode: "-"
+        )
+      end
+
+      def html_root_template_erb
+        @html_root_template_erb ||= ERB.new(
+          File.read(html_template_path, encoding: Encoding::UTF_8),
+          trim_mode: "-"
+        )
+      end
+      # rubocop:enable ThreadSafety/ClassInstanceVariable
+      private_class_method :html_partial_erb, :html_root_template_erb
+
       def html_file_payload(path, file, root)
         line_arr = line_array_from_file_entry(file) || []
         source_lines = html_source_lines(path, line_arr.length)

data/lib/polyrun/coverage/merge.rb

@@ -26,10 +26,16 @@ module Polyrun
       def merge_fragments(paths)
         return {blob: {}, meta: {}, groups: nil} if paths.empty?
 
-        docs = paths.map { |p| JSON.parse(File.read(p)) }
-        blobs = docs.map { |d| extract_coverage_blob(d) }
+        # Parse one fragment at a time: keep only meta + blob so peak RSS drops after each fold step.
+        metas = []
+        blobs = []
+        paths.each do |path|
+          doc = JSON.parse(File.read(path))
+          metas << extract_doc_meta(doc)
+          blobs << extract_coverage_blob(doc)
+        end
         merged_blob = merge_blob_tree(blobs)
-        merged_meta = merge_fragment_metas(docs)
+        merged_meta = merge_fragment_metas_from_metas(metas)
         merged_blob = apply_track_files_once_after_merge(merged_blob, merged_meta)
         groups_payload = recompute_groups_from_meta(merged_blob, merged_meta)
         {blob: merged_blob, meta: merged_meta, groups: groups_payload}

data/lib/polyrun/coverage/merge_fragment_meta.rb

@@ -4,7 +4,12 @@ module Polyrun
       module_function
 
       def merge_fragment_metas(docs)
-        metas = docs.map { |d| extract_doc_meta(d) }
+        merge_fragment_metas_from_metas(docs.map { |d| extract_doc_meta(d) })
+      end
+
+      def merge_fragment_metas_from_metas(metas)
+        return {} if metas.empty?
+
         base = metas.first.dup
         roots = metas.map { |m| m["polyrun_coverage_root"] }.compact
         grs = metas.map { |m| m["polyrun_coverage_groups"] }.compact

data/lib/polyrun/coverage/rails.rb

@@ -67,7 +67,7 @@ module Polyrun
         path = File.expand_path(path)
         return {} unless File.file?(path)
 
-        data = YAML.load_file(path)
+        data = YAML.safe_load_file(path, permitted_classes: [Symbol], aliases: true)
         data.is_a?(Hash) ? stringify_keys(data) : {}
       end
 

data/lib/polyrun/database/clone_shards.rb

@@ -9,6 +9,7 @@ module Polyrun
       # See +provision!+ on the singleton class for options.
       def provision!(databases_hash, workers:, rails_root:, migrate: true, replace: true, force_drop: false, dry_run: false, silent: true)
         dh = databases_hash.is_a?(Hash) ? databases_hash : {}
+        ensure_postgresql!(dh)
         workers = Integer(workers)
         raise Polyrun::Error, "workers must be >= 1" if workers < 1
 
@@ -19,6 +20,16 @@ module Polyrun
         true
       end
 
+      def ensure_postgresql!(dh)
+        return if UrlBuilder::ConnectionInfer.postgresql?(dh)
+
+        adapter = UrlBuilder::ConnectionInfer.infer_adapter_name(dh)
+        raise Polyrun::Error,
+          "CloneShards is PostgreSQL-only (databases adapter is #{adapter}). " \
+          "Use polyrun env for URLs and provision shards yourself."
+      end
+      private_class_method :ensure_postgresql!
+
       def migrate_canonical_databases!(dh, rails_root, dry_run, silent)
         pt = (dh["template_db"] || dh[:template_db]).to_s
         if pt.empty?
@@ -37,6 +48,7 @@ module Polyrun
       private_class_method :migrate_canonical_databases!
 
       def create_shards_from_plan!(dh, workers, replace, force_drop, dry_run)
+        conn = UrlBuilder::Connection.resolve_connection(dh)
         if dry_run
           workers.times do |shard_index|
             plan = UrlBuilder.shard_database_plan(dh, shard_index: shard_index)
@@ -44,7 +56,7 @@ module Polyrun
               raise Polyrun::Error, "CloneShards: empty shard plan for shard_index=#{shard_index}"
             end
 
-            plan.each { |row| create_one_shard!(row, replace, force_drop, dry_run) }
+            plan.each { |row| create_one_shard!(row, replace, force_drop, dry_run, conn) }
           end
           return
         end
@@ -56,7 +68,7 @@ module Polyrun
               raise Polyrun::Error, "CloneShards: empty shard plan for shard_index=#{shard_index}"
             end
 
-            plan.each { |row| create_one_shard!(row, replace, force_drop, dry_run) }
+            plan.each { |row| create_one_shard!(row, replace, force_drop, dry_run, conn) }
           rescue => e
             raise Polyrun::Error, "CloneShards shard_index=#{shard_index}: #{e.message}"
           end
@@ -65,7 +77,7 @@ module Polyrun
       end
       private_class_method :create_shards_from_plan!
 
-      def create_one_shard!(row, replace, force_drop, dry_run)
+      def create_one_shard!(row, replace, force_drop, dry_run, conn)
         new_db = row[:new_db].to_s
         tmpl = row[:template_db].to_s
         if dry_run
@@ -74,10 +86,21 @@ module Polyrun
           return
         end
 
-        Provision.drop_database_if_exists!(database: new_db, force: force_drop) if replace
-        Provision.create_database_from_template!(new_db: new_db, template_db: tmpl)
+        opts = provision_connection_options(conn)
+        Provision.drop_database_if_exists!(database: new_db, force: force_drop, **opts) if replace
+        Provision.create_database_from_template!(new_db: new_db, template_db: tmpl, **opts)
       end
       private_class_method :create_one_shard!
+
+      def provision_connection_options(conn)
+        {
+          host: conn[:host],
+          port: conn[:port],
+          username: conn[:user],
+          password: conn[:password]
+        }
+      end
+      private_class_method :provision_connection_options
     end
   end
 end

data/lib/polyrun/database/provision.rb

@@ -14,7 +14,7 @@ module Polyrun
       end
 
       # +DROP DATABASE IF EXISTS name;+ — maintenance DB +postgres+ (or +maintenance_db+).
-      def drop_database_if_exists!(database:, host: nil, port: nil, username: nil, maintenance_db: "postgres", force: false)
+      def drop_database_if_exists!(database:, host: nil, port: nil, username: nil, password: nil, maintenance_db: "postgres", force: false)
         host ||= ENV["PGHOST"] || "localhost"
         port ||= ENV["PGPORT"] || "5432"
         username ||= ENV["PGUSER"] || "postgres"
@@ -25,26 +25,32 @@ module Polyrun
           else
             "DROP DATABASE IF EXISTS #{quote_ident(database)};"
           end
-        cmd = ["psql", "-U", username, "-h", host, "-p", port.to_s, "-d", maintenance_db, "-v", "ON_ERROR_STOP=1", "-c", sql]
-        _out, err, st = Open3.capture3(*cmd)
-        raise Polyrun::Error, "drop database failed: #{err}" unless st.success?
-
-        true
+        run_psql!(sql, host: host, port: port, username: username, password: password, maintenance_db: maintenance_db, failure_prefix: "drop database failed")
       end
 
       # CREATE DATABASE new_db TEMPLATE template_db — connects to maintenance DB +postgres+.
-      def create_database_from_template!(new_db:, template_db:, host: nil, port: nil, username: nil, maintenance_db: "postgres")
+      def create_database_from_template!(new_db:, template_db:, host: nil, port: nil, username: nil, password: nil, maintenance_db: "postgres")
         host ||= ENV["PGHOST"] || "localhost"
         port ||= ENV["PGPORT"] || "5432"
         username ||= ENV["PGUSER"] || "postgres"
 
         sql = "CREATE DATABASE #{quote_ident(new_db)} TEMPLATE #{quote_ident(template_db)};"
+        run_psql!(sql, host: host, port: port, username: username, password: password, maintenance_db: maintenance_db, failure_prefix: "create database failed")
+      end
+
+      def run_psql!(sql, host:, port:, username:, password:, maintenance_db:, failure_prefix:)
         cmd = ["psql", "-U", username, "-h", host, "-p", port.to_s, "-d", maintenance_db, "-v", "ON_ERROR_STOP=1", "-c", sql]
-        _out, err, st = Open3.capture3(*cmd)
-        raise Polyrun::Error, "create database failed: #{err}" unless st.success?
+        _out, err, st =
+          if password.nil? || password.to_s.empty?
+            Open3.capture3(*cmd)
+          else
+            Open3.capture3(ENV.to_h.merge("PGPASSWORD" => password.to_s), *cmd)
+          end
+        raise Polyrun::Error, "#{failure_prefix}: #{err}" unless st.success?
 
         true
       end
+      private_class_method :run_psql!
 
       # Runs +bin/rails db:prepare+ with merged ENV (+DATABASE_URL+ for primary, +CACHE_DATABASE_URL+, etc.).
       # Multi-DB Rails apps must pass all template URLs in one invocation so each DB uses its own +migrations_paths+.

data/lib/polyrun/database/url_builder/connection/infer.rb

@@ -29,6 +29,10 @@ module Polyrun
           "postgresql"
         end
 
+        def postgresql?(databases_hash)
+          infer_adapter_name(databases_hash.is_a?(Hash) ? databases_hash : {}) == "postgresql"
+        end
+
         def normalize_adapter_alias(name)
           case name
           when "postgres", "pg" then "postgresql"

data/lib/polyrun/database/url_builder.rb

@@ -48,7 +48,9 @@ module Polyrun
       end
 
       def template_prepare_env_shell_log(databases_hash)
-        template_prepare_env(databases_hash).sort.map { |k, v| "#{k}=#{Shellwords.escape(v.to_s)}" }.join(" ")
+        template_prepare_env(databases_hash).sort.map do |k, v|
+          "#{k}=#{Shellwords.escape(redact_url_userinfo_password(v.to_s))}"
+        end.join(" ")
       end
 
       def unique_template_migrate_urls(databases_hash)
@@ -111,6 +113,19 @@ module Polyrun
       def url_for_shard(databases_hash, shard_index:, connection: nil)
         dh = databases_hash.is_a?(Hash) ? databases_hash : {}
         conn = Connection.resolve_connection(dh)
+        pattern = shard_pattern(dh, connection)
+        validate_shard_db_pattern!(pattern)
+
+        dbname = pattern.to_s.gsub("%{shard}", Integer(shard_index).to_s).gsub("%<shard>d", format("%d", Integer(shard_index)))
+        template_name = template_database_name_for(dh, connection: connection)
+        if !template_name.to_s.empty? && dbname == template_name.to_s
+          raise Polyrun::Error,
+            "databases.shard_db_pattern resolves to template_db #{template_name.inspect} for shard #{shard_index}"
+        end
+        Connection.build_database_url(dbname, conn)
+      end
+
+      def shard_pattern(dh, connection)
         pattern =
           if connection
             conns = dh["connections"] || dh[:connections] || []
@@ -120,10 +135,23 @@ module Polyrun
             dh["shard_db_pattern"] || dh[:shard_db_pattern]
           end
         pattern ||= "app_test_%{shard}"
+        pattern
+      end
+      private_class_method :shard_pattern
 
-        dbname = pattern.to_s.gsub("%{shard}", Integer(shard_index).to_s).gsub("%<shard>d", format("%d", Integer(shard_index)))
-        Connection.build_database_url(dbname, conn)
+      def validate_shard_db_pattern!(pattern)
+        p = pattern.to_s
+        return if p.include?("%{shard}") || p.include?("%<shard>d")
+
+        raise Polyrun::Error, "databases.shard_db_pattern must include %{shard} or %<shard>d (got #{p.inspect})"
+      end
+      private_class_method :validate_shard_db_pattern!
+
+      def redact_url_userinfo_password(url)
+        s = url.to_s
+        s.sub(%r{\A([a-z][a-z0-9+.-]*://[^:/?#]+:)[^@/?#]+(@)}i, '\1***\2')
       end
+      private_class_method :redact_url_userinfo_password
 
       def env_exports_for_databases(databases_hash, shard_index:)
         dh = databases_hash.is_a?(Hash) ? databases_hash : {}

data/lib/polyrun/partition/paths.rb

@@ -23,9 +23,10 @@ module Polyrun
       end
 
       # Infer parallel suite from explicit paths (+_spec.rb+ vs +_test.rb+ vs Polyrun quick-style +.rb+).
+      # Recognizes RSpec-style +path:line+ locators (strips a trailing numeric locator before classifying).
       # Returns +:rspec+, +:minitest+, +:quick+, +:invalid+ (mixed spec and test), or +nil+ (empty).
       def infer_suite_from_paths(paths)
-        paths = paths.map { |p| File.expand_path(p) }
+        paths = Array(paths).map { |p| suite_classify_path(p) }
         return nil if paths.empty?
 
         specs = paths.count { |p| File.basename(p).end_with?("_spec.rb") }
@@ -44,8 +45,10 @@ module Polyrun
       # When +paths_file+ is set but missing, returns +{ error: "..." }+.
       # Otherwise returns +{ items:, source: }+ (human-readable source label).
       #
-      # +partition.suite+ (optional): +auto+ (default), +rspec+, +minitest+, +quick+ — used only when resolving
-      # from globs (no explicit +paths_file+ and no +spec/spec_paths.txt+).
+      # +partition.suite+ (optional): +auto+ (default), +rspec+, +minitest+, +quick+ — used when resolving
+      # from globs. Legacy +spec/spec_paths.txt+ is used only for +auto+/+rspec+ (RSpec-oriented); an
+      # explicit +minitest+/+quick+ suite skips it and globs instead. Bare +polyrun+ suite selection is
+      # {Suite.resolve_default} (explicit suite → paths_file inference → {detect_auto_suite}).
       def resolve_run_shard_items(paths_file: nil, cwd: Dir.pwd, partition: {})
         if paths_file
           abs = File.expand_path(paths_file.to_s, cwd)
@@ -53,7 +56,7 @@ module Polyrun
             return {error: "paths file not found: #{abs}"}
           end
           {items: read_lines(abs), source: paths_file.to_s}
-        elsif File.file?(File.join(cwd, "spec", "spec_paths.txt"))
+        elsif use_legacy_spec_paths?(cwd, partition)
           {items: read_lines(File.join(cwd, "spec", "spec_paths.txt")), source: "spec/spec_paths.txt"}
         else
           resolve_run_shard_items_glob(cwd: cwd, partition: partition)
@@ -104,6 +107,22 @@ module Polyrun
         require_relative "../quick/runner"
         Polyrun::Quick::Runner.parallel_default_paths(base)
       end
+
+      # Strip trailing numeric locators (+path:line+ or +path:line:column+), then expand.
+      def suite_classify_path(path)
+        raw = path.to_s.sub(/(?::\d+)+\z/, "")
+        File.expand_path(raw)
+      end
+      private_class_method :suite_classify_path
+
+      def use_legacy_spec_paths?(cwd, partition)
+        return false unless File.file?(File.join(cwd, "spec", "spec_paths.txt"))
+
+        suite = (partition["suite"] || partition[:suite] || "auto").to_s.downcase
+        suite = "auto" if suite.empty?
+        %w[auto rspec].include?(suite)
+      end
+      private_class_method :use_legacy_spec_paths?
     end
   end
 end

data/lib/polyrun/partition/plan.rb

@@ -110,11 +110,9 @@ module Polyrun
       end
 
       def default_weight
-        vals = @costs&.values || []
-        if vals.empty?
-          1.0
-        else
-          vals.sum / vals.size
+        @default_weight ||= begin
+          vals = @costs&.values || []
+          vals.empty? ? 1.0 : vals.sum / vals.size
         end
       end
 
@@ -193,13 +191,7 @@ module Polyrun
 
         out = {}
         map.each do |k, v|
-          key =
-            if @timing_granularity == :example
-              TimingKeys.normalize_locator(k.to_s, @root, :example)
-            else
-              File.expand_path(k.to_s, @root)
-            end
-          out[key] = Integer(v)
+          out[TimingKeys.normalize_locator(k.to_s, @root, @timing_granularity)] = Integer(v)
         end
         out
       end
@@ -209,13 +201,7 @@ module Polyrun
 
         c = {}
         costs.each do |k, v|
-          key =
-            if @timing_granularity == :example
-              TimingKeys.normalize_locator(k.to_s, @root, :example)
-            else
-              File.expand_path(k.to_s, @root)
-            end
-          c[key] = v.to_f
+          c[TimingKeys.normalize_locator(k.to_s, @root, @timing_granularity)] = v.to_f
         end
         c
       end
@@ -243,11 +229,7 @@ module Polyrun
       end
 
       def cost_lookup_key(path)
-        if @timing_granularity == :example
-          TimingKeys.normalize_locator(path, @root, :example)
-        else
-          File.expand_path(path, @root)
-        end
+        TimingKeys.normalize_locator(path, @root, @timing_granularity)
       end
 
       def cost_shards