rigortype 0.4.5 → 0.4.6

data/sig/rigor/effects/registry.rbs

@@ -32,17 +32,19 @@ module Rigor
       # an empty vocabulary (fail-open).
       def self.load_file: (untyped path) -> Registry
 
-      # sig-gen gap: #1154 — `attr_reader` over an ivar assigned in `initialize` from the
-      # parameter of the same name; sig-gen proposes `untyped` for it.
       attr_reader vocabulary_version: Integer
-      # sig-gen gap: #1154 — every declared label, sorted; implied ancestors are recognised by
-      # {#known?} but not listed here.
+      # sig-gen gap: #2321 — `labels:` is declared `Array[untyped]` (input `untyped`, looks deliberate; a declared
+      # type is authoring intent tracked by #2325, and only then does this row generate; coercion-facing:
+      # `map(&:to_s)`); every declared label, sorted. Implied ancestors are recognised by {#known?} but not listed
+      # here.
       attr_reader labels: Array[String]
       # The roots of the vocabulary — the outermost segments {#with} treats as already owned.
       # Unmarked residue: `@roots` is computed from `@known` in `initialize`, not assigned from a
-      # parameter, so #1154 does not cover it.
+      # parameter, so no parameter credit applies.
       attr_reader roots: Array[String]
-      # sig-gen gap: #1154 — one line per root, from the data file's `descriptions:`.
+      # sig-gen gap: #2321 — `descriptions:` is declared `Hash[untyped, untyped]` (input `untyped`, looks deliberate;
+      # a declared type is authoring intent tracked by #2325, and only then does this row generate; coercion-facing:
+      # keys and texts `to_s`'d); one line per root, from the data file's `descriptions:`.
       attr_reader descriptions: Hash[String, String]
 
       def initialize: (vocabulary_version: Integer, labels: Array[untyped],

data/sig/rigor/effects/summary.rbs

@@ -12,17 +12,18 @@ module Rigor
       # could not finish.
       def self.tainted: (String cause, ?String? detail) -> Summary
 
-      # sig-gen gap: #1154 — `initialize` normalizes the `bundles:`/`declared_bundles:` kwargs through
-      # `normalize_bundles` (join-merging per origin), so the readers do not trace to the parameters.
+      # sig-gen gap: #2312 — `initialize` normalizes the `bundles:`/`declared_bundles:` kwargs through
+      # `normalize_bundles` (join-merging per origin), a private helper whose parameters are undeclared.
       attr_reader bundles: Hash[Origin, LabelSet]
-      # sig-gen gap: #1154 — as above.
+      # sig-gen gap: #2312 — as above.
       attr_reader declared_bundles: Hash[Origin, LabelSet]
       # Unmarked residue — `proven`/`declared` are flattened from the bundle tables by `initialize`,
-      # not assigned from a parameter, so #1154 does not cover them (same shape as
+      # not assigned from a parameter at all, so no parameter credit applies (same shape as
       # `Registry#additional_initializers`).
       attr_reader declared: LabelSet
       attr_reader proven: LabelSet
-      # sig-gen gap: #1154 — `causes` are `[cause, detail]` pairs normalized in `initialize`.
+      # sig-gen gap: #2312 — `causes` are `[cause, detail]` pairs normalized by the private `normalize_causes` helper,
+      # whose parameters are undeclared.
       attr_reader causes: Array[[String, String?]]
 
       def initialize: (?bundles: Hash[Origin, LabelSet], ?declared_bundles: Hash[Origin, LabelSet],

data/sig/rigor/environment.rbs

@@ -31,8 +31,6 @@ module Rigor
     def nominal_for_name: (String | Symbol name) -> Type::Nominal?
     def singleton_for_name: (String | Symbol name) -> Type::Singleton?
     def constant_for_name: (String | Symbol name) -> Type::t?
-    # sig-gen gap: #1154 — the answer comes through `rbs_loader`, an `attr_reader` over an ivar assigned in
-    # `initialize` from a parameter, which reaches `untyped`.
     def global_for_name: (String | Symbol name, ?builtin: bool) -> Type::t?
     def class_known?: (String | Symbol name) -> bool
     def rbs_module?: (String | Symbol name) -> bool
@@ -57,7 +55,8 @@ module Rigor
       attr_reader libraries: Array[String]
       attr_reader signature_paths: Array[String | _ToPath]
       attr_reader cache_store: untyped?
-      # sig-gen gap: #160 — sig-gen emits no `attr_reader` for the loader's readers; typed as the initializer stores it.
+      # sig-gen gap: #160 — sig-gen emits no `attr_reader` for the loader's readers; typed as the initializer stores
+      # it.
       attr_reader deferred_signature_paths: Array[Pathname]
 
       def self.default: () -> RbsLoader
@@ -82,6 +81,9 @@ module Rigor
       def singleton_extended_module_names: (String | Symbol class_name) -> Array[String]
       def constant_type: (String name) -> Type::t?
       def constant_names: () -> Array[String]
+      # sig-gen gap: #2326 — the answer is `global_declarations[name.to_sym]&.first`, a lookup in the loader's memo
+      # hash `@state`, which sig-gen skips as untyped.
+      def global_type: (String | Symbol name) -> Type::t?
       def each_known_class_name: () { (String name) -> void } -> void
                               | () -> ::Enumerator[String, void]
     end

data/sig/rigor/inference/optimistic_origin.rbs

@@ -5,6 +5,17 @@ module Rigor
       # (sig.skipped.untyped-return). The answer is the recorded `true` / `false` / `nil`, or the `UNKNOWN_MISS`
       # sentinel; declaring it is what lets sig-gen type `Scope#optimistic_local_miss` / `#optimistic_ivar_miss`.
       def self?.bound_miss: (untyped mark) -> Object?
+
+      class BoundMark < ::Data
+        # sig-gen gap: #1150 — a `Data.define` member; sig-gen proposes `untyped`. The cause a mark records.
+        def cause: () -> Symbol
+        # sig-gen gap: #1150 — a `Data.define` member; the recorded miss answer.
+        def miss: () -> bool?
+        # sig-gen gap: #1150 — the `Data.define` constructor; sig-gen types its members `untyped`.
+        def self.new: (cause: Symbol, miss: bool?) -> instance | (Symbol cause, bool? miss) -> instance
+        # sig-gen gap: #1150 — as above.
+        def self.[]: (cause: Symbol, miss: bool?) -> instance | (Symbol cause, bool? miss) -> instance
+      end
     end
   end
 end

data/sig/rigor/inference.rbs

@@ -174,6 +174,12 @@ module Rigor
       def self?.constant_literal_value: (untyped rvalue) -> Array[untyped]?
       def self?.finalize_constant_writes: (Hash[String, Hash[String, untyped]] writes) -> [Hash[String, Type::Constant], Hash[String, Set[String]]]
       def self?.propagate: (untyped node, Hash[untyped, Scope] table, Scope parent_scope) -> void
+
+      class LayeredDefNestings
+        def initialize: (Hash[untyped, Array[String]] file, Scope::DiscoveryIndex::def_nestings seed) -> void
+        def []: (untyped def_node) -> Array[String]?
+        def empty?: () -> bool
+      end
     end
 
     class CoverageScanner

data/sig/rigor/plugin/additional_initializer.rbs

@@ -4,15 +4,15 @@ module Rigor
     # the read-before-write nil soundness gate does not widen their ivars. See
     # lib/rigor/plugin/additional_initializer.rb for the full contract.
     class AdditionalInitializer
-      # sig-gen gap: #1154 — `attr_reader` rows over ivars assigned from `initialize` parameters are
-      # skipped (untyped return); the constructor validates `receiver_constraint` is a non-empty
-      # String and normalizes both lists with `map(&:to_sym)`, so the stored types are hand-written.
+      # sig-gen gap: #2321 — `attr_reader` rows over ivars `initialize` assigns from expressions derived from its
+      # parameters are skipped (untyped return); the constructor validates `receiver_constraint` is a non-empty String
+      # and normalizes both lists with `map(&:to_sym)`, so the stored types are hand-written.
       attr_reader receiver_constraint: String
 
-      # sig-gen gap: #1154 — as above.
+      # sig-gen gap: #2321 — as above.
       attr_reader methods: Array[Symbol]
 
-      # sig-gen gap: #1154 — as above.
+      # sig-gen gap: #2321 — as above.
       attr_reader block_methods: Array[Symbol]
 
       # The validators accept Symbol or non-empty String elements; `initialize` normalizes to

data/sig/rigor/plugin/effect_ancestry.rbs

@@ -5,12 +5,14 @@ module Rigor
     # immediate superclass. Bundled plugins only — `Effects::PluginFacts` enforces it. Frozen value
     # object.
     class EffectAncestry
-      # sig-gen gap: #1154 — validated in `initialize` from the parameter of the same name
-      # (`to_s`-normalized, frozen), so sig-gen proposes the raw parameter shape.
+      # sig-gen gap: #2312 — `child:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
+      # intent tracked by #2325, and only then does this row generate; coercion-facing: `to_s`, then a class-name
+      # check), and `initialize` stores the private `validate_class_name!` helper's result (#2312).
       attr_reader child: String
-      # sig-gen gap: #1154 — same shape as `child`.
+      # sig-gen gap: #2312 — same shape as `child`.
       attr_reader parent: String
-      # sig-gen gap: #1154 — same shape; `why:` is required and validated non-empty.
+      # sig-gen gap: #2312 — same shape; `why:` is `untyped` and the private `validate_why!` helper (#2312) requires
+      # it non-empty.
       attr_reader why: String
 
       def initialize: (child: untyped, parent: untyped, why: untyped) -> void

data/sig/rigor/plugin/effect_attribution.rbs

@@ -15,28 +15,43 @@ module Rigor
       # The taint causes a plugin row may name — a closed subset of `Effects::TaintCause::ALL`.
       TAINT_CAUSES: Array[String]
 
-      # sig-gen gap: #1154 — normalized/validated in `initialize` from the parameter of the same
-      # name (`to_s`-coerced, frozen), so sig-gen proposes the raw parameter shape.
+      # sig-gen gap: #2312 — `receiver:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
+      # intent tracked by #2325, and only then does this row generate; coercion-facing: `to_s`), and `initialize`
+      # stores the private `validate_receiver!` helper's result (#2312).
       attr_reader receiver: String
-      # sig-gen gap: #1154 — `to_sym`-normalized from the `method:` parameter.
+      # sig-gen gap: #2321 — `method:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
+      # intent tracked by #2325, and only then does this row generate; coercion-facing: `String | Symbol`), stored as
+      # `method.to_sym`.
       attr_reader method: Symbol
       attr_reader singleton: bool
-      # sig-gen gap: #1154 — `Array()`-normalized, deduplicated and frozen from `labels:`.
+      # sig-gen gap: #2312 — `labels:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
+      # intent tracked by #2325, and only then does this row generate; coercion-facing: `Array()` of anything
+      # answering `to_s`), stored from the private `normalize_labels` helper (#2312).
       attr_reader labels: Array[String]
-      # sig-gen gap: #1154 — `to_s`-normalized from the `narrow:` parameter.
+      # sig-gen gap: #2321 — `narrow:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
+      # intent tracked by #2325, and only then does this row generate; coercion-facing: `to_s`, nil kept).
       attr_reader narrow: String?
       attr_reader discharge: bool
-      # sig-gen gap: #1154 — `to_s`-normalized from the `within:` parameter.
+      # sig-gen gap: #2312 — `within:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
+      # intent tracked by #2325, and only then does this row generate; coercion-facing: `to_s`), stored from the
+      # private `validate_within!` helper (#2312).
       attr_reader within: String?
       attr_reader on_result: bool
-      # sig-gen gap: #1154 — `to_s`-normalized from the `taint:` parameter.
+      # sig-gen gap: #2312 — `taint:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
+      # intent tracked by #2325, and only then does this row generate; coercion-facing: `to_s`), stored from the
+      # private `validate_taint!` helper (#2312).
       attr_reader taint: String?
-      # sig-gen gap: #1154 — `to_s`-normalized from the `callee:` parameter.
+      # sig-gen gap: #2321 — `callee:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
+      # intent tracked by #2325, and only then does this row generate; coercion-facing: `to_s`, nil kept).
       attr_reader callee: String?
-      # sig-gen gap: #1154 — normalized from the `callee_fallbacks:` parameter.
+      # sig-gen gap: #2312 — `callee_fallbacks:` is `untyped` (input `untyped`, looks deliberate; a declared type is
+      # authoring intent tracked by #2325, and only then does this row generate; coercion-facing: a Hash of coercible
+      # names), stored from the private `validate_callee_fallbacks!` helper (#2312).
       attr_reader callee_fallbacks: Hash[String, Array[String]]?
       attr_reader responds: bool
-      # sig-gen gap: #1154 — `to_s`-normalized from the `why:` parameter.
+      # sig-gen gap: #2312 — `why:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
+      # intent tracked by #2325, and only then does this row generate; coercion-facing: `to_s`), stored from the
+      # private `validate_why!` helper (#2312).
       attr_reader why: String
 
       # The coercion-facing constructor: every parameter is `to_s`/`to_sym`/`Array()`-normalized,

data/sig/rigor/plugin/effect_edge.rbs

@@ -7,15 +7,22 @@ module Rigor
       # The closed set of framework-edge strategies the engine implements.
       TARGETS: Array[Symbol]
 
-      # sig-gen gap: #1154 — validated/normalized in `initialize` from the parameter of the same
-      # name, so sig-gen proposes the raw parameter shape.
+      # sig-gen gap: #2312 — `receiver:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
+      # intent tracked by #2325, and only then does this row generate; coercion-facing: `to_s`), and `initialize`
+      # stores the result of the private `validate_receiver!` helper (#2312).
       attr_reader receiver: String
-      # sig-gen gap: #1154 — `to_sym`-normalized from the `method:` parameter.
+      # sig-gen gap: #2321 — `method:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
+      # intent tracked by #2325, and only then does this row generate; coercion-facing: `String | Symbol | nil`),
+      # stored as `method&.to_sym`.
       attr_reader method: Symbol?
       attr_reader singleton: bool
-      # sig-gen gap: #1154 — validated against `TARGETS` in `initialize`.
+      # sig-gen gap: #2312 — `target:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
+      # intent tracked by #2325, and only then does this row generate; coercion-facing: a Symbol or String checked
+      # against `TARGETS`), stored from the private `validate_target!` helper (#2312).
       attr_reader target: (:activerecord_callbacks | :perform_now | :mailer_body)
-      # sig-gen gap: #1154 — `to_s`-normalized from the `why:` parameter.
+      # sig-gen gap: #2312 — `why:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
+      # intent tracked by #2325, and only then does this row generate; coercion-facing: `to_s`), stored from the
+      # private `validate_why!` helper (#2312).
       attr_reader why: String
 
       def initialize: (receiver: untyped, target: untyped, why: untyped, ?method: untyped,

data/sig/rigor/plugin/effect_entry_points.rbs

@@ -4,11 +4,16 @@ module Rigor
     # framework entry points (ADR-103 WD6). Frozen value object; {#globs} are deduplicated and
     # sorted in `initialize`.
     class EffectEntryPoints
-      # sig-gen gap: #1154 — `to_s`-normalized in `initialize` from the `name:` parameter.
+      # sig-gen gap: #2321 — `initialize` declares `name:` `untyped` (input `untyped`, looks deliberate; a declared
+      # type is authoring intent tracked by #2325, and only then does this row generate; coercion-facing: it takes
+      # anything that answers `to_s`), so no input type reaches the reader.
       attr_reader name: String
-      # sig-gen gap: #1154 — deduplicated/sorted/frozen in `initialize` from `globs:`.
+      # sig-gen gap: #2321 — `globs:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
+      # intent tracked by #2325, and only then does this row generate; coercion-facing: `Array(globs)`, each `to_s`),
+      # deduplicated and sorted in `initialize`.
       attr_reader globs: Array[String]
-      # sig-gen gap: #1154 — `to_s`-normalized in `initialize` from `why:`.
+      # sig-gen gap: #2321 — `why:` is `untyped` (input `untyped`, looks deliberate; a declared type is authoring
+      # intent tracked by #2325, and only then does this row generate; coercion-facing: `to_s`).
       attr_reader why: String
 
       def initialize: (name: untyped, globs: untyped, ?why: untyped) -> void

data/sig/rigor/plugin/io_boundary.rbs

@@ -8,10 +8,10 @@ class Rigor::Plugin::IoBoundary
   # Records a `:names` glob row (membership only); a caller needing a match's content `read_file`s it. A `..`
   # segment, a brace or a backslash in `pattern` raises `AccessDeniedError`.
   def glob: (untyped root, untyped pattern) -> Array[String]
-  # sig-gen gap: #1154 — the proposal leaves both string fields untyped. `nearest_root` comes from `@policy`, an
-  # ivar assigned from an `initialize` parameter (the #1154 shape); `first_path` comes from `@first_refused_path`,
-  # written from `record_refusal(path)`'s parameter outside `initialize`, a case #1154 as titled does not yet cover.
-  # The record's fields are the running count and the first refused path, nil when nothing was refused.
+  # sig-gen gap: #2312 — the proposal leaves both string fields untyped. `nearest_root` comes from `@policy`, a bare
+  # assignment of the `policy:` parameter, declared `untyped` above (a `TrustPolicy`; typing it is authoring work,
+  # tracked by #2325); `first_path` comes from `@first_refused_path`, written from the private `record_refusal(path)`,
+  # whose parameter is undeclared.
   def refusal_summary: () -> { count: Integer, first_path: String?, nearest_root: String? }?
   def open_url: (untyped url) -> String
   # Returns a frozen `Rigor::Cache::Descriptor` (no RBS yet -> untyped).

data/sig/rigor/plugin/manifest.rbs

@@ -3,7 +3,7 @@ class Rigor::Plugin::Manifest::Consumption
 end
 
 class Rigor::Plugin::Manifest
-  def initialize: (id: untyped, version: untyped, ?description: untyped, ?config_schema: untyped, ?target_gems: untyped, ?produces: untyped, ?consumes: untyped, ?owns_receivers: untyped, ?open_receivers: untyped, ?rbs_complete_ancestors: untyped, ?type_node_resolvers: untyped, ?block_as_methods: untyped, ?heredoc_templates: untyped, ?nested_class_templates: untyped, ?trait_registries: untyped, ?hkt_registrations: untyped, ?hkt_definitions: untyped, ?signature_paths: untyped, ?protocol_contracts: Array[Rigor::Plugin::ProtocolContract], ?source_rbs_synthesizer: untyped, ?additional_initializers: Array[Rigor::Plugin::AdditionalInitializer], ?effect_root: String?, ?effect_labels: Array[String], ?effect_attributions: Array[Rigor::Plugin::EffectAttribution], ?effect_edges: Array[Rigor::Plugin::EffectEdge], ?effect_entry_points: Array[Rigor::Plugin::EffectEntryPoints], ?effect_ancestry: Array[Rigor::Plugin::EffectAncestry], ?template_globs: untyped) -> void
+  def initialize: (id: untyped, version: untyped, ?description: untyped, ?config_schema: untyped, ?target_gems: untyped, ?produces: untyped, ?consumes: untyped, ?owns_receivers: untyped, ?open_receivers: untyped, ?rbs_complete_ancestors: untyped, ?type_node_resolvers: untyped, ?block_as_methods: untyped, ?heredoc_templates: untyped, ?nested_class_templates: untyped, ?trait_registries: untyped, ?hkt_registrations: untyped, ?hkt_definitions: untyped, ?signature_paths: untyped, ?protocol_contracts: Array[Rigor::Plugin::ProtocolContract], ?source_rbs_synthesizer: untyped, ?additional_initializers: Array[Rigor::Plugin::AdditionalInitializer], ?effect_root: String?, ?effect_labels: Array[String], ?effect_attributions: Array[Rigor::Plugin::EffectAttribution], ?effect_edges: Array[Rigor::Plugin::EffectEdge], ?effect_entry_points: Array[Rigor::Plugin::EffectEntryPoints], ?effect_ancestry: Array[Rigor::Plugin::EffectAncestry], ?template_globs: Array[String], ?per_invocation_classes: Array[String], ?per_invocation_non_action_macros: Array[Symbol | String]) -> void
 
   # Public attribute readers (the full `attr_reader` surface). Plugins
   # read `manifest.id` / `manifest.protocol_contracts` etc.; declaring
@@ -18,9 +18,9 @@ class Rigor::Plugin::Manifest
   def config_schema: () -> untyped
   def config_defaults: () -> Hash[String, untyped]
   def target_gems: () -> Array[String]
-  # sig-gen gap: #1154 — an `attr_reader` over an ivar assigned in `initialize` from a parameter the
-  # manifest validates but does not type, so inference reaches `untyped` where the contract is
-  # `Array[String]` (the same gap every other reader in this block carries).
+  # sig-gen gap: #2321 — written by a private `assign_*` helper whose parameters are undeclared (`initialize` hands
+  # its fields to such helpers); each write is a derived expression (`dup.freeze`, `map`), so the helper's parameter
+  # types alone would not generate it.
   def template_globs: () -> Array[String]
   def produces: () -> Array[Symbol]
   def consumes: () -> Array[Rigor::Plugin::Manifest::Consumption]
@@ -35,33 +35,31 @@ class Rigor::Plugin::Manifest
   def hkt_registrations: () -> untyped
   def hkt_definitions: () -> untyped
   def signature_paths: () -> Array[String]
-  # sig-gen gap: #1154 — `attr_reader` over an ivar assigned in `initialize` from a parameter;
-  # `validate_protocol_contracts!` requires every element `is_a?(ProtocolContract)`.
+  # sig-gen gap: #2321 — same shape as `template_globs`: `validate_protocol_contracts!` requires every element
+  # `is_a?(ProtocolContract)`.
   def protocol_contracts: () -> Array[Rigor::Plugin::ProtocolContract]
   # ADR-32 WD6/WD12 — any object responding to `call`, and its result is a documented multi-shape
   # outcome (`String` / nil / `[:error, msg]` / `[:ok, src, msgs]`), not `String?` — `untyped` is the
   # honest claim until the outcome has a sig'd shape.
   def source_rbs_synthesizer: () -> untyped
-  # sig-gen gap: #1154 — `attr_reader` over an ivar assigned in `initialize` from a parameter;
-  # the validator (`validate_additional_initializers!`) requires every element
-  # `is_a?(AdditionalInitializer)`, so the element type is hand-written.
+  # sig-gen gap: #2321 — same shape as `template_globs`: the validator (`validate_additional_initializers!`) requires
+  # every element `is_a?(AdditionalInitializer)`, so the element type is hand-written.
   def additional_initializers: () -> Array[Rigor::Plugin::AdditionalInitializer]
 
-  # sig-gen gap: #1154 — `attr_reader` over an ivar assigned in `initialize` from a parameter
-  # (`to_s`-normalized); `validate_effect_root!` bounds the spelling.
+  # sig-gen gap: #2321 — same shape as `template_globs`: `validate_effect_root!` bounds the spelling.
   def effect_root: () -> String?
-  # sig-gen gap: #1154 — `attr_reader` over an ivar normalized in `initialize` from a parameter;
-  # `validate_effect_labels!` requires non-empty `String` elements.
+  # sig-gen gap: #2321 — same shape as `template_globs`: `validate_effect_labels!` requires non-empty `String`
+  # elements.
   def effect_labels: () -> Array[String]
-  # sig-gen gap: #1154 — `attr_reader` over an ivar assigned in `initialize` from a parameter;
-  # `validate_effect_attributions!` requires every element `is_a?(EffectAttribution)`.
+  # sig-gen gap: #2321 — same shape as `template_globs`: `validate_effect_attributions!` requires every element
+  # `is_a?(EffectAttribution)`.
   def effect_attributions: () -> Array[Rigor::Plugin::EffectAttribution]
-  # sig-gen gap: #1154 — same shape; `validate_effect_edges!` requires `is_a?(EffectEdge)`.
+  # sig-gen gap: #2321 — same shape as `template_globs`: `validate_effect_edges!` requires `is_a?(EffectEdge)`.
   def effect_edges: () -> Array[Rigor::Plugin::EffectEdge]
-  # sig-gen gap: #1154 — same shape; `validate_effect_entry_points!` requires
+  # sig-gen gap: #2321 — same shape as `template_globs`: `validate_effect_entry_points!` requires
   # `is_a?(EffectEntryPoints)`.
   def effect_entry_points: () -> Array[Rigor::Plugin::EffectEntryPoints]
-  # sig-gen gap: #1154 — same shape; `validate_effect_ancestry!` requires `is_a?(EffectAncestry)`.
+  # sig-gen gap: #2321 — same shape as `template_globs`: `validate_effect_ancestry!` requires `is_a?(EffectAncestry)`.
   def effect_ancestry: () -> Array[Rigor::Plugin::EffectAncestry]
 
   # The identity opening a root when this plugin's labels join the run's vocabulary: the

data/sig/rigor/plugin/protocol_contract.rbs

@@ -23,26 +23,27 @@ module Rigor
         def self.[]: (index: Integer, type_name: String) -> instance | (Integer index, String type_name) -> instance
       end
 
-      # sig-gen gap: #1154 — `attr_reader` rows over ivars assigned in `initialize`; each is
-      # validated/normalized first (`dup.freeze`/`to_sym`/truthiness collapse/coerce), so the
-      # stored types are hand-written.
+      # sig-gen gap: #2321 — `attr_reader` rows over ivars `initialize` assigns from expressions derived
+      # from its parameters (`dup.freeze`/`to_sym`), so the stored types are hand-written.
       attr_reader path_glob: String
 
-      # sig-gen gap: #1154 — as above (`to_sym` normalizes the accepted Symbol|String).
+      # sig-gen gap: #2321 — as above (`to_sym` normalizes the accepted Symbol|String).
       attr_reader method_name: Symbol
 
       # `singleton ? true : false` collapses any truthy input to bool — sig-gen already infers
-      # `false | true`, so this row is generated-equivalent rather than a #1154 gap.
+      # `false | true`, so this row is generated-equivalent rather than a gap.
       attr_reader singleton: bool
 
-      # sig-gen gap: #1154 — as above (`coerce_param_types` guarantees `Array[ParamType]`).
+      # sig-gen gap: #2312 — `initialize` stores what the private `coerce_param_types` helper returns, whose
+      # parameters are undeclared (it guarantees `Array[ParamType]`).
       attr_reader param_types: Array[ParamType]
 
-      # sig-gen gap: #1154 — as above (nil or a non-empty `dup.freeze`d String).
+      # sig-gen gap: #2321 — as above (nil or a non-empty `dup.freeze`d String).
       attr_reader return_type_name: String?
 
-      # sig-gen gap: #1154 — as above (`VALID_SEVERITIES.include?(to_sym)` bounds the stored value
-      # to the three declared literals).
+      # sig-gen gap: #2321 — as above (`VALID_SEVERITIES.include?(to_sym)` bounds the stored value
+      # to the three declared literals; a derived-write credit would generate `Symbol`, not the literal union, so
+      # this row needs the declared literals kept as intent).
       attr_reader severity: :error | :warning | :info
 
       # `method_name`/`severity` accept String too (both are `to_sym`'d); `param_types` entries are

data/sig/rigor/plugin/registry.rbs

@@ -18,7 +18,7 @@ class Rigor::Plugin::Registry
 
   # Newly declared — the attr_reader was absent from the sig. `compile_aggregates` builds the ivar
   # with `flat_map` over the manifests (not from an `initialize` parameter, so this is unmarked
-  # residue like the `rbs_complete_ancestors` sibling rather than a #1154 row); the element type is
+  # residue like the `rbs_complete_ancestors` sibling rather than a parameter-credit row); the element type is
   # `AdditionalInitializer`, enforced per manifest by `validate_additional_initializers!`.
   attr_reader additional_initializers: Array[Rigor::Plugin::AdditionalInitializer]