rigortype 0.4.0 → 0.4.1

data/lib/rigor/sig_gen/alias_index.rb

@@ -142,7 +142,7 @@ module Rigor
         buffer_name = decl.location&.buffer&.name
         return nil if buffer_name.nil?
 
-        File.expand_path(buffer_name.to_s)
+        File.absolute_path(buffer_name.to_s)
       rescue StandardError
         nil
       end

data/lib/rigor/sig_gen/effect_annotation.rb

@@ -182,8 +182,8 @@ module Rigor
         def relative_path(path)
           return nil if path.nil?
 
-          expanded = File.expand_path(path.to_s)
-          root = "#{File.expand_path(Dir.pwd)}#{File::SEPARATOR}"
+          expanded = File.absolute_path(path.to_s)
+          root = "#{File.absolute_path(Dir.pwd)}#{File::SEPARATOR}"
           expanded.start_with?(root) ? expanded.delete_prefix(root) : nil
         end
 

data/lib/rigor/sig_gen/generator.rb

@@ -13,6 +13,7 @@ require_relative "../source/literals"
 require_relative "../source/node_children"
 require_relative "../inference/def_return_typer"
 require_relative "../inference/scope_indexer"
+require_relative "../inference/module_function_state"
 require_relative "../inference/rbs_type_translator"
 require_relative "alias_index"
 require_relative "meta_class_shape"
@@ -464,7 +465,7 @@ module Rigor
         @class_superclasses = {}
         @meta_layouts = collect_meta_layouts(scope_index)
         register_meta_classes
-        defs = collect_method_definitions(parse_result.value)
+        defs = collect_method_definitions(parse_result.value, scope_index)
         # Candidate construction freezes the per-file maps above (see {#build_candidate}), so every registration
         # pass has to be finished before the first `build_candidate` call. Meta members lead the RETURNED order —
         # a value class's members and constructors read first, ahead of the methods its block body defines.
@@ -497,7 +498,8 @@ module Rigor
       # - `@module_function_methods` records `(class_name, method_name)` pairs where a `module_function` (no
       #   args) call preceded the `def` inside a module body. The renderer emits `def self?.name` for these, the
       #   RBS spelling that matches the dual instance + singleton dispatch the runtime produces.
-      def collect_method_definitions(root)
+      def collect_method_definitions(root, scope_index)
+        @declared_types = scope_index[root].declared_types
         out = []
         walk_defs(root, [], false, false, out)
         out
@@ -542,6 +544,11 @@ module Rigor
       # `prefix` stays the nesting the header is WRITTEN in for {#record_superclass}: `::` re-anchors the
       # declaration, not the superclass expression beside it, which Ruby still evaluates in the enclosing cref.
       def descend_into_namespace?(node, prefix, out)
+        # Issue #1518 — a `class self::X` / `module self::X` the indexer declined (`self` is opaque, as under
+        # `REGISTRY.first.class_eval`) names no class, so its body must not be written out under the lexical
+        # `X`. The indexer's identity table is the single source of that decision.
+        return true if declined_self_header?(node)
+
         child_prefix = Source::ConstantPath.declaration_prefix(prefix, node.constant_path)
         return false unless child_prefix
 
@@ -552,6 +559,12 @@ module Rigor
         true
       end
 
+      def declined_self_header?(node)
+        path = node.constant_path
+        path.is_a?(Prism::ConstantPathNode) && path.parent.is_a?(Prism::SelfNode) &&
+          !@declared_types.key?(path)
+      end
+
       # ADR-14: a generated subclass declaration MUST carry its superclass, or the sidecar `sig/` misrepresents
       # the class (inherited members vanish → receiver dispatch degrades to `Dynamic`) and, worse, a nested
       # reference to an inherited type re-declares the class as a bare namespace on the RBS side and can
@@ -662,29 +675,22 @@ module Rigor
         walk_defs(namespace_node.body, prefix, false, false, out)
       end
 
+      # The directive's reach is {Inference::ModuleFunctionState.each_sig_gen_statement}.
       def walk_statements(stmts_node, prefix, in_singleton_class, module_function_active, out)
-        stmts_node.body.each do |stmt|
-          if module_function_directive?(stmt)
-            module_function_active = true
-            next
-          end
-          walk_defs(stmt, prefix, in_singleton_class, module_function_active, out)
+        Inference::ModuleFunctionState.each_sig_gen_statement(stmts_node.body,
+                                                              module_function_active) do |stmt, active|
+          walk_defs(stmt, prefix, in_singleton_class, active, out)
         end
       end
 
-      def module_function_directive?(node)
-        return false unless node.is_a?(Prism::CallNode)
-        return false unless node.name == :module_function && node.receiver.nil?
-
-        (node.arguments&.arguments || []).empty?
-      end
-
       def collect_def_node(node, prefix, in_singleton_class, module_function_active, out)
         return if prefix.empty?
 
         kind = node.receiver.is_a?(Prism::SelfNode) || in_singleton_class ? :singleton : :instance
         class_name = prefix.join("::")
-        @module_function_methods << [class_name, node.name] if module_function_active && kind == :instance
+        if Inference::ModuleFunctionState.sig_gen_module_function?(module_function_active, kind)
+          @module_function_methods << [class_name, node.name]
+        end
         out << [node, class_name, kind]
       end
 

data/lib/rigor/type/combinator.rb

@@ -991,13 +991,37 @@ module Rigor
           end
         end
 
+        # The order a new union or intersection keeps: by each member's `describe(:short)`, which is
+        # observable in messages and in cache fingerprints, so it must not move. Two members, the common
+        # case, compare directly instead of paying `sort_by`'s work arrays; `sort_by` keeps an equal pair in
+        # place as well ([#1505](https://github.com/rigortype/rigor/issues/1505)).
         def sort_members(members)
-          members.sort_by { |m| m.describe(:short) }
+          if members.size == 2
+            first, second = members
+            return sort_key(second) < sort_key(first) ? [second, first] : members
+          end
+
+          members.sort_by { |member| sort_key(member) }
+        end
+
+        # A member's `describe(:short)`, rendered at most once per type instance between garbage collections.
+        # No type carrier has a method that changes it once built (a built type is frozen; one `Marshal.load`
+        # restores is not, but nothing mutates it either), so a memoised key cannot go stale. The memo is weak
+        # in both key and value: it keeps neither the type nor the string alive, and an entry whose string
+        # nothing else holds is dropped at the next GC. It is keyed by identity on purpose: `Constant[0.0]` and
+        # `Constant[-0.0]` are equal and hash alike, but render differently. A non-main Ractor may not read the
+        # module's ivar, so a pool worker renders the key every time, as every run did before.
+        def sort_key(member)
+          return member.describe(:short) unless Ractor.main?
+
+          @sort_keys[member] ||= member.describe(:short)
         end
       end
 
       # Eager-allocated at load time; see `untyped` method comment above.
       @untyped = Dynamic.new(Top.instance)
+      # The main Ractor's {sort_key} memo, allocated here for the same reason.
+      @sort_keys = ObjectSpace::WeakMap.new
 
       NIL_CONSTANT = Constant.new(nil)
       TRUE_CONSTANT = Constant.new(true)

data/lib/rigor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rigor
-  VERSION = "0.4.0"
+  VERSION = "0.4.1"
 end

data/plugins/rigor-ffi/lib/rigor/plugin/ffi.rb

@@ -137,6 +137,16 @@ module Rigor
         @exceptions = config["exceptions"] || []
       end
 
+      # ADR-88 channel (c) — the detected `:ffx` / `:ffi` target decides whether the `plugin.ffi.ffx.unsupported-*`
+      # rules fire, and {TargetDetector} reads `<root>/Gemfile.lock` and `ext/**/extconf.rb` directly, not the
+      # lockfile `bundler.lockfile:` resolves to — so neither the `--incremental` snapshot's gem-set digest nor an
+      # edit to an analysed file covers a change in them. Declaring the target makes a flip send the warm
+      # snapshot cold. Everything else this plugin contributes is per-file or comes from the `ffi_catalog`
+      # producer (channel b).
+      def incremental_state_fingerprint
+        "target:#{@target || :ffi}"
+      end
+
       private
 
       # Every discovered name in both `dynamic_return receivers:` kinds (#701), for the two rules whose

data/sig/rigor/environment.rbs

@@ -20,6 +20,8 @@ module Rigor
 
     def self.default: () -> Environment
     def self.for_project: (?root: String, ?libraries: Array[String], ?signature_paths: Array[String | _ToPath]?, ?cache_store: untyped?, ?plugin_registry: untyped?, ?dependency_source_index: untyped?, ?rbs_extended_reporter: untyped?, ?boundary_cross_reporter: untyped?, ?source_rbs_synthesis_reporter: untyped?, ?bundler_bundle_path: String?, ?bundler_auto_detect: bool, ?synthetic_method_index: untyped?, ?project_patched_methods: untyped?) -> Environment
+    # authored: the return is the `signature_paths:` argument's type (authored intent) or the default [Pathname]; sig-gen types the `||` fallback untyped.
+    def self.project_signature_roots: (Array[String | _ToPath]? signature_paths, ?root: String) -> Array[String | _ToPath]
 
     def initialize: (?class_registry: ClassRegistry, ?rbs_loader: RbsLoader?, ?plugin_registry: untyped?, ?dependency_source_index: untyped?, ?rbs_extended_reporter: untyped?, ?boundary_cross_reporter: untyped?, ?source_rbs_synthesis_reporter: untyped?, ?synthetic_method_index: untyped?, ?project_patched_methods: untyped?) -> void
     def rbs_extended_reporter: () -> untyped?

data/sig/rigor/plugin/io_boundary.rbs

@@ -10,4 +10,5 @@ class Rigor::Plugin::IoBoundary
   def open_url: (untyped url) -> String
   # Returns a frozen `Rigor::Cache::Descriptor` (no RBS yet -> untyped).
   def cache_descriptor: () -> untyped
+  def replay: (untyped descriptor) -> nil
 end

data/sig/rigor/scope.rbs

@@ -37,6 +37,9 @@ module Rigor
     # Issue #1429 — the pre-guard type of each global or constant a guard narrowed.
     # sig-gen gap: #1154 — a reader over an ivar `initialize` assigns from a parameter.
     attr_reader guard_records: Hash[[Symbol, Symbol | String], Type::t]
+    # Issue #1446 — the classes a class guard narrowed a `bot` receiver to.
+    # sig-gen gap: #1154 — a reader over an ivar `initialize` assigns from a parameter.
+    attr_reader bot_guard_classes: Hash[[Symbol, Symbol | String], Array[String]]
 
     # ADR-53 Track A — the seed-time discovery tables live on the
     # DiscoveryIndex; Scope keeps per-table readers as delegates.
@@ -154,10 +157,38 @@ module Rigor
       # `untyped`: the value is an `Inference::LastLine::SelfEvidence` (or nil), and that class carries no signature,
       # as `Inference::MatchRebinding::Frame` carries none for `match_frame`.
       attr_reader implicit_self_evidence: untyped
+      # sig-gen gap: #1150 — `Data.define` members carry no type, as for every other row in this class.
+      attr_reader possible_discovered_methods: Hash[String, Hash[Symbol, Symbol]]
+      # sig-gen gap: #1150 — `Data.define` members carry no type, as for every other row in this class.
+      attr_reader possible_discovered_deferred_ranges: Hash[String, Array[[Integer, Integer, Symbol?, Symbol?, String?]]]
+      # sig-gen gap: #1150 — `Data.define` members carry no type, as for every other row in this class.
+      attr_reader contested_discovered_def_nodes: Set[Array[untyped]]
+      # sig-gen gap: #1150 — `Data.define` members carry no type, as for every other row in this class.
+      attr_reader contested_discovered_singleton_def_nodes: Set[Array[untyped]]
+      # sig-gen gap: #1150 — `Data.define` members carry no type, as for every other row in this class.
+      attr_reader contested_discovered_method_visibilities: Set[Array[untyped]]
+      # sig-gen gap: #1150 — `Data.define` members carry no type, as for every other row in this class.
+      attr_reader contested_discovered_parameter_envelopes: Set[Array[untyped]]
 
       EMPTY: DiscoveryIndex
+      # authored: ADR-119 WD1 — hand-written beside the `Data.define` rows above (#1150).
+      # authored: ADR-119 WD1 sibling pairing; no inferred signature exists for it (#1150).
+      SIBLINGS: Hash[Symbol, Symbol]
+      # authored: ADR-119 WD1 sibling pairing; no inferred signature exists for it (#1150).
+      EMPTY_SIBLINGS: Hash[Symbol, untyped]
+
+      # authored: ADR-119 WD1 sibling pairing; no inferred signature exists for it (#1150).
+      def self.empty_value: (Symbol name) -> untyped
+      # authored: ADR-119 WD1 sibling pairing; no inferred signature exists for it (#1150).
+      def self.empty_siblings: () -> Hash[Symbol, untyped]
+      # authored: ADR-119 WD1 sibling pairing; no inferred signature exists for it (#1150).
+      def self.compact_pairs: (Hash[Symbol, untyped] tables) -> Hash[Symbol, untyped]
+      # authored: ADR-119 WD1 sibling pairing; no inferred signature exists for it (#1150).
+      def self.paired?: (Symbol name) -> bool
+      # authored: ADR-119 WD1 sibling pairing; no inferred signature exists for it (#1150).
+      def sibling_tables: () -> Hash[Symbol, untyped]
 
-      def with: (?declared_types: Hash[untyped, Type::t], ?class_ivars: Hash[String, Hash[Symbol, Type::t]], ?class_cvars: Hash[String, Hash[Symbol, Type::t]], ?program_globals: Hash[Symbol, Type::t], ?program_global_seeds: Hash[Symbol, Type::t], ?discovered_classes: Hash[String, Type::Singleton], ?in_source_constants: Hash[String, Type::t], ?discovered_methods: Hash[String, Hash[Symbol, Symbol]], ?discovered_def_nodes: Hash[String, Hash[Symbol, untyped]], ?discovered_def_nestings: Hash[untyped, Array[String]], ?discovered_singleton_def_nodes: Hash[String, Hash[Symbol, untyped]], ?discovered_def_sources: Hash[String, Hash[Symbol, String]], ?discovered_singleton_def_sources: Hash[String, Hash[Symbol, String]], ?discovered_method_visibilities: Hash[String, Hash[Symbol, Symbol]], ?discovered_parameter_envelopes: Hash[String, Hash[untyped, untyped]], ?discovered_superclasses: Hash[String, String], ?discovered_includes: Hash[String, Array[String]], ?discovered_prepends: Hash[String, Array[String]], ?discovered_extends: Hash[String, Array[String]], ?discovered_class_sources: Hash[String, Set[String]], ?constant_sources: Hash[String, Set[String]], ?constant_writers: Hash[String, Array[String]], ?constant_shadowers: Hash[String, Array[String]], ?published_constant_names: Set[String], ?local_constant_names: Set[String], ?published_constant_alias_names: Set[String], ?published_constant_ivars: Hash[String, Set[Symbol]], ?data_member_layouts: Hash[String, Array[Symbol]], ?struct_member_layouts: Hash[String, { members: Array[Symbol], keyword_init: bool }], ?param_inferred_types: Hash[[String, Symbol, Symbol], Hash[Symbol, Type::t]], ?discovered_deferred_ranges: Hash[String, Array[[Integer, Integer, Symbol?, Symbol?, String?]]], ?discovered_refinements: Hash[String, Hash[Symbol, Array[String]]], ?discovered_global_write_census: Set[Array[untyped]], ?run_generation: Object?, ?patched_line_readers: Set[Symbol], ?clears_last_status: bool, ?defines_case_equality: bool, ?implicit_self_evidence: untyped) -> DiscoveryIndex
+      def with: (?declared_types: Hash[untyped, Type::t], ?class_ivars: Hash[String, Hash[Symbol, Type::t]], ?class_cvars: Hash[String, Hash[Symbol, Type::t]], ?program_globals: Hash[Symbol, Type::t], ?program_global_seeds: Hash[Symbol, Type::t], ?discovered_classes: Hash[String, Type::Singleton], ?in_source_constants: Hash[String, Type::t], ?discovered_methods: Hash[String, Hash[Symbol, Symbol]], ?discovered_def_nodes: Hash[String, Hash[Symbol, untyped]], ?discovered_def_nestings: Hash[untyped, Array[String]], ?discovered_singleton_def_nodes: Hash[String, Hash[Symbol, untyped]], ?discovered_def_sources: Hash[String, Hash[Symbol, String]], ?discovered_singleton_def_sources: Hash[String, Hash[Symbol, String]], ?discovered_method_visibilities: Hash[String, Hash[Symbol, Symbol]], ?discovered_parameter_envelopes: Hash[String, Hash[untyped, untyped]], ?discovered_superclasses: Hash[String, String], ?discovered_includes: Hash[String, Array[String]], ?discovered_prepends: Hash[String, Array[String]], ?discovered_extends: Hash[String, Array[String]], ?discovered_class_sources: Hash[String, Set[String]], ?constant_sources: Hash[String, Set[String]], ?constant_writers: Hash[String, Array[String]], ?constant_shadowers: Hash[String, Array[String]], ?published_constant_names: Set[String], ?local_constant_names: Set[String], ?published_constant_alias_names: Set[String], ?published_constant_ivars: Hash[String, Set[Symbol]], ?data_member_layouts: Hash[String, Array[Symbol]], ?struct_member_layouts: Hash[String, { members: Array[Symbol], keyword_init: bool }], ?param_inferred_types: Hash[[String, Symbol, Symbol], Hash[Symbol, Type::t]], ?discovered_deferred_ranges: Hash[String, Array[[Integer, Integer, Symbol?, Symbol?, String?]]], ?discovered_refinements: Hash[String, Hash[Symbol, Array[String]]], ?discovered_global_write_census: Set[Array[untyped]], ?run_generation: Object?, ?patched_line_readers: Set[Symbol], ?clears_last_status: bool, ?defines_case_equality: bool, ?implicit_self_evidence: untyped, ?possible_discovered_methods: Hash[String, Hash[Symbol, Symbol]], ?possible_discovered_deferred_ranges: Hash[String, Array[[Integer, Integer, Symbol?, Symbol?, String?]]], ?contested_discovered_def_nodes: Set[Array[untyped]], ?contested_discovered_singleton_def_nodes: Set[Array[untyped]], ?contested_discovered_method_visibilities: Set[Array[untyped]], ?contested_discovered_parameter_envelopes: Set[Array[untyped]]) -> DiscoveryIndex
     end
 
     class IndexedKey
@@ -206,6 +237,15 @@ module Rigor
     # Issue #1429 — `rigor sig-gen` output; the parameters are not inferred here, as for `with_mutated_local`.
     def with_guarded_global: (untyped name, untyped type, untyped pre_guard, ?record: untyped) -> Scope
     def with_constant_narrowing: (untyped key, untyped type, untyped pre_guard) -> Scope
+    # Issue #1446 — `rigor sig-gen` output.
+    def with_guarded_ivar: (untyped name, untyped type, untyped pre_guard) -> Scope
+    def without_ivar_guard: (untyped name) -> Scope
+    # sig-gen gap: #1154 — the table reader over an ivar `initialize` assigns from a parameter reaches `untyped`.
+    def guard_narrowed_ivar?: (untyped name) -> bool
+    # Issue #1446 — `rigor sig-gen` output.
+    def with_bot_guard_classes: (untyped kind, untyped name, untyped class_names) -> Scope
+    # sig-gen gap: #1154 — the table reader over an ivar `initialize` assigns from a parameter reaches `untyped`.
+    def bot_guard_classes_for: (untyped kind, untyped name) -> Array[String]?
     def without_constant_narrowing: (untyped key) -> Scope
     def guard_narrowed?: () -> bool
     def forget_guard_narrowings: () -> Scope
@@ -259,6 +299,8 @@ module Rigor
     def class_ivars_for: (String | Symbol? class_name) -> Hash[Symbol, Type::t]
     def class_cvars_for: (String | Symbol? class_name) -> Hash[Symbol, Type::t]
     def discovered_method?: (String | Symbol class_name, String | Symbol method_name, Symbol kind) -> bool
+    # authored: the slot is a Prism::DefNode or a DefHandle until ADR-119 C1d/C2 decide its type.
+    def def_node_slot: (untyped class_name, untyped method_name, ?Symbol kind) -> untyped
     def user_def_for: (String | Symbol class_name, String | Symbol method_name) -> ::Prism::DefNode?
     def user_def_through_ancestors: (String | Symbol class_name, String | Symbol method_name, ?name_memo: Hash[untyped, untyped]) -> ([::Prism::DefNode, String] | [nil, nil])
     def discovered_method_through_ancestors?: (String | Symbol? class_name, String | Symbol method_name, Symbol kind, ?name_memo: Hash[untyped, untyped]) -> bool

data/skills/rigor-project-init/SKILL.md

@@ -88,7 +88,7 @@ diagnostics.
 | Today's diagnostics | Snapshotted into `.rigor-baseline.yml`; suppressed as long as the count does not grow. | All surfaced; every one is fixed or consciously suppressed. |
 | Hard-to-fix diagnostics | Left in the baseline. The project **trusts its test / spec suite** to cover runtime correctness for those sites — the static `T | nil` reading is worst-case-sound, the suite proves the worst case is not hit. | Fixed, or annotated `# rigor:disable <rule>` with an author-intent reason at the specific line. No blanket suppression. |
 | `severity_profile` | `lenient` (or `balanced` for a small project). | `strict`. |
-| Best for | Mature codebases; incremental adoption; teams that want the regression guard without a big upfront fix. | New / small projects; libraries; teams that want the maximum guarantee and have the budget to reach zero. |
+| Best for | **Every project by default** — mature or brand-new, large or small. | Users fluent in both type theory and RBS who opt in and will resolve Rigor's inference gaps themselves. |
 | New diagnostics later | Surface immediately — anything beyond the baseline envelope is a regression. | Surface immediately — there is no envelope; every diagnostic is live. |
 
 Both modes give the same core guarantee: **a change that introduces
@@ -97,12 +97,35 @@ diagnostics that exist *today*. Acknowledge mode parenthesises them
 behind a baseline and leans on the test suite; strict mode refuses to
 parenthesise anything.
 
-If the project's first `rigor check` reports more than ~100 errors,
-recommend acknowledge mode as the default and let the user override.
-Below that, either mode is reasonable — ask.
-
-Note the ordering: the error count that feeds this recommendation (and
-the `severity_profile` choice in Phase 4) is only *measured* in
+**Recommend acknowledge mode for every project, including new and
+small ones.** Rigor's inference still has gaps, so even a fresh
+project meets diagnostics on correct code. Under strict mode each one
+needs a `sig/` fix, an RBS workaround, or a reasoned
+`# rigor:disable` — work that takes type theory and RBS. Without that
+knowledge, users rewrite correct code for the tool or scatter
+suppressions. Acknowledge mode keeps the same regression guard with an
+exit: a new diagnostic still fails the check, and once it is confirmed
+as an inference gap, the baseline can absorb it (report the false
+positive upstream). `rigor baseline regenerate` rewrites the baseline
+from every live diagnostic, so run it only when a whole-project
+`rigor check` (no path arguments) shows nothing but confirmed false
+positives; otherwise it silences a real
+bug alongside them.
+
+Present strict mode as an opt-in for users who know type theory and
+RBS, want the zero-diagnostic gate, and accept resolving inference
+gaps themselves — never as the recommendation, and never because the
+project is new, small, or a library. If the user picks it, tell them
+how to move to acknowledge mode later: optionally relax
+`severity_profile`, re-run triage, then run Phase 7 (generate a
+baseline and wire `baseline:`). The profile change comes first because
+it changes which rules fire.
+
+For a large first run (more than ~100 errors), acknowledge mode also
+suggests `severity_profile: lenient`; see Phase 4.
+
+Note the ordering: the error count that feeds the `severity_profile`
+choice in Phase 4 is only *measured* in
 Phase 6's triage run. Any profile written in Phase 4 is therefore
 **provisional** — Phase 6 revisits it against the measured count (see
 [`references/02-configure.md`](references/02-configure.md)
@@ -111,12 +134,15 @@ Phase 6's triage run. Any profile written in Phase 4 is therefore
 ## Non-interactive / agent-driven runs
 
 This skill has several ask-the-user points (the mode choice, the RBS
-collection install, the final gitignore-and-commit confirmation). When
-the user delegated the onboarding up front — including the adoption
-mode — those points resolve without blocking:
+collection install, the final gitignore-and-commit confirmation). A
+*delegation* is the user asking, before the run, for the onboarding to
+proceed without these questions ("set it up, don't ask me"). An
+ordinary request to set Rigor up is not one: ask as usual. Under a
+delegation those points resolve without blocking:
 
 - The **mode** the user pre-declared is settled; record it and skip the
-  Phase 2 presentation.
+  Phase 2 presentation. If the delegation names no mode, choose
+  acknowledge mode and say so in the report — never strict.
 - Low-risk, reversible, in-repo confirmations (`rbs collection
   install`, the `.gitignore` addition) are covered by the delegation —
   act, and note each self-answer in your report.

data/skills/rigor-project-init/references/02-configure.md

@@ -138,14 +138,19 @@ entirely — including a `sig/` that `rigor sig-gen --write` created.
 List only directories that contain `.rbs` files or subdirectories of
 them. Rigor walks each path recursively.
 
-A strict-mode plain-Ruby gem is shorter:
+A plain-Ruby gem is shorter. The `balanced` default needs no
+`severity_profile:` key:
 
 ```yaml
 paths:
   - lib
 test_paths:
   - test
-severity_profile: strict
+
+# Phase 7 (acknowledge mode) appends this line after generating the
+# baseline. Strict mode (opt-in) sets `severity_profile: strict` and
+# leaves it out.
+# baseline: .rigor-baseline.yml
 ```
 
 ### Test roots — write `test_paths:` explicitly

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rigortype
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Rigor contributors
@@ -460,6 +460,8 @@ files:
 - lib/rigor/analysis/erb_template_detector.rb
 - lib/rigor/analysis/fact_store.rb
 - lib/rigor/analysis/incremental.rb
+- lib/rigor/analysis/incremental_run_slot.rb
+- lib/rigor/analysis/incremental_run_slot/write_guard.rb
 - lib/rigor/analysis/incremental_session.rb
 - lib/rigor/analysis/path_expansion.rb
 - lib/rigor/analysis/plugin_fact_fingerprint.rb
@@ -487,6 +489,8 @@ files:
 - lib/rigor/analysis/runner/run_snapshots.rb
 - lib/rigor/analysis/self_call_resolution_recorder.rb
 - lib/rigor/analysis/severity_stamp.rb
+- lib/rigor/analysis/shadow_harness.rb
+- lib/rigor/analysis/source_rbs_gate.rb
 - lib/rigor/analysis/template_unit_collector.rb
 - lib/rigor/analysis/template_unit_paths.rb
 - lib/rigor/analysis/template_unit_positions.rb
@@ -514,6 +518,7 @@ files:
 - lib/rigor/cache/rbs_environment_marshal_patch.rb
 - lib/rigor/cache/rbs_known_class_names.rb
 - lib/rigor/cache/store.rb
+- lib/rigor/cache/value_digest.rb
 - lib/rigor/ci_detector.rb
 - lib/rigor/cli.rb
 - lib/rigor/cli/annotate_command.rb
@@ -574,6 +579,7 @@ files:
 - lib/rigor/cli/unused_command.rb
 - lib/rigor/cli/upgrade_command.rb
 - lib/rigor/config_audit.rb
+- lib/rigor/config_path.rb
 - lib/rigor/configuration.rb
 - lib/rigor/configuration/dependencies.rb
 - lib/rigor/configuration/severity_profile.rb
@@ -638,6 +644,7 @@ files:
 - lib/rigor/environment/rbs_loader.rb
 - lib/rigor/environment/reflection.rb
 - lib/rigor/environment/reporters.rb
+- lib/rigor/environment/source_rbs_synthesis.rb
 - lib/rigor/flow_contribution.rb
 - lib/rigor/flow_contribution/conflict.rb
 - lib/rigor/flow_contribution/element.rb
@@ -677,10 +684,16 @@ files:
 - lib/rigor/inference/closure_escape_analyzer.rb
 - lib/rigor/inference/content_join.rb
 - lib/rigor/inference/coverage_scanner.rb
+- lib/rigor/inference/declaration_walk.rb
+- lib/rigor/inference/declaration_walk/context.rb
+- lib/rigor/inference/declaration_walk/errors.rb
+- lib/rigor/inference/declaration_walk/shadow.rb
+- lib/rigor/inference/declaration_walk/traversal.rb
 - lib/rigor/inference/def_handle.rb
 - lib/rigor/inference/def_node_resolver.rb
 - lib/rigor/inference/def_return_typer.rb
 - lib/rigor/inference/define_method_block_self.rb
+- lib/rigor/inference/definer_resolution.rb
 - lib/rigor/inference/dynamic_origin.rb
 - lib/rigor/inference/element_read_widening.rb
 - lib/rigor/inference/error_info.rb
@@ -751,6 +764,7 @@ files:
 - lib/rigor/inference/method_dispatcher/universal_object_dispatch.rb
 - lib/rigor/inference/method_dispatcher/uri_folding.rb
 - lib/rigor/inference/method_parameter_binder.rb
+- lib/rigor/inference/module_function_state.rb
 - lib/rigor/inference/multi_target_binder.rb
 - lib/rigor/inference/mutation_rejoin.rb
 - lib/rigor/inference/mutation_widening.rb
@@ -775,6 +789,14 @@ files:
 - lib/rigor/inference/return_barrier.rb
 - lib/rigor/inference/rewrite_mutation.rb
 - lib/rigor/inference/scope_indexer.rb
+- lib/rigor/inference/scope_indexer/certainty.rb
+- lib/rigor/inference/scope_indexer/class_cvars_collector.rb
+- lib/rigor/inference/scope_indexer/def_nestings_collector.rb
+- lib/rigor/inference/scope_indexer/layered_def_nestings.rb
+- lib/rigor/inference/scope_indexer/member_layouts_collector.rb
+- lib/rigor/inference/scope_indexer/mixin_accumulator.rb
+- lib/rigor/inference/scope_indexer/superclasses_collector.rb
+- lib/rigor/inference/singleton_hook_decline.rb
 - lib/rigor/inference/singleton_object_constant.rb
 - lib/rigor/inference/statement_evaluator.rb
 - lib/rigor/inference/stored_block_call.rb
@@ -868,6 +890,8 @@ files:
 - lib/rigor/runtime/jit.rb
 - lib/rigor/scope.rb
 - lib/rigor/scope/discovery_index.rb
+- lib/rigor/scope/resolution_chain.rb
+- lib/rigor/scope/resolution_chain/relevance.rb
 - lib/rigor/sig_gen.rb
 - lib/rigor/sig_gen/alias_index.rb
 - lib/rigor/sig_gen/classification.rb