rigortype 0.1.7 → 0.1.8

data/lib/rigor/scope.rb

@@ -21,6 +21,7 @@ module Rigor
                 :class_ivars, :class_cvars, :program_globals,
                 :discovered_classes, :in_source_constants, :discovered_methods,
                 :discovered_def_nodes, :discovered_method_visibilities,
+                :discovered_superclasses, :discovered_includes,
                 :source_path
 
     EMPTY_DECLARED_TYPES = {}.compare_by_identity.freeze
@@ -51,6 +52,8 @@ module Rigor
       discovered_methods: EMPTY_CLASS_BINDINGS,
       discovered_def_nodes: EMPTY_CLASS_BINDINGS,
       discovered_method_visibilities: EMPTY_CLASS_BINDINGS,
+      discovered_superclasses: EMPTY_CLASS_BINDINGS,
+      discovered_includes: EMPTY_CLASS_BINDINGS,
       source_path: nil
     )
       @environment = environment
@@ -69,6 +72,8 @@ module Rigor
       @discovered_methods = discovered_methods
       @discovered_def_nodes = discovered_def_nodes
       @discovered_method_visibilities = discovered_method_visibilities
+      @discovered_superclasses = discovered_superclasses
+      @discovered_includes = discovered_includes
       @source_path = source_path
       freeze
     end
@@ -284,6 +289,41 @@ module Rigor
       rebuild(discovered_def_nodes: table)
     end
 
+    # ADR-24 slice 2 — per-class table mapping a fully
+    # qualified user-class name to its superclass name AS
+    # WRITTEN at the `class Foo < Bar` declaration (`"Bar"`,
+    # possibly a qualified `"A::B"`). Populated by `ScopeIndexer`
+    # — per-file plus the cross-file project pre-pass — and
+    # consumed by `ExpressionTyper#try_user_method_inference`
+    # to walk the superclass chain when an implicit-self call
+    # does not resolve against the enclosing class's own defs.
+    # The as-written name is resolved to a qualified class at
+    # walk time against the call's lexical nesting.
+    def superclass_of(class_name)
+      @discovered_superclasses[class_name.to_s]
+    end
+
+    def with_discovered_superclasses(table)
+      rebuild(discovered_superclasses: table)
+    end
+
+    # ADR-24 slice 2 — per-class/module table mapping a fully
+    # qualified user class or module to the list of module
+    # names it `include`s / `prepend`s, AS WRITTEN at the
+    # mixin call. Populated by `ScopeIndexer` (per-file plus
+    # the cross-file pre-pass) and consumed by
+    # `ExpressionTyper#resolve_user_def_through_ancestors` so an
+    # implicit-self call resolves against an included module's
+    # `def`s, not just the superclass chain. As-written names
+    # are resolved to qualified classes at walk time.
+    def includes_of(class_name)
+      @discovered_includes[class_name.to_s] || []
+    end
+
+    def with_discovered_includes(table)
+      rebuild(discovered_includes: table)
+    end
+
     # v0.1.2 — per-class table mapping `method_name (Symbol) →
     # :public | :private | :protected`. Populated by
     # `ScopeIndexer` for every `def` it sees inside a class
@@ -372,6 +412,8 @@ module Rigor
       discovered_classes: @discovered_classes, in_source_constants: @in_source_constants,
       discovered_methods: @discovered_methods, discovered_def_nodes: @discovered_def_nodes,
       discovered_method_visibilities: @discovered_method_visibilities,
+      discovered_superclasses: @discovered_superclasses,
+      discovered_includes: @discovered_includes,
       source_path: @source_path
     )
       self.class.new(
@@ -386,6 +428,8 @@ module Rigor
         discovered_methods: discovered_methods,
         discovered_def_nodes: discovered_def_nodes,
         discovered_method_visibilities: discovered_method_visibilities,
+        discovered_superclasses: discovered_superclasses,
+        discovered_includes: discovered_includes,
         source_path: source_path
       )
     end
@@ -413,6 +457,8 @@ module Rigor
         discovered_methods: discovered_methods,
         discovered_def_nodes: discovered_def_nodes,
         discovered_method_visibilities: discovered_method_visibilities,
+        discovered_superclasses: discovered_superclasses,
+        discovered_includes: discovered_includes,
         source_path: source_path
       )
     end

data/lib/rigor/triage/catalogue.rb

@@ -0,0 +1,296 @@
+# frozen_string_literal: true
+
+require_relative "hint"
+
+module Rigor
+  module Triage
+    # ADR-23 § "Heuristic catalogue" — the six v1 recognisers.
+    #
+    # {.recognise} runs them in order over the diagnostic stream.
+    # Each recogniser sees only the diagnostics not yet claimed by
+    # an earlier one, so a `5.minutes` diagnostic counted by H1
+    # (ActiveSupport) is not re-counted by H2 (monkey-patch).
+    #
+    # WD3 / slice 4: recognisers key on the structured
+    # `qualified_rule` first; where they additionally need the
+    # receiver type or method name they read the structured
+    # `Diagnostic#receiver_type` / `#method_name` fields, falling
+    # back to parsing the diagnostic message only when those are
+    # absent. A parse failure degrades to "skip this diagnostic" —
+    # never a crash.
+    module Catalogue # rubocop:disable Metrics/ModuleLength
+      module_function
+
+      UNDEFINED_METHOD_RULE = "call.undefined-method"
+
+      # `undefined method `foo' for <receiver>`
+      UNDEF_METHOD = /\Aundefined method [`'"]([^`'"]+)['"`] for (.+)\z/
+
+      # ActiveSupport `core_ext` selectors, grouped by the core
+      # class they extend. Survey-grounded (the dominant clusters
+      # from the five-project survey + the Mastodon measurement).
+      AS_NUMERIC = %w[
+        day days hour hours minute minutes second seconds week weeks
+        fortnight fortnights month months year years
+        byte bytes kilobyte kilobytes megabyte megabytes gigabyte gigabytes
+        terabyte terabytes petabyte petabytes exabyte exabytes
+        ago since from_now in_milliseconds
+      ].freeze
+      AS_STRING = %w[
+        squish squish! strip_heredoc html_safe underscore camelize camelcase
+        pluralize singularize titleize titlecase humanize dasherize
+        parameterize tableize classify constantize safe_constantize
+        demodulize deconstantize foreign_key indent indent! truncate
+        truncate_words to_datetime to_date to_time exclude? at from
+        remove remove! mb_chars upcase_first downcase_first
+      ].freeze
+      AS_HASH = %w[
+        deep_dup deep_merge deep_merge! symbolize_keys symbolize_keys!
+        stringify_keys stringify_keys! deep_symbolize_keys deep_stringify_keys
+        deep_transform_keys deep_transform_keys! deep_transform_values
+        except! with_indifferent_access assert_valid_keys
+        reverse_merge reverse_merge! extract!
+      ].freeze
+      AS_ARRAY = %w[
+        to_sentence in_groups_of in_groups second third fourth fifth
+        forty_two extract_options! wrap deep_dup
+      ].freeze
+      AS_TIMEDATE = %w[
+        zone current beginning_of_day end_of_day beginning_of_week
+        end_of_week beginning_of_month end_of_month beginning_of_year
+        end_of_year next_week prev_week next_month prev_month
+        tomorrow yesterday all_day all_week all_month advance
+        ago since change to_fs
+      ].freeze
+      AS_BY_CLASS = {
+        "Integer" => AS_NUMERIC, "Float" => AS_NUMERIC, "Numeric" => AS_NUMERIC,
+        "String" => AS_STRING, "Symbol" => AS_STRING,
+        "Hash" => AS_HASH, "Array" => AS_ARRAY,
+        "Time" => AS_TIMEDATE, "Date" => AS_TIMEDATE,
+        "DateTime" => AS_TIMEDATE, "ActiveSupport::TimeWithZone" => AS_TIMEDATE
+      }.freeze
+      private_constant :AS_NUMERIC, :AS_STRING, :AS_HASH, :AS_ARRAY, :AS_TIMEDATE
+
+      # ActiveRecord query-builder methods. When flagged on an
+      # `Array[...]` receiver they signal a relation misinference.
+      AR_QUERY_METHODS = %w[
+        where joins includes preload eager_load references select
+        order reorder distinct group having limit offset pluck
+        find_by find_each find_in_batches in_batches none rewhere
+        unscope merge except_query extending
+      ].freeze
+      private_constant :AR_QUERY_METHODS
+
+      SYSTEMIC_THRESHOLD = 8       # (file, rule) count → "systemic"
+      MONKEY_PATCH_MIN_FILES = 3   # same (method, receiver) across N files
+      GENUINE_BUG_MAX_COUNT = 5    # rule total ≤ N → "likely genuine bug"
+      private_constant :SYSTEMIC_THRESHOLD, :MONKEY_PATCH_MIN_FILES, :GENUINE_BUG_MAX_COUNT
+
+      # @param diagnostics [Array<Analysis::Diagnostic>]
+      # @return [Array<Hint>]
+      def recognise(diagnostics)
+        claimed = {}.compare_by_identity
+        recognisers.filter_map do |recogniser|
+          pool = diagnostics.reject { |d| claimed[d] }
+          hint, matched = send(recogniser, pool)
+          next unless hint
+
+          matched.each { |d| claimed[d] = true }
+          hint
+        end
+      end
+
+      # H4 (ActiveRecord query methods) runs before H2 (generic
+      # monkey-patch): a known AR method on `Array[...]` deserves
+      # the precise relation-misinference hint, not the generic
+      # "project core-ext" guess H2 would otherwise claim it for.
+      def recognisers
+        %i[h1_activesupport h4_ar_relation h3_gem_without_rbs
+           h2_monkey_patch h5_systemic_cluster h6_genuine_bugs]
+      end
+
+      # --- H1 — likely ActiveSupport core_ext --------------------
+      def h1_activesupport(pool)
+        matched = pool.select do |d|
+          parsed = parse_undefined_method(d)
+          parsed && activesupport?(parsed[:receiver], parsed[:method])
+        end
+        return nil if matched.empty?
+
+        [Hint.new(
+          id: "activesupport-core-ext", confidence: :likely,
+          diagnostic_count: matched.size,
+          summary: "undefined-method on core classes (#{top_methods(matched)}) — " \
+                   "ActiveSupport monkey-patches these",
+          action: "Wire the rigor-activesupport-core-ext RBS bundle via " \
+                  "`signature_paths:` in .rigor.yml."
+        ), matched]
+      end
+
+      # --- H2 — likely a project monkey-patch / refinement -------
+      def h2_monkey_patch(pool)
+        groups = undefined_method_groups(pool).select do |(_method, _recv), diags|
+          diags.map(&:path).uniq.size >= MONKEY_PATCH_MIN_FILES
+        end
+        return nil if groups.empty?
+
+        matched = groups.values.flatten(1)
+        [Hint.new(
+          id: "project-monkey-patch", confidence: :possible,
+          diagnostic_count: matched.size,
+          summary: "same method undefined across many files " \
+                   "(#{describe_groups(groups)}) — likely a project core-ext / refinement",
+          action: "Register the defining file via `pre_eval:` (ADR-17), " \
+                  "or add an RBS overlay for the method."
+        ), matched]
+      end
+
+      # --- H3 — gem ships no RBS ---------------------------------
+      def h3_gem_without_rbs(pool)
+        notice = pool.find { |d| d.message.match?(/gem\(s\).*have no RBS available/) }
+        return nil unless notice
+
+        count = notice.message[/\A(\d+) gem/, 1] || "some"
+        [Hint.new(
+          id: "gem-without-rbs", confidence: :likely, diagnostic_count: 1,
+          summary: "#{count} Gemfile.lock gem(s) ship no RBS — undefined-method " \
+                   "diagnostics on their classes are expected, not bugs",
+          action: "`rbs collection install`, ship `sig/` in the gem, or opt the " \
+                  "gem into `dependencies.source_inference:` (ADR-10)."
+        ), [notice]]
+      end
+
+      # --- H4 — possible ActiveRecord relation misinference ------
+      def h4_ar_relation(pool)
+        matched = pool.select do |d|
+          parsed = parse_undefined_method(d)
+          parsed && AR_QUERY_METHODS.include?(parsed[:method]) &&
+            parsed[:receiver].start_with?("Array[")
+        end
+        return nil if matched.empty?
+
+        [Hint.new(
+          id: "activerecord-relation-misinference", confidence: :possible,
+          diagnostic_count: matched.size,
+          summary: "ActiveRecord query methods (#{top_methods(matched)}) flagged " \
+                   "on an `Array[...]` receiver",
+          action: "Enable rigor-activerecord; if it persists the receiver is an " \
+                  "engine misinference (an AR relation read as Array) — worth a Rigor issue."
+        ), matched]
+      end
+
+      # --- H5 — systemic single-file cluster ---------------------
+      def h5_systemic_cluster(pool)
+        bucket = pool.group_by { |d| [d.path, rule_of(d)] }
+                     .select { |_key, diags| diags.size >= SYSTEMIC_THRESHOLD }
+                     .max_by { |_key, diags| diags.size }
+        return nil unless bucket
+
+        (path, rule), matched = bucket
+        [Hint.new(
+          id: "systemic-file-cluster", confidence: :likely,
+          diagnostic_count: matched.size,
+          summary: "#{matched.size}× `#{rule}` concentrated in #{path}",
+          action: "Likely systemic in this file — one fix may clear many; " \
+                  "or a strong baseline candidate (ADR-22)."
+        ), matched]
+      end
+
+      # --- H6 — low-count scattered rules = likely genuine bugs --
+      def h6_genuine_bugs(pool)
+        small = pool.group_by { |d| rule_of(d) }
+                    .select { |rule, diags| rule && diags.size.between?(1, GENUINE_BUG_MAX_COUNT) }
+        return nil if small.empty?
+
+        matched = small.values.flatten(1)
+        rules = small.map { |rule, diags| "#{rule}×#{diags.size}" }.sort.join(", ")
+        [Hint.new(
+          id: "genuine-bugs", confidence: :likely,
+          diagnostic_count: matched.size,
+          summary: "low-count, scattered rules (#{rules})",
+          action: "Review these first — low-count diagnostics are usually the " \
+                  "localised bugs Rigor caught, not systemic noise."
+        ), matched]
+      end
+
+      # --- shared helpers ----------------------------------------
+
+      # WD3 / slice 4: prefer the structured `receiver_type` /
+      # `method_name` fields the `call.undefined-method` rule now
+      # populates; fall back to parsing the message only when they
+      # are absent (older diagnostics, plugin-emitted rules). Either
+      # way the receiver token is normalised through `receiver_class`.
+      def parse_undefined_method(diag)
+        return nil unless rule_of(diag) == UNDEFINED_METHOD_RULE
+
+        method, receiver_token = structured_undefined_method(diag) ||
+                                 message_undefined_method(diag)
+        return nil unless method
+
+        receiver = receiver_class(receiver_token)
+        return nil unless receiver
+
+        { method: method, receiver: receiver }
+      end
+
+      def structured_undefined_method(diag)
+        return nil unless diag.method_name && diag.receiver_type
+
+        [diag.method_name, diag.receiver_type]
+      end
+
+      def message_undefined_method(diag)
+        m = UNDEF_METHOD.match(diag.message)
+        m && [m[1], m[2]]
+      end
+
+      # Normalises a message receiver token to a class name.
+      # Integer / string / symbol literals fold to their class;
+      # `Foo[...]` keeps the `Array[...]` form (H4 needs it);
+      # `singleton(Foo)` and bare `Foo` fold to `Foo`.
+      def receiver_class(token)
+        t = token.strip
+        return "Integer" if t.match?(/\A-?\d+\z/)
+        return "Float"   if t.match?(/\A-?\d+\.\d+\z/)
+        return "String"  if t.start_with?('"', "'")
+        return "Symbol"  if t.start_with?(":")
+
+        singleton = t[/\Asingleton\(([\w:]+)\)\z/, 1]
+        return singleton if singleton
+        return t if t.start_with?("Array[")
+
+        nominal = t[/\A([\w:]+)\[/, 1]
+        return nominal if nominal
+        return t if t.match?(/\A[\w:]+\z/)
+
+        nil
+      end
+
+      def activesupport?(receiver, method)
+        AS_BY_CLASS[receiver]&.include?(method) || false
+      end
+
+      def undefined_method_groups(pool)
+        pairs = pool.filter_map do |d|
+          parsed = parse_undefined_method(d)
+          parsed ? [[parsed[:method], parsed[:receiver]], d] : nil
+        end
+        pairs.group_by(&:first).transform_values { |group| group.map(&:last) }
+      end
+
+      def describe_groups(groups)
+        groups.keys.first(3).map { |method, recv| "`#{method}` on #{recv}" }.join(", ")
+      end
+
+      def top_methods(diagnostics, limit: 5)
+        diagnostics.filter_map { |d| parse_undefined_method(d)&.fetch(:method) }
+                   .tally.sort_by { |method, count| [-count, method] }
+                         .first(limit).map { |method, count| "#{method}×#{count}" }.join(" ")
+      end
+
+      def rule_of(diag)
+        diag.qualified_rule
+      end
+    end
+  end
+end

data/lib/rigor/triage/hint.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Rigor
+  module Triage
+    # ADR-23 — one heuristic finding produced by the {Catalogue}.
+    #
+    # - `id`     — stable kebab-case identifier (`activesupport-core-ext`, …).
+    # - `confidence` — `:likely` or `:possible`. Surfaced in the
+    #   `[likely …]` / `[possible …]` report framing; a hint is
+    #   signal, never a verdict.
+    # - `diagnostic_count` — size of the matched cluster.
+    # - `summary` — one-line evidence string (what was matched).
+    # - `action`  — the suggested next step, phrased imperatively
+    #   for a human / agent (ADR-23 WD4: triage never acts itself).
+    Hint = Data.define(:id, :confidence, :diagnostic_count, :summary, :action) do
+      def to_h
+        {
+          "id" => id,
+          "confidence" => confidence.to_s,
+          "diagnostic_count" => diagnostic_count,
+          "summary" => summary,
+          "action" => action
+        }
+      end
+    end
+  end
+end

data/lib/rigor/triage.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require_relative "triage/hint"
+require_relative "triage/catalogue"
+
+module Rigor
+  # ADR-23 — diagnostic triage. Aggregates a `rigor check`
+  # diagnostic stream into the data behind the `rigor triage`
+  # report: a rule-ID distribution, per-file hotspots, and the
+  # heuristic hint catalogue ({Triage::Catalogue}).
+  #
+  # Pure over the diagnostic stream — no second analysis pass, no
+  # analyzer internals. `Triage.analyze` is the single entry point;
+  # rendering is {CLI::TriageRenderer}'s job.
+  module Triage
+    UNCATEGORISED = "(uncategorised)"
+
+    Summary = Data.define(:total, :error, :warning, :info)
+    RuleCount = Data.define(:rule, :count)
+    Hotspot = Data.define(:file, :count, :by_rule)
+    Report = Data.define(:summary, :distribution, :hotspots, :hints)
+
+    module_function
+
+    # @param diagnostics [Array<Analysis::Diagnostic>]
+    # @param top [Integer] hotspot-file cap
+    # @param hints [Boolean] run the heuristic catalogue
+    # @return [Report]
+    def analyze(diagnostics, top: 10, hints: true)
+      Report.new(
+        summary: build_summary(diagnostics),
+        distribution: build_distribution(diagnostics),
+        hotspots: build_hotspots(diagnostics, top),
+        hints: hints ? Catalogue.recognise(diagnostics) : []
+      )
+    end
+
+    # Diagnostics without a `rule` (parse errors, internal-analyzer
+    # errors) bucket under a single sentinel rather than vanishing.
+    def rule_key(diagnostic)
+      diagnostic.qualified_rule || UNCATEGORISED
+    end
+
+    def build_summary(diagnostics)
+      by_severity = diagnostics.group_by(&:severity).transform_values(&:size)
+      Summary.new(
+        total: diagnostics.size,
+        error: by_severity.fetch(:error, 0),
+        warning: by_severity.fetch(:warning, 0),
+        info: by_severity.fetch(:info, 0)
+      )
+    end
+
+    def build_distribution(diagnostics)
+      diagnostics.group_by { |d| rule_key(d) }
+                 .map { |rule, group| RuleCount.new(rule: rule, count: group.size) }
+                 .sort_by { |row| [-row.count, row.rule] }
+    end
+
+    def build_hotspots(diagnostics, top)
+      diagnostics.group_by(&:path)
+                 .map { |path, group| hotspot_for(path, group) }
+                 .sort_by { |spot| [-spot.count, spot.file] }
+                 .first(top)
+    end
+
+    def hotspot_for(path, group)
+      by_rule = group.group_by { |d| rule_key(d) }
+                     .transform_values(&:size)
+                     .sort_by { |rule, count| [-count, rule] }
+                     .to_h
+      Hotspot.new(file: path, count: group.size, by_rule: by_rule)
+    end
+
+    def report_to_h(report)
+      {
+        "summary" => {
+          "total" => report.summary.total, "error" => report.summary.error,
+          "warning" => report.summary.warning, "info" => report.summary.info
+        },
+        "distribution" => report.distribution.map { |r| { "rule" => r.rule, "count" => r.count } },
+        "hotspots" => report.hotspots.map do |h|
+          { "file" => h.file, "count" => h.count, "by_rule" => h.by_rule }
+        end,
+        "hints" => report.hints.map(&:to_h)
+      }
+    end
+  end
+end

data/lib/rigor/version.rb

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

data/sig/rigor/inference.rbs

@@ -135,6 +135,7 @@ module Rigor
       def self?.build_declaration_overrides: (untyped root) -> Hash[untyped, Type::t]
       def self?.record_declarations: (untyped node, Array[String] qualified_prefix, Hash[untyped, Type::t] identity_table, Hash[String, Type::t] discovered) -> void
       def self?.discovered_classes_for_paths: (Array[String] paths, ?buffer: untyped) -> Hash[String, Type::t]
+      def self?.discovered_def_index_for_paths: (Array[String] paths, ?buffer: untyped) -> Hash[Symbol, untyped]
       def self?.collect_class_decls: (untyped node, Array[String] qualified_prefix, Hash[String, Type::t] accumulator) -> void
       def self?.qualified_name_for: (untyped constant_path_node) -> String?
       def self?.render_constant_path: (untyped node) -> String

data/sig/rigor/scope.rbs

@@ -16,6 +16,8 @@ module Rigor
     attr_reader discovered_methods: Hash[String, Hash[Symbol, Symbol]]
     attr_reader discovered_def_nodes: Hash[String, Hash[Symbol, untyped]]
     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]]
     attr_reader source_path: String?
 
     def self.empty: (?environment: Environment, ?source_path: String?) -> Scope
@@ -44,6 +46,10 @@ module Rigor
     def top_level_def_for: (String | Symbol method_name) -> untyped?
     def with_discovered_method_visibilities: (Hash[String, Hash[Symbol, Symbol]] table) -> Scope
     def discovered_method_visibility: (String | Symbol class_name, String | Symbol method_name) -> Symbol?
+    def superclass_of: (String | Symbol class_name) -> String?
+    def with_discovered_superclasses: (Hash[String, String] table) -> Scope
+    def includes_of: (String | Symbol class_name) -> Array[String]
+    def with_discovered_includes: (Hash[String, Array[String]] table) -> Scope
     def with_fact: (Analysis::FactStore::Fact fact) -> Scope
     def with_self_type: (Type::t? type) -> Scope
     def with_declared_types: (Hash[untyped, Type::t] table) -> Scope

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rigortype
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.8
 platform: ruby
 authors:
 - Rigor contributors
@@ -266,6 +266,8 @@ files:
 - lib/rigor/cli/explain_command.rb
 - lib/rigor/cli/lsp_command.rb
 - lib/rigor/cli/sig_gen_command.rb
+- lib/rigor/cli/triage_command.rb
+- lib/rigor/cli/triage_renderer.rb
 - lib/rigor/cli/type_of_command.rb
 - lib/rigor/cli/type_of_renderer.rb
 - lib/rigor/cli/type_scan_command.rb
@@ -401,6 +403,9 @@ files:
 - lib/rigor/source/node_locator.rb
 - lib/rigor/source/node_walker.rb
 - lib/rigor/testing.rb
+- lib/rigor/triage.rb
+- lib/rigor/triage/catalogue.rb
+- lib/rigor/triage/hint.rb
 - lib/rigor/trinary.rb
 - lib/rigor/type.rb
 - lib/rigor/type/accepts_result.rb