rigortype 0.4.6 → 0.4.7

data/lib/rigor/language_server/project_context.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "tempfile"
+
 require_relative "../environment"
 require_relative "../project_environment"
 require_relative "../cache/store"
@@ -9,6 +11,7 @@ require_relative "../cache/incremental_snapshot"
 require_relative "../effects/identity"
 require_relative "../analysis/path_expansion"
 require_relative "../protection/discovery_seed"
+require_relative "../config_audit"
 
 module Rigor
   module LanguageServer
@@ -68,6 +71,24 @@ module Rigor
         @project_scan = nil
         @incremental_session = nil
         @session_primed = false
+        @announced_config_warnings = Set.new
+        @announce_lock = Mutex.new
+      end
+
+      # Issue #2231 — the {ConfigAudit} warnings for the configuration as last loaded that the editor has not been
+      # shown yet, or an empty array. `rigor check` prints these on every run; the server is one long run, so it
+      # announces each warning once: at `initialized` for the configuration it started with, and after a later reload
+      # (every save round re-reads `.rigor.yml`) only the warnings that were not in the previous reload's set. The
+      # comparison is by message, not by order, so reordering entries announces nothing, and fixing one of two
+      # warnings does not show the other again. A warning that was fixed and then comes back is new and is shown.
+      # Called from the dispatch thread and the save round's thread alike, hence the lock.
+      def unannounced_config_warnings
+        @announce_lock.synchronize do
+          warnings = ConfigAudit.warnings(@configuration)
+          fresh = warnings.reject { |warning| @announced_config_warnings.include?(warning.message) }
+          @announced_config_warnings = warnings.to_set(&:message)
+          fresh
+        end
       end
 
       # Returns the cached `Rigor::Environment` for this session, building it on first access. The build
@@ -132,6 +153,22 @@ module Rigor
                                                     buffer: buffer, constant_sources: true)
       end
 
+      # Issue #2282 — the base scope an editor query (hover, completion, signature help) probes with: the same
+      # cross-file discovery seed the diagnostic publisher hands its `Runner` ({#discovery_seed_for}), so a constant
+      # or method another file defines answers what `rigor check` would. The seed fold reads the buffer through a
+      # {Analysis::BufferBinding}, so `bytes` is staged in a tempfile for the call. An empty seed (no configured
+      # files, or nothing discovered) leaves the bare single-file scope every query used before.
+      def seeded_scope_for(path:, bytes:)
+        seed = Tempfile.create(["rigor-lsp-query-", ".rb"]) do |tmp|
+          # Staged as the publisher stages them; the seed's job is to withhold the stale on-disk declarations of
+          # this file, so an empty-bytes stage is not observable by design.
+          tmp.write(bytes)
+          tmp.flush
+          discovery_seed_for(Analysis::BufferBinding.new(logical_path: path, physical_path: tmp.path))
+        end
+        Protection::DiscoverySeed.seeded_scope(environment: environment, seed: seed)
+      end
+
       # Builds what {#discovery_seed_for} reads once per generation, so a fork batch's children inherit it instead
       # of each walking the project.
       def prepare_discovery_seed
@@ -251,7 +288,8 @@ module Rigor
       def reload_configuration
         return unless @configuration_loader
 
-        @configuration = @configuration_loader.call
+        loaded = @configuration_loader.call
+        @announce_lock.synchronize { @configuration = loaded }
       rescue StandardError
         nil
       end

data/lib/rigor/language_server/publish_batcher.rb

@@ -15,10 +15,9 @@ module Rigor
     # dropped. The same claim/consume shape `DiagnosticPublisher#run_project_round` already uses for the
     # whole-project save round (#246), generalised to an arbitrary key type and an arbitrary batch action.
     class PublishBatcher
-      # @param on_batch — `(keys) -> void`, called with the deduplicated Array of keys pending at the
-      #   start of one round. May be called more than once in a row when keys keep arriving while a round
-      #   runs.
-      # @param on_error — `(exception) -> void`, called when `on_batch` raises. A round must
+      # @param on_batch — called with the deduplicated keys pending at the start of one round. May be called
+      #   more than once in a row when keys keep arriving while a round runs.
+      # @param on_error — called with the exception when `on_batch` raises. A round must
       #   never wedge the coalescing lock for every future `#enqueue` call — ownership is always released
       #   before this fires. Whatever was mid-flight when the round raised is lost; anything enqueued by a
       #   concurrent `#enqueue` call after this round's drain but before the rescue stays pending and rides

data/lib/rigor/language_server/selection_range_provider.rb

@@ -20,10 +20,8 @@ module Rigor
         @project_context = project_context
       end
 
-      # @param positions — LSP `Position[]` — each
-      #   `{ line:, character: }` 0-based.
-      # @return one `SelectionRange` per
-      #   position, or nil when the URI / buffer isn't resolvable.
+      # @param positions — LSP positions, each `{ line:, character: }` 0-based.
+      # @return one `SelectionRange` per position, or nil when the URI / buffer isn't resolvable.
       def provide(uri, positions)
         path, entry = buffer_for(uri)
         return nil if entry.nil?

data/lib/rigor/language_server/server.rb

@@ -194,7 +194,12 @@ module Rigor
 
       # `initialized` is a notification — no response body. Nothing is registered here yet: the server handles
       # `workspace/didChangeWatchedFiles` when a client sends it, but does not register for it dynamically.
+      #
+      # Issue #2231 — the configuration the server started with is audited here, the first point at which the
+      # client is listening, so a `.rigor.yml` key that does nothing is named in the editor as `rigor check`
+      # names it on STDERR.
       def handle_initialized
+        @publisher&.announce_config_warnings
         nil
       end
 
@@ -267,8 +272,7 @@ module Rigor
 
       # textDocument/hover REQUEST. Slice 5 returns either a `Hover` payload (markdown contents wrapping type
       # + erased-RBS info) or nil when no expression is at the queried position. Nil maps to `result: null`
-      # per LSP spec; clients suppress the popup. Returns `MethodNotFound` when no hover_provider is wired
-      # (slice 1-4 behaviour).
+      # per LSP spec; clients suppress the popup. Returns `MethodNotFound` when no hover_provider is wired.
       def handle_hover(params)
         return method_not_found("textDocument/hover") unless @hover_provider
 
@@ -351,7 +355,7 @@ module Rigor
         )
       end
 
-      # textDocument/documentSymbol REQUEST. Returns the `DocumentSymbol[]` outline for the buffer at the
+      # textDocument/documentSymbol REQUEST. Returns the document-symbol outline for the buffer at the
       # requested URI. Returns `MethodNotFound` when no provider is wired.
       def handle_document_symbol(params)
         return method_not_found("textDocument/documentSymbol") unless @document_symbol_provider

data/lib/rigor/language_server/signature_help_provider.rb

@@ -25,7 +25,7 @@ module Rigor
     # parses the buffer, locates the enclosing `CallNode`, infers the receiver's type, and returns the
     # method's first overload as a `SignatureInformation`.
     #
-    # Slice C1 (this commit) ships:
+    # Slice C1 ships:
     # - Sentinel patching for `obj.foo(|` so Prism's parse succeeds (mirrors `CompletionProvider`'s slice B4
     #   pattern).
     # - First-overload signature only.
@@ -111,7 +111,7 @@ module Rigor
       end
 
       def build_signature(call_node, root, path, bytes, line, character)
-        scope_index = build_scope_index(root, path)
+        scope_index = build_scope_index(root, path, bytes)
         receiver_node = call_node.receiver
         return nil if receiver_node.nil?
 
@@ -197,8 +197,8 @@ module Rigor
         end
       end
 
-      def build_scope_index(root, _path)
-        scope = Scope.empty(environment: @project_context.environment)
+      def build_scope_index(root, path, bytes)
+        scope = @project_context.seeded_scope_for(path: path, bytes: bytes)
         Inference::ScopeIndexer.index(root, default_scope: scope)
       end
 

data/lib/rigor/lens/plugins.rb

@@ -29,7 +29,7 @@ module Rigor
         return Rigor::VERSION if absolute.start_with?("#{BUNDLED_PLUGINS}/")
 
         spec = Gem.loaded_specs.each_value.find do |gem|
-          absolute.start_with?("#{gem.full_gem_path}/") # rigor:disable undefined-method
+          absolute.start_with?("#{gem.full_gem_path}/")
         end
         spec&.version&.to_s
       rescue StandardError

data/lib/rigor/mcp/server.rb

@@ -155,6 +155,10 @@ module Rigor
       ].freeze
       Ractor.make_shareable(TOOLS)
 
+      # The tools that read a configuration — the ones taking a `config` argument — and so report its warnings.
+      CONFIG_TOOLS = TOOLS.filter_map { |tool| tool[:name] if tool.dig(:inputSchema, :properties, :config) }.freeze
+      Ractor.make_shareable(CONFIG_TOOLS)
+
       def initialize(config_path: nil, err: $stderr)
         @config_path = config_path
         @err = err
@@ -165,7 +169,7 @@ module Rigor
         id = request["id"]
         method_name = request["method"]
 
-        # Notifications carry no `id` and require no response.
+        # A notification carries no `id` and requires no response.
         return nil if id.nil?
 
         case method_name
@@ -181,8 +185,38 @@ module Rigor
         end
       end
 
+      # ADR-126 WD4 — `rigor_type_of` and `rigor_explain` print documents whose top-level shape changes in the next
+      # minor, and their CLI says so on stderr, which `tool_result` drops once there is a document. The notice is
+      # carried to the agent as its own `text` content block, the same text the CLI printed, so the document block
+      # stays byte-for-byte what the CLI wrote. When stdout is empty the error text already is stderr.
+      SHAPE_NOTICE_TOOLS = %w[rigor_type_of rigor_explain].freeze
+
       private
 
+      def finish_tool_result(name, args, out, err, exit_code)
+        result = with_config_warnings(tool_result(out, err, exit_code), name, args, out)
+        result = with_shape_notice(result, name, out, err)
+        with_path_warnings(result, name, out, err)
+      end
+
+      # #2206 — `rigor coverage` writes its path warnings (a missing path skipped beside files it measures) to stderr,
+      # which a successful run drops. The tool carries the CLI's whole stderr (path warnings and any other warnings)
+      # as a second text block, unfiltered, so an agent sees what was skipped.
+      def with_path_warnings(result, name, out, err)
+        return result unless name == "rigor_coverage" && !out.empty? && !err.strip.empty?
+
+        result.merge(content: result.fetch(:content) + [{ type: "text", text: err }])
+      end
+
+      def with_shape_notice(result, name, out, err)
+        return result unless SHAPE_NOTICE_TOOLS.include?(name) && !out.empty?
+
+        notice = err[CLI::JsonDocument::NOTICE_PATTERN]
+        return result unless notice
+
+        result.merge(content: result.fetch(:content) + [{ type: "text", text: notice }])
+      end
+
       def handle_initialize(id)
         require_relative "../version"
         success(id, {
@@ -201,7 +235,7 @@ module Rigor
         require_relative "../cli"
         exit_code = with_captured_streams(out_io, err_io) { CLI.new(argv, out: out_io, err: err_io).run }
 
-        success(id, tool_result(out_io.string, err_io.string, exit_code))
+        success(id, finish_tool_result(name, args, out_io.string, err_io.string, exit_code))
       rescue SystemExit => e
         # Defence against any command that exits: it must not take the server down with it.
         success(id, { content: [{ type: "text", text: "Command exited (status #{e.status})" }], isError: true })
@@ -221,6 +255,43 @@ module Rigor
         { content: [{ type: "text", text: out.empty? ? err : out }], isError: is_error }
       end
 
+      # Issue #2231 — `rigor check` puts {ConfigAudit} warnings in its JSON `config_warnings`; the other tools read the
+      # same configuration and said nothing about it, so an agent saw `call.undefined-method` on a project whose
+      # `.rigor.yml` misspelt the key meant to silence it and got no hint why. Every tool that takes a `config`
+      # argument now carries them: a second `text` content block holding `{"config_warnings": [...]}`, each entry the
+      # shape check's JSON uses. The tool's own document is left byte-for-byte as its CLI printed it, and an output
+      # that already carries the key (check's) gets no second copy. Nothing is added when there is nothing to say,
+      # nor when the configuration does not load — the CLI has already reported that.
+      def with_config_warnings(result, name, args, out)
+        return result unless CONFIG_TOOLS.include?(name)
+
+        warnings = config_warnings(present_config(args["config"]) || @config_path)
+        return result if warnings.empty? || carries_config_warnings?(out)
+
+        block = { type: "text", text: JSON.generate({ "config_warnings" => warnings.map(&:to_h) }) }
+        result.merge(content: result.fetch(:content) + [block])
+      end
+
+      # Only a configuration that does not load is "no warnings to show": the CLI has already reported that error.
+      # A failure in ConfigAudit itself is a bug and surfaces as an internal error rather than reading as clean.
+      def config_warnings(config_path)
+        require_relative "../configuration"
+        require_relative "../config_audit"
+        begin
+          configuration = Configuration.load(config_path)
+        rescue ConfigurationError
+          return []
+        end
+        ConfigAudit.warnings(configuration)
+      end
+
+      def carries_config_warnings?(out)
+        document = JSON.parse(out)
+        document.is_a?(Hash) && document.key?("config_warnings")
+      rescue JSON::ParserError
+        false
+      end
+
       # The JSON-RPC channel is the process's stdout, so nothing a command writes past its `out:` (an option
       # parser's `--help`, a stray `puts`) may reach it while the command runs.
       def with_captured_streams(out_io, err_io)

data/lib/rigor/mcp.rb

@@ -4,7 +4,7 @@ module Rigor
   # The MCP (Model Context Protocol) server subsystem. See `docs/adr/33-mcp-server.md` for the design.
   #
   # Entry point: `rigor mcp --transport stdio`. The server exposes Rigor's analysis tools (check, type-of, triage,
-  # annotate, sig-gen, explain, coverage) as MCP tool calls over a newline-delimited JSON-RPC 2.0 stdio stream.
+  # lens, annotate, sig-gen, explain, coverage) as MCP tool calls over a newline-delimited JSON-RPC 2.0 stdio stream.
   module MCP
   end
 end

data/lib/rigor/plugin/access_denied_error.rb

@@ -6,8 +6,7 @@ module Rigor
     # analyzer can convert the exception into a `:plugin_loader` diagnostic without crashing `rigor check`.
     #
     # The policy is documented in [ADR-2 § "Plugin Trust and I/O Policy"](../../../docs/adr/2-extension-api.md).
-    # Slice 2's surface lists `:read_outside_scope` and `:network_disabled` as the two reason codes; future slices
-    # may extend the set.
+    # `reason:` is one of `:read_outside_scope`, `:network_disabled`, `:url_fetch_failed` or `:url_body_too_large`.
     class AccessDeniedError < StandardError
       attr_reader :reason, :resource
 

data/lib/rigor/plugin/bundled_catalog.rb

@@ -127,7 +127,7 @@ module Rigor
         def require_bundled_plugins
           return {} unless File.directory?(BUNDLED_PLUGINS_ROOT)
 
-          add_bundled_lib_dirs
+          Loader.add_bundled_lib_dirs
           Dir.children(BUNDLED_PLUGINS_ROOT).sort.each_with_object({}) do |gem_name, resolved|
             path = Loader.bundled_plugin_path(gem_name)
             next if path.nil?
@@ -137,17 +137,6 @@ module Rigor
           end
         end
 
-        # A bundled plugin's entry file requires its own tree by bare feature name (`require
-        # "rigor/plugin/activestorage"`), which resolves only with that plugin's `lib` on the load path — the
-        # loader gets it from the bundle, and this catalogue has to arrange it itself. Prepending the engine's
-        # own copies matches ADR-93 WD5's anti-skew rule, where the bundled copy always wins.
-        def add_bundled_lib_dirs
-          Dir.children(BUNDLED_PLUGINS_ROOT).sort.each do |gem_name|
-            dir = File.join(BUNDLED_PLUGINS_ROOT, gem_name, "lib")
-            $LOAD_PATH.unshift(dir) if File.directory?(dir) && !$LOAD_PATH.include?(dir)
-          end
-        end
-
         # A plugin gem that fails to load is skipped rather than fatal: the catalogue exists to *advise*, and
         # a broken bundled copy is already reported by `rigor doctor`'s plugin checks for the plugins the
         # project actually enabled. The failure is recorded in {load_failures} so a missing entry stays

data/lib/rigor/plugin/io_boundary.rb

@@ -17,7 +17,7 @@ module Rigor
     # scope and feed the cache descriptor; contributions built on top of out-of-scope reads will not
     # invalidate correctly.
     #
-    # Slice 2 ships a minimal surface:
+    # The surface:
     #
     # - `#read_file(path)` — validates against the policy, returns the file's contents, and adds a
     #   digest-keyed {Cache::Descriptor::FileEntry} to the boundary's accumulated descriptor. A read that

data/lib/rigor/plugin/loader.rb

@@ -90,6 +90,20 @@ module Rigor
         File.directory?(path) ? path : nil
       end
 
+      # Puts every bundled plugin's `lib` on `$LOAD_PATH`, so a bundled plugin that requires another by gem
+      # name (`require "rigor-ffi"` from `rigor-ethon`, `rigor-sassc`, `rigor-ffi-rzmq` and `rigor-rbnacl`)
+      # resolves without a bundle. The engine's own copies go first, which matches ADR-93 WD5's anti-skew
+      # rule: the bundled copy always wins. Idempotent; a trimmed packaging with no `plugins/` tree adds none.
+      def self.add_bundled_lib_dirs
+        root = File.join(ENGINE_ROOT, "plugins")
+        return unless File.directory?(root)
+
+        Dir.children(root).sort.each do |gem_name|
+          dir = File.join(root, gem_name, "lib")
+          $LOAD_PATH.unshift(dir) if File.directory?(dir) && !$LOAD_PATH.include?(dir)
+        end
+      end
+
       # @param entries — the raw `plugins:` list from the configuration.
       def load(entries)
         plugins = []
@@ -233,7 +247,13 @@ module Rigor
       # `feature_resolver` is unaffected: an absolute-path require's `$LOADED_FEATURES` entry still ends in
       # `/<gem>.rb`, the suffix {FEATURE_RESOLVER} matches.
       def require_gem!(entry)
-        @requirer.call(self.class.bundled_plugin_path(entry[:gem]) || entry[:gem])
+        path = self.class.bundled_plugin_path(entry[:gem])
+        if path
+          self.class.add_bundled_lib_dirs
+          @requirer.call(path)
+        else
+          @requirer.call(entry[:gem])
+        end
       rescue ::LoadError => e
         raise LoadError.new(
           "could not load plugin gem #{entry[:gem].inspect}: #{e.message}",
@@ -272,13 +292,10 @@ module Rigor
         end
       end
 
-      # A gem that registers more than one plugin is a meta-gem only when NONE of the ids is its own. The
-      # FFI family (`rigor-sassc`, `rigor-ethon`, `rigor-ffi-rzmq`, `rigor-rbnacl`) each `require "rigor-ffi"`
-      # for the shared binding analyzer, so listing one of them ALONE registered two plugins — its own and
-      # `ffi` — and the meta-gem branch rejected the entry, telling the user to list `rigor-ffi` instead,
-      # which activates the wrong plugin. The failure was load-order dependent (listing `rigor-ffi` first
-      # made the nested require a no-op and the entry loaded), so it never showed up in the suite, where
-      # some earlier example has always loaded `rigor-ffi`.
+      # A gem that registers several plugins is a meta-gem only when NONE of the ids is its own. The FFI family
+      # (`rigor-sassc`, `rigor-ethon`, `rigor-ffi-rzmq`, `rigor-rbnacl`) each `require "rigor-ffi"`, so listing
+      # one alone registered `ffi` too and was wrongly rejected as a meta-gem. The bug was load-order dependent
+      # and hid in the suite, where an earlier example always loaded `rigor-ffi`.
       #
       # `rigor-rails` stays a meta-gem under this rule: it registers eight ids and none of them is `rails`.
       def own_id_among(gem_name, ids)

data/lib/rigor/plugin/macro/heredoc_template.rb

@@ -48,11 +48,11 @@ module Rigor
       #
       # Slice 2 ships at the **floor**: each emit row's `name:` is the source of truth for the synthetic
       # method's name (a single `"\#{name}"` placeholder gets interpolated with the literal symbol argument at
-      # `symbol_arg_position`). The `returns:` strings are **recorded in the manifest but not resolved**; the
-      # engine emits synthetic methods with `Dynamic[T]` returns plus a `macro.tier_c.unresolved-return`
-      # provenance marker. Precise return-type resolution via ADR-13's `Plugin::TypeNodeResolver` is the
-      # **ceiling**, deferred to a later slice — the `returns:` declarations cost nothing to write today and
-      # unlock precision then.
+      # `symbol_arg_position`). The synthetic method's return type is the `returns_from_arg:` lookup when it
+      # resolves, else a non-empty `returns:` string (`SyntheticMethodScanner#resolve_emit_return_type`); the
+      # dispatcher turns it into a nominal type through `MethodDispatcher#promote_via_return_type` when the
+      # environment knows the class. With neither, an `"untyped"` / `"void"` placeholder, or an unknown class, the
+      # method answers `Dynamic[Top]`. Resolution through ADR-13's `Plugin::TypeNodeResolver` is not wired.
       #
       # Engine wiring: `Inference::SyntheticMethodScanner` (slice 2b, `synthetic_method_scanner.rb`) consumes
       # `manifest.heredoc_templates`. Worked consumers: `plugins/rigor-dry-struct/` and
@@ -98,7 +98,7 @@ module Rigor
         # `\#{name}` with the call-site literal symbol) and its declared return type. The return type can be
         # a static String (resolved via `Environment#nominal_for_name` per ADR-16 slice 6b) or a
         # per-call-site lookup ({ReturnsFromArg}) — see
-        # [ADR-18](../../../../../docs/adr/18-substrate-per-call-site-return-type.md). When both are nil, the
+        # [ADR-18](../../../../docs/adr/18-substrate-per-call-site-return-type.md). When both are nil, the
         # synthesised method's return type falls back to `Dynamic[Top]`.
         class Emit
           attr_reader :name, :returns, :returns_from_arg
@@ -147,8 +147,7 @@ module Rigor
         #       lookup_via: { plugin_id: "dry-types", fact: :dry_type_aliases }
         #     }
         #
-        # Slice 1 (this file) ships the value class + validation only. The scanner-side arg-position
-        # extraction + fact-store lookup land in slice 2 / 3.
+        # The scanner's `resolve_emit_return_type` does the arg-position extraction and fact-store lookup.
         class ReturnsFromArg
           attr_reader :position, :plugin_id, :fact
 

data/lib/rigor/plugin/macro/trait_registry.rb

@@ -39,12 +39,10 @@ module Rigor
       #   lexical receiver class equals or inherits from this constraint.
       # - `method_name` — Symbol naming the DSL method (e.g. `:devise`).
       # - `symbol_arg_position` — `:rest` (all positional Symbol args are traits, slice 3a's only supported
-      #   form) or a non-negative Integer (the index of a single trait symbol — reserved for future shapes;
-      #   not yet honoured by the scanner).
-      # - `modules_by_symbol` — Hash<Symbol, String>. Maps each recognised trait symbol to a fully-qualified
-      #   module name. Symbols not in the table fall through (silent skip; the scanner emits a
-      #   `macro.tier_b.unknown-trait` `:info` provenance marker per WD9 / WD13).
-      # - `always_included` — Array<String>. Fully-qualified module names that are added to every call site
+      #   form) or a non-negative Integer (the index of a single trait symbol).
+      # - `modules_by_symbol` — Maps each recognised trait symbol to a fully-qualified module name. Symbols not
+      #   in the table are silently skipped.
+      # - `always_included` — Fully-qualified module names that are added to every call site
       #   (even when no symbols match). Mirrors Devise's `always_include` modules.
       #
       # ## Floor / ceiling per ADR-16 WD13
@@ -53,7 +51,7 @@ module Rigor
       # methods into the existing `SyntheticMethodIndex` (slice 2b primitive). The synthesised methods adopt
       # the module's authored RBS return types — Tier B is NOT subject to the Tier C `Dynamic[T]` floor
       # because the source-of-truth (the module's authored RBS) is not a manifest-declared string. Per ADR-5
-      # robustness, the substrate does not fabricate precision; it simply replays the modules's signatures.
+      # robustness, the substrate does not fabricate precision; it simply replays the module's signatures.
       #
       # **Out of scope for slice 3** (deferred follow-ups):
       # - `class_methods_module:` per-trait (Devise's `ClassMethods` extend-pattern); slice 3 covers instance
@@ -106,8 +104,7 @@ module Rigor
         end
 
         # @return fully-qualified module name for the given trait symbol, or nil when the
-        #   registry doesn't know the symbol (caller emits a tier_b.unknown-trait provenance marker and falls
-        #   through).
+        #   registry doesn't know the symbol (the caller skips it).
         def module_for(symbol)
           modules_by_symbol[symbol.to_sym]
         end

data/lib/rigor/plugin/manifest.rb

@@ -168,9 +168,8 @@ module Rigor
       end
       private :assign_additional_initializers
 
-      # ADR-103 WD2 / WD6 / WD10 / WD14 — the effect contract's five fields, assigned together and outside
-      # `assign_fields` (which already carries the maximum positional arity).
-      # The six `effect_*` fields validate together, so {#initialize} carries one call rather than six.
+      # ADR-103 WD2 / WD6 / WD10 / WD14 — the six `effect_*` fields validate together here, so {#initialize}
+      # carries one call rather than six.
       def validate_effect_fields!(effect_root, effect_labels, effect_attributions, effect_edges,
                                   effect_entry_points, effect_ancestry)
         validate_effect_root!(effect_root)
@@ -475,10 +474,9 @@ module Rigor
         end
       end
 
-      # ADR-13 slice 2 — `type_node_resolvers:` declares the plugin-supplied `TypeNodeResolver` instances the
-      # parser consults (in slice 3) when an RBS::Extended payload's named- or generic-type head misses the
-      # built-in registry. Slice 2 carries the declarations on the manifest and the registry exposes them in
-      # registration order; the parser integration that actually drives the chain lands in slice 3.
+      # ADR-13 — `type_node_resolvers:` declares the plugin-supplied `TypeNodeResolver` instances the parser
+      # consults when an RBS::Extended payload's named- or generic-type head misses the built-in registry. The
+      # registry exposes them in registration order, and `Environment#build_name_scope` builds the chain.
       def validate_type_node_resolvers!(resolvers)
         validate_array_of!("type_node_resolvers", resolvers, "Rigor::Plugin::TypeNodeResolver instances") do |r|
           r.is_a?(TypeNodeResolver)
@@ -486,8 +484,7 @@ module Rigor
       end
 
       # ADR-16 slice 1a — `block_as_methods:` declares the Tier A substrate entries the plugin contributes.
-      # Slice 1a carries the declarations on the manifest; the engine hook that actually narrows
-      # `Scope#self_type` for matching blocks arrives in a subsequent slice.
+      # The engine hook that narrows `Scope#self_type` for matching blocks is `Inference::MacroBlockSelfType`.
       def validate_block_as_methods!(entries)
         validate_array_of!("block_as_methods", entries, "Rigor::Plugin::Macro::BlockAsMethod instances") do |e|
           e.is_a?(Macro::BlockAsMethod)
@@ -495,8 +492,7 @@ module Rigor
       end
 
       # ADR-16 slice 2a — `heredoc_templates:` declares the Tier C substrate entries (heredoc-template
-      # synthesis on class-level DSL calls). Slice 2a carries the declarations on the manifest; the pre-pass +
-      # `SyntheticMethodIndex` that actually emit synthetic methods arrive in slice 2b.
+      # synthesis on class-level DSL calls). `Inference::SyntheticMethodScanner` emits the synthetic methods.
       def validate_heredoc_templates!(entries)
         validate_array_of!("heredoc_templates", entries, "Rigor::Plugin::Macro::HeredocTemplate instances") do |e|
           e.is_a?(Macro::HeredocTemplate)
@@ -515,8 +511,8 @@ module Rigor
       end
 
       # ADR-16 slice 3a — `trait_registries:` declares the Tier B substrate entries (trait-inlining via
-      # bundled module registry). Slice 3a carries the declarations on the manifest; the scanner + per-method
-      # explosion through `SyntheticMethodIndex` (slice 2b primitive) arrives in slice 3b.
+      # bundled module registry). `Inference::SyntheticMethodScanner#collect_trait_registries` explodes them
+      # per method through `SyntheticMethodIndex`.
       def validate_trait_registries!(entries)
         validate_array_of!("trait_registries", entries, "Rigor::Plugin::Macro::TraitRegistry instances") do |e|
           e.is_a?(Macro::TraitRegistry)

data/lib/rigor/plugin/registry.rb

@@ -214,7 +214,7 @@ module Rigor
     # tie-breaker.
     #
     # ADR-15 Phase 3 — alongside the instantiated `plugins`, the registry carries `blueprints`: a frozen,
-    # Ractor-shareable `Array<Blueprint>` that records how to re-instantiate the same plugin set in a worker
+    # Ractor-shareable list of {Blueprint} that records how to re-instantiate the same plugin set in a worker
     # Ractor. The eventual Phase 4 pool ships `blueprints` across the boundary and calls {.materialize}
     # per-Ractor; the live `plugins` carriage on the coordinator registry stays unchanged.
     class Registry
@@ -556,8 +556,8 @@ module Rigor
       # Issue #806 — {#safe_manifest} with a receipt. The construction-time aggregates degraded silently
       # when a manifest read raised, so a plugin that contributed nothing looked identical to a plugin that
       # was never asked; the load-error channel is where "a plugin could not be loaded" already lives, and
-      # `Analysis::Runner` turns each entry into one `plugin_loader.load-error` row naming the plugin. The
-      # plugin ref is the CLASS, not `manifest.id`: the manifest is the surface that just failed.
+      # `Analysis::Runner` turns each entry into one `load-error` row (source family `plugin_loader`) naming
+      # the plugin. The plugin ref is the CLASS, not `manifest.id`: the manifest is the surface that just failed.
       def guarded_manifest(plugin, errors)
         plugin.manifest
       rescue StandardError => e

data/lib/rigor/plugin/services.rb

@@ -25,9 +25,8 @@ module Rigor
     # documents the trust model the boundary enforces.
     #
     # ADR-9 slice 2 adds `fact_store`: the per-run cross-plugin `Plugin::FactStore`. Producer plugins publish
-    # their facts in `#prepare(services)` (slice 3); consumer plugins read in `#diagnostics_for_file` via
-    # `services.fact_store.read(...)`. A fresh `FactStore` instance is constructed per Services when none is
-    # supplied — the runner threads its own instance in once slice 3 wires `#prepare` invocation.
+    # their facts in `#prepare(services)`; consumer plugins read in `#diagnostics_for_file` via
+    # `services.fact_store.read(...)`. A fresh `FactStore` is constructed when none is supplied.
     class Services
       attr_reader :reflection, :type, :configuration, :cache_store, :trust_policy, :fact_store
 

data/lib/rigor/plugin/source_rbs_synthesis_reporter.rb

@@ -61,6 +61,17 @@ module Rigor
       def empty?
         @entries.empty?
       end
+
+      # The pool drain ({Rigor::Analysis::WorkerSession#drain_reporters}): the frozen entries.
+      def snapshot
+        entries
+      end
+
+      # Replays one worker's {#snapshot}, `kind:` (#824) and `line:` (#1075) included; the dedup above
+      # collapses every worker's copy. Nil records nothing.
+      def absorb(snapshot)
+        Array(snapshot).each { |entry| record(**entry.to_h) }
+      end
     end
   end
 end

data/lib/rigor/plugin/trust_policy.rb

@@ -19,8 +19,8 @@ module Rigor
     # - `trusted_gems`: gem names the user has authorised. Derived from the `plugins:` section of `.rigor.yml`
     #   plus any gems they reach transitively. Used today for documentation and future trust diagnostics.
     # - `allowed_read_roots`: absolute paths plugin code may read from through the {IoBoundary}. The default
-    #   set covers the project root, the project's `signature_paths`, the active `Gemfile.lock`, and each
-    #   trusted gem's `Gem::Specification#full_gem_path`. The user extends this with `.rigor.yml`'s
+    #   set covers the project root, the project's `signature_paths`, and each trusted
+    #   gem's `Gem::Specification#full_gem_path`. The user extends this with `.rigor.yml`'s
     #   `plugins_io.allowed_paths:`.
     # - `network_policy`: one of {VALID_NETWORK_POLICIES}. `:disabled` (default) makes
     #   {IoBoundary#open_url} always raise. `:allowlist` (v0.1.2) consults `allowed_url_hosts` on every fetch —

data/lib/rigor/plugin/type_node_resolver.rb

@@ -28,10 +28,8 @@ module Rigor
     # Resolvers SHOULD be stateless and re-entrant; the registry builds the chain once per
     # `Analysis::Runner.run` and may consult any resolver multiple times for the same node.
     class TypeNodeResolver
-      # @param node — the parser-emitted node the chain is
-      #   asking about.
-      # @param scope — companion value object (slice 3); slice 2 invocations MAY pass
-      #   `nil` because the chain doesn't exist yet.
+      # @param node — the parser-emitted node the chain is asking about.
+      # @param scope — the scope the chain was invoked with.
       # @return resolved type, or `nil` to fall through.
       def resolve(node, scope) # rubocop:disable Lint/UnusedMethodArgument
         nil