rails-ai-context 5.30.2 → 5.32.0

data/lib/rails_ai_context/introspectors/model_introspector.rb

@@ -52,7 +52,7 @@ module RailsAiContext
 
         unloadable_models.each { |class_name, details| result[class_name] ||= details }
 
-        result
+        tag_tenancy(result)
       end
 
       # Models the static scan finds, abstract bases left out. excluded_models is the app's
@@ -80,7 +80,7 @@ module RailsAiContext
         candidates = static_candidates
         sti_parents = candidates.keys.to_h { |name| [ name, sti_parent(name, candidates, []) ] }
         bases = declared_bases(candidates)
-        candidates.each_with_object({}) do |(class_name, candidate), result|
+        models = candidates.each_with_object({}) do |(class_name, candidate), result|
           # Hidden from the listing, kept in the walk: its children still
           # inherit its table and its declarations.
           next if config.excluded_models.include?(class_name)
@@ -112,6 +112,7 @@ module RailsAiContext
           table = resolve_table_name(class_name, candidates)
           result[class_name] = static_model_details(candidate[:path], class_name, file: candidate[:file],
                                                     table_name: table,
+                                                    primary_key: resolve_primary_key(class_name, candidates),
                                                     inherited_from: declaring_bases(class_name, candidates),
                                                     sti: static_sti_info(class_name, sti_parents),
                                                     parent_model: sti_parents[class_name])
@@ -123,14 +124,38 @@ module RailsAiContext
           # not have.
           result[class_name] = { error: e.message, file: candidate[:file], table_name: table }.compact
         end
+        tag_tenancy(models)
       end
 
       private
 
+      # Apartment keeps an excluded model, and an STI subclass sharing its table, in the
+      # shared schema; every other ActiveRecord model has a table in each tenant's schema.
+      def tag_tenancy(models)
+        config = ApartmentConfig.read(app.root) or return models
+        excluded = config[:excluded_models]
+        models.each do |name, data|
+          next if data[:error] || data[:mongoid]
+
+          scope = if excluded.nil? then "unknown"
+          elsif apartment_shared?(name, models, excluded) then "shared"
+          else "per_tenant"
+          end
+          data[:tenancy] = { gem: "apartment", scope: scope, declared_in: config[:file], excluded_models: config[:excluded_models_source] }.compact
+        end
+      end
+
+      def apartment_shared?(name, models, excluded, seen = [])
+        return true if excluded.include?(name)
+        return false if seen.include?(name)
+
+        parent = models.dig(name, :sti, :sti_parent)
+        parent ? apartment_shared?(parent, models, excluded, seen + [ name ]) : false
+      end
+
       # The same shape the booted tier reports under :sti, off the chain the
-      # static tier already resolves to share the base's table. A model that
-      # inherits from another model IS the STI relation, so no type column has
-      # to be read to name it.
+      # static tier already resolves to share the base's table. The caller
+      # drops it when the schema shows that table has no type column.
       def static_sti_info(class_name, sti_parents)
         parent = sti_parents[class_name]
         children = sti_parents.select { |_name, other_parent| other_parent == class_name }.keys.sort
@@ -144,6 +169,18 @@ module RailsAiContext
         }.compact
       end
 
+      # Rails runs no STI on a table without the type column; a table the dump does not hold is not known to lack it.
+      def lacks_column?(table, column)
+        reader = SchemaReader.for(app.root)
+        reader.tables.key?(table) && column != RailsAiContext::Confidence::INFERRED && !reader.column?(table, column)
+      end
+
+      # Rails' default column, the literal a class sets, or nil where `inheritance_column = nil` turns STI off.
+      def static_type_column(source_data)
+        setting = Array(source_data[:macros]).select { |m| m[:macro] == :model_setting && m[:setting] == "inheritance_column" }.last
+        setting ? setting[:literal].presence : "type"
+      end
+
       # A model file the app cannot load leaves its class out of reflection,
       # and leaving it out here answers that the model does not exist and that
       # its table has no model at all. The file is a fact the source walk
@@ -155,6 +192,9 @@ module RailsAiContext
         candidates = static_candidates
         @unloadable.each_with_object({}) do |(class_name, error), entries|
           candidate = candidates[class_name]
+          # Other roots hold generators and gem subclasses too; static lists one only as a model.
+          next if @outside_model_dirs&.include?(class_name) && !static_model?(class_name, candidates)
+
           entries[class_name] = {
             error: error,
             file: candidate&.dig(:file),
@@ -172,7 +212,7 @@ module RailsAiContext
       # process cannot stat is an error entry rather than one that quietly
       # is not there. The count is an answer too.
       def static_candidates
-        SourceScan.paths(app.root, kind: "app/models", skip_concerns: false).each_with_object({}) do |record, found|
+        SourceScan.model_paths(app.root).each_with_object({}) do |record, found|
           begin
             source = model_source(record.path) if File.size(record.path) <= RailsAiContext.configuration.max_file_size
             if source.nil?
@@ -182,7 +222,7 @@ module RailsAiContext
 
             next if mixin_path?(record.path_name.underscore, source)
 
-            declarations = DeclaredConstant.declarations(source)
+            declarations = DeclaredConstant.declarations(source, path_name: record.path_name)
             declaration = DeclaredConstant.declaration_for(declarations, record.path_name)
             class_name = declaration&.name || record.path_name
             # Two files can declare one class (an app reopening a model to add methods);
@@ -197,6 +237,7 @@ module RailsAiContext
               path: record.path,
               file: record.file,
               superclass: declaration&.superclass,
+              superclass_nesting: declaration&.nesting,
               abstract: abstract_class?(source)
             }.merge(TableName.declarations(source, class_name, app.root))
           rescue => e
@@ -244,6 +285,10 @@ module RailsAiContext
         end
       end
 
+      def static_model?(class_name, candidates)
+        candidates.key?(class_name) && !candidates.dig(class_name, :abstract) && model_class?(class_name, candidates)
+      end
+
       def model_class?(class_name, candidates, seen = [])
         return false if seen.include?(class_name)
         # A base under app/models that nobody can read is taken at its word:
@@ -271,7 +316,8 @@ module RailsAiContext
       # so `Admin::Report < Post` means the top-level Post unless Admin
       # declares one.
       def resolve_superclass(name, from, candidates)
-        SuperclassChain.resolve_in_scope(from, name) { |qualified| qualified if candidates.key?(qualified) }
+        nesting = candidates.dig(from, :superclass_nesting)
+        SuperclassChain.resolve_in_scope(from, name, nesting: nesting) { |qualified| qualified if candidates.key?(qualified) }
       end
 
       # Rails' own order: what the class assigns itself wins, an STI child
@@ -290,10 +336,43 @@ module RailsAiContext
 
         [ namespace_affix(class_name, candidates, :table_name_prefix),
           contained_prefix(class_name, candidates, seen),
-          TableName.stem(candidate[:path]),
+          TableName.stem(candidate[:path], pluralize_tables?(class_name, candidates)),
           namespace_affix(class_name, candidates, :table_name_suffix) ].join
       end
 
+      # A key the class does not assign is read through a new connection, which an
+      # unreachable host can hold for a full connect timeout per model; unconnected, read the source.
+      def model_primary_key(model)
+        return model.primary_key if model.connected?
+
+        base = model.respond_to?(:base_class) ? model.base_class : model
+        path = model_source_path(base)
+        path && TableName.declarations(model_source(path), base.name, app.root)[:primary_key]
+      rescue StandardError => e
+        RailsAiContext.debug_fail(e, nil, label: "model_primary_key")
+      end
+
+      # Rails reads an STI child's key off its base class; an abstract base's assignment reaches no model.
+      def resolve_primary_key(class_name, candidates, seen = [])
+        own = candidates.dig(class_name, :primary_key)
+        return own if own
+
+        parent = sti_parent(class_name, candidates, seen)
+        parent && resolve_primary_key(parent, candidates, seen + [ class_name ])
+      end
+
+      # A class attribute: the class's own assignment, else its superclass chain's, else the app's.
+      def pluralize_tables?(class_name, candidates, seen = [])
+        own = candidates.dig(class_name, :pluralize_table_names)
+        return own unless own.nil?
+
+        parent = candidates.dig(class_name, :superclass)
+        resolved = parent && !seen.include?(class_name) && resolve_superclass(parent, class_name, candidates)
+        return pluralize_tables?(resolved, candidates, seen + [ class_name ]) if resolved && candidates.key?(resolved)
+
+        ActiveRecordSettings.for(app.root)[:pluralize_table_names] != false
+      end
+
       # compute_table_name (7.0 and 8.1): a class nested in a concrete model
       # takes that model's singular table as a prefix (Project::Phase, project_phases).
       def contained_prefix(class_name, candidates, seen)
@@ -302,7 +381,9 @@ module RailsAiContext
         return "" unless model_class?(parent, candidates)
 
         table = resolve_table_name(parent, candidates, seen + [ class_name ])
-        table.to_s.empty? ? "" : "#{table.singularize}_"
+        return "" if table.to_s.empty?
+
+        "#{pluralize_tables?(parent, candidates) ? table.singularize : table}_"
       end
 
       # Every class this one inherits declarations from: the superclass chain
@@ -383,7 +464,7 @@ module RailsAiContext
 
           scope.pop
         end
-        candidates.dig(class_name, key) || TableName.app_affixes(app.root)[key] || ""
+        candidates.dig(class_name, key) || ActiveRecordSettings.for(app.root)[key] || ""
       end
 
       def isolated_prefixes
@@ -411,7 +492,7 @@ module RailsAiContext
         return false unless segments.include?("concerns")
         return true if segments.first == "concerns"
 
-        !DeclaredConstant.declares_class?(source)
+        !DeclaredConstant.declares_class?(source, path_name: relative.camelize)
       end
 
       # A class whose file is inside an installed gem (PaperTrail::Version) is
@@ -426,24 +507,13 @@ module RailsAiContext
         location = Object.const_source_location(model.name)&.first
         return false unless location
 
-        root = "#{app.root}#{File::SEPARATOR}"
-        Gem.loaded_specs.each_value.any? do |spec|
-          dir = "#{spec.full_gem_path}#{File::SEPARATOR}"
-          location.start_with?(dir) && !app_owned_gem?(spec, dir, root)
-        end
+        PortablePath.gem_file?(location, app.root)
       rescue NameError, ArgumentError, TypeError
         false
       end
 
-      # A `path:` gem kept in the repo, or a gem the app sits inside (an
-      # engine's dummy app). A bundle installed under the root (vendor/bundle)
-      # is still the gems' own.
-      def app_owned_gem?(spec, dir, root)
-        return true if root.start_with?(dir)
-        return false unless dir.start_with?(root) && defined?(Bundler::Source::Path)
-
-        source = spec.respond_to?(:source) ? spec.source : nil
-        source.is_a?(Bundler::Source::Path) && !source.is_a?(Bundler::Source::Git)
+      def model_dir_file?(path)
+        PathResolver.model_dirs(app.root).any? { |dir| SafePath.contained?(path, PathResolver.root_key(dir)) }
       end
 
       def discover_models
@@ -458,12 +528,13 @@ module RailsAiContext
         end
 
         known = models.map(&:name).to_set
+        @outside_model_dirs = Set.new
         # Concerns stay in: a nested concerns directory is a namespace, so a
         # class declared under one is a model and constantize sorts the mixins
         # out. A top-level `app/models/concerns` is an autoload root instead,
         # so its files declare no `Concerns::` prefix and that path name never
         # constantizes.
-        SourceScan.paths(app.root, kind: "app/models", skip_concerns: false).each do |record|
+        SourceScan.model_paths(app.root, base_model: model_base_check).each do |record|
           next if record.path_name.start_with?("Concerns::")
           next if known.include?(record.path_name)
           next if config.excluded_models.include?(record.path_name)
@@ -471,9 +542,10 @@ module RailsAiContext
           # The path does not name the class: an app inflection only changes
           # case, so activitypub/activity.rb camelizes to a constant the app
           # does not have and the file was listed as a model that will not
-          # load. Read only where the camelized name is not already loaded, so
+          # load. A root pushed under a namespace declares a prefix the path
+          # lacks. Read only where the camelized name is not already loaded, so
           # a booted run does not parse every model file to learn nothing.
-          class_name = DeclaredConstant.resolve(model_source(record.path).to_s, record.path_name)
+          class_name = DeclaredConstant.named(model_source(record.path).to_s, record.path_name)
           next if known.include?(class_name)
           next if config.excluded_models.include?(class_name)
 
@@ -487,6 +559,7 @@ module RailsAiContext
             # its name is recorded: a file that exists for a class reflection
             # lacks is not the same answer as no such model.
             @unloadable[class_name] = e.message.to_s.lines.first.to_s.strip
+            @outside_model_dirs << class_name unless model_dir_file?(record.path)
           end
         end
 
@@ -501,9 +574,10 @@ module RailsAiContext
         # and the superclasses are merged here too, or the static tier
         # out-answers this one.
         bases = booted_declaring_bases(model)
-        calls = class_calls([ model_source_path(model), *bases.map(&:last) ])
+        calls = singleton_lookup([ [ model.name, model_source_path(model) ], *bases ])
         source_data, unread, bases_unread, hidden =
-          merge_class_and_bases(own_source, model.name, calls, bases, file: model_source_path(model))
+          merge_class_and_bases(own_source, model.name, calls, bases, file: model_source_path(model),
+                                commits_in_order: booted_commits_in_order)
 
         class_methods = extract_class_methods_from_ast(model, source_data)
         instance_methods = extract_instance_methods_from_ast(model, source_data)
@@ -512,12 +586,14 @@ module RailsAiContext
         # reflection's own list is inflated by an attribute method per column
         # as soon as anything instantiates the model.
         source_instance_methods = own_source_methods(model, source_data)
+        concerns = booted_concerns(model, source_data[:mixins])
 
         details = {
           table_name:       model.table_name,
+          primary_key:      model_primary_key(model),
           file:             relative_to_root(model_source_path(model)),
           # Reflection-based (runtime, most accurate for these)
-          associations:     extract_associations(model),
+          associations:     extract_associations(model, source_data),
           # Reflection has no text for a Proc condition and names `validates_with` by kind only,
           # so the list is read off the source; an unreadable file falls back to reflection.
           validations:      booted_validations(model, source_data),
@@ -526,8 +602,8 @@ module RailsAiContext
           # hold no block callbacks, so both tiers read the model's source.
           callbacks:        group_callbacks_by_type(source_data[:callbacks]),
           callback_conditions: callback_conditions(source_data[:callbacks]),
-          concerns:         booted_concerns(model),
-          concern_sources:  concern_sources(booted_concerns(model), source_data[:mixins], booted: true),
+          concerns:         concerns,
+          concern_sources:  concern_sources(concerns, source_data[:mixins], booted: true),
           concerns_hidden:  (hidden.size if hidden.any?),
           concern_callbacks: concern_callbacks(source_data[:callbacks]),
           concerns_unread:  (unread if unread.any?),
@@ -537,7 +613,9 @@ module RailsAiContext
           # AST-based (replaces regex source parsing)
           custom_validates: extract_custom_validates_from_ast(source_data),
           custom_validate_conditions: custom_validate_conditions(source_data),
+          custom_validate_blocks: custom_validate_blocks(source_data),
           scopes:           extract_scopes_from_ast(source_data),
+          default_scopes:   default_scopes(source_data),
           class_methods:    class_methods.first(PAYLOAD_METHOD_CAP),
           class_method_count: class_methods.size,
           instance_methods: instance_methods.first(PAYLOAD_METHOD_CAP),
@@ -547,6 +625,7 @@ module RailsAiContext
 
         sti_info = extract_sti_info(model)
         details[:sti] = sti_info if sti_info
+
         parent = model.superclass
         details[:parent_model] = parent.name if parent < ActiveRecord::Base && !parent.abstract_class?
 
@@ -561,6 +640,7 @@ module RailsAiContext
         # AST-based detailed macros (replaces regex)
         detailed = extract_detailed_macros_from_ast(source_data)
         details.merge!(detailed)
+        details[:ignored_columns] = model.ignored_columns.map(&:to_s).presence
 
         details.compact
       end
@@ -659,8 +739,7 @@ module RailsAiContext
           AstWalk.each(AstCache.parse_string(source).value) do |node|
             next unless node.is_a?(Prism::CallNode) && node.receiver.is_a?(Prism::SelfNode)
 
-            setting = required_default_literal(node)
-            return setting unless setting.nil?
+            return setting_value(node) if node.name == :belongs_to_required_by_default=
           end
         end
         nil
@@ -708,67 +787,79 @@ module RailsAiContext
         validator.kind == :presence && validator.options[:message] == :required
       end
 
-      # Rails' rule: an explicit optional: wins, then required:, then the app's
-      # default. An option the source cannot evaluate makes it conditional.
+      # Rails' rule: a required: key sets optional: to its negation, then a nil
+      # optional: means the app's default. An unevaluable option makes it conditional.
       def static_required_belongs_to(associations, default = belongs_to_required_by_default?)
         Array(associations).select { |a| a.is_a?(Hash) && a[:type].to_s == "belongs_to" }.filter_map do |a|
           name = a[:name].to_s
-          optional_value = a.key?(:optional) ? a[:optional] : a.dig(:options, :optional)
-          required_value = a.dig(:options, :required)
-          optional = literal_boolean(optional_value)
-          required = literal_boolean(required_value)
-          if !optional.nil? then (name unless optional)
-          elsif !optional_value.nil? then [ name, "optional: #{optional_value} is false" ]
-          elsif !required.nil? then (name if required)
-          elsif !required_value.nil? then [ name, "required: #{required_value} is true" ]
+          options = a[:options] || {}
+          optional_value = a.key?(:optional) ? a[:optional] : options[:optional]
+          if options.key?(:required)
+            required = literal_boolean(options[:required])
+            required.nil? ? [ name, "required: #{options[:required]} is true" ] : (name if required)
+          elsif !optional_value.nil?
+            optional = literal_boolean(optional_value)
+            optional.nil? ? [ name, "optional: #{optional_value} is false" ] : (name unless optional)
+          elsif default.is_a?(String) then [ name, default ]
           elsif default then name
           end
         end
       end
 
       def literal_boolean(value)
-        { true => true, false => false, "true" => true, "false" => false }[value]
+        { true => true, false => false, nil => false, "true" => true, "false" => false }[value]
       end
 
-      # The last `belongs_to_required_by_default =` Rails would run, from
-      # config/application.rb then each initializer in load order, on any
-      # receiver (`config.active_record`, `ActiveRecord::Base`); without one,
-      # Rails turns it on from `load_defaults 5.0`.
+      # Without a `belongs_to_required_by_default =` of its own, Rails turns it
+      # on from `load_defaults 5.0`. True, false, or the condition it holds under.
       def belongs_to_required_by_default?
-        return @belongs_to_required if defined?(@belongs_to_required)
-
-        root = app.root.to_s
-        paths = [ File.join(root, "config", "application.rb"),
-                  *Dir.glob(File.join(root, "config", "initializers", "**", "*.rb")).sort ]
-        setting = nil
-        version = nil
-        paths.each do |path|
-          source = SafeFile.read(path) or next
-          AstWalk.each(AstCache.parse_string(source).value) do |node|
-            next unless node.is_a?(Prism::CallNode)
-
-            if node.name == :belongs_to_required_by_default= && node.receiver
-              literal = required_default_literal(node)
-              setting = literal unless literal.nil?
-            elsif node.name == :load_defaults && path.end_with?("application.rb") && node.receiver&.slice.to_s == "config"
-              version = defaults_version(node.arguments&.arguments&.first)
+        setting = framework_setting(:belongs_to_required_by_default=, since: 5.0)
+        setting.assigned ? setting.value : setting.version.to_f >= 5.0
+      end
+
+      # `value` is the deciding assignment's setting_value when `assigned`;
+      # else `load_defaults`' `version` decides.
+      FrameworkSetting = Struct.new(:assigned, :value, :version, :read, keyword_init: true)
+
+      # Application.rb then the initializers, as Rails runs them; a `load_defaults`
+      # of version `since` or later assigns the setting too, and the last line wins.
+      def framework_setting(setter, since:)
+        @framework_settings ||= {}
+        @framework_settings[setter] ||= begin
+          root = app.root.to_s
+          application = File.join(root, "config", "application.rb")
+          setting = FrameworkSetting.new(assigned: false, read: false)
+          [ application, *PathResolver.initializer_paths(root) ].each do |path|
+            source = SafeFile.read(path) or next
+            setting.read ||= path == application
+            AstWalk.each(AstCache.parse_string(source).value) do |node|
+              next unless node.is_a?(Prism::CallNode)
+
+              if node.name == setter && node.receiver
+                setting.assigned = true
+                setting.value = setting_value(node)
+              elsif node.name == :load_defaults && path == application && node.receiver&.slice.to_s == "config"
+                setting.version = defaults_version(node.arguments&.arguments&.first)
+                setting.assigned = false if setting.version.to_f >= since
+              end
             end
           end
+          setting
         end
-        @belongs_to_required = setting.nil? ? version.to_f >= 5.0 : setting
       end
 
-      # The true or false a `belongs_to_required_by_default =` call assigns;
-      # nil for another call or a value the source cannot evaluate.
-      def required_default_literal(node)
-        return nil unless node.name == :belongs_to_required_by_default=
-
+      # A literal true, false or nil (false, as Rails tests for truth) as itself;
+      # any other value reads as the condition "<setting> = <expression> is true".
+      def setting_value(node)
         value = node.arguments&.arguments&.first
-        { Prism::TrueNode => true, Prism::FalseNode => false }[value.class]
+        literal = { Prism::TrueNode => true, Prism::FalseNode => false, Prism::NilNode => false }[value.class]
+        return literal unless literal.nil? && value
+
+        "#{node.name.to_s.delete_suffix('=')} = #{value.slice} is true"
       end
 
-      # A literal version as written; anything else (`Rails::VERSION::STRING.to_f`)
-      # is the running Rails, which is past 5.0.
+      # A literal version as written; anything else (`Rails::VERSION::STRING.to_f`) is the
+      # running Rails, Float::INFINITY: on for belongs_to, unknown for the commit order.
       def defaults_version(arg)
         case arg
         when Prism::FloatNode, Prism::IntegerNode then arg.value.to_f
@@ -782,11 +873,31 @@ module RailsAiContext
       # ActiveRecord::Base's chain, which is what a gem (or an initializer)
       # puts into all models. A module a gem macro includes into this model
       # alone (`devise :lockable`) stays.
-      def booted_concerns(model)
-        own = (model.ancestors - every_model_modules).reject { |mod| mod.is_a?(Class) }.filter_map(&:name).reverse
+      def booted_concerns(model, mixins = [])
+        own = (model.ancestors - every_model_modules - base_gem_modules(model, mixins)).reject { |mod| mod.is_a?(Class) }.filter_map(&:name).reverse
         ConcernMembership.payload(own)
       end
 
+      # A module a gem's inherited hook mixes into every model (Kaminari) is left out; one the app includes or defines stays.
+      def base_gem_modules(model, mixins)
+        written = ConcernMembership.from_mixins(mixins)
+        gem_bases(model).flat_map { |base| base.ancestors - every_model_modules }.uniq.select do |mod|
+          !mod.is_a?(Class) && mod.name && !written.include?(mod.name) && !ConcernPaths.find_file(app.root.to_s, mod.name)
+        end
+      end
+
+      def abstract_bases(model)
+        model.ancestors.select { |klass| klass.is_a?(Class) && klass < ActiveRecord::Base && klass != model && klass.abstract_class? }
+      end
+
+      # The app's bases a gem's inherited hook reaches as it reaches the model (Kaminari: each direct ActiveRecord::Base child).
+      def gem_bases(model)
+        bases = abstract_bases(model)
+        return bases unless model.superclass == ActiveRecord::Base
+
+        bases | ActiveRecord::Base.subclasses.select { |klass| klass.name && klass.abstract_class? }
+      end
+
       def every_model_modules
         @every_model_modules ||= ActiveRecord::Base.ancestors
       end
@@ -824,15 +935,32 @@ module RailsAiContext
 
       # ── Reflection-based extraction (unchanged) ─────────────────────
 
-      def extract_associations(model)
+      def extract_associations(model, source_data = empty_source_data)
+        declared = Array(source_data[:associations]).group_by { |a| [ a[:type].to_s, a[:name].to_s ] }
         # The reject stays ahead of the map: class_name/foreign_key on an
         # excluded reflection with a broken :through raises, and `call`'s
         # per-model rescue would replace the whole model with one error line.
         model.reflect_on_all_associations.reject { |assoc| excluded_association?(assoc.name) }.map do |assoc|
-          association_detail(assoc)
+          with_declared_options(association_detail(assoc), declared[[ assoc.macro.to_s, assoc.name.to_s ]]&.first, model)
         end
       end
 
+      # Only what the source declares, so both tiers print one spelling; a gem
+      # macro's generated association carries Rails' options, not the app's.
+      def with_declared_options(detail, source, model = nil)
+        options = declared_association_options(detail[:type], source&.dig(:options))
+        extensions = source&.dig(:extension_methods)
+        delegated = source&.dig(:delegated_types)
+        unread = source&.dig(:delegated_types_source)
+        # delegated_type defines `<role>_types`, which answers a list the source names only as an expression.
+        if unread && model.respond_to?(reader = :"#{detail[:name]}_types")
+          delegated = Array(model.public_send(reader)).map(&:to_s).presence
+          unread = nil if delegated
+        end
+        detail.merge({ declared_options: options, extension_methods: extensions, delegated_types: delegated,
+                       delegated_types_source: unread }.compact)
+      end
+
       # One reflection that cannot resolve costs that reflection, not the
       # model. `class_name` on a `:through` whose through association does not
       # exist ends in `nil.klass`, and the per-model rescue in `call` then
@@ -908,10 +1036,11 @@ module RailsAiContext
       end
 
       def extract_sti_info(model)
+        type_column = model.inheritance_column.to_s
         has_type_column = if model.connected? && model.table_exists?
-          model.columns_hash.key?("type")
+          model.columns_hash.key?(type_column)
         else
-          SchemaReader.for(app.root).column?(model.table_name, "type")
+          SchemaReader.for(app.root).column?(model.table_name, type_column)
         end
 
         return nil unless has_type_column
@@ -933,7 +1062,8 @@ module RailsAiContext
         {
           sti_base: sti_parent.nil? && children.any?,
           sti_parent: sti_parent,
-          sti_children: children.empty? ? nil : children
+          sti_children: children.empty? ? nil : children,
+          type_column: type_column
         }.compact
       rescue => e
         RailsAiContext.debug_fail(e, nil, label: "extract_sti_info")
@@ -942,7 +1072,7 @@ module RailsAiContext
       # ── AST-based extraction (replaces all regex parsing) ──────────
 
       def extract_scopes_from_ast(source_data)
-        source_data[:scopes].map do |s|
+        source_data[:scopes].reject { |s| s[:default] }.map do |s|
           {
             name: s[:name],
             body: s[:body],
@@ -952,12 +1082,26 @@ module RailsAiContext
         end
       end
 
+      # Base first, as Rails stacks them; each one filters every query.
+      def default_scopes(source_data)
+        found = Array(source_data[:scopes]).select { |s| s[:default] }.map { |s| s.slice(:body, :all_queries, :confidence) }
+        found.presence
+      end
+
       def extract_custom_validates_from_ast(source_data)
         source_data[:validations]
           .select { |v| v[:kind] == "custom" }
           .flat_map { |v| v[:attributes] }
       end
 
+      # A validate block is listed by what it runs; Rails registers it next to any methods named.
+      def custom_validate_blocks(source_data)
+        found = Array(source_data[:validations]).select { |v| v[:kind] == "custom" && v[:block] }.map do |v|
+          { body: v[:block], conditions: (v[:options] || {}).slice(*CONDITION_KEYS, :on).presence }.compact
+        end
+        found.presence
+      end
+
       # `validate :check, on: :create` runs only then; the method name alone
       # reads as a rule that always holds.
       def custom_validate_conditions(source_data)
@@ -968,26 +1112,28 @@ module RailsAiContext
         found.presence
       end
 
+      # The options that decide the value a new record holds and the names of
+      # the methods the enum defines.
       def extract_enum_options_from_ast(source_data)
-        source_data[:enums].each_with_object({}) do |enum, opts|
-          entry = {}
-          entry[:prefix] = enum[:options][:prefix] || enum[:options][:_prefix] if enum[:options][:prefix] || enum[:options][:_prefix]
-          entry[:suffix] = enum[:options][:suffix] || enum[:options][:_suffix] if enum[:options][:suffix] || enum[:options][:_suffix]
-          opts[enum[:name]] = entry if entry.any?
+        Array(source_data[:enums]).each_with_object({}) do |enum, opts|
+          options = enum[:options] || {}
+          entry = %i[prefix suffix default].to_h { |key| [ key, options.fetch(key) { options[:"_#{key}"] } ] }
+          entry.reject! { |_, value| value.nil? || value == false }
+          opts[enum[:name].to_s] = entry if entry.any?
         end
       end
 
       CONDITION_KEYS = %i[if unless].freeze
 
-      # One conditions entry per callback occurrence, in step with the name list: a model can
-      # declare one method twice under different conditions.
+      # One conditions entry per callback, in step with the name list: one method can sit under
+      # two types with different conditions.
       def callback_conditions(callbacks)
         Array(callbacks).each_with_object({}) do |cb, hash|
           next unless cb.is_a?(Hash) && cb[:type]
 
-          # A plain after_commit carries the events its one declaration names.
-          keys = cb[:type].to_s == "after_commit" ? CONDITION_KEYS + [ :on ] : CONDITION_KEYS
-          conditions = (cb[:options] || {}).slice(*keys)
+          options = cb[:options] || {}
+          conditions = options.select { |key, _| CONDITION_KEYS.include?(key) }
+          conditions = { on: options[:on] }.merge(conditions) if options.key?(:on) && !Listeners::CallbacksListener.names_event?(cb[:type])
           (hash[cb[:type].to_s] ||= []) << (conditions.empty? ? nil : conditions)
         end.reject { |_, list| list.none? }
       end
@@ -1018,7 +1164,10 @@ module RailsAiContext
           .reject { |m| scope_names.include?(m) }
 
         # Reflection-discovered class methods (for completeness)
-        all_methods = (model.methods - ActiveRecord::Base.methods - Object.methods)
+        # The abstract bases' class methods reach every model, the static tier reads none of
+        # them, and a gem's (Kaminari's `page`) would otherwise be listed on each model.
+        base_methods = gem_bases(model).flat_map(&:methods)
+        all_methods = (model.methods - ActiveRecord::Base.methods - Object.methods - base_methods)
           .reject { |m|
             ms = m.to_s
             ms == "self" ||
@@ -1073,12 +1222,11 @@ module RailsAiContext
         has_rich_text: :has_rich_text,
         generates_token_for: :generates_token_for,
         serialize: :serialize,
-        store: :store,
-        store_accessor: :store
+        has_secure_token: :has_secure_token,
+        attr_readonly: :attr_readonly,
+        query_constraints: :query_constraints
       }.freeze
 
-      BROADCAST_MACROS = %i[broadcasts broadcasts_to broadcasts_refreshes_to].to_set.freeze
-
       def extract_macros_from_ast(source_data, source_path = nil)
         macros = {}
         source_data[:macros].each do |m|
@@ -1086,17 +1234,36 @@ module RailsAiContext
 
           if macro == :has_secure_password
             macros[:has_secure_password] = true
+            (macros[:secure_passwords] ||= []) << { attribute: m[:attribute], options: m[:written] || {} }
           elsif (key = ATTRIBUTE_MACRO_MAP[macro])
             (macros[key] ||= []) << m[:attribute]
+            (macros[:serialize_options] ||= {})[m[:attribute]] = m[:written] if macro == :serialize && m[:written]&.any?
+          elsif Listeners::MacrosListener::STORE_MACROS.include?(macro)
+            add_store_accessors(macros, m)
+          elsif macro == :accepts_nested_attributes_for
+            (macros[:nested_attributes] ||= []) << { names: m[:names], options: m[:options] }.compact
+          elsif macro == :ignored_columns
+            macros[:ignored_columns] = apply_ignored_columns(macros[:ignored_columns] || [], m)
           elsif macro == :delegate
-            (macros[:delegations] ||= []) << { methods: m[:methods], to: m[:to] }
+            (macros[:delegations] ||= []) << delegation_entry(m)
           elsif macro == :delegate_missing_to
             macros[:delegate_missing_to] = m[:to]
           elsif macro == :attribute
-            (macros[:attributes] ||= []) << { name: m[:attribute], type: m[:type] }.compact
+            (macros[:attributes] ||= []) << { name: m[:attribute], type: m[:type], default: m.dig(:options, :default) }.compact
+          elsif macro == :alias_attribute
+            (macros[:alias_attributes] ||= []) << { name: m[:attribute], target: m[:target] }
+          elsif macro == :model_setting
+            # Bases arrive first, so the class's own assignment wins.
+            (macros[:model_settings] ||= {})[m[:setting]] = m[:value]
+          elsif macro == :connects_to
+            macros[:database] = { connects_to: m[:text], condition: m[:condition], declared_in: m[:declared_in], writing: m[:writing] }.compact
+          elsif macro == :gem_macro
+            (macros[:gem_macros] ||= []) << m.slice(:text, :adds)
+          elsif macro == :aasm
+            (macros[:state_machines] ||= []) << m.slice(:column, :initial, :states, :events)
           end
 
-          if BROADCAST_MACROS.include?(macro)
+          if Listeners::MacrosListener::BROADCAST_MACROS.include?(macro)
             (macros[:broadcasts] ||= []) << macro.to_s
             macros[:broadcasts].uniq!
           end
@@ -1108,6 +1275,59 @@ module RailsAiContext
         macros.reject { |_, v| v.is_a?(Array) && v.empty? }
       end
 
+      # Declarations arrive bases first, so `=` replaces what a base set and
+      # `+=` adds to it; a list the source computes cannot be read.
+      def apply_ignored_columns(current, macro)
+        return [ RailsAiContext::Confidence::INFERRED ] if macro[:columns].nil? || current.include?(RailsAiContext::Confidence::INFERRED)
+
+        case macro[:op]
+        when :assign then macro[:columns].uniq
+        when :add then (current + macro[:columns]).uniq
+        else current - macro[:columns]
+        end
+      end
+
+      # Rails names a store accessor "#{prefix}_#{key}_#{suffix}", where true
+      # stands for the column name (ActiveRecord::Store.store_accessor).
+      def add_store_accessors(macros, macro)
+        column = macro[:attribute]
+        (macros[:store] ||= []) << column unless macros[:store]&.include?(column)
+        keys = macro[:keys] || []
+        return if keys.empty?
+
+        options = macro[:options] || {}
+        accessors = (macros[:store_accessors] ||= {})[column] ||= []
+        affixes = options.values_at(:prefix, :suffix)
+        if affixes.include?(RailsAiContext::Confidence::INFERRED)
+          accessors << RailsAiContext::Confidence::INFERRED unless accessors.include?(RailsAiContext::Confidence::INFERRED)
+          return
+        end
+
+        prefix, suffix = affixes.map { |affix| affix == true ? column : (affix.is_a?(Symbol) || affix.is_a?(String) ? affix : nil) }
+        keys.each do |key|
+          name = [ prefix, key, suffix ].compact.join("_")
+          accessors << name unless accessors.include?(name)
+        end
+      end
+
+      # ActiveSupport names a prefixed delegate "#{prefix == true ? to : prefix}_#{method}".
+      def delegation_entry(macro)
+        options = macro[:options] || {}
+        entry = { methods: macro[:methods], to: macro[:to] }
+        entry[:private] = true if options[:private] == true
+        prefix = options[:prefix]
+        case prefix
+        when true, Symbol, String
+          if prefix == RailsAiContext::Confidence::INFERRED
+            entry[:prefix_computed] = true
+          else
+            head = prefix == true ? macro[:to] : prefix
+            entry[:defines] = macro[:methods].map { |name| "#{head}_#{name}" } if head
+          end
+        end
+        entry
+      end
+
       # Extract constant definitions from source via AST.
       # Finds ConstantWriteNode where the value is an ArrayNode
       # (covers %w[], %i[], and literal array forms).
@@ -1128,9 +1348,7 @@ module RailsAiContext
           name = node.name.to_s
           # Only capture UPPER_CASE constants (matching the old regex behavior)
           if name.match?(/\A[A-Z][A-Z_]+\z/)
-            # Unwrap .freeze if present: STATUSES = %w[...].freeze
-            value_node = node.value
-            value_node = value_node.receiver if value_node.is_a?(Prism::CallNode) && value_node.name == :freeze
+            value_node = unwrap_frozen(node.value)
 
             if value_node.is_a?(Prism::ArrayNode)
               values = value_node.elements.filter_map { |el|
@@ -1147,25 +1365,37 @@ module RailsAiContext
         node.child_nodes.compact.each { |child| find_constant_arrays(child, constants) }
       end
 
+      # `%w[...].freeze` and `Ractor.make_shareable(%w[...])` are the array itself, frozen.
+      def unwrap_frozen(node)
+        loop do
+          break node unless node.is_a?(Prism::CallNode)
+
+          if node.name == :freeze && node.arguments.nil?
+            node = node.receiver
+          elsif node.name == :make_shareable && node.receiver&.slice&.delete_prefix("::") == "Ractor" && node.arguments&.arguments&.size == 1
+            node = node.arguments.arguments.first
+          else
+            break node
+          end
+        end
+      end
+
       def extract_detailed_macros_from_ast(source_data)
         encryption = []
         normalizations = []
         tokens = []
 
         source_data[:macros].each do |m|
+          written = m[:written] || {}
           case m[:macro]
           when :encrypts
-            opts = {}
-            opts[:deterministic] = true if m[:options][:deterministic] == true
-            opts[:downcase] = true if m[:options][:downcase] == true
-            encryption << { field: m[:attribute], options: opts }
+            encryption << { field: m[:attribute], options: written }
           when :normalizes
-            entry = { field: m[:attribute] }
-            entry[:transformation] = m[:options][:with].to_s if m[:options][:with]
+            entry = { field: m[:attribute], transformation: written[:with], options: written.except(:with).presence }
             normalizations << entry.compact
           when :generates_token_for
             entry = { purpose: m[:attribute] }
-            entry[:expires_in] = m[:options][:expires_in].to_s if m[:options][:expires_in]
+            entry[:expires_in] = written[:expires_in] if written[:expires_in]
             tokens << entry.compact
           end
         end
@@ -1275,6 +1505,31 @@ module RailsAiContext
       ].freeze
       BOOLEAN_ASSOCIATION_OPTIONS = %i[polymorphic optional].freeze
 
+      # What the record already says another way, or what Rails keeps for itself. A has_many's declared
+      # foreign key stays: its record carries reflection's default key too.
+      UNLISTED_ASSOCIATION_OPTIONS = [ *(LIFTED_ASSOCIATION_OPTIONS - [ :foreign_key ]), :anonymous_class ].freeze
+
+      # Every other option the association declares, each as display text:
+      # its callbacks, extensions, counter cache and the rest.
+      def declared_association_options(type, options)
+        return nil unless options.is_a?(Hash)
+
+        shown = options.except(*UNLISTED_ASSOCIATION_OPTIONS)
+        shown = shown.except(:required, :foreign_key, :query_constraints) if type.to_s == "belongs_to"
+        shown.to_h { |key, value| [ key.to_s, association_option_text(value) ] }.presence
+      end
+
+      def association_option_text(value)
+        case value
+        when Symbol then ":#{value}"
+        when Module then value.name.to_s
+        when Proc then "(proc)"
+        when Array then "[#{value.map { |v| association_option_text(v) }.join(', ')}]"
+        when Hash then "{ #{value.map { |k, v| "#{k}: #{association_option_text(v)}" }.join(', ')} }"
+        else value.to_s
+        end
+      end
+
       # A habtm join_table built from the class's affixes, as the table it names.
       def with_join_tables(associations, path, class_name)
         own = nil
@@ -1308,7 +1563,18 @@ module RailsAiContext
           else value.to_s
           end
         end
-        with_default_foreign_key(lifted)
+        lifted = with_rails_option_rules(lifted, options)
+        declared = declared_association_options(lifted[:type], options)
+        with_default_foreign_key(declared ? lifted.merge(declared_options: declared) : lifted)
+      end
+
+      # `required:` on a belongs_to sets `optional:` to its negation; Rails 7.1 takes `query_constraints:` as the foreign key.
+      def with_rails_option_rules(assoc, options)
+        required = literal_boolean(options[:required]) if options.key?(:required)
+        assoc = assoc.merge(optional: !required) if assoc[:type] == "belongs_to" && !required.nil?
+        keys = options[:query_constraints]
+        assoc = assoc.merge(foreign_key: keys.map(&:to_s)) if keys.is_a?(Array) && !assoc.key?(:foreign_key)
+        assoc
       end
 
       # Reflection answers a belongs_to's key when none is declared: the name plus _id.
@@ -1338,10 +1604,11 @@ module RailsAiContext
       end
 
       def static_model_details(path, class_name, file: relative_to_root(path), table_name: nil, inherited_from: [],
-                               sti: nil, parent_model: nil)
+                               sti: nil, parent_model: nil, primary_key: nil)
         own = own_body(source_walk(path), class_name)
-        calls = class_calls([ path, *Array(inherited_from).map(&:last) ])
-        data, unread, bases_unread, hidden = merge_class_and_bases(own, class_name, calls, inherited_from, file: path)
+        calls = singleton_lookup([ [ class_name, path ], *Array(inherited_from) ])
+        data, unread, bases_unread, hidden = merge_class_and_bases(own, class_name, calls, inherited_from, file: path,
+                                                                   commits_in_order: static_commits_in_order)
         own_methods = ActionResolver.own_methods(own[:methods], class_name)
         scope_names = Array(data[:scopes]).filter_map { |scope| scope[:name]&.to_s }.to_set
         static_instance_methods = own_methods.select { |m| m[:scope] == :instance && m[:visibility] == :public }.map { |m| m[:name].to_s }
@@ -1350,15 +1617,19 @@ module RailsAiContext
         details = {
           confidence: Confidence::STATIC,
           table_name: table_name || TableName.stem(path),
+          primary_key: primary_key,
           associations: with_join_tables(reject_excluded_associations(data[:associations]), path, class_name),
           validations: static_validations(data, [ path, *Array(inherited_from).map(&:last) ]),
           custom_validates: extract_custom_validates_from_ast(data),
           custom_validate_conditions: custom_validate_conditions(data),
-          scopes: data[:scopes],
+          custom_validate_blocks: custom_validate_blocks(data),
+          scopes: Array(data[:scopes]).reject { |s| s[:default] },
+          default_scopes: default_scopes(data),
           # The booted tier answers a Hash of attribute => value map, and
           # every renderer destructures one; the listener's records are a
           # different shape under the same key.
           enums: static_enums(data[:enums]),
+          enum_options: extract_enum_options_from_ast(data).presence,
           # Same shape as the booted tier: a Hash keyed by callback type. The
           # listener hands back a flat Array, and every consumer filters on
           # `callbacks.is_a?(Hash)` - so passing it through rendered "No models
@@ -1372,6 +1643,7 @@ module RailsAiContext
           concern_callbacks: concern_callbacks(data[:callbacks]),
           concerns_unread: (unread if unread.any?),
           bases_unread: (bases_unread if bases_unread.any?),
+          commit_order_unread: commit_order_unread(data[:callbacks]),
           conditional_declarations: declarations(data[:conditional]),
           foreign_declarations: declarations(data[:foreign]),
           macros: data[:macros],
@@ -1391,6 +1663,8 @@ module RailsAiContext
         }
         details.merge!(extract_macros_from_ast(data, path))
         details.merge!(extract_detailed_macros_from_ast(data))
+        type_column = static_type_column(data)
+        details[:sti] = sti && type_column && !lacks_column?(details[:table_name], type_column) ? sti.merge(type_column: type_column) : nil
         downgrade_records(details.compact)
       end
 
@@ -1400,6 +1674,9 @@ module RailsAiContext
       # associations, on that tier.
       MERGED_CONCERN_KEYS = %i[associations validations scopes enums callbacks macros].freeze
 
+      # The class's own declarations a method body can hold; MacrosListener skips method bodies itself.
+      METHOD_PLACED_KEYS = %i[validations associations scopes enums].freeze
+
       # The merged keys, plus what a mixin's macro methods declare only under a
       # condition the call cannot decide.
       WALKED_KEYS = [ *MERGED_CONCERN_KEYS, :conditional, :foreign ].freeze
@@ -1408,36 +1685,73 @@ module RailsAiContext
       # so on the booted tier an unread concern costs the other keys only.
       REFLECTED_CONCERN_KEYS = %i[associations validations enums].freeze
 
-      # The mixin names are in the same walk and their files are on disk, so
-      # the class's own declarations and its concerns' answer as one. Methods
-      # and mixins stay the model's own: those are its interface, not the
-      # sum of what it included.
-      # The modules mixed into every model from outside, and the app modules
-      # the class extends itself with: a macro method one of them defines is
-      # read where the class calls it. An extended module whose file is not the
-      # app's is a gem's, and a gem's macro methods are not read.
-      def class_extras(own, class_name)
-        extended = Array(own[:mixins]).filter_map do |mixin|
-          next unless mixin[:macro] == :extend && !mixin[:receiver]
-          next unless ConcernMembership.candidate?(mixin[:name])
-
-          path = ConcernPaths.find_file(app.root.to_s, mixin[:name], prefer: "model", within: class_name)
-          BaseMixins::Mixin.new(mixin[:name], path, :extend) if path
-        end
-        BaseMixins.models(app.root.to_s) + extended
+      # The walk only collects: where a declaration lands waits for every class's walk.
+      Walk = Struct.new(:own, :collected, :unread, :hidden, :skipped, :rank) do
+        def self.empty(own) = new(own, {}, [], [], Set.new, 0)
       end
 
-      def merge_concern_macros(own, class_name, calls = nil, extra: [], file: nil)
-        collected, unread, hidden, included, _placement, skipped = ConcernMacros.collect(
+      def walk_class(own, class_name, calls, extra: [], file: nil, rank: 0)
+        found = ConcernMacros.collect(
           app.root.to_s, own[:mixins] || [],
           keys: [ *WALKED_KEYS, :expanded ], prefer: "model", within: class_name,
           cache: @source_cache, calls: calls, extra: extra, file: file
         )
-        ConcernMacros::Run.merge_calls(calls.included, included) if calls.respond_to?(:included)
-        own = without_expanded_calls(own, collected.delete(:expanded))
-        return [ own, unread, hidden, skipped ] if collected.empty?
+        placement = found.placement
+        included_at = included_at(own, placement)
+        every = extra.map(&:name).to_set
+        bodies = method_bodies(own)
+        mixins = found.mixins.map do |label, macro, defs, in_module|
+          line, order = included_at.call(label)
+          added, line = in_module || [ ConcernMacros::SingletonLookup.added_in(rank, line, bodies), line ]
+          ConcernMacros::SingletonLookup::Mixin.new(label, macro, defs, added, [ line, order ], every.include?(placement.dig(label, 0)))
+        end
+        calls.add(rank, found.included_calls, found.block_sites, mixins)
+        Walk.new(own, found.collected, found.unread, found.hidden, found.skipped, rank)
+      end
 
-        [ merge_inherited(own, collected), unread, hidden, skipped ]
+      # Where a concern the walk read joins the class's chain: at the line
+      # including it, after the concerns that include brought in before it.
+      def included_at(own, placement)
+        line_of = Array(own[:mixins]).reverse.to_h { |mixin| [ mixin[:name], mixin[:location].to_i ] }
+        lambda do |name|
+          top, order = placement[name]
+          top ? [ line_of[top].to_i, order.to_i ] : [ 0, 0 ]
+        end
+      end
+
+      # A walk's declarations where Ruby runs them: one in a method body, the class's own or a
+      # module's, once per call running that body; a concern's where its code runs.
+      def settle(walk, calls, expanded = nil)
+        own, rank = walk.own, walk.rank
+        collected = walk.collected.to_h do |key, entries|
+          [ key, entries.flat_map { |entry| place(entry, rank, calls) }.then { |found| key == :callbacks ? found : found.map { |entry| entry.except(*CHAIN_KEYS) }.uniq } ]
+        end
+        own = without_expanded_calls(own, Array(collected.delete(:expanded)) + Array(expanded))
+        bodies = method_bodies(own)
+        callbacks = Array(own[:callbacks]).flat_map { |cb| placed_in_method(cb, bodies, rank, calls) || [ cb.merge(rank: rank) ] }
+        own = own.merge(callbacks: callbacks + Array(collected.delete(:callbacks)))
+        own = own.merge(METHOD_PLACED_KEYS.to_h { |key| [ key, Array(own[key]).select { |entry| (placed_in_method(entry, bodies, rank, calls) || [ entry ]).any? } ] })
+        [ collected.empty? ? own : merge_inherited(own, collected), walk.unread, walk.hidden ]
+      end
+
+      # Nil outside a method body; else where the calls running that method place the
+      # declaration, none for an instance method.
+      def placed_in_method(entry, bodies, rank, calls)
+        line = entry[:location] if entry.is_a?(Hash)
+        method = line && ConcernMacros.enclosing(bodies, line)&.last
+        # A `def self.default_scope` is the declaration itself, not a body holding one.
+        return nil if method.nil? || (method[:name] == entry[:name] && method[:location] == line)
+        return [] unless method[:scope] == :class
+
+        calls.placed(entry, [ rank, method[:location] ], [ line ])
+      end
+
+      def place(entry, rank, calls)
+        entry.is_a?(Hash) ? calls.mixed_in(entry, rank) : [ entry ]
+      end
+
+      def method_bodies(own)
+        Array(own[:methods]).filter_map { |m| [ m[:location]..m[:end_location], m ] if m[:location] && m[:end_location] }
       end
 
       # A `validates_translation :title` call the listener read as a validation
@@ -1457,33 +1771,133 @@ module RailsAiContext
       #
       # Each side is walked again only when the other has since learned a call
       # that releases something it held back.
-      def merge_class_and_bases(own, class_name, calls, bases, file:)
-        extra = class_extras(own, class_name)
-        mine = merge_concern_macros(own, class_name, calls, extra: extra, file: file)
+      def merge_class_and_bases(own, class_name, calls, bases, file:, commits_in_order:)
+        extra = BaseMixins.models(app.root.to_s)
+        mine = walk_class(own, class_name, calls, extra: extra, file: file)
         walked = walk_bases(bases, calls)
         ConcernMacros::MAX_DEPTH.times do
-          known = Set.new(calls.call.keys)
-          break unless mine.last.intersect?(known)
+          known = Set.new(calls.sites_by_name.keys)
+          break unless mine.skipped.intersect?(known)
 
-          mine = merge_concern_macros(own, class_name, calls, extra: extra, file: file)
-          held = walked.flat_map { |_name, base_own, *rest| base_own ? Array(rest.last).to_a : [] }.to_set
-          grown = Set.new(calls.call.keys) - known
+          mine = walk_class(own, class_name, calls, extra: extra, file: file)
+          held = walked.flat_map { |_name, walk| walk ? walk.skipped.to_a : [] }.to_set
+          grown = Set.new(calls.sites_by_name.keys) - known
           walked = walk_bases(bases, calls) if held.intersect?(grown)
         end
-        data, unread, hidden = mine
-        merge_inherited_macros(data, unread, hidden, walked)
+        declared = base_declarations(calls, [ [ class_name, file ], *bases ])
+        expanded = Array(declared.delete(:expanded)).group_by { |call| call[:rank] }
+        data, unread, hidden = settle(mine, calls, expanded[0])
+        data = merge_inherited(data, declared)
+        settled = walked.map { |name, walk| walk ? [ name, walk.own, *settle(walk, calls, expanded[walk.rank]) ] : [ name, nil ] }
+        data, *rest = merge_inherited_macros(data, unread, hidden, settled)
+        [ data.merge(callbacks: chain_order(data[:callbacks], commits_in_order)), *rest ]
+      end
+
+      CHAIN_KEYS = %i[rank chain_at hook owner].freeze
+
+      # What the class methods the app's base bodies give the class declare, at each call reaching them,
+      # with the calls read that way (`:expanded`) by the rank they stand at.
+      def base_declarations(calls, classes)
+        found = Hash.new { |hash, key| hash[key] = [] }
+        base_defs(classes).each do |node, definition|
+          next unless node.is_a?(Prism::DefNode)
+
+          sites = Array(calls.sites_by_name[definition.name]).compact
+          expansion, = ConcernMacros.expand_calls(node, sites, [ *WALKED_KEYS, :expanded ], SourceIntrospector::LISTENER_MAP) do |entry, site|
+            calls.placed(entry, definition.key, [ entry[:location] ], site)
+          end
+          expansion.each do |key, entries|
+            found[key].concat(%i[callbacks expanded].include?(key) ? entries : entries.map { |entry| entry.except(*CHAIN_KEYS) }.uniq)
+          end
+        end
+        found.to_h
+      end
+
+      # Rails builds the chain from the outermost base in, each class in the
+      # order its body runs.
+      def chain_order(callbacks, commits_in_order)
+        sorted = Array(callbacks).each_with_index.sort_by do |cb, index|
+          [ -cb[:rank].to_i, cb[:chain_at] || [ cb[:location].to_i, -1 ], index ]
+        end
+        run_order(callback_chain(without_skipped(sorted.map(&:first))), commits_in_order).map { |cb| cb.except(*CHAIN_KEYS) }
+      end
+
+      # A `skip_callback` removes the matching callback already in the chain;
+      # with `if:`/`unless:` Rails keeps it under the negated condition.
+      def without_skipped(callbacks)
+        callbacks.each_with_object([]) do |cb, kept|
+          next kept << cb unless cb[:skip]
+
+          key = Listeners::CallbacksListener.chain_key(cb[:type])
+          matching = ->(k) { Listeners::CallbacksListener.chain_key(k[:type]) == key && k[:method].to_s == cb[:method].to_s }
+          conditions = (cb[:options] || {}).slice(:if, :unless)
+          if conditions.empty?
+            kept.reject!(&matching)
+          else
+            kept.map! { |k| matching.call(k) ? k.merge(options: negated_conditions(k[:options] || {}, conditions)) : k }
+          end
+        end
+      end
+
+      def negated_conditions(options, skip)
+        flipped = { unless: skip[:if], if: skip[:unless] }.compact
+        options.merge(flipped) { |_key, ours, theirs| [ *Array(ours), theirs ] }
+      end
+
+      # A prepended callback goes to the front and after callbacks run from the
+      # back; ActiveModel prepends every after_*, after_commit only on request.
+      def run_order(callbacks, commits_in_order)
+        ordered = callbacks.dup
+        callbacks.each_index.group_by { |i| Listeners::CallbacksListener.chain_key(callbacks[i][:type]) }.each_value do |slots|
+          chain = slots.each_with_object([]) do |i, list|
+            prepended?(callbacks[i], commits_in_order) ? list.unshift(callbacks[i]) : list.push(callbacks[i])
+          end
+          chain.reverse! if Listeners::CallbacksListener.after?(callbacks[slots.first][:type])
+          slots.zip(chain) { |i, cb| ordered[i] = cb }
+        end
+        ordered
+      end
+
+      # An unknown setting keeps the transaction callbacks in declaration order.
+      def prepended?(callback, commits_in_order)
+        declared = callback.dig(:options, :prepend).to_s == "true"
+        return declared unless Listeners::CallbacksListener.after?(callback[:type])
+        return true unless Listeners::CallbacksListener.transaction?(callback[:type])
+
+        declared || commits_in_order != false
+      end
+
+      # Rails 7.0 has no setting and always runs them last declared first.
+      def booted_commits_in_order
+        ActiveRecord.respond_to?(:run_after_transaction_callbacks_in_order_defined) &&
+          ActiveRecord.run_after_transaction_callbacks_in_order_defined == true
+      end
+
+      # nil when the config cannot say: no config/application.rb, a version or
+      # a value that is not a literal. A chain order has no way to carry a condition.
+      def static_commits_in_order
+        setting = framework_setting(:run_after_transaction_callbacks_in_order_defined=, since: 7.1)
+        return (setting.value unless setting.value.is_a?(String)) if setting.assigned
+        return nil if !setting.read || setting.version == Float::INFINITY
+
+        setting.version.to_f >= 7.1
+      end
+
+      # Only a chain with two of them can be out of order.
+      def commit_order_unread(callbacks)
+        return nil unless static_commits_in_order.nil?
+
+        chains = Array(callbacks).select { |cb| Listeners::CallbacksListener.transaction?(cb[:type]) }.map { |cb| Listeners::CallbacksListener.chain_key(cb[:type]) }
+        true if chains.tally.values.any? { |count| count > 1 }
       end
 
       # Each base read with its concerns; a base's concern macro that sits in a
       # class method runs for the class that calls it, the child as often as
       # the base.
       def walk_bases(bases, calls)
-        Array(bases).map do |name, path|
+        Array(bases).each_with_index.map do |(name, path), index|
           own = sti_base_source(path)
-          next [ name, nil ] if own.nil?
-
-          own = own_body(own, name)
-          [ name, own, *merge_concern_macros(own, name, calls, file: path) ]
+          [ name, own && walk_class(own_body(own, name), name, calls, file: path, rank: index + 1) ]
         end
       end
 
@@ -1503,7 +1917,9 @@ module RailsAiContext
             next
           end
 
-          data = merge_inherited(data, base.slice(*WALKED_KEYS))
+          # A connection is declared on an abstract base, so the child says which one.
+          macros = Array(base[:macros]).map { |m| m[:macro] == :connects_to ? m.merge(declared_in: name) : m }
+          data = merge_inherited(data, base.slice(*WALKED_KEYS).merge(macros: macros))
           # A base's concerns are the child's too: the child's record already
           # carries what they declared, and its callbacks credit them by name.
           data[:mixins] = Array(data[:mixins]) | Array(own[:mixins])
@@ -1553,21 +1969,18 @@ module RailsAiContext
       def merge_inherited(mine, inherited)
         merged = mine.merge(inherited) { |_key, ours, theirs| Array(ours) + Array(theirs) }
         merged[:associations] = dedup(merged[:associations]) { |a| [ a[:type], a[:name] ] }
-        merged[:scopes] = dedup(merged[:scopes]) { |s| s[:name] }
+        # Default scopes stack base first; a named scope the model redefines is its own.
+        base_defaults, base_named = Array(inherited[:scopes]).partition { |s| s[:default] }
+        own_defaults, own_named = Array(mine[:scopes]).partition { |s| s[:default] }
+        merged[:scopes] = dedup(base_defaults + own_defaults + own_named + base_named) { |s| s[:default] ? [ s[:name], s[:body] ] : s[:name] }
         merged[:enums] = dedup(merged[:enums]) { |e| e[:name].to_s }
         # `encrypts :secret` on a base and again on the child is one macro, and
         # the consumers read it as a list of attributes. The key is the
         # declaration: the line it was read at differs between two files, and
         # the concern tag differs between two ways of reaching one file.
-        merged[:macros] = dedup(merged[:macros]) { |m| m.except(:from_concern, :location) }
-        # Rails keeps one entry for a symbol callback declared on a base and
-        # again on the child, and two validators for a validation declared
-        # twice, so these two are not deduped alike. Two blocks are two
-        # callbacks unless they are one line of one file read twice.
-        merged[:callbacks] = dedup(merged[:callbacks]) do |c|
-          block = c[:method].to_s == Listeners::CallbacksListener::INLINE_BLOCK
-          [ c[:type], c[:method].to_s, (block ? [ c[:from_concern], c[:location] ] : nil) ]
-        end
+        # Bases first, the order Rails runs them: a child's `ignored_columns +=` adds to its base's list.
+        merged[:macros] = dedup(Array(inherited[:macros]) + Array(mine[:macros])) { |m| m.except(:from_concern, :location, :owner) }
+        merged[:callbacks] = Array(inherited[:callbacks]) + Array(mine[:callbacks])
         # One source line read twice is still one declaration: a concern the
         # model and one of its bases both include is walked once per class, and
         # `included do` runs once. Two validations really written twice differ
@@ -1576,6 +1989,16 @@ module RailsAiContext
         merged
       end
 
+      SYMBOL_TARGET = /\A[a-z_]\w*[?!]?\z/
+
+      # Rails keeps the later of a symbol declared twice; two blocks stay two.
+      def callback_chain(callbacks)
+        keys = callbacks.each_with_index.map do |c, i|
+          c[:method].to_s.match?(SYMBOL_TARGET) ? [ Listeners::CallbacksListener.chain_key(c[:type]), c[:method].to_s ] : i
+        end
+        keys.zip(callbacks).reverse.uniq(&:first).reverse.map(&:last)
+      end
+
       # The model's own declaration wins: it is the one whose options the
       # class actually runs with.
       def dedup(entries)
@@ -1628,24 +2051,31 @@ module RailsAiContext
       def mongoid_static_models
         entries = mongoid_candidates
         models = mongoid_model_names(entries)
-        entries.each_with_object({}) do |(class_name, entry), result|
-          if entry[:error]
-            result[class_name] = { error: entry[:error] }
-            next
-          end
-          next unless models.include?(class_name)
+        done = {}
+        entries.each_key { |class_name| mongoid_entry(class_name, entries, models, done) }
+        entries.keys.select { |class_name| done[class_name] }.to_h { |class_name| [ class_name, done[class_name].except(:settled_callbacks) ] }
+      end
 
-          result[class_name] = if entry[:source].include?("Mongoid::Document")
-            mongoid_model_details(entry[:source]).merge(file: relative_to_root(entry[:path]))
-          else
-            # This walk keeps no candidate hash, so an AR model in a
-            # hybrid app gets the table it assigns itself and the derived
-            # stem otherwise - no namespace prefix, no STI parent.
-            static_model_details(entry[:path], class_name, table_name: TableName.explicit(entry[:source], class_name, app.root))
-          end
-        rescue => e
-          result[class_name] = { error: e.message }
+      # A subclass of a document is a document; its parent is read first.
+      def mongoid_entry(class_name, entries, models, done)
+        return done[class_name] if done.key?(class_name)
+
+        entry = entries[class_name]
+        return done[class_name] = { error: entry[:error] } if entry[:error]
+        return done[class_name] = nil unless models.include?(class_name)
+
+        done[class_name] = false
+        parent_name = entry[:superclass] && SuperclassChain.resolve_in_scope(class_name, entry[:superclass], nesting: entry[:nesting]) { |q| q if models.include?(q) }
+        parent = parent_name && mongoid_entry(parent_name, entries, models, done)
+        done[class_name] = if entry[:source].include?("Mongoid::Document") || (parent.is_a?(Hash) && parent[:mongoid])
+          mongoid_model_details(entry[:source], class_name, entry[:path], parent: parent && parent[:mongoid] ? [ parent_name, parent ] : nil)
+            .merge(file: relative_to_root(entry[:path]))
+        else
+          # A hybrid app's AR model gets only its own or the derived table here: no namespace prefix, no STI parent.
+          static_model_details(entry[:path], class_name, table_name: TableName.explicit(entry[:source], class_name, app.root))
         end
+      rescue => e
+        done[class_name] = { error: e.message }
       end
 
       def mongoid_candidates
@@ -1665,8 +2095,8 @@ module RailsAiContext
               class_name = DeclaredConstant.resolve(source, relative.camelize)
               next if found.key?(class_name) || config.excluded_models.include?(class_name)
 
-              declaration = DeclaredConstant.declaration_for(DeclaredConstant.declarations(source), class_name)
-              found[class_name] = { path: path, source: source, superclass: declaration&.superclass }
+              declaration = DeclaredConstant.declaration_for(DeclaredConstant.declarations(source, path_name: relative.camelize), class_name)
+              found[class_name] = { path: path, source: source, superclass: declaration&.superclass, nesting: declaration&.nesting }
             rescue => e
               found[relative.camelize] ||= { error: e.message }
             end
@@ -1684,7 +2114,7 @@ module RailsAiContext
           added = entries.select do |name, entry|
             parent = entry[:superclass]
             !names.include?(name) && parent &&
-              SuperclassChain.resolve_in_scope(name, parent) { |q| q if names.include?(q) }
+              SuperclassChain.resolve_in_scope(name, parent, nesting: entry[:nesting]) { |q| q if names.include?(q) }
           end.keys
           break if added.empty?
 
@@ -1704,7 +2134,10 @@ module RailsAiContext
       # A path the read could not answer falls through to the path walk, which raises. A class
       # nested in the model's file includes for itself, not for the model.
       def own_body(data, class_name)
-        data.merge(mixins: ConcernMembership.own_mixins(data[:mixins], class_name))
+        data.merge(mixins: ConcernMembership.owned_by(data[:mixins], class_name, root: app.root),
+                   callbacks: ConcernMembership.owned_by(data[:callbacks], class_name),
+                   macros: ConcernMembership.owned_by(data[:macros], class_name),
+                   scopes: ConcernMembership.owned_by(data[:scopes], class_name).map { |scope| scope.except(:owner) })
       end
 
       def source_walk(path)
@@ -1712,70 +2145,131 @@ module RailsAiContext
         source ? SourceIntrospector.walk_source(source) : SourceIntrospector.call(path)
       end
 
-      # Class methods the class and its bases call, read only when a concern asks: a macro
-      # inside `def acts_as_watchable` belongs to the models that call it.
-      #
-      # A concern's `included do` calls join the set too, so a base walked later sees them.
-      def class_calls(paths)
+      # The class files' side of the lookup, read only when a concern asks: their class-body
+      # calls and their own class methods, `alias_method` in `class << self` included.
+      def singleton_lookup(classes)
         reader = lambda do
-          paths.compact.select { |path| readable_source?(path) }.each_with_object({}) do |path, found|
+          ranks = {}
+          defs = []
+          readable = classes.each_with_index.select { |(_, path), _| path && readable_source?(path) }
+          found = readable.each_with_object({}) do |((name, path), rank), into|
             source = model_source(path)
-            tree = (source ? AstCache.parse_string(source) : AstCache.parse(path)).value
-            ConcernMacros::Run.merge_calls(found, SourceIntrospector.calls_outside_methods(tree))
+            scope = class_scope((source ? AstCache.parse_string(source) : AstCache.parse(path)).value, name)
+            own = scope.select { |node| node.is_a?(Prism::CallNode) && (node.receiver.nil? || node.receiver.is_a?(Prism::SelfNode)) }
+                       .group_by { |node| node.name.to_s }
+            own.each_value { |sites| sites.each { |site| ranks[site.__id__] = rank } }
+            defs.concat(ConcernMacros::SingletonLookup.own_defs(scope, rank))
+            ConcernMacros::Run.merge_calls(into, own)
           rescue StandardError, ScriptError => e
             # A file the walk cannot read calls nothing it can see.
             RailsAiContext.debug_fail(e, nil, label: "class calls of #{path}")
           end
+          defs.concat(base_defs(classes).map(&:last))
+          ConcernMacros::SingletonLookup::Read.new(found, ranks, defs, classes.size)
         end
-        ClassCalls.new(reader, {})
+        ConcernMacros::SingletonLookup.new(reader)
       end
 
-      # The class files' own calls are read once; the included-block calls
-      # grow as the walks read concerns.
-      ClassCalls = Struct.new(:reader, :included) do
-        def call = ConcernMacros::Run.merge_calls(ConcernMacros::Run.merge_calls({}, own), included)
+      # [node, definition] for each class method a base body outside app/models gives the class: one
+      # reopening ApplicationRecord at that base's rank, the rest at the outermost; each after its base's file.
+      def base_defs(classes)
+        application = classes.index { |name, _| name == "ApplicationRecord" }
+        BaseMixins.bodies(app.root.to_s).flat_map do |body|
+          rank = body.target == "ApplicationRecord" ? application : classes.size
+          next [] unless rank
 
-        def own
-          @own ||= reader.call
+          ConcernMacros::SingletonLookup.member_defs(body.statements, rank, body.order)
         end
       end
 
+      # The nodes the class body runs with the class as self: the node opening a
+      # method, nested class or `class << x` is there, its body is not.
+      def class_scope(tree, class_name)
+        short = class_name.to_s.split("::").last.to_s
+        roots = AstWalk.each(tree).select { |node| node.is_a?(Prism::ClassNode) && node.constant_path.slice.split("::").last.casecmp?(short) }
+        roots.empty? ? AstWalk.scope(tree) : roots.flat_map { |root| AstWalk.scope(root.body) }
+      end
 
-      def mongoid_model_details(source)
+      MONGOID_MACROS = -> { Listeners::GenericMacroListener.new(%i[field embeds_many embeds_one embedded_in store_in index], call_source: %i[index]) }
+
+      def mongoid_model_details(source, class_name, path, parent: nil)
         data = SourceIntrospector.walk_source(source, {
-          mongoid: -> { Listeners::GenericMacroListener.new(%i[field embeds_many embeds_one embedded_in store_in]) },
+          mongoid: MONGOID_MACROS,
           associations: Listeners::AssociationsListener,
           validations: Listeners::ValidationsListener,
           scopes: Listeners::ScopesListener,
           callbacks: Listeners::CallbacksListener,
-          methods: Listeners::MethodsListener
+          methods: Listeners::MethodsListener,
+          mixins: Listeners::MixinsListener
         })
-        macros = data[:mongoid] || []
+        # A concern's `included` block declares into the document before the body that follows it.
+        from_concerns = ConcernMacros.collect(app.root.to_s, data[:mixins], keys: %i[mongoid], prefer: "model", within: class_name,
+                                              listeners: { mongoid: MONGOID_MACROS, mixins: Listeners::MixinsListener }, file: path).collected
+        macros = Array(from_concerns[:mongoid]) + Array(data[:mongoid])
+        calls = singleton_lookup([ [ class_name, path ] ])
+        calls.add(0, {}, {}, [])
+        own = own_body(data.merge(mixins: []), class_name)
+        parent_name, inherited = parent
+        settled = settle(Walk.empty(own), calls).first[:callbacks]
+        # A parent's callbacks join the chain as a base's do, one rank above the subclass's.
+        settled = Array(inherited&.dig(:settled_callbacks)).map { |cb| cb.merge(rank: cb[:rank].to_i + 1) } + settled
+        # Mongoid sets after_commit without prepend, as Rails 7.0 does, so it runs last declared first.
+        callbacks = chain_order(settled, false)
         details = {
           confidence: Confidence::STATIC,
           mongoid: true,
-          fields: macros.select { |m| m[:macro] == :field }
-                        .map { |m| { name: m[:args].first, type: m[:options][:type] }.compact },
+          fields: macros.select { |m| m[:macro] == :field }.map { |m| mongoid_field(m) },
           embeds: macros.select { |m| %i[embeds_many embeds_one embedded_in].include?(m[:macro]) }
                         .map { |m| { type: m[:macro], name: m[:args].first } },
+          indexes: macros.select { |m| m[:macro] == :index }.map { |m| m[:text] },
           # An embedded child is a relation like any other, so every count and the graph see it.
           associations: reject_excluded_associations(Array(data[:associations]) + embedded_associations(macros)),
           validations: data[:validations],
-          scopes: data[:scopes],
+          scopes: own[:scopes],
           # Same shape as the booted tier: a Hash keyed by callback type. The
           # listener hands back a flat Array, and every consumer filters on
           # `callbacks.is_a?(Hash)` - so passing it through rendered "No models
           # with callbacks found" and then raised a TypeError on a Hash lookup
           # against an Array.
-          callbacks: group_callbacks_by_type(data[:callbacks]),
-          callback_conditions: callback_conditions(data[:callbacks]),
-          methods: data[:methods]
+          callbacks: group_callbacks_by_type(callbacks),
+          callback_conditions: callback_conditions(callbacks),
+          methods: data[:methods],
+          settled_callbacks: settled
         }
-        collection = macros.find { |m| m[:macro] == :store_in }&.dig(:options, :collection)
-        details[:collection] = collection if collection
+        if inherited
+          { fields: :name, embeds: :name, associations: :name, scopes: :name }.each do |key, name|
+            mine = Array(details[key]).map { |entry| entry[name].to_s }
+            details[key] = Array(inherited[key]).reject { |entry| mine.include?(entry[name].to_s) } + Array(details[key])
+          end
+          details[:validations] = (Array(inherited[:validations]) + Array(details[:validations])).uniq
+          details[:parent_model] = parent_name
+        end
+        embedded = macros.find { |m| m[:macro] == :embedded_in }
+        embedded_in = embedded ? embedded_parent(embedded) : inherited&.dig(:embedded_in)
+        if embedded_in
+          details[:embedded_in] = embedded_in
+        else
+          # Mongoid's collection_name: store_in's, else the root class's name tableized with "/" as "_".
+          details[:collection] = macros.find { |m| m[:macro] == :store_in }&.dig(:options, :collection) ||
+                                 inherited&.dig(:collection) || class_name.tableize.tr("/", "_")
+        end
         downgrade_records(details)
       end
 
+      # A default Mongoid computes (a lambda) is left out, as the replay leaves a computed column default.
+      def mongoid_field(macro)
+        options = macro[:options]
+        default = SchemaConventions.format_default(options[:default]) unless options[:default] == Confidence::INFERRED
+        { name: macro[:args].first, type: options[:type], default: default }.compact
+      end
+
+      def embedded_parent(macro)
+        options = macro[:options] || {}
+        return "#{macro[:args].first} (polymorphic)" if options[:polymorphic]
+
+        options[:class_name]&.to_s || macro[:args].first.to_s.camelize
+      end
+
       def embedded_associations(macros)
         macros.select { |m| %i[embeds_many embeds_one].include?(m[:macro]) }.map do |m|
           { name: m[:args].first.to_s, type: m[:macro].to_s, class_name: m[:options][:class_name]&.to_s }.compact