rigortype 0.3.8 → 0.3.9

data/sig/rigor/inference.rbs

@@ -45,11 +45,7 @@ module Rigor
       def singleton_def?: (untyped def_node) -> bool
       def self_type_for_class_body: (Array[ClassFrame] class_context) -> Type::t?
       def self_type_for_method_body: (singleton: bool) -> Type::t?
-      def qualified_name_for: (untyped constant_path_node) -> String?
-      def render_constant_path: (untyped node) -> String
       def singleton_context_for: (untyped node) -> Array[ClassFrame]
-      def captured_local_writes: (untyped block_node, Scope base_scope) -> Array[Symbol]
-      def block_introduced_locals: (untyped block_node) -> Set[Symbol]
       def drop_captured_narrowing: (untyped block_node, Scope base_scope) -> Scope
       def classify_closure_escape: (untyped call_node) -> closure_classification
       def record_closure_escape_if_any: (untyped node) -> Scope
@@ -108,12 +104,12 @@ module Rigor
       def self?.narrow_non_nil: (Type::t type) -> Type::t
       def self?.narrow_equal: (Type::t type, untyped literal) -> Type::t
       def self?.narrow_not_equal: (Type::t type, untyped literal) -> Type::t
-      def self?.narrow_class: (Type::t type, String class_name, ?exact: bool, ?environment: Environment) -> Type::t
-      def self?.narrow_not_class: (Type::t type, String class_name, ?exact: bool, ?environment: Environment) -> Type::t
+      def self?.narrow_class: (Type::t type, String class_name, ?exact: bool, ?environment: Environment, ?scope: Scope?) -> Type::t
+      def self?.narrow_not_class: (Type::t type, String class_name, ?exact: bool, ?environment: Environment, ?scope: Scope?) -> Type::t
       def self?.narrow_not_refinement: (Type::t current_type, Type::t refinement_type) -> Type::t
       def self?.narrow_for_fact: (Type::t current, untyped fact, untyped environment) -> Type::t
       def self?.predicate_certainty: (Type::t? type) -> (:truthy | :falsey | nil)
-      def self?.class_pattern_certainty: (Type::t subject_type, String class_name, environment: Environment) -> (:yes | :no | :maybe)
+      def self?.class_pattern_certainty: (Type::t subject_type, String class_name, environment: Environment, ?scope: Scope?) -> (:yes | :no | :maybe)
       def self?.value_pattern_certainty: (Type::t subject_type, untyped pattern_value) -> (:yes | :no | :maybe)
       def self?.predicate_scopes: (untyped node, Scope scope) -> [Scope, Scope]
       def self?.case_when_scopes: (untyped subject, Array[untyped] conditions, Scope scope) -> [Scope, Scope]
@@ -162,7 +158,6 @@ module Rigor
 
     module ScopeIndexer
       def self?.index: (untyped root, default_scope: Scope) -> Hash[untyped, Scope]
-      def self?.build_declaration_overrides: (untyped root) -> Hash[untyped, Type::t]
       def self?.build_declaration_artifacts: (untyped root) -> [Hash[untyped, Type::t], Hash[String, Type::t]]
       def self?.build_in_source_constants: (untyped root, Scope default_scope) -> Hash[String, Type::t]
       def self?.record_declarations: (untyped node, Array[String] qualified_prefix, Hash[untyped, Type::t] identity_table, Hash[String, Type::t] discovered) -> void
@@ -176,8 +171,6 @@ module Rigor
       def self?.constant_writes_for_file: (untyped root) -> Hash[String, untyped]
       def self?.constant_literal_value: (untyped rvalue) -> Array[untyped]?
       def self?.finalize_constant_writes: (Hash[String, Hash[String, untyped]] writes) -> [Hash[String, Type::t], Hash[String, Set[String]]]
-      def self?.qualified_name_for: (untyped constant_path_node) -> String?
-      def self?.render_constant_path: (untyped node) -> String
       def self?.propagate: (untyped node, Hash[untyped, Scope] table, Scope parent_scope) -> void
     end
 

data/sig/rigor/plugin/io_boundary.rbs

@@ -3,6 +3,10 @@ class Rigor::Plugin::IoBoundary
   def read_file: (untyped) -> String
   def file?: (untyped) -> bool
   def directory?: (untyped) -> bool
+  def list_directory: (untyped) -> Array[String]
+  # sig-gen gap: #959 — the generator pins the empty-summary literal (`count: 0, first_path: nil`); the
+  # record's fields are the running count and the first refused path, nil when nothing was refused.
+  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).
   def cache_descriptor: () -> 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, ?produces: untyped, ?consumes: untyped, ?owns_receivers: untyped, ?open_receivers: 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: untyped, ?source_rbs_synthesizer: untyped, ?additional_initializers: 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, ?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: untyped, ?source_rbs_synthesizer: untyped, ?additional_initializers: untyped) -> void
 
   # Public attribute readers (the full `attr_reader` surface). Plugins
   # read `manifest.id` / `manifest.protocol_contracts` etc.; declaring
@@ -16,6 +16,7 @@ class Rigor::Plugin::Manifest
   def description: () -> String?
   def config_schema: () -> untyped
   def config_defaults: () -> Hash[String, untyped]
+  def target_gems: () -> Array[String]
   def produces: () -> untyped
   def consumes: () -> untyped
   def owns_receivers: () -> untyped

data/sig/rigor/reflection.rbs

@@ -3,11 +3,13 @@ module Rigor
     def self?.class_known?: (String | Symbol class_name, ?scope: Scope) -> bool
     def self?.rbs_class_known?: (String | Symbol class_name, ?scope: Scope) -> bool
     def self?.project_declared_class?: (String | Symbol class_name, ?scope: Scope?, ?environment: Environment?) -> bool
-    def self?.class_ordering: (String | Symbol lhs, String | Symbol rhs, ?scope: Scope) -> Symbol
+    def self?.class_ordering: (String | Symbol lhs, String | Symbol rhs, ?scope: Scope) -> (:disjoint | :equal | :subclass | :superclass | :unknown)
     def self?.nominal_for_name: (String | Symbol class_name, ?scope: Scope) -> Type::Nominal?
     def self?.singleton_for_name: (String | Symbol class_name, ?scope: Scope) -> Type::Singleton?
     def self?.constant_type_for: (String | Symbol constant_name, ?scope: Scope) -> Type::t?
     def self?.resolve_constant_type: (String | Symbol name, ?scope: Scope, ?rooted: bool) -> Type::t?
+    # sig-gen gap: #656 — sig-gen skips the method (untyped return), so the resolved-name-or-decline is hand-written.
+    def self?.resolve_constant_path_name: (String | Symbol name, Scope scope) { (String candidate) -> boolish } -> String?
     def self?.lexical_nesting_chain: (Scope scope) -> Array[String]
     def self?.instance_method_definition: (String | Symbol class_name, String | Symbol method_name, ?scope: Scope) -> untyped
     def self?.singleton_method_definition: (String | Symbol class_name, String | Symbol method_name, ?scope: Scope) -> untyped

data/sig/rigor/scope.rbs

@@ -39,12 +39,17 @@ module Rigor
     def discovered_method_visibilities: () -> Hash[String, Hash[Symbol, Symbol]]
     def discovered_superclasses: () -> Hash[String, String]
     def discovered_includes: () -> Hash[String, Array[String]]
+    # sig-gen gap: #898 — sig-gen skips the endless-def reader (untyped return), so the table shape is hand-written.
+    def discovered_extends: () -> Hash[String, Array[String]]
     def discovered_class_sources: () -> Hash[String, Set[String]]
     def constant_sources: () -> Hash[String, Set[String]]
     def published_constant_names: () -> Set[String]
     def local_constant_names: () -> Set[String]
+    # sig-gen gap: #667 — sig-gen types the `||` fallback `untyped`, so the element type is hand-written.
+    def published_constant_ivars_for: (String class_name) -> Set[Symbol]
     def published_constant?: (String name) -> bool
     def record_constant_dependency: (String name) -> void
+    def record_class_existence: (String class_name) -> void
     def data_member_layouts: () -> Hash[String, Array[Symbol]]
     def struct_member_layouts: () -> Hash[String, { members: Array[Symbol], keyword_init: bool }]
     def param_inferred_types: () -> Hash[[String, Symbol, Symbol], Hash[Symbol, Type::t]]
@@ -73,10 +78,16 @@ module Rigor
       attr_reader discovered_method_visibilities: Hash[String, Hash[Symbol, Symbol]]
       attr_reader discovered_superclasses: Hash[String, String]
       attr_reader discovered_includes: Hash[String, Array[String]]
+      # sig-gen gap: #898 — `Data.define` members carry no type, as for every other row in this class.
+      attr_reader discovered_extends: Hash[String, Array[String]]
       attr_reader discovered_class_sources: Hash[String, Set[String]]
       attr_reader constant_sources: Hash[String, Set[String]]
       attr_reader published_constant_names: Set[String]
       attr_reader local_constant_names: Set[String]
+      # sig-gen gap: #667 — `Data.define` members carry no type, so every row in this class is authored.
+      attr_reader published_constant_alias_names: Set[String]
+      # sig-gen gap: #667 — as above.
+      attr_reader published_constant_ivars: Hash[String, Set[Symbol]]
       attr_reader data_member_layouts: Hash[String, Array[Symbol]]
       attr_reader struct_member_layouts: Hash[String, { members: Array[Symbol], keyword_init: bool }]
       attr_reader param_inferred_types: Hash[[String, Symbol, Symbol], Hash[Symbol, Type::t]]
@@ -84,7 +95,7 @@ module Rigor
 
       EMPTY: 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], ?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_superclasses: Hash[String, String], ?discovered_includes: Hash[String, Array[String]], ?discovered_class_sources: Hash[String, Set[String]], ?constant_sources: Hash[String, Set[String]], ?published_constant_names: Set[String], ?local_constant_names: Set[String], ?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]], ?run_generation: Object?) -> 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], ?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_superclasses: Hash[String, String], ?discovered_includes: Hash[String, Array[String]], ?discovered_extends: Hash[String, Array[String]], ?discovered_class_sources: Hash[String, Set[String]], ?constant_sources: Hash[String, Set[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]], ?run_generation: Object?) -> DiscoveryIndex
     end
 
     class IndexedKey
@@ -125,6 +136,12 @@ module Rigor
     def with_ivar_origin: (String | Symbol name, Symbol? cause) -> Scope
     def with_cvar: (String | Symbol name, Type::t type) -> Scope
     def with_global: (String | Symbol name, Type::t type) -> Scope
+    # sig-gen gap: #667 — an `attr_reader` over a frozen Set literal types `untyped`, as the sibling
+    # `declaration_sourced` row does.
+    def published_constant_sourced: () -> Set[[Symbol, Symbol]]
+    # sig-gen gap: #667 — `Set#include?` over a tuple key types `untyped`, so the `bool` is hand-written.
+    def published_constant_sourced?: (Symbol kind, String | Symbol name) -> bool
+    def with_published_constant_mark: (Symbol kind, String | Symbol name) -> Scope
     def declaration_sourced: () -> Set[[Symbol, Symbol]]
     def seed_declaration_sourced_ivar: (String | Symbol name, Type::t type) -> Scope
     def with_declaration_sourced_local: (String | Symbol name, Type::t type) -> Scope
@@ -138,15 +155,16 @@ module Rigor
     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
     def user_def_for: (String | Symbol class_name, String | Symbol method_name) -> untyped?
-    def user_def_through_ancestors: (String | Symbol class_name, String | Symbol method_name, ?name_memo: Hash[untyped, untyped]) -> [untyped?, String?]
+    def user_def_through_ancestors: (String | Symbol class_name, String | Symbol method_name, ?name_memo: Hash[untyped, untyped]) -> ([untyped, String] | [nil, nil])
     def discovered_method_through_ancestors?: (String | Symbol? class_name, String | Symbol method_name, Symbol kind, ?name_memo: Hash[untyped, untyped]) -> bool
+    def external_ancestor_name_candidates: (String | Symbol class_name, ?name_memo: Hash[untyped, untyped]) -> Array[Array[String]]
     def enqueue_ancestors: (String current, Array[String] queue, Hash[untyped, untyped] name_memo, ?mixins: bool) -> void
     def ancestor_name_candidates: (String | Symbol subclass_qualified, String | Symbol raw_ancestor) -> Array[String]
 
     # Issue #530 — public so the external-gem ancestry probe asks the same question the walk does.
     def known_user_class?: (String | Symbol name) -> bool
     def singleton_def_for: (String | Symbol class_name, String | Symbol method_name) -> untyped?
-    def singleton_def_through_ancestors: (String | Symbol class_name, String | Symbol method_name, ?name_memo: Hash[untyped, untyped]) -> [untyped?, String?]
+    def singleton_def_through_ancestors: (String | Symbol class_name, String | Symbol method_name, ?name_memo: Hash[untyped, untyped]) -> ([untyped, String] | [nil, nil])
     def user_def_site_for: (String | Symbol class_name, String | Symbol method_name) -> String?
     def user_singleton_def_site_for: (String | Symbol class_name, String | Symbol method_name) -> String?
     def top_level_def_for: (String | Symbol method_name) -> untyped?
@@ -157,6 +175,9 @@ module Rigor
     def data_member_layout: (String | Symbol class_name) -> Array[Symbol]?
     def struct_member_layout: (String | Symbol class_name) -> { members: Array[Symbol], keyword_init: bool }?
     def includes_of: (String | Symbol class_name) -> Array[String]
+    # sig-gen gap: #898 — sig-gen proposes `Array[untyped] | []` off the empty-table early return, so the
+    # element type is hand-written, matching {#includes_of}.
+    def singleton_extends_of: (String | Symbol class_name) -> Array[String]
     def indexed_narrowing: (Symbol receiver_kind, String | Symbol receiver_name, untyped key) -> Type::t?
     def with_indexed_narrowing: (Symbol receiver_kind, String | Symbol receiver_name, untyped key, Type::t type) -> Scope
     def without_indexed_narrowing: (Symbol receiver_kind, String | Symbol receiver_name, untyped key) -> Scope

data/sig/rigor/sig_gen/skip_reason_catalog.rbs

@@ -0,0 +1,14 @@
+class Rigor::SigGen::SkipReasonCatalog::Entry < ::Data
+  def id: () -> untyped
+  def summary: () -> untyped
+  def explanation: () -> untyped
+  def next_step: () -> untyped
+  def self.new: (id: untyped, summary: untyped, explanation: untyped, next_step: untyped) -> instance | (untyped id, untyped summary, untyped explanation, untyped next_step) -> instance
+  def self.[]: (id: untyped, summary: untyped, explanation: untyped, next_step: untyped) -> instance | (untyped id, untyped summary, untyped explanation, untyped next_step) -> instance
+  def to_h: () -> Hash[String, untyped]
+end
+
+module Rigor::SigGen::SkipReasonCatalog
+  def self?.resolve: (untyped) -> Rigor::SigGen::SkipReasonCatalog::Entry?
+  def self?.all: () -> Array[Rigor::SigGen::SkipReasonCatalog::Entry]
+end

data/sig/rigor/type.rbs

@@ -1,6 +1,6 @@
 module Rigor
   module Type
-    type t = Top | Bot | Dynamic | Constant | IntegerRange | Nominal | Singleton | Union | Difference | Refined | Intersection | Tuple | HashShape | DataClass | DataInstance | StructClass | StructInstance | BoundMethod | Result | Maybe | App
+    type t = Top | Bot | Dynamic | Constant | IntegerRange | FloatRange | Nominal | Singleton | Union | Difference | Refined | Intersection | Tuple | HashShape | DataClass | DataInstance | StructClass | StructInstance | BoundMethod | Result | Maybe | App
 
     type accepts_mode = :strict | :gradual | :loose
 
@@ -115,7 +115,30 @@ module Rigor
       def inspect: () -> String
     end
 
+    class FloatRange
+      ALIAS_NAMES: Hash[[Float, Float], String]
+      attr_reader min: Float
+      attr_reader max: Float
+      def initialize: (Float min, Float max, ?exclude_end: bool) -> void
+      def exclude_end?: () -> bool
+      def canonical_max: () -> Float
+      def universal?: () -> bool
+      def covers?: (untyped value) -> bool
+      def describe: (?Symbol verbosity) -> String
+      def generic_description: () -> String
+      def erase_to_rbs: () -> "Float"
+      def top: () -> Trinary
+      def bot: () -> Trinary
+      def dynamic: () -> Trinary
+      def accepts: (Type::t other, ?mode: accepts_mode) -> AcceptsResult
+      def ==: (untyped other) -> bool
+      def eql?: (untyped other) -> bool
+      def hash: () -> Integer
+      def inspect: () -> String
+    end
+
     class Nominal
+      EMPTY_TYPE_ARGS: Array[Type::t]
       attr_reader class_name: String
       attr_reader type_args: Array[Type::t]
       def initialize: (String class_name, ?Array[Type::t] type_args) -> void
@@ -460,6 +483,9 @@ module Rigor
       def self?.negative_int: () -> IntegerRange
       def self?.non_positive_int: () -> IntegerRange
       def self?.universal_int: () -> IntegerRange
+      def self?.float_range: (Float min, Float max, ?exclude_end: bool) -> FloatRange
+      def self?.non_nan_float: () -> FloatRange
+      def self?.finite_float: () -> FloatRange
       def self?.tuple_of: (*Type::t elements) -> Tuple
       def self?.hash_shape_of: (?Hash[untyped, Type::t]? pairs, **untyped options) -> HashShape
       def self?.data_class_of: (members: Array[Symbol], ?class_name: String?) -> DataClass

data/sig/rigor.rbs

@@ -24,6 +24,7 @@ module Rigor
 
   class CLI
     EXIT_USAGE: Integer
+    EXIT_INTERNAL_ERROR: Integer
 
     def self.start: (?Array[String] argv, ?out: untyped, ?err: untyped) -> Integer
 

data/skills/rigor-ask/SKILL.md

@@ -30,11 +30,12 @@ Two things make that easy, and you have both offline:
   `type-of` / `triage` / `coverage` answer from what Rigor inferred. A
   concrete inferred type beats any abstract explanation.
 
-This is the user's shortcut: they only ever need to remember two skills —
-**`rigor-next-steps`** ("what should we do next?") and **`rigor-ask`**
-("answer this about Rigor"). They ask in plain language; *you* turn it
-into the right lookup or analysis so they never have to remember the
-command.
+This is the user's shortcut: they only ever need to remember three
+skills — **`rigor-next-steps`** ("what should we do next?"),
+**`rigor-ask`** ("answer this about Rigor"), and **`rigor-type-oracle`**
+("before you write a type, ask Rigor"). They ask in plain language; *you*
+turn it into the right lookup or analysis so they never have to remember
+the command.
 
 ## Prefer the live map over this skill's tables
 
@@ -125,8 +126,9 @@ A good hand-off is two or three sentences of orientation plus the pointer:
 - CI → **`rigor-ci-setup`** · editor → **`rigor-editor-setup`** · MCP agent → **`rigor-mcp-setup`**
 - baseline reduction → **`rigor-baseline-reduce`** · coverage holes → **`rigor-protection-uplift`**
 - a missing gem/DSL → **`rigor-plugin-author`** · monkey-patch clusters → **`rigor-monkeypatch-resolve`**
+- about to *write* a type (RBS, `#:`, a Sorbet `sig`, a YARD tag, a doc sentence) → **`rigor-type-oracle`**
 
-When in doubt, give less and point — it respects the user's "two skills
+When in doubt, give less and point — it respects the user's "three skills
 to remember" promise and keeps each answer to the part only `rigor-ask`
 can give.
 

data/skills/rigor-plugin-author/references/02-walker-and-types.md

@@ -152,8 +152,9 @@ For your own target library, follow the same harness: a **fixed
 allow-list** of pure methods, inputs derived from source, and **decline
 (return nil / emit nothing) when the library is unavailable — never
 approximate**. How the call is isolated from Rigor (in-process, a forked
-worker, or a `Ruby::Box`) is a configurable strategy the user picks
-(`plugins_isolation:`); you just call the method.
+worker, or a `Ruby::Box`) is a configurable strategy the user picks with
+`.rigor.yml`'s `plugins_isolation:` key or the `RIGOR_PLUGIN_ISOLATION`
+environment variable (which wins over it); you just call the method.
 
 For the common "did you mean …?" suggestion, use the shared helper
 rather than hand-rolling Levenshtein:
@@ -194,6 +195,16 @@ dynamic_return receivers: ["Money"] do |call_node, scope|
   Rigor::Type::Combinator.nominal_of("Money")
 end
 
+# A `receivers:` entry names the receiver KIND too. `"Money"` matches an
+# INSTANCE receiver; the class object itself is `"singleton(Money)"`,
+# spelled as RBS spells it; a rule for both lists both. Write the kind
+# the rule actually models: a plugin answer suppresses that call site's
+# `call.undefined-method`, so an instance rule that also answered on the
+# class would silence a genuine miss on the class-level call.
+dynamic_return receivers: ["singleton(Money)"], methods: [:from_cents] do |call_node, scope|
+  Rigor::Type::Combinator.nominal_of("Money")
+end
+
 # Post-return NARROWING FACTS, gated on the call's method name.
 # Return an Array of facts (or nil). Used for assertion / predicate
 # narrowing (`assert_kind_of(Foo, x)` ⇒ x is Foo afterwards).

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

@@ -135,6 +135,7 @@ mode — those points resolve without blocking:
 | 6a | **Pre-baseline cleanup** — apply quick fixes that triage diagnosed (`pre_eval:` for monkey-patch hints, `rbs collection install` if still needed). Re-run triage; repeat until the count is stable. | [`references/03-baseline-and-bugs.md`](references/03-baseline-and-bugs.md) § "Phase 6a" |
 | 7 | Acknowledge mode only — generate the baseline and wire `baseline:`. | [`references/03-baseline-and-bugs.md`](references/03-baseline-and-bugs.md) |
 | 8 | Surface likely real bugs; distinguish sig quality FPs from real bugs; offer escalation paths. | [`references/03-baseline-and-bugs.md`](references/03-baseline-and-bugs.md) |
+| 8a | Install the agent type-contract into `AGENTS.md` / `CLAUDE.md`, so an AI contributor sources types from Rigor instead of guessing them. | [`references/06-agent-contract.md`](references/06-agent-contract.md) |
 | 9 | Confirm the generated files with the user — what each is, and whether to commit it. | (this file — § "Final step") |
 
 Load each reference when you reach its phase. Phases run in order;
@@ -150,6 +151,7 @@ committed `sig/` directory.
 | 2 | [`references/02-configure.md`](references/02-configure.md) | **Phase 4.** Severity-profile choice tied to the mode. The `.rigor.dist.yml` template and every key it uses. The `.rigor.dist.yml` vs `.rigor.yml` convention. |
 | 3 | [`references/04-sig-uplift.md`](references/04-sig-uplift.md) | **Phase 5.** `rigor sig-gen --write` baseline. `rigor sig-gen --params=observed --write` attr_reader precision uplift. Handling residual `untyped` methods. Committing `sig/`. |
 | 4 | [`references/03-baseline-and-bugs.md`](references/03-baseline-and-bugs.md) | **Phases 6–8.** `rigor triage` as the diagnosis layer. Phase 6a pre-baseline cleanup loop (`pre_eval:` for monkey-patch hints, `rbs collection install`). `rigor baseline generate` + wiring `baseline:`. Surfacing likely real bugs; sig quality FP recognition (Struct `call.wrong-arity`, `-> bot` return-type-mismatch, regex-capture `$1` FPs). The two escalation paths — write a project plugin, or open a Rigor issue. |
+| 5 | [`references/06-agent-contract.md`](references/06-agent-contract.md) | **Phase 8a.** The one paragraph the project's `AGENTS.md` / `CLAUDE.md` keeps so every agent session sources types from Rigor rather than guessing them. Where to append it, when to create the file, and what never to overwrite. |
 | — (optional) | [`references/05-jit-performance.md`](references/05-jit-performance.md) | **Operational, not a phase.** Run speed via a Ruby JIT: Rigor auto-enables YJIT for long runs (~5 s break-even), how to detect JIT support in your install, the override env vars, and why YJIT beats ZJIT for Rigor on Ruby 4.0. Read only when a large project's `rigor check` wall time matters. |
 
 ## Escalation paths (Phase 7 preview)
@@ -227,10 +229,11 @@ only in acknowledge mode). For each, give the commit recommendation:
 | `.rigor/` (contains `cache/`) | The per-file analysis cache `rigor check` writes to speed up re-runs. Regenerable and machine-local. | **No** — add `.rigor/` to `.gitignore`. |
 | `.rigor.yml` | Optional per-developer local override (not written by this skill). Takes precedence over `.rigor.dist.yml`; used to opt out locally (e.g. run without the baseline). | **No** — gitignore it if a developer creates one. |
 | `rbs_collection.lock.yaml` | Not a Rigor artefact — but if Phase 1 ran `rbs collection install`, the install may have regenerated this pre-existing project file (e.g. the stdlib gem list for the resolved Ruby). | **Yes**, but flag it separately: it is a change to an existing project file, not part of the Rigor file set. |
+| `AGENTS.md` / `CLAUDE.md` | The agent type-contract section added in Phase 8a — "a type you did not obtain from Rigor is a guess". Created only if neither file existed; otherwise this is an appended section in a pre-existing file. | **Yes** — commit it; the point is that every contributor's agent reads the same rule. Flag an appended section separately, as with `rbs_collection.lock.yaml`. |
 
 Recommend the two concrete actions and **ask before doing them**
 (both touch the user's repo): (1) add `.rigor/` — and `.rigor.yml`
 if present — to `.gitignore`; (2) commit `.rigor.dist.yml`,
-`.rigor-baseline.yml`, and `sig/` as the shared Rigor setup. Per the
-git-safety default, do not commit on the user's behalf until they
-confirm.
+`.rigor-baseline.yml`, `sig/`, and the Phase 8a `AGENTS.md` /
+`CLAUDE.md` section as the shared Rigor setup. Per the git-safety
+default, do not commit on the user's behalf until they confirm.

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

@@ -114,10 +114,11 @@ severity_profile: lenient
 
 ### Existing `sig/` directory
 
-If the project already has a `sig/` directory (from Steep, `rbs_rails`,
-or handwritten annotations), wire it into `signature_paths:` so Rigor
-consumes it. Phase 5 (sig uplift) can be skipped, but the paths must
-still be declared — Rigor does not auto-detect `sig/`:
+A plain `<project root>/sig` directory needs no wiring: with
+`signature_paths:` unset, Rigor auto-detects it and loads it recursively.
+Phase 5 (sig uplift) can be skipped. Declare `signature_paths:` when the
+layout is something else — several trees, or a `sig/` that is not at the
+project root:
 
 ```yaml
 signature_paths:
@@ -125,9 +126,12 @@ signature_paths:
   - sig/generated
 ```
 
+Declaring the key REPLACES the auto-detected `sig`, so list it too if you
+want it. `signature_paths: []` is the way to opt out of project RBS
+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. If the sig layout is a single
-flat `sig/` directory, use `- sig` instead.
+them. Rigor walks each path recursively.
 
 A strict-mode plain-Ruby gem is shorter:
 

data/skills/rigor-project-init/references/06-agent-contract.md

@@ -0,0 +1,67 @@
+# 06 — Install the agent type-contract into AGENTS.md / CLAUDE.md
+
+Covers **Phase 8a**. Input: an onboarded project (config written, sigs
+generated, baseline decided). Output: one section in the file the
+project's coding agents read at startup.
+
+## Why this is part of onboarding
+
+Everything the earlier phases produced — `sig/`, the baseline, the
+severity profile — is a record of what Rigor *proved*. The moment an AI
+agent starts contributing to the project, it can write types that Rigor
+never proved: a `@param currency [String]` in a doc comment, an
+rbs-inline `#:` that Rigor then ingests as a live contract. Those enter
+the same files, look identical to derived types, and are believed.
+
+The fix is not a tool. It is one paragraph in the project's agent
+contract, so the rule is in context every session rather than only when
+a skill happens to trigger: **a type not obtained from Rigor is a guess,
+and a guessed type is never written.**
+
+## The text
+
+The canonical fragment is served by the installed Rigor, so it stays
+current with the CLI it names:
+
+```sh
+rigor skill --full rigor-type-oracle
+```
+
+Its `references/02-agents-md-fragment.md` section carries the paragraph
+and the five bullets. Copy that block **verbatim** — including its
+single-long-line shape, which is deliberate (some renderers turn a
+newline inside a paragraph into a line break).
+
+Do not paraphrase it from memory, and do not shorten it: the five bullets
+are the load-bearing part — expression, method signature, parameter,
+the gap rule, and provenance.
+
+## Where it goes
+
+| Project state | What to do |
+| --- | --- |
+| `AGENTS.md` exists | **Append** the section at the end. Do not reorganise the file. |
+| Only `CLAUDE.md` exists | Append it there. |
+| Both exist | Put it in `AGENTS.md`. Add `@AGENTS.md` to `CLAUDE.md` only if it is not already pulled in. |
+| Neither exists | **Create `AGENTS.md`** with this as its first section. |
+| A types / type-checking section already exists | Merge into it; keep the five bullets intact. Never write a second, competing rule. |
+
+Never overwrite unrelated content. If the project already states a rule
+about type authorship that contradicts this one, stop and show the user
+the conflict — the project's own rule wins until they say otherwise.
+
+## Report it in the final step
+
+This is a change to the file that governs every future agent session in
+the repo, so it belongs in Phase 9's file inventory, not in a silent
+diff. Recommend committing it: the point is that every contributor's
+agent reads the same rule.
+
+## When to skip
+
+- The project has no coding-agent contract file **and** the user has said
+  they do not use AI agents on it. Offer once, accept "no".
+- The user declined it earlier in this session.
+
+Otherwise install it — an unonboarded agent is the one contributor that
+cannot be trained by review.