rigortype 0.1.2 → 0.1.4

data/lib/rigor/cli/sig_gen_command.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require "optionparser"
+
+require_relative "../configuration"
+require_relative "../sig_gen"
+
+module Rigor
+  class CLI
+    # Executes the `rigor sig-gen` command — ADR-14 slices 1–3.
+    #
+    # Walks the given paths (or `configuration.paths` when none
+    # are supplied), classifies every reachable instance method
+    # via {Rigor::SigGen::Generator}, and either prints the
+    # resulting RBS skeletons / unified-style diffs (`--print`,
+    # `--diff`; slice 1) or writes them to the project signature
+    # tree via {Rigor::SigGen::Writer} (`--write`; slice 2).
+    #
+    # `--write` follows the established Ruby community
+    # convention: `lib/foo/bar.rb` → `sig/foo/bar.rbs`. New
+    # methods are inserted into the matching class declaration
+    # just before its closing `end`; new classes are appended
+    # to the file; non-existent target files are created. User-
+    # authored declarations are NEVER replaced unless
+    # `--overwrite` is set AND the candidate is a
+    # `tighter-return`.
+    #
+    # Parameter policy defaults to `untyped`. `--params=observed`
+    # (slice 3) opts in to caller-side observation harvesting:
+    # the `ObservationCollector` walks `--observe=PATH...`
+    # (default `spec/` when no flag is given AND a `spec/`
+    # directory exists), unions per-position arg types, and the
+    # generator emits the union per ADR-5 clause 2.
+    # `--params=observed-strict` stays reserved-but-inert until
+    # the capability-role catalog ships (rejected with a usage
+    # error so the surface stays stable).
+    class SigGenCommand
+      USAGE = "Usage: rigor sig-gen [options] [paths]"
+
+      VALID_MODES = %w[print diff write].freeze
+      VALID_PARAM_POLICIES = %w[untyped observed observed-strict].freeze
+      VALID_FORMATS = %w[text json].freeze
+
+      def initialize(argv:, out:, err:)
+        @argv = argv
+        @out = out
+        @err = err
+      end
+
+      # @return [Integer] CLI exit status.
+      def run
+        options = parse_options
+        return CLI::EXIT_USAGE if options.nil?
+
+        configuration = Configuration.load(options.fetch(:config))
+        paths = @argv.empty? ? configuration.paths : @argv
+
+        observations = collect_observations(configuration, options)
+        candidates = SigGen::Generator.new(configuration: configuration, paths: paths,
+                                           observations: observations,
+                                           include_private: options.fetch(:include_private)).run
+        mode = options.fetch(:mode).to_sym
+
+        if mode == :write
+          dispatch_write(candidates, configuration, options)
+        else
+          dispatch_print_or_diff(candidates, mode, options)
+        end
+        0
+      end
+
+      private
+
+      def dispatch_print_or_diff(candidates, mode, options)
+        SigGen::Renderer.new(out: @out).render(
+          candidates: candidates,
+          mode: mode,
+          format: options.fetch(:format),
+          selection: options.fetch(:selection)
+        )
+      end
+
+      def dispatch_write(candidates, configuration, options)
+        layout_index = SigGen::LayoutIndex.new(signature_paths: configuration.signature_paths)
+        path_mapper = SigGen::PathMapper.new(configuration: configuration, layout_index: layout_index)
+        writer = SigGen::Writer.new(path_mapper: path_mapper, overwrite: options.fetch(:overwrite))
+
+        results = writer.write_all(candidates)
+
+        SigGen::Renderer.new(out: @out).render_write(results: results, format: options.fetch(:format))
+      end
+
+      # Slice 3 — collect call-site argument observations when
+      # `--params=observed` is set. When `--observe=PATH` is
+      # not specified, default to `spec/` (skipped silently
+      # when the directory is absent).
+      def collect_observations(configuration, options)
+        return {} if options.fetch(:params) != "observed"
+
+        observe_paths = options.fetch(:observe)
+        observe_paths = ["spec"] if observe_paths.empty? && File.directory?("spec")
+        SigGen::ObservationCollector.new(configuration: configuration, paths: observe_paths).collect
+      end
+
+      def parse_options
+        options = {
+          mode: "print",
+          format: "text",
+          params: "untyped",
+          selection: [],
+          overwrite: false,
+          observe: [],
+          include_private: false,
+          config: nil
+        }
+        build_option_parser(options).parse!(@argv)
+
+        message = validation_error(options)
+        return options if message.nil?
+
+        @err.puts("sig-gen: #{message}")
+        nil
+      end
+
+      def build_option_parser(options) # rubocop:disable Metrics/AbcSize
+        OptionParser.new do |opts| # rubocop:disable Metrics/BlockLength
+          opts.banner = USAGE
+          opts.on("--print", "Write RBS skeletons to stdout (default)") { options[:mode] = "print" }
+          opts.on("--diff", "Write a unified diff against existing RBS") { options[:mode] = "diff" }
+          opts.on("--write", "Write generated RBS to sig/<path>.rbs files") { options[:mode] = "write" }
+          opts.on("--overwrite", "Allow tighter-return updates to replace user-authored RBS") do
+            options[:overwrite] = true
+          end
+          opts.on("--include-private", "Emit private / protected instance methods (default: public only)") do
+            options[:include_private] = true
+          end
+          opts.on("--format=FORMAT", "Output format: text or json") { |value| options[:format] = value }
+          opts.on("--params=POLICY", "Parameter policy: untyped (default), observed, observed-strict") do |value|
+            options[:params] = value
+          end
+          opts.on("--observe=PATH", "Directory / file to scan for call-site observations (repeatable)") do |value|
+            options[:observe] << value
+          end
+          opts.on("--new-files", "Emit only new-file classifications") do
+            options[:selection] << SigGen::Classification::NEW_FILE
+          end
+          opts.on("--new-methods", "Emit only new-method classifications") do
+            options[:selection] << SigGen::Classification::NEW_METHOD
+          end
+          opts.on("--tighter-returns", "Emit only tighter-return classifications") do
+            options[:selection] << SigGen::Classification::TIGHTER_RETURN
+          end
+          opts.on("--config=PATH", "Path to the Rigor configuration file") { |value| options[:config] = value }
+        end
+      end
+
+      def validation_error(options)
+        mode = options.fetch(:mode)
+        format = options.fetch(:format)
+        params = options.fetch(:params)
+
+        return "--print, --diff, and --write are mutually exclusive flags; pick one" unless VALID_MODES.include?(mode)
+        return "unsupported --format=#{format}" unless VALID_FORMATS.include?(format)
+        return "unsupported --params=#{params}" unless VALID_PARAM_POLICIES.include?(params)
+        if params == "observed-strict"
+          return "--params=observed-strict is reserved until the capability-role catalog ships"
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/rigor/cli/type_of_command.rb

@@ -61,7 +61,7 @@ module Rigor
         options
       end
 
-      def execute(target:, options:) # rubocop:disable Metrics/AbcSize
+      def execute(target:, options:)
         file, line, column = target
         return 1 unless file_exists?(file)
 

data/lib/rigor/cli/type_scan_renderer.rb

@@ -10,7 +10,7 @@ module Rigor
     # branches share a single source of truth (the `Report` value object) so
     # the two formats stay in lockstep; that pairing is why this class is a
     # bit longer than the default class-length budget.
-    class TypeScanRenderer # rubocop:disable Metrics/ClassLength
+    class TypeScanRenderer
       def initialize(out:)
         @out = out
       end

data/lib/rigor/cli/type_scan_report.rb

@@ -5,14 +5,14 @@ module Rigor
     # Aggregated report assembled by `TypeScanCommand` and consumed by
     # `TypeScanRenderer`. The struct holds per-file paths, accumulated
     # per-class counts, located fallback events, and any parse errors.
-    Report = Data.define(
+    class Report < Data.define(
       :files,
       :parse_errors,
       :visits,
       :unrecognized,
       :events,
       :options
-    ) do
+    )
       def visited_count
         visits.values.sum
       end

data/lib/rigor/cli.rb

@@ -24,7 +24,8 @@ module Rigor
       "type-of" => :run_type_of,
       "type-scan" => :run_type_scan,
       "explain" => :run_explain,
-      "diff" => :run_diff
+      "diff" => :run_diff,
+      "sig-gen" => :run_sig_gen
     }.freeze
 
     def self.start(argv = ARGV, out: $stdout, err: $stderr)
@@ -279,6 +280,12 @@ module Rigor
       DiffCommand.new(argv: @argv, out: @out, err: @err).run
     end
 
+    def run_sig_gen
+      require_relative "cli/sig_gen_command"
+
+      SigGenCommand.new(argv: @argv, out: @out, err: @err).run
+    end
+
     def write_result(result, format)
       case format
       when "json"
@@ -318,6 +325,7 @@ module Rigor
           type-scan  Report Scope#type_of coverage across PATHs
           explain    Print the description of one or all CheckRules
           diff       Compare current diagnostics to a saved baseline JSON
+          sig-gen    Emit RBS skeletons inferred from .rb sources (ADR-14)
           version    Print the Rigor version
           help       Print this help
       HELP

data/lib/rigor/configuration/dependencies.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+module Rigor
+  class Configuration
+    # Parsed `dependencies:` section of `.rigor.yml`. Per
+    # [ADR-10](../../../docs/adr/10-dependency-source-inference.md),
+    # the only nested key today is `source_inference:`, listing
+    # gems whose Ruby implementation Rigor MAY walk during
+    # inference instead of degrading to `Dynamic[top]` at the
+    # dependency boundary.
+    #
+    # Slice 1 lands the parser only — `Configuration#dependencies`
+    # is read, but no analyzer machinery consumes it yet. Slice 2
+    # wires `Analysis::DependencySourceInference` against this
+    # value object.
+    class Dependencies
+      # Walking modes per
+      # [ADR-10 § "Decision"](../../../docs/adr/10-dependency-source-inference.md#decision).
+      VALID_MODES = %i[disabled when_missing full].freeze
+
+      # Default `roots:` for an entry that does not supply one.
+      # The hard-excluded directories (`spec/` / `test/` / `bin/`
+      # / C extensions) are enforced by the walker, not the
+      # parser — see ADR-10 § "Hard exclusions".
+      DEFAULT_ROOTS = %w[lib].freeze
+
+      # Default per-gem catalog cap. ADR-10 slice 4 picks
+      # 5000 method definitions: it covers Rack (~1500),
+      # Faraday (~500), Sidekiq (~800) and other realistic
+      # opt-in targets, while still surfacing a diagnostic for
+      # ActiveSupport-class libraries (~10 000+ methods) where
+      # the user should ship RBS or de-list the gem instead.
+      DEFAULT_BUDGET_PER_GEM = 5000
+
+      # Range bounds per ADR-10 § "Budget interaction"
+      # ("range 0.25× – 4×"). Configured against the default,
+      # this lands at 1250 – 20 000.
+      MIN_BUDGET_PER_GEM = (DEFAULT_BUDGET_PER_GEM * 0.25).to_i
+      MAX_BUDGET_PER_GEM = (DEFAULT_BUDGET_PER_GEM * 4).to_i
+
+      # ADR-10 5b — budget-overrun strategy enum.
+      #
+      # - `:walker_cap` (default): the (α) semantics. The
+      #   walker stops harvesting at the cap; methods past the
+      #   cap fall through to the existing user-class fallback
+      #   path. Existing v0.1.3 behaviour.
+      # - `:dependency_silence`: the (β) semantics. Same
+      #   walker behaviour, but the dispatcher additionally
+      #   consults `Index#class_to_gem` after a catalog miss.
+      #   When the receiver's class belongs to a budget-
+      #   exceeded gem, the call resolves to `Dynamic[top]`
+      #   rather than falling through to user-class fallback.
+      #   This silences `call.undefined-method` for unrecorded
+      #   methods at the cost of weaker static checking on
+      #   that gem's surface.
+      VALID_BUDGET_OVERRUN_STRATEGIES = %i[walker_cap dependency_silence].freeze
+      DEFAULT_BUDGET_OVERRUN_STRATEGY = :walker_cap
+
+      # Frozen value object describing a single per-gem opt-in.
+      # `gem:` is the gem name (matched against the bundle at
+      # walk time); `mode:` is one of {VALID_MODES}; `roots:` is
+      # the list of subdirectories within the gem's installation
+      # directory to walk (defaults to `["lib"]`).
+      class Entry < Data.define(:gem, :mode, :roots)
+        def disabled? = mode == :disabled
+        def when_missing? = mode == :when_missing
+        def full? = mode == :full
+      end
+
+      attr_reader :source_inference, :budget_per_gem, :budget_overrun_strategy, :warnings
+
+      # Parse the YAML-shaped `dependencies:` value into a
+      # frozen {Dependencies}. Accepts `nil` / `{}` / a Hash with
+      # `source_inference:` and / or `budget_per_gem:` /
+      # `budget_overrun_strategy:` present.
+      def self.from_h(data)
+        return new([]) if data.nil?
+        raise ArgumentError, "dependencies: must be a Hash, got #{data.inspect}" unless data.is_a?(Hash)
+
+        raw_entries = Array(data["source_inference"]).map { |raw| coerce_entry(raw) }
+        entries, warnings = dedupe_entries(raw_entries)
+        budget = coerce_budget_per_gem(data.fetch("budget_per_gem", DEFAULT_BUDGET_PER_GEM))
+        strategy = coerce_budget_overrun_strategy(
+          data.fetch("budget_overrun_strategy", DEFAULT_BUDGET_OVERRUN_STRATEGY)
+        )
+        new(entries, budget, warnings, strategy)
+      end
+
+      def initialize(source_inference, budget_per_gem = DEFAULT_BUDGET_PER_GEM,
+                     warnings = [], budget_overrun_strategy = DEFAULT_BUDGET_OVERRUN_STRATEGY)
+        @source_inference = source_inference.freeze
+        @budget_per_gem = budget_per_gem
+        @warnings = warnings.freeze
+        @budget_overrun_strategy = budget_overrun_strategy
+        freeze
+      end
+
+      def to_h
+        {
+          "source_inference" => @source_inference.map do |entry|
+            {
+              "gem" => entry.gem,
+              "mode" => entry.mode.to_s,
+              "roots" => entry.roots
+            }
+          end,
+          "budget_per_gem" => @budget_per_gem,
+          "budget_overrun_strategy" => @budget_overrun_strategy.to_s
+        }
+      end
+
+      def empty? = @source_inference.empty?
+
+      class << self
+        # ADR-10 § "config-conflict diagnostic" — merges a
+        # potentially-duplicated entry list (the `includes:`
+        # chain produces concatenated arrays via
+        # `Configuration.deep_merge`'s special-case for
+        # `dependencies.source_inference`) into a single
+        # canonical entry per gem name. The merge rules:
+        #
+        # - Same gem, same all fields → idempotent collapse
+        #   (no warning).
+        # - Same gem, different `mode:` → keep the LAST entry
+        #   (matches existing right-wins semantics elsewhere)
+        #   AND emit a `:warning` so the user knows their
+        #   `includes:` chain is ambiguous.
+        # - Same gem, different `roots:` → union the roots
+        #   silently (no warning). The walker is happy to
+        #   visit the union.
+        #
+        # Returns `[entries, warnings]` so the caller can
+        # plumb the warning list through to the Runner for
+        # diagnostic emission.
+        def dedupe_entries(entries)
+          warnings = []
+          by_gem = {}
+          entries.each do |entry|
+            existing = by_gem[entry.gem]
+            by_gem[entry.gem] = if existing.nil?
+                                  entry
+                                else
+                                  merge_entry_pair(existing, entry, warnings)
+                                end
+          end
+          [by_gem.values, warnings]
+        end
+
+        def merge_entry_pair(existing, incoming, warnings)
+          if existing.mode != incoming.mode
+            warnings << "dependencies.source_inference[].gem #{incoming.gem.inspect} declared with " \
+                        "conflicting modes (#{existing.mode.inspect} vs #{incoming.mode.inspect}); " \
+                        "the later (#{incoming.mode.inspect}) wins."
+          end
+          merged_roots = (existing.roots + incoming.roots).uniq.freeze
+          Entry.new(gem: incoming.gem, mode: incoming.mode, roots: merged_roots)
+        end
+
+        private
+
+        def coerce_entry(raw)
+          unless raw.is_a?(Hash)
+            raise ArgumentError,
+                  "dependencies.source_inference[] entry must be a Hash, got #{raw.inspect}"
+          end
+
+          Entry.new(
+            gem: coerce_gem(raw["gem"]),
+            mode: coerce_mode(raw["mode"]),
+            roots: coerce_roots(raw)
+          )
+        end
+
+        def coerce_gem(value)
+          unless value.is_a?(String) && !value.empty?
+            raise ArgumentError,
+                  "dependencies.source_inference[].gem must be a non-empty String, got #{value.inspect}"
+          end
+
+          value.dup.freeze
+        end
+
+        def coerce_mode(value)
+          mode = (value || "when_missing").to_sym
+          return mode if VALID_MODES.include?(mode)
+
+          raise ArgumentError,
+                "dependencies.source_inference[].mode must be one of " \
+                "#{VALID_MODES.inspect}, got #{value.inspect}"
+        end
+
+        def coerce_roots(raw)
+          roots = Array(raw.fetch("roots", DEFAULT_ROOTS)).map(&:to_s).freeze
+          return roots unless roots.empty?
+
+          raise ArgumentError,
+                "dependencies.source_inference[].roots must not be empty when supplied " \
+                "(omit the key to fall back to the default #{DEFAULT_ROOTS.inspect})"
+        end
+
+        def coerce_budget_overrun_strategy(value)
+          symbol = value.to_sym
+          return symbol if VALID_BUDGET_OVERRUN_STRATEGIES.include?(symbol)
+
+          raise ArgumentError,
+                "dependencies.budget_overrun_strategy must be one of " \
+                "#{VALID_BUDGET_OVERRUN_STRATEGIES.inspect}, got #{value.inspect}"
+        end
+
+        # ADR-10 slice 4. Per-gem catalog cap is mandatory
+        # (the parser supplies the default before this is
+        # called, so `nil` only reaches here on an explicit
+        # `budget_per_gem: ~`). Range bounds match
+        # MIN_BUDGET_PER_GEM .. MAX_BUDGET_PER_GEM
+        # (i.e. 0.25× – 4× of the default).
+        def coerce_budget_per_gem(value)
+          unless value.is_a?(Integer)
+            raise ArgumentError,
+                  "dependencies.budget_per_gem must be an Integer, " \
+                  "got #{value.inspect}"
+          end
+
+          unless value.between?(MIN_BUDGET_PER_GEM, MAX_BUDGET_PER_GEM)
+            raise ArgumentError,
+                  "dependencies.budget_per_gem must be in the range " \
+                  "#{MIN_BUDGET_PER_GEM}..#{MAX_BUDGET_PER_GEM}, " \
+                  "got #{value.inspect}"
+          end
+
+          value
+        end
+      end
+    end
+  end
+end

data/lib/rigor/configuration.rb

@@ -2,6 +2,7 @@
 
 require "yaml"
 
+require_relative "configuration/dependencies"
 require_relative "configuration/severity_profile"
 
 module Rigor
@@ -58,7 +59,11 @@ module Rigor
         "allowed_url_hosts" => []
       },
       "severity_profile" => "balanced",
-      "severity_overrides" => {}
+      "severity_overrides" => {},
+      "dependencies" => {
+        "source_inference" => [],
+        "budget_per_gem" => Configuration::Dependencies::DEFAULT_BUDGET_PER_GEM
+      }
     }.freeze
 
     # Top-level keys whose values are file/directory paths that
@@ -72,7 +77,8 @@ module Rigor
                 :libraries, :signature_paths, :fold_platform_specific_paths,
                 :plugins_io_network, :plugins_io_allowed_paths,
                 :plugins_io_allowed_url_hosts,
-                :severity_profile, :severity_overrides
+                :severity_profile, :severity_overrides,
+                :dependencies
 
     # Loads a configuration file.
     #
@@ -174,17 +180,41 @@ module Rigor
 
       merged = left.dup
       right.each do |key, value|
-        merged[key] = if merged.key?(key) && merged[key].is_a?(Hash) && value.is_a?(Hash)
-                        deep_merge(merged[key], value)
-                      else
-                        value
-                      end
+        merged[key] = merge_value(key, merged, value)
       end
       merged
     end
-    private_class_method :load_with_includes, :merge_includes, :resolve_paths_in, :deep_merge
 
-    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength
+    # Most keys are right-wins (override) or recursively
+    # merged hashes. ADR-10 § "config-conflict diagnostic"
+    # carves out `dependencies.source_inference[]`: the
+    # per-gem merge across `includes:` chains needs union
+    # behaviour with mode-conflict detection. The Hash itself
+    # still merges deeply; only the inner array gets
+    # concatenated so {Dependencies.from_h} sees every
+    # contributor's entries and can dedupe them.
+    def self.merge_value(key, merged, value)
+      if key == "dependencies" && merged[key].is_a?(Hash) && value.is_a?(Hash)
+        merge_dependencies_hash(merged[key], value)
+      elsif merged.key?(key) && merged[key].is_a?(Hash) && value.is_a?(Hash)
+        deep_merge(merged[key], value)
+      else
+        value
+      end
+    end
+
+    def self.merge_dependencies_hash(left, right)
+      out = deep_merge(left, right)
+      left_si = Array(left["source_inference"])
+      right_si = Array(right["source_inference"])
+      both_empty = left_si.empty? && right_si.empty?
+      out["source_inference"] = left_si + right_si unless both_empty # rigor:disable flow.always-truthy-condition
+      out
+    end
+    private_class_method :load_with_includes, :merge_includes, :resolve_paths_in, :deep_merge,
+                         :merge_value, :merge_dependencies_hash
+
+    # rubocop:disable Metrics/AbcSize
     def initialize(data = DEFAULTS)
       cache = DEFAULTS.fetch("cache").merge(data.fetch("cache", {}))
       plugins_io = DEFAULTS.fetch("plugins_io").merge(data.fetch("plugins_io", {}))
@@ -213,8 +243,11 @@ module Rigor
       @severity_overrides = coerce_severity_overrides(
         data.fetch("severity_overrides", DEFAULTS.fetch("severity_overrides"))
       )
+      @dependencies = Dependencies.from_h(
+        data.fetch("dependencies", DEFAULTS.fetch("dependencies"))
+      )
     end
-    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength
+    # rubocop:enable Metrics/AbcSize
 
     def to_h
       {
@@ -235,7 +268,8 @@ module Rigor
           "allowed_url_hosts" => plugins_io_allowed_url_hosts
         },
         "severity_profile" => severity_profile.to_s,
-        "severity_overrides" => severity_overrides.to_h { |k, v| [k, v.to_s] }
+        "severity_overrides" => severity_overrides.to_h { |k, v| [k, v.to_s] },
+        "dependencies" => dependencies.to_h
       }
     end
 

data/lib/rigor/environment.rb

@@ -2,6 +2,8 @@
 
 require_relative "environment/class_registry"
 require_relative "environment/rbs_loader"
+require_relative "type_node/name_scope"
+require_relative "type_node/resolver_chain"
 
 module Rigor
   # The engine's view of the type universe outside the current scope.
@@ -41,7 +43,8 @@ module Rigor
       prism rbs
     ].freeze
 
-    attr_reader :class_registry, :rbs_loader, :plugin_registry
+    attr_reader :class_registry, :rbs_loader, :plugin_registry, :dependency_source_index,
+                :rbs_extended_reporter, :boundary_cross_reporter, :name_scope
 
     # @param class_registry [Rigor::Environment::ClassRegistry]
     # @param rbs_loader [Rigor::Environment::RbsLoader, nil] when nil the
@@ -57,10 +60,21 @@ module Rigor
     #   default), no plugin-level return-type contribution
     #   participates — useful for tests, the `Environment.default`
     #   facade, and analyses that don't load plugins.
-    def initialize(class_registry: ClassRegistry.default, rbs_loader: nil, plugin_registry: nil)
+    # @param dependency_source_index [Rigor::Analysis::DependencySourceInference::Index, nil]
+    #   ADR-10 slice 2b-ii. The per-run index of opt-in gem
+    #   sources the dispatcher consults BELOW RBS dispatch.
+    #   When nil (the default), no dep-source contribution
+    #   participates and the dispatcher tier is a no-op.
+    def initialize(class_registry: ClassRegistry.default, rbs_loader: nil,
+                   plugin_registry: nil, dependency_source_index: nil,
+                   rbs_extended_reporter: nil, boundary_cross_reporter: nil)
       @class_registry = class_registry
       @rbs_loader = rbs_loader
       @plugin_registry = plugin_registry
+      @dependency_source_index = dependency_source_index
+      @rbs_extended_reporter = rbs_extended_reporter
+      @boundary_cross_reporter = boundary_cross_reporter
+      @name_scope = build_name_scope
       freeze
     end
 
@@ -90,7 +104,9 @@ module Rigor
       #   reflection artefacts) consult the cache. Pass `nil` (the
       #   default) to skip caching for this environment.
       # @return [Rigor::Environment]
-      def for_project(root: Dir.pwd, libraries: [], signature_paths: nil, cache_store: nil, plugin_registry: nil)
+      def for_project(root: Dir.pwd, libraries: [], signature_paths: nil, cache_store: nil, # rubocop:disable Metrics/ParameterLists
+                      plugin_registry: nil, dependency_source_index: nil,
+                      rbs_extended_reporter: nil, boundary_cross_reporter: nil)
         resolved_paths = signature_paths || default_signature_paths(root)
         merged_libraries = (DEFAULT_LIBRARIES + libraries.map(&:to_s)).uniq
         loader = RbsLoader.new(
@@ -98,7 +114,13 @@ module Rigor
           signature_paths: resolved_paths,
           cache_store: cache_store
         )
-        new(rbs_loader: loader, plugin_registry: plugin_registry)
+        new(
+          rbs_loader: loader,
+          plugin_registry: plugin_registry,
+          dependency_source_index: dependency_source_index,
+          rbs_extended_reporter: rbs_extended_reporter,
+          boundary_cross_reporter: boundary_cross_reporter
+        )
       end
 
       private
@@ -192,5 +214,26 @@ module Rigor
     def normalize_class_name(name)
       name.to_s.delete_prefix("::")
     end
+
+    # ADR-13 slice 3b — composes the per-run plugin-supplied
+    # {Rigor::TypeNode::ResolverChain} into a single
+    # {Rigor::TypeNode::NameScope} that the RBS::Extended
+    # directive parser threads down to the
+    # {Rigor::Builtins::ImportedRefinements::Resolver}. Returns
+    # `nil` when no plugin contributes a type-node resolver so
+    # the parser short-circuits the chain consultation and
+    # behaves bit-for-bit like the v0.1.0 → v0.1.3 default.
+    def build_name_scope
+      return nil if @plugin_registry.nil? || @plugin_registry.empty?
+
+      resolvers = @plugin_registry.type_node_resolvers
+      return nil if resolvers.empty?
+
+      TypeNode::NameScope.new(
+        resolver: TypeNode::ResolverChain.new(resolvers),
+        class_context: nil,
+        type_alias_table: {}
+      )
+    end
   end
 end

data/lib/rigor/flow_contribution/conflict.rb

@@ -28,8 +28,8 @@ module Rigor
       lower_tier_contradiction
     ].freeze
 
-    Conflict = Data.define(:target, :edge, :kind, :reason, :provenances, :message) do
-      def initialize(target:, edge:, kind:, reason:, provenances:, message:) # rubocop:disable Metrics/ParameterLists
+    class Conflict < Data.define(:target, :edge, :kind, :reason, :provenances, :message)
+      def initialize(target:, edge:, kind:, reason:, provenances:, message:)
         unless CONFLICT_VALID_REASONS.include?(reason)
           raise ArgumentError,
                 "FlowContribution::Conflict reason must be one of " \