rigortype 0.2.0 → 0.2.2

data/lib/rigor/cli.rb

@@ -16,8 +16,10 @@ require_relative "cli/ci_detector"
 module Rigor
   # The CLI class is a dispatcher: each `run_*` method delegates to a
   # command-specific class once the command grows beyond a few lines (see
-  # {CLI::TypeOfCommand} and {CLI::CheckCommand}).
-  class CLI
+  # {CLI::TypeOfCommand} and {CLI::CheckCommand}). It necessarily grows by
+  # one delegator + one help line per command, so — like the command
+  # classes it fans out to — it carries an explicit ClassLength exemption.
+  class CLI # rubocop:disable Metrics/ClassLength
     EXIT_USAGE = 64
 
     HANDLERS = {
@@ -39,6 +41,8 @@ module Rigor
       "plugin" => :run_plugin,
       "playground" => :run_playground,
       "skill" => :run_skill,
+      "describe" => :run_describe,
+      "docs" => :run_docs,
       "show-bleedingedge" => :run_show_bleedingedge
     }.freeze
 
@@ -285,6 +289,22 @@ module Rigor
       CLI::SkillCommand.new(argv: @argv, out: @out, err: @err).run
     end
 
+    # `rigor describe` — a top-level alias for `rigor skill describe`,
+    # the entry point most users reach for first. Surfaced because a
+    # bare `rigor describe` is the intuitive guess (the onboarding field
+    # trial saw it tried and met "Unknown command").
+    def run_describe
+      require_relative "cli/skill_command"
+
+      CLI::SkillCommand.new(argv: ["describe", *@argv], out: @out, err: @err).run
+    end
+
+    def run_docs
+      require_relative "cli/docs_command"
+
+      CLI::DocsCommand.new(argv: @argv, out: @out, err: @err).run
+    end
+
     def run_plugin
       require_relative "cli/plugin_command"
 
@@ -318,7 +338,9 @@ module Rigor
           plugins    Report activation status of every configured plugin
           plugin     Browse bundled plugin source as worked examples (list/path/print/root)
           playground Start the browser playground (requires rigor-playground gem)
-          skill      List or print bundled Agent Skills (rigor-project-init, ...)
+          describe   Recommend the next skill for this project (alias for `skill describe`)
+          skill      Recommend the next skill + list/print bundled Agent Skills (skill describe, skill <name>)
+          docs       Print the bundled docs offline (docs <name>, docs --list)
           show-bleedingedge  Show the bleeding-edge overlay + what your config adopts (ADR-50)
           version    Print the Rigor version
           help       Print this help

data/lib/rigor/config_audit.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require_relative "signature_path_audit"
+require_relative "analysis/check_rules"
+
+module Rigor
+  # Audits a loaded {Configuration} for the class of mistake where a
+  # configured value silently resolves to nothing — a typo'd or moved
+  # path, an unknown library name, an inert rule id. The shared failure
+  # mode is that the loader filters the bad entry without a word, so the
+  # only symptom is downstream and confusing: missing signatures turn
+  # every call into the types they were meant to cover into a
+  # high-confidence `call.undefined-method`, and an unrecognised
+  # suppression token leaves the rule firing as if the `disable:` line
+  # were never written. This module surfaces each such entry up front so
+  # the cause is visible instead of inferred.
+  #
+  # Every check is held to the same bar that {SignaturePathAudit} set:
+  # it mirrors the loader's own acceptance test, so a warning means the
+  # loader really did load nothing, and it never fires on a setup that
+  # works. In particular the rule-token check only flags a token under a
+  # built-in family (`call`, `flow`, …) — a plugin- or `rbs_extended.*`
+  # rule id (whose family Rigor cannot statically enumerate, since a
+  # `node_rule` block emits any `rule:` string it likes) is left alone, so
+  # disabling a plugin rule is never mistaken for a typo.
+  module ConfigAudit
+    # One config-level finding. `kind` discriminates the source key
+    # (`:signature_path`, `:library`, `:disabled_rule`,
+    # `:severity_override`, `:bundler_bundle_path`, `:bundler_lockfile`,
+    # `:rbs_collection_lockfile`); `fields` carries the kind-specific
+    # structured data merged into {#to_h} for JSON consumers.
+    Warning = Data.define(:kind, :message, :fields) do
+      def to_h
+        { "kind" => kind.to_s, "message" => message }.merge(fields)
+      end
+    end
+
+    # @param configuration [Rigor::Configuration]
+    # @param project_root [String] the directory the run's relative
+    #   bundler / collection paths resolve against (the CLI's CWD), used
+    #   only by the explicit-path checks.
+    # @return [Array<Warning>]
+    def self.warnings(configuration, project_root: Dir.pwd)
+      signature_path_warnings(configuration) +
+        library_warnings(configuration) +
+        rule_token_warnings(configuration) +
+        explicit_path_warnings(configuration, project_root)
+    end
+
+    # `signature_paths:` entries that resolve to nothing — delegated to
+    # {SignaturePathAudit}, which mirrors the loader's `directory?` +
+    # recursive `**/*.rbs` acceptance test.
+    def self.signature_path_warnings(configuration)
+      SignaturePathAudit.warnings(configuration.signature_paths).map do |entry|
+        Warning.new(
+          kind: :signature_path,
+          message: entry.message,
+          fields: { "path" => entry.path, "status" => entry.status.to_s, "rbs_file_count" => entry.rbs_file_count }
+        )
+      end
+    end
+
+    # `libraries:` entries RBS does not recognise. Uses the same
+    # `RBS::EnvironmentLoader#has_library?` guard the loader filters
+    # through ({Environment::RbsLoader} `build_env_for`), so a flagged
+    # name is exactly one the loader skipped. Fails soft: if RBS itself
+    # raises, no warning rather than a crash.
+    def self.library_warnings(configuration)
+      configured = Array(configuration.libraries)
+      return [] if configured.empty?
+
+      loader = ::RBS::EnvironmentLoader.new
+      configured.reject { |lib| loader.has_library?(library: lib.to_s, version: nil) }.map do |lib|
+        Warning.new(
+          kind: :library,
+          message: "libraries: #{lib.to_s.inspect} is not an available RBS library (no signatures loaded from it)",
+          fields: { "name" => lib.to_s }
+        )
+      end
+    rescue StandardError
+      []
+    end
+
+    # `disable:` tokens and `severity_overrides:` keys that name no rule.
+    # Restricted to tokens under a built-in family so a plugin rule id is
+    # never mis-flagged (see the module docstring).
+    def self.rule_token_warnings(configuration)
+      disable = Array(configuration.disabled_rules).filter_map do |token|
+        next unless inert_builtin_token?(token.to_s)
+
+        Warning.new(
+          kind: :disabled_rule,
+          message: "disable: #{token.to_s.inspect} is not a recognized rule id; the suppression has no effect",
+          fields: { "token" => token.to_s }
+        )
+      end
+      overrides = configuration.severity_overrides.keys.filter_map do |key|
+        next unless inert_builtin_token?(key.to_s)
+
+        Warning.new(
+          kind: :severity_override,
+          message: "severity_overrides: #{key.to_s.inspect} is not a recognized rule id; the override has no effect",
+          fields: { "token" => key.to_s }
+        )
+      end
+      disable + overrides
+    end
+
+    # True when `token` looks like a built-in rule id but matches none —
+    # its first segment is a built-in family yet it is neither a bare
+    # family wildcard nor a known canonical id. A token whose family is
+    # not built-in (a plugin / `rbs_extended.*` rule, or a bare legacy
+    # alias) is deliberately NOT flagged: it may resolve at run time, so
+    # under-warning is the FP-safe choice.
+    def self.inert_builtin_token?(token)
+      family = token.split(".").first
+      return false unless Analysis::CheckRules::RULE_FAMILIES.include?(family)
+      return false if token == family
+      return false if Analysis::CheckRules::ALL_RULES.include?(token)
+
+      true
+    end
+
+    # Explicitly-configured bundler / rbs-collection paths that do not
+    # exist. Only the explicit form is audited (a nil value means
+    # auto-detection, which finding nothing is normal); messages stay
+    # factual about the path rather than guessing the fallback.
+    def self.explicit_path_warnings(configuration, project_root)
+      warnings = []
+      add_missing_dir(warnings, configuration.bundler_bundle_path, project_root,
+                      :bundler_bundle_path, "bundler.bundle_path")
+      add_missing_file(warnings, configuration.bundler_lockfile, project_root,
+                       :bundler_lockfile, "bundler.lockfile")
+      add_missing_file(warnings, configuration.rbs_collection_lockfile, project_root,
+                       :rbs_collection_lockfile, "rbs_collection.lockfile")
+      warnings
+    end
+
+    def self.add_missing_dir(warnings, path, project_root, kind, key)
+      return if path.nil? || File.directory?(File.expand_path(path, project_root))
+
+      warnings << Warning.new(kind: kind, message: "#{key}: #{path.inspect} is not a directory",
+                              fields: { "path" => path })
+    end
+
+    def self.add_missing_file(warnings, path, project_root, kind, key)
+      return if path.nil? || File.file?(File.expand_path(path, project_root))
+
+      warnings << Warning.new(kind: kind, message: "#{key}: #{path.inspect} does not exist", fields: { "path" => path })
+    end
+  end
+end

data/lib/rigor/configuration.rb

@@ -600,6 +600,18 @@ module Rigor
       raise ArgumentError, "severity_overrides must be a Hash, got #{value.inspect}" unless value.is_a?(Hash)
 
       value.to_h do |k, v|
+        # YAML 1.1 parses bare `off`/`on`/`no`/`yes`/`true`/`false`
+        # as booleans, so a user who wrote `off` (a valid severity)
+        # without quotes hands us `false`. Catch the non-Symbol /
+        # non-String case before `to_sym` blows up with a backtrace.
+        unless v.is_a?(String) || v.is_a?(Symbol)
+          hint = v == false ? %( — did you mean the string "off"?) : ""
+          raise ArgumentError,
+                "severity_overrides[#{k.inspect}] is #{v.inspect}, a YAML boolean#{hint} " \
+                "Bare off/on/no/yes/true/false are parsed as booleans; quote the severity " \
+                "(e.g. \"off\")."
+        end
+
         sym = v.to_sym
         unless SeverityProfile::VALID_SEVERITIES.include?(sym)
           raise ArgumentError,

data/lib/rigor/environment/rbs_loader.rb

@@ -323,6 +323,33 @@ module Rigor
           [Pathname(CORE_OVERLAY_SIGS_ROOT)]
         end
 
+        # Rigor-owned per-gem RBS overlays (`data/gem_overlay/<gem>/`),
+        # ADR-72. Unlike the unconditional `core_overlay`, each gem's
+        # overlay is loaded ONLY when that gem is locked in the
+        # project's Gemfile.lock but ships no RBS of its own —
+        # {Environment.for_project} decides eligibility and passes the
+        # already-filtered gem-name set here. One directory per gem name
+        # keeps the membership check a cheap `File.directory?`.
+        GEM_OVERLAY_SIGS_ROOT = File.expand_path(
+          "../../../data/gem_overlay",
+          __dir__
+        ).freeze
+
+        # @param gem_names [Enumerable<String>] overlay-eligible
+        #   Gemfile.lock gem names (the caller filters to the
+        #   `:missing`-coverage, no-conflicting-plugin set).
+        # @return [Array<Pathname>] the bundled overlay directory for
+        #   each gem that ships one; empty when none match or the
+        #   overlay root is absent.
+        def gem_overlay_sig_paths(gem_names)
+          return [] unless File.directory?(GEM_OVERLAY_SIGS_ROOT)
+
+          gem_names.filter_map do |name|
+            dir = File.join(GEM_OVERLAY_SIGS_ROOT, name.to_s)
+            Pathname(dir) if File.directory?(dir)
+          end
+        end
+
         def vendored_gem_sig_paths
           return [] unless File.directory?(VENDORED_GEM_SIGS_ROOT)
 

data/lib/rigor/environment.rb

@@ -65,6 +65,13 @@ module Rigor
       prism rbs
     ].freeze
 
+    # ADR-72 — a Gemfile.lock gem name mapped to the opt-in plugin id
+    # that ships the SAME core-ext RBS. When that plugin is loaded the
+    # auto-overlay for the gem stands down, so the two never both
+    # declare the methods (which would raise a duplicate-declaration
+    # error). Keyed on the gem name `RbsCoverageReport` reports.
+    GEM_OVERLAY_PLUGIN_IDS = { "activesupport" => "activesupport-core-ext" }.freeze
+
     attr_reader :class_registry, :rbs_loader, :plugin_registry, :dependency_source_index,
                 :reporters, :name_scope,
                 :synthetic_method_index, :project_patched_methods
@@ -291,7 +298,24 @@ module Rigor
         # collection discovery. A duplicate-declaration conflict
         # degrades through the same O7 failure-memo path.
         plugin_sig_paths = plugin_registry ? plugin_registry.signature_paths.map(&:to_s) : []
-        loader_signature_paths = resolved_paths + plugin_sig_paths + gem_sig_paths + collection_paths
+        # ADR-72 — Gemfile.lock-gated bundled RBS overlays. For each
+        # locked gem that ships no RBS through any resolution path
+        # (`:missing`) and has a Rigor-bundled overlay, load that
+        # overlay so its core-class extensions resolve (e.g.
+        # `Integer#minutes` on a Rails project) — turning a systematic
+        # false `call.undefined-method` into a no-op while a project
+        # WITHOUT the gem still sees the genuine diagnostic. Appended
+        # last so any RBS the project already supplies wins, and skipped
+        # for a gem whose opt-in plugin twin is loaded (no duplicate
+        # declaration). The paths ride in `loader_signature_paths`, so
+        # the env cache descriptor digests them for free.
+        overlay_paths = gem_overlay_paths(
+          locked: locked, default_libraries: merged_libraries,
+          bundle_sig_paths: gem_sig_paths, rbs_collection_paths: collection_paths,
+          plugin_registry: plugin_registry
+        )
+        loader_signature_paths = resolved_paths + plugin_sig_paths + gem_sig_paths +
+                                 collection_paths + overlay_paths
         # ADR-32 WD4 + WD5 — invoke each loaded plugin's
         # `source_rbs_synthesizer` once per project source file
         # and collect non-nil `[filename, rbs_source]` pairs.
@@ -346,6 +370,30 @@ module Rigor
         sig.directory? ? [sig] : []
       end
 
+      # ADR-72 — resolve the bundled RBS overlay directories to load for
+      # this project. A gem is eligible when it is locked in the
+      # Gemfile.lock, classified `:missing` by {RbsCoverageReport}
+      # (no RBS through default-library / vendored / bundle-`sig/` /
+      # rbs-collection), and its conflicting opt-in plugin (if any) is
+      # not loaded. Returns `[Pathname]`, deterministically ordered, or
+      # `[]` when no lockfile / no eligible gem.
+      def gem_overlay_paths(locked:, default_libraries:, bundle_sig_paths:,
+                            rbs_collection_paths:, plugin_registry:)
+        return [] if locked.empty?
+
+        missing = RbsCoverageReport.classify(
+          locked_gems: locked, default_libraries: default_libraries,
+          bundle_sig_paths: bundle_sig_paths, rbs_collection_paths: rbs_collection_paths
+        ).select { |row| row.source == :missing }.map(&:gem_name)
+
+        loaded_ids = plugin_registry ? plugin_registry.ids.to_set : Set.new
+        eligible = missing.reject do |gem_name|
+          plugin_id = GEM_OVERLAY_PLUGIN_IDS[gem_name]
+          plugin_id && loaded_ids.include?(plugin_id)
+        end.sort
+        RbsLoader.gem_overlay_sig_paths(eligible)
+      end
+
       # ADR-32 WD4 + WD5 — for each project source file, invoke
       # every plugin-registered synthesizer once and collect
       # non-nil returns. The returned array is `[[virtual_filename,

data/lib/rigor/inference/method_dispatcher/constant_folding.rb

@@ -51,7 +51,15 @@ module Rigor
         NUMERIC_BINARY = Set[
           :+, :-, :*, :/, :%, :**, :&, :|, :^, :<<, :>>,
           :<, :<=, :>, :>=, :==, :!=, :<=>,
-          :gcd, :lcm, :fdiv, :quo, :ceildiv, :[]
+          :gcd, :lcm, :fdiv, :quo, :ceildiv, :[],
+          # Integer bit-test predicates (`(self & mask) <=> mask|0`). The
+          # catalog marks them `:dispatch` only because a non-Integer mask
+          # would route through `to_int`; a concrete Integer literal never
+          # does, so the fold is pure here — the sibling of the already-folded
+          # bit-reference `:[]`. Integer-only, but Float-safe to list: a Float
+          # receiver has no such method, so `invoke_binary` rescues the
+          # `NoMethodError` to nil and the RBS tier answers.
+          :allbits?, :anybits?, :nobits?
         ].freeze
         STRING_BINARY  = Set[
           :+, :*, :==, :!=, :<, :<=, :>, :>=, :<=>,
@@ -86,6 +94,17 @@ module Rigor
         # delegates to operand `==`); ordering is undefined for Complex.
         COMPLEX_BINARY = Set[:+, :-, :*, :/, :**].freeze
 
+        # `Set#&` and its alias `Set#intersection` are leaf-pure for a
+        # concrete Set operand exactly like their siblings `|` / `-` / `^`
+        # (all `:leaf` in the catalog), but the catalog flags
+        # `set_i_intersection`'s C body `block_dependent` — it drives Set's
+        # own internal iterator — so the catalog tier declines and the
+        # intersection alone fails to fold. A concrete Set argument's `each`
+        # is the pure core method, so the fold is sound; the hand-rolled
+        # allow-list is the right tool, mirroring the bit-test predicates.
+        # (The other binary set ops keep folding through the catalog.)
+        SET_BINARY = Set[:&, :intersection].freeze
+
         # v0.0.3 C — pure unary catalogue. Each method must:
         # - take zero arguments,
         # - have no side effects,
@@ -114,17 +133,35 @@ module Rigor
         # siblings `:inspect` / `:to_s` remain folded.
         INTEGER_UNARY = Set[
           :odd?, :even?, :zero?, :positive?, :negative?,
+          # `finite?` / `infinite?` are total on Integer (`true` / `nil`
+          # always) and round out the numeric predicate family — the Float
+          # sibling already folds them. `nonzero?` returns `self` (non-zero)
+          # or `nil`, both foldable Constants.
+          :finite?, :infinite?, :nonzero?,
           :succ, :pred, :next, :abs, :magnitude,
           :bit_length, :to_s, :to_i, :to_int, :to_f,
           :floor, :ceil, :round, :truncate, :chr,
           :inspect, :-@, :+@, :~, :to_r, :to_c
         ].freeze
         FLOAT_UNARY = Set[
-          :zero?, :positive?, :negative?,
-          :nan?, :finite?, :infinite?,
+          :zero?, :positive?, :negative?, :nonzero?,
+          :nan?, :finite?, :infinite?, :integer?,
           :abs, :magnitude, :floor, :ceil, :round, :truncate,
           :next_float, :prev_float,
           :to_s, :to_i, :to_int, :to_f, :to_r, :rationalize,
+          # `numerator` / `denominator` expose the rational
+          # decomposition of the float (`2.5.numerator → 5`,
+          # `.denominator → 2`) — pure arithmetic, the Float siblings
+          # of the already-folded Rational accessors. The non-finite
+          # edges stay sound: `Infinity.numerator → Infinity` /
+          # `.denominator → 1` fold to the same value Ruby returns, and
+          # `NaN.numerator → NaN` is declined by `foldable_constant_value?`.
+          :numerator, :denominator,
+          # `arg` / `angle` / `phase` (aliases) return the complex
+          # argument of the real number: `0` for `self >= 0`, `Math::PI`
+          # for `self < 0`. Pure sign test, deterministic; a NaN
+          # receiver yields NaN which `foldable_constant_value?` declines.
+          :arg, :angle, :phase,
           :inspect, :-@, :+@
         ].freeze
         STRING_UNARY = Set[
@@ -133,12 +170,21 @@ module Rigor
           :empty?, :strip, :lstrip, :rstrip, :chomp, :chop, :squeeze,
           :to_s, :to_str, :to_sym, :intern,
           :to_i, :to_f, :ord, :chr, :hex, :oct, :succ, :next,
-          :sum, :inspect
+          :sum, :inspect,
+          # `shellescape` is the String-receiver twin of the already-folded
+          # `Shellwords.escape` — deterministic shell-quoting, no global
+          # state. The `shellwords` library is loaded process-wide via
+          # `shellwords_folding`, so the method is always defined here.
+          :shellescape
         ].freeze
         SYMBOL_UNARY = Set[
           :to_s, :to_sym, :to_proc, :length, :size,
           :empty?, :upcase, :downcase, :capitalize,
-          :swapcase, :succ, :next, :inspect
+          :swapcase, :succ, :next, :inspect,
+          # `name` (the frozen-string accessor), `id2name` (alias of
+          # `to_s`), and `intern` (alias of `to_sym`) are pure reads of the
+          # symbol's text — siblings of the already-folded `to_s` / `to_sym`.
+          :name, :id2name, :intern
         ].freeze
         BOOL_UNARY = Set[:!, :to_s, :inspect, :&, :|, :^].freeze
         NIL_UNARY  = Set[:nil?, :!, :to_s, :to_a, :to_h, :inspect].freeze
@@ -377,26 +423,8 @@ module Rigor
         end
 
         def try_fold_unary_set(receiver_values, method_name)
-          range_lift = try_fold_range_constant_unary(receiver_values, method_name)
-          return range_lift if range_lift
-
-          string_lift = try_fold_string_array_unary(receiver_values, method_name)
-          return string_lift if string_lift
-
-          pathname_lift = try_fold_pathname_unary(receiver_values, method_name)
-          return pathname_lift if pathname_lift
-
-          regexp_lift = try_fold_regexp_array_unary(receiver_values, method_name)
-          return regexp_lift if regexp_lift
-
-          set_lift = try_fold_set_array_unary(receiver_values, method_name)
-          return set_lift if set_lift
-
-          integer_lift = try_fold_integer_array_unary(receiver_values, method_name)
-          return integer_lift if integer_lift
-
-          numeric_lift = try_fold_numeric_array_unary(receiver_values, method_name)
-          return numeric_lift if numeric_lift
+          special = try_fold_unary_special(receiver_values, method_name)
+          return special if special
 
           # Type-level allow check on every receiver. If one member's
           # type does not have the method in its allow list (e.g.
@@ -411,6 +439,23 @@ module Rigor
           end
           build_constant_type(results, source: receiver_values)
         end
+
+        # The carrier-specific unary lifts — Range-to-Tuple, the
+        # Array-returning String / Pathname / Regexp / Set / Integer /
+        # Numeric folds — that produce a precise structural type before
+        # the generic scalar `invoke_unary` path. The first match wins;
+        # nil means none applied and the caller falls through to the
+        # scalar allow-list path.
+        def try_fold_unary_special(receiver_values, method_name)
+          try_fold_range_constant_unary(receiver_values, method_name) ||
+            try_fold_string_array_unary(receiver_values, method_name) ||
+            try_fold_pathname_unary(receiver_values, method_name) ||
+            try_fold_pathname_array_unary(receiver_values, method_name) ||
+            try_fold_regexp_array_unary(receiver_values, method_name) ||
+            try_fold_set_array_unary(receiver_values, method_name) ||
+            try_fold_integer_array_unary(receiver_values, method_name) ||
+            try_fold_numeric_array_unary(receiver_values, method_name)
+        end
         # v0.0.7 — `Constant<Range>#to_a` and the no-arg
         # `first` / `last` / `min` / `max` short-circuit through a
         # Range-specific arm that catalog dispatch cannot reach:
@@ -427,10 +472,13 @@ module Rigor
         RANGE_FOLD_METHODS = Set[:to_a, :first, :last, :min, :max, :count, :size, :length, :entries, :minmax,
                                  :sum].freeze
         # 1-arg head/tail projections on a `Constant<Range>`. `first(n)` /
-        # `take(n)` return the first `n` elements, `last(n)` the final `n` —
-        # each lifts to a per-position `Tuple[Constant[Integer]…]`. The
-        # no-arg `first` / `last` stay on the unary path (single Integer).
-        RANGE_FOLD_BINARY_METHODS = Set[:first, :last, :take].freeze
+        # `take(n)` return the first `n` elements, `last(n)` the final `n`,
+        # and `min(n)` / `max(n)` the n smallest / largest (for an ascending
+        # integer range `min(n) == first(n)` and `max(n) == last(n).reverse`)
+        # — each lifts to a per-position `Tuple[Constant[Integer]…]`. The
+        # no-arg `first` / `last` / `min` / `max` stay on the unary path
+        # (single Integer endpoint).
+        RANGE_FOLD_BINARY_METHODS = Set[:first, :last, :take, :min, :max].freeze
         RANGE_TO_A_LIMIT = 16
         private_constant :RANGE_FOLD_METHODS, :RANGE_FOLD_BINARY_METHODS, :RANGE_TO_A_LIMIT
 
@@ -509,17 +557,31 @@ module Rigor
 
         def range_take_tuple(range, method_name, count)
           return nil unless count.is_a?(Integer) && !count.negative?
-          # `first(n)`/`last(n)`/`take(n)` materialise at most `min(n, size)`
-          # elements; cap that count so a huge `n` (or range) never blows up
-          # the Constant. `Range#size` is O(1) for integer endpoints.
+          # `first(n)`/`last(n)`/`take(n)`/`min(n)`/`max(n)` materialise at
+          # most `min(n, size)` elements; cap that count so a huge `n` (or
+          # range) never blows up the Constant. `Range#size` and the head/
+          # tail projections are O(n) for integer endpoints (no full
+          # materialisation).
           return nil if [count, range.size].min > RANGE_TO_A_LIMIT
 
-          values = method_name == :last ? range.last(count) : range.first(count)
+          values = range_head_tail(range, method_name, count)
           return Type::Combinator.tuple_of if values.empty?
 
           Type::Combinator.tuple_of(*values.map { |v| Type::Combinator.constant_of(v) })
         end
 
+        # The n elements a head/tail projection selects, in Ruby's order.
+        # For an ascending integer range `min(n)` is the leading `n`
+        # (`first(n)`) and `max(n)` the trailing `n` reversed (descending),
+        # so neither needs the full sort `Array#min`/`#max` would do.
+        def range_head_tail(range, method_name, count)
+          case method_name
+          when :last then range.last(count)
+          when :max  then range.last(count).reverse
+          else            range.first(count) # :first, :take, :min
+          end
+        end
+
         def try_fold_binary_set(receiver_values, method_name, arg_values)
           range_lift = try_fold_range_constant_binary(receiver_values, method_name, arg_values)
           return range_lift if range_lift
@@ -542,14 +604,21 @@ module Rigor
           build_constant_type(results, source: receiver_values + arg_values)
         end
         # v0.0.7 — `Constant<String>#chars` / `bytes` / `codepoints` /
-        # `lines` / `split` (no-arg) return a Ruby Array of foldable
-        # scalars; `foldable_constant_value?` rejects Array
+        # `grapheme_clusters` / `lines` / `split` (no-arg) return a Ruby
+        # Array of foldable scalars; `foldable_constant_value?` rejects Array
         # results, so the standard unary path declines. Lift the
         # Array to a per-position `Tuple[Constant…]` directly,
         # capped at `STRING_ARRAY_LIFT_LIMIT` to keep the result
         # bounded for long strings. (`codepoints` yields per-character
-        # Integer codepoints, the sibling of the byte-valued `bytes`.)
-        STRING_ARRAY_UNARY_METHODS = Set[:chars, :bytes, :codepoints, :lines, :split].freeze
+        # Integer codepoints, the sibling of the byte-valued `bytes`;
+        # `grapheme_clusters` is the extended-grapheme sibling of `chars`.)
+        # `shellsplit` is the String-receiver twin of the already-folded
+        # `Shellwords.split` — lifts the token Array to a Tuple. Raises
+        # `ArgumentError` on unmatched quotes, which `try_fold_string_array_unary`
+        # rescues to nil (RBS tier widens). `shellwords` is loaded process-wide
+        # via `shellwords_folding`.
+        STRING_ARRAY_UNARY_METHODS = Set[:chars, :bytes, :codepoints, :grapheme_clusters,
+                                         :lines, :split, :shellsplit].freeze
         # `partition` / `rpartition` always return a fixed 3-element
         # `[head, separator, tail]` Array whose members are substrings of
         # the receiver (bounded by the input), so they lift to a precise
@@ -613,10 +682,26 @@ module Rigor
         ].freeze
         PATHNAME_PURE_BINARY = Set[
           :+, :join, :sub_ext, :<=>, :==, :eql?, :===,
-          :relative_path_from
+          :relative_path_from,
+          # `/` is the exact alias of `+` (`def /(other) = self + other`),
+          # the idiomatic path-join operator (`dir / "file"`). `basename`'s
+          # 1-arg suffix-stripping form (`path.basename(".rb")` → the stem)
+          # is the binary sibling of the already-folded no-arg `basename` —
+          # both are pure `@path` string manipulation, no filesystem read.
+          :/, :basename
         ].freeze
         private_constant :PATHNAME_PURE_UNARY, :PATHNAME_PURE_BINARY
 
+        # `Constant<Pathname>#split` returns the fixed 2-element
+        # `[dirname, basename]` pair (both Pathname), the path-string
+        # split of `File.split`. Lifted to `Tuple[Constant[Pathname],
+        # Constant[Pathname]]`. Filesystem-independent — reads only
+        # `@path` — so it is deterministic at fold time, the
+        # Array-returning sibling of the scalar `basename` / `dirname`
+        # folds (which `try_fold_pathname_unary` already covers).
+        PATHNAME_ARRAY_UNARY_METHODS = Set[:split].freeze
+        private_constant :PATHNAME_ARRAY_UNARY_METHODS
+
         def try_fold_pathname_unary(receiver_values, method_name)
           return nil unless PATHNAME_PURE_UNARY.include?(method_name)
           return nil unless receiver_values.size == 1
@@ -649,6 +734,22 @@ module Rigor
           nil
         end
 
+        # `Constant<Pathname>#split` — lift the `[dirname, basename]`
+        # Pathname pair to a Tuple[Constant[Pathname], Constant[Pathname]].
+        # Pure path-string manipulation (no filesystem read); both
+        # elements are Pathname, a foldable Constant class.
+        def try_fold_pathname_array_unary(receiver_values, method_name)
+          return nil unless PATHNAME_ARRAY_UNARY_METHODS.include?(method_name)
+          return nil unless receiver_values.size == 1
+
+          receiver = receiver_values.first
+          return nil unless receiver.is_a?(Pathname)
+
+          lift_array_result(receiver.split)
+        rescue StandardError
+          nil
+        end
+
         def try_fold_string_array_unary(receiver_values, method_name)
           return nil unless STRING_ARRAY_UNARY_METHODS.include?(method_name)
           return nil unless receiver_values.size == 1
@@ -1490,6 +1591,7 @@ module Rigor
           when nil            then NIL_BINARY
           when Rational       then RATIONAL_BINARY
           when Complex        then COMPLEX_BINARY
+          when ::Set          then SET_BINARY
           else                     Set.new
           end
         end