rails-ai-context 5.20.1 → 5.20.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e7cbf76ef448db45165cf06f3c2af8303b23f8629a709b20ffb61ae33093c192
-  data.tar.gz: 65fe97840d3fd23ab66b1b8e6b108914b3675e3648c51d746769d4016b6a846a
+  metadata.gz: 812fc2b5160e39c746e9d399bf6cea5752339f53c57a80f3ce0d01a5e819b7d0
+  data.tar.gz: 22254f62db474a0f0b7f364f156b3098819b52285e88df2835b32ea25c86972b
 SHA512:
-  metadata.gz: b4816a51648a6aaee1a3fd48b649ff35967e2efea2c75805da08c605a0668b8afa7dbe113b8d7f555a13c268d72f1284b69091a3b9d102465e3a6b00f5b2282b
-  data.tar.gz: cc12eaa6400a9a2906ca706b37fc92f211f0837e69038f14e6a25742be8207d529c915c4ecdb122c6bd2a20a9dc0eb86a3474cd4a65a321fa8ded9f2aa64a47d
+  metadata.gz: 4eddc9f145293be65bc99e9b0dd5334de7570ef217df4dca4f554c191ae314bd6544ed16f49be013a2db93c3394e49f02204c1d76c1c256d7394881ea273eb81
+  data.tar.gz: 53e469b48920a4baefe955ff90624199f60200a6759d180a02d040d4c1368322d0b9648637fe4a13d20cf1ecc9153d3b7a1b041e1d41ae835c7a8e523cfd4bdf

data/CHANGELOG.md

@@ -5,6 +5,141 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [5.20.3] - 2026-08-11
+
+### Fixed
+
+- **`serve --transport http` no longer answers "Session not found" to about half
+  of all requests.** Rackup hands Puma the host app's `config/puma.rb`, and a
+  real app sets `workers` there, so the transport ran as a cluster - but MCP
+  sessions live in one process's memory, and a forked worker cannot answer a
+  request whose `initialize` a sibling handled. Puma is now pinned to single
+  mode. Both options are load-bearing: refusing the config file still leaves
+  `WEB_CONCURRENCY` able to start a cluster on its own, and pinning the worker
+  count still lets the file's `pidfile` and `preload_app!` through - the pidfile
+  being one this server would otherwise write over the app's own. (#123)
+
+- **A gem's background job is no longer counted as the app's.** `extract_jobs`
+  filtered `ActiveJob::Base.descendants` with a list of framework name
+  prefixes, which no list can keep up with: on an app with 118 Sidekiq workers
+  and no ActiveJob of its own, the generated `CLAUDE.md` read `Async: 1 job`
+  and that job was an indexing worker belonging to a gem. Ownership is now
+  decided by where the class is defined. A class with no source location is
+  kept, because understating what the app runs is the worse mistake. (#120)
+
+- **`get_job_pattern` now names the queues `config/sidekiq.yml` declares.**
+  `extract_sidekiq_config` already read them; holding the result back left the
+  answer describing `app/jobs/` and nothing else, on an app whose sidekiq.yml
+  is the one piece of evidence in reach that async work happens elsewhere. It
+  reaches the job listing as well as the empty-directory message - a count of
+  what `app/jobs/` holds is still a claim about the app's async work, and on an
+  app running most of it through Sidekiq that count is the small half. (#120)
+
+- **The context no longer carries `static_parse` as a database name.**
+  `SchemaIntrospector` writes that placeholder when it reads a dump instead of
+  the connection, and laundering it at each rendering surface left the ones
+  nobody thought of - `.ai-context.json` and `rails://schema` - naming a
+  database that does not exist beside a `multi_database` section in the same
+  file naming the real one. It is now resolved once, where the context is
+  assembled, so nothing downstream has to remember. The raw observation stays
+  under `adapter_source`. (#128)
+
+- **The static tier follows `draw` into `config/routes/*.rb`.** An app that
+  splits its routing table that way kept most of it in files the parser never
+  opened: `--no-boot` answered 94 routes on a 723-route app. Rails resolves
+  `draw(:admin)` by literal path, so following it is a plain file read; the
+  resolved path is confirmed inside `config/routes/` with `realpath` first, so
+  a symlink there cannot reach the rest of the disk. (#127)
+
+- **Every surface that prints a route count says how much of the table it
+  could not expand.** `RouteIntrospector` recorded `dynamic_routes` for
+  constructs it refused to fabricate (`devise_for`, a `draw` whose target is
+  computed or too large to parse) and nothing read it, so `rails_get_routes`,
+  `rails_onboard`, `CLAUDE.md`, the Cursor and Copilot rule files, the markdown
+  context and the rake summary all quoted a partial count as the whole routing
+  table. `RouteCoverage` is the one answer they now share, shaped as a suffix
+  so no call site needs a conditional of its own - nine each having to remember
+  is what produced this. A `draw` whose routes are in the list does not count,
+  whether this pass read the file or an earlier branch did; one stopped by the
+  depth cap, or naming a file too large to parse, does. A drawn file that
+  cannot be parsed costs its own routes rather than the whole section. (#127)
+
+- **The static tier counts an update route once.** Rails registers PATCH and
+  PUT separately for one action and every surface that lists routes merges
+  them, but the static total did not - so the generated files said "8 total"
+  where `rails_get_routes`, which merges for itself, said 7 on the same
+  `resources :posts`. (#127)
+
+### Changed
+
+- `actionmailer` and `puma` are development dependencies now. Without
+  ActionMailer loaded, `ActionMailer::Base` is undefined and every assertion
+  about mailer actions passed over an empty array; the Puma single-mode pin is
+  only testable against Puma's own option semantics. Neither affects the
+  gem's runtime dependencies. (#123, #126)
+
+## [5.20.2] - 2026-08-11
+
+### Fixed
+
+- **A long-lived process no longer answers about the app as it was at boot.**
+  The MCP server and `watch` invalidated their own caches on a file change but
+  never reloaded Rails, and `Zeitwerk#eager_load_dir` does not re-scan a
+  directory it has already loaded - so a model written after the server started
+  stayed invisible for the life of the process, and the server told callers it
+  did not exist. Routes were unaffected because `RouteIntrospector` already
+  asked `routes_reloader.execute_if_updated`. Both change handlers now run
+  Rails' own reloader first, gated on `config.enable_reloading` (the flag that
+  decides whether Rails unloads anything - `eager_load` does not), and every
+  tool call and every resource read now runs inside the executor so a reload
+  cannot unload constants while one is reading them. A failing reload leaves
+  the process alive, and a tool failure is not reported to the host app's
+  error reporter - it is handled here and returned as an isError result.
+
+- **A `validates_with` validator no longer replaces the whole model answer.**
+  `ActiveModel::Validator` has no `#attributes` - only `EachValidator` does -
+  so one of them anywhere on a model turned `rails_get_model_details`,
+  `rails_get_callbacks` and `rails://models/X` into a single
+  "Error inspecting X" line. (#121)
+- **Static-tier callbacks are reported.** The two tiers handed back different
+  types for one key: a Hash keyed by callback type when booted, a flat Array
+  from the listener otherwise. Every consumer filters on `is_a?(Hash)`, so
+  `--no-boot` answered "No models with callbacks found" for an app full of
+  them, and `--model X --no-boot` raised `TypeError` on a Hash lookup against
+  an Array. (#122)
+- **`get_mailers` reports the actions Rails calls actions.** It listed
+  `instance_methods(false)`, which includes ActiveSupport's generated
+  `_run_*_callbacks` and any public helper, so an abstract `ApplicationMailer`
+  was reported as having deliverable actions. It now asks
+  `action_methods`. (#126)
+- **One answer to which database the app runs on.** Four surfaces each carried
+  their own substitute for the internal `static_parse` marker and disagreed:
+  the generated `CLAUDE.md`, `rails_get_schema`, `rails_onboard` and
+  `rails ai:inspect` could name three different databases for one app, and
+  `onboard`'s gem loop let the last match win where the serializer's let the
+  first. They now share `RailsAiContext::SchemaAdapter`, which resolves from
+  the app's own database configuration first, then the `structure.sql` dialect
+  already parsed, then the Gemfile - order-independent. (#125)
+- **Generated context files no longer print `Database: static_parse`.** That is
+  the internal marker for "read from db/schema.rb, not the connection";
+  `onboard` already substituted the live adapter and the serializers did
+  not. (#125)
+- **`get_job_pattern` says what it checked.** "This app may not use background
+  jobs" was a claim about the whole app drawn from one directory, and apps
+  keeping Sidekiq workers in `app/workers/` were told they have none. (#120)
+- **`validate`'s empty-files message advises a syntax the CLI accepts.** It
+  recommended `files:["..."]`, which the CLI reads as a literal filename. (#124)
+- **`validate --files a.rb b.rb` validates every file.** Array parameters
+  consumed only the first token, so the rest were dropped silently and the
+  summary read "1/1 files passed" for a set containing a broken file. (#124)
+
+### Added
+
+- **The static tier reads `config.api_only`.** Without a booted app the view
+  tools fell back to "no Stimulus controllers found" on an API-only app, where a
+  booted run says "Not applicable". Both were true, but only one of them stops
+  an agent adding a view layer to an app that has none by design.
+
 ## [5.20.1] - 2026-08-11
 
 ### Fixed

data/gemfiles/prism_floor.gemfile

@@ -15,6 +15,8 @@ rails_version = ENV.fetch("RAILS_VERSION", "8.0")
 group :development, :test do
   gem "railties", "~> #{rails_version}.0"
   gem "activerecord", "~> #{rails_version}.0"
+  gem "actionmailer", "~> #{rails_version}.0"
+  gem "puma"
   gem "sqlite3"
   gem "logger"
 end

data/gemfiles/prism_head.gemfile

@@ -14,6 +14,8 @@ rails_version = ENV.fetch("RAILS_VERSION", "8.0")
 group :development, :test do
   gem "railties", "~> #{rails_version}.0"
   gem "activerecord", "~> #{rails_version}.0"
+  gem "actionmailer", "~> #{rails_version}.0"
+  gem "puma"
   gem "sqlite3"
   gem "logger"
 end

data/lib/rails_ai_context/app_kind.rb

@@ -27,5 +27,28 @@ module RailsAiContext
       content = RailsAiContext::SafeFile.read(gemfile)
       !!content&.match?(/^\s*gem\s+["']mongoid["']/)
     end
+
+    # An API-only app has no view layer, and saying "no Stimulus controllers
+    # found" about one invites an agent to add some. The flag is written in
+    # config/application.rb, so this answer needs no booted app.
+    #
+    # Read from the AST, not a regex: `config.api_only = true` is an
+    # assignment, which docs/INTROSPECTORS.md puts squarely in AST territory,
+    # and ConfigAssignmentListener already reports exactly this shape. A regex
+    # also has to hand-roll what the parser knows for free - comments, strings
+    # and heredocs that merely contain the text.
+    def api_only?(root)
+      path = File.join(root.to_s, "config", "application.rb")
+      return false unless File.exist?(path)
+      return false unless RailsAiContext::SafeFile.read(path)
+
+      walked = Introspectors::SourceIntrospector.walk(
+        path, { config: Introspectors::Listeners::ConfigAssignmentListener }
+      )
+      hit = Array(walked[:config]).find { |entry| entry[:path] == [ :api_only ] }
+      !hit.nil? && hit[:value] == true
+    rescue StandardError, ScriptError
+      false
+    end
   end
 end

data/lib/rails_ai_context/cli/tool_runner.rb

@@ -211,7 +211,17 @@ module RailsAiContext
             if arg.include?("=")
               key, value = arg.sub("--", "").split("=", 2)
               key = key.tr("-", "_").to_sym
-              result[key] = coerce_value(value, properties[key] || {})
+              prop = properties[key] || {}
+              if prop[:type] == "array"
+                # `--files=a.rb b.rb` is the same call as `--files a.rb b.rb`;
+                # honouring only one of the two spellings docs/CLI.md teaches
+                # left the other still dropping every file after the first.
+                trailing = collect_array_values(args, i + 1)
+                result[key] = Array(coerce_value(value, prop)) + trailing
+                i += 1 + values_consumed(args, i + 1)
+                next
+              end
+              result[key] = coerce_value(value, prop)
             else
               key = arg.sub("--", "").tr("-", "_").to_sym
               prop = properties[key] || {}
@@ -232,6 +242,24 @@ module RailsAiContext
                 next
               end
 
+              if prop[:type] == "array"
+                values = collect_array_values(args, i + 1)
+                unless values.empty?
+                  result[key] = values
+                  i += 1 + values_consumed(args, i + 1)
+                  next
+                end
+              end
+
+              # A bare `--files` with nothing after it is a mistake, not a
+              # request for `files: true` - an array param holding a Boolean
+              # reaches the tool as a type it never accepts.
+              if prop[:type] == "array"
+                result[key] = []
+                i += 1
+                next
+              end
+
               value = (i + 1 < args.size) ? args[i + 1] : nil
               if value && !value.start_with?("--")
                 result[key] = coerce_value(value, prop)
@@ -258,6 +286,21 @@ module RailsAiContext
         result
       end
 
+      # Tokens belonging to an array flag: everything up to the next flag,
+      # stopping at a rake-style `key=value` token so `--include a model=Post`
+      # does not swallow the second parameter. Each token is still
+      # comma-split, so the documented `a.rb,b.rb` form keeps working and
+      # mixing the two spellings does not fabricate a path.
+      def collect_array_values(args, from)
+        args[from..].to_a
+            .take_while { |a| !a.start_with?("--") && !a.include?("=") }
+            .flat_map { |a| Array(coerce_value(a, { type: "array" })) }
+      end
+
+      def values_consumed(args, from)
+        args[from..].to_a.take_while { |a| !a.start_with?("--") && !a.include?("=") }.size
+      end
+
       # Coerce a string value to the type specified in the JSON Schema property.
       def coerce_value(raw, property_schema)
         case property_schema[:type]

data/lib/rails_ai_context/code_reloader.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  # Re-runs Rails' own code reloader so a long-lived process sees files written
+  # after it booted.
+  #
+  # Clearing the gem's caches is not enough on its own. Introspectors reach the
+  # app through constants, and the eager loading they trigger
+  # (`Zeitwerk::Loader#eager_load_dir`) is idempotent per process - a directory
+  # already loaded is never re-scanned, so a model added after boot stays
+  # invisible for the life of the server. Routes never had the problem because
+  # RouteIntrospector asks `routes_reloader.execute_if_updated` every call.
+  module CodeReloader
+    module_function
+
+    # Reload the app's autoloaded code. Returns whether a reload actually ran,
+    # so callers can say what they did instead of guessing.
+    def reload!
+      return false unless reloadable?
+
+      Rails.application.reloader.reload!
+      true
+    rescue StandardError, ScriptError => e
+      # A broken file mid-edit is the common case. Zeitwerk reloads by
+      # unload-then-setup, so a raise can leave constants already unloaded -
+      # they re-autoload lazily on next reference. Either way a running server
+      # must survive it.
+      $stderr.puts "[rails-ai-context] code reload failed: #{e.class}: #{e.message}" if ENV["DEBUG"]
+      false
+    end
+
+    # Run a block with the sharing lock held, so a reload cannot unload
+    # constants underneath it.
+    #
+    # `Reloader#class_unload!` takes the unload lock through
+    # ActiveSupport::Dependencies.interlock, but that only blocks threads
+    # holding the sharing lock - which is acquired inside `executor.wrap`.
+    # Nothing here wrapped anything, so the Listen thread could clear
+    # DescendantsTracker while a tool call was midway through reading
+    # `ActiveRecord::Base.descendants`, returning a short list with no
+    # exception for the per-section rescue to notice.
+    #
+    # Only taken when a reload could actually happen; everywhere else this is
+    # a plain yield.
+    def with_app_code
+      return yield unless reloadable?
+
+      app = Rails.application
+      return yield unless app.respond_to?(:executor)
+
+      app.executor.wrap { yield }
+    end
+
+    # `enable_reloading` is the flag that decides whether Rails unloads
+    # anything: with it off, the finisher registers no class_unload callback,
+    # so `reload!` runs the prepare callbacks and returns having reloaded
+    # nothing. Gating on `eager_load` instead reported success for every
+    # eager_load=false + cache_classes=true environment (stock `test`, a
+    # cache-classes staging container) - a reload that never happened,
+    # announced as one.
+    def reloadable?
+      return false if RailsAiContext.static_tier?
+      return false unless defined?(Rails) && Rails.respond_to?(:application)
+
+      app = Rails.application
+      return false unless app.respond_to?(:reloader) && app.respond_to?(:config)
+
+      config = app.config
+      # Rails 7.1+ names it enable_reloading; older releases only have
+      # cache_classes, which is its inverse.
+      return config.enable_reloading if config.respond_to?(:enable_reloading)
+      return !config.cache_classes if config.respond_to?(:cache_classes)
+
+      false
+    rescue StandardError
+      false
+    end
+  end
+end

data/lib/rails_ai_context/introspector.rb

@@ -48,6 +48,8 @@ module RailsAiContext
       end
       context[:_warnings] = warnings if warnings.any?
 
+      resolve_schema_adapter(context)
+
       context
     end
 
@@ -99,6 +101,41 @@ module RailsAiContext
 
     private
 
+    # `SchemaIntrospector` writes `static_parse` when it read a dump instead of
+    # the connection, and every surface that rendered the section raw named a
+    # database that does not exist. Fixing that one surface at a time meant
+    # `.ai-context.json` and `rails://schema` still disagreed with the
+    # multi_database section of the same file. Resolving it here means the
+    # context never carries the placeholder, so nothing downstream has to
+    # remember. The raw observation stays under `adapter_source` for a reader
+    # that needs to know the schema was parsed rather than observed.
+    #
+    # Runs after the loop: the answer comes from the database config and gem
+    # list, which are sections of this same context.
+    #
+    # Rescued for the same reason the loop above is: this reads two other
+    # sections, and a malformed one raising here would cost the whole context
+    # rather than one entry. The placeholder surviving is the honest failure.
+    def resolve_schema_adapter(context)
+      schema = context[:schema]
+      return unless schema.is_a?(Hash) && !schema[:error]
+      # Only correct a claim that was made. A missing or nil adapter said
+      # nothing about the database, and answering for it would be the
+      # fabrication this method exists to remove.
+      return if schema[:adapter].nil?
+      return unless SchemaAdapter.placeholder?(schema[:adapter])
+
+      # "unknown" is a placeholder too. Swapping one for another buys nothing
+      # and would bury the parse mode that at least says how the schema was read.
+      resolved = SchemaAdapter.label(context)
+      return if SchemaAdapter.placeholder?(resolved)
+
+      schema[:adapter_source] = schema[:adapter]
+      schema[:adapter] = resolved
+    rescue StandardError => e
+      RailsAiContext.log_warn "[rails-ai-context] schema adapter resolution failed: #{e.message}"
+    end
+
     def app_name
       return File.basename(app.root.to_s) if app.is_a?(RailsAiContext::StaticApp)
 

data/lib/rails_ai_context/introspectors/api_introspector.rb

@@ -6,7 +6,7 @@ module RailsAiContext
     # versioning patterns, rate limiting.
     class ApiIntrospector
       extend StaticTier
-      static_tier :runtime_only
+      static_tier :alternate_source
 
       attr_reader :app
 
@@ -14,6 +14,20 @@ module RailsAiContext
         @app = app
       end
 
+      # Everything but api_only needs a booted app, but api_only itself is a
+      # plain assignment in config/application.rb - and the view tools already
+      # read it there. Leaving this section wholly unavailable meant one
+      # process answering "this is an API-only app" from get_stimulus and
+      # "cannot say" from get_api.
+      def static_call
+        {
+          api_only: AppKind.api_only?(app.root),
+          unavailable_sections: StaticTier.unavailable_reason
+        }
+      rescue StandardError
+        { unavailable: StaticTier.unavailable_reason }
+      end
+
       def call
         {
           api_only: app.config.api_only,

data/lib/rails_ai_context/introspectors/job_introspector.rb

@@ -2,8 +2,10 @@
 
 module RailsAiContext
   module Introspectors
-    # Discovers background jobs (ActiveJob/Sidekiq), mailers,
-    # and Action Cable channels.
+    # Discovers ActiveJob jobs, mailers, and Action Cable channels. Sidekiq
+    # reaches this only as config/sidekiq.yml: a class that includes
+    # Sidekiq::Worker without subclassing ActiveJob::Base is not a descendant
+    # and does not live in app/jobs/, so neither pass here finds it.
     class JobIntrospector
       extend StaticTier
       static_tier :alternate_source
@@ -52,6 +54,7 @@ module RailsAiContext
         ActiveJob::Base.descendants.filter_map do |job|
           next if job.name.nil? || job.name == "ApplicationJob" ||
                   job.name.start_with?("ActionMailer", "ActiveStorage::", "ActionMailbox::", "Turbo::", "Sentry::")
+          next unless app_defined?(job)
 
           queue = job.queue_name
           queue = "dynamic" if queue.is_a?(Proc)
@@ -67,6 +70,26 @@ module RailsAiContext
         []
       end
 
+      # `descendants` is every ActiveJob subclass in the process, and the name
+      # prefixes above only cover the framework's own - a job from any other gem
+      # was counted as the app's. Where the class is defined answers it for gems
+      # the list has never heard of. A class with no source location stays:
+      # dropping one would understate what the app runs.
+      def app_defined?(job)
+        location = Object.const_source_location(job.name)&.first
+        return true unless location
+
+        File.realpath(location).start_with?("#{app_root_real}/")
+      rescue NameError, ArgumentError, TypeError, SystemCallError
+        true
+      end
+
+      def app_root_real
+        @app_root_real ||= File.realpath(app.root.to_s)
+      rescue SystemCallError
+        @app_root_real = app.root.to_s
+      end
+
       def extract_jobs_from_source
         jobs_dir = File.join(app.root, "app", "jobs")
         return [] unless Dir.exist?(jobs_dir)
@@ -234,7 +257,14 @@ module RailsAiContext
         ActionMailer::Base.descendants.filter_map do |mailer|
           next if mailer.name.nil?
 
-          actions = mailer.instance_methods(false).map(&:to_s).sort
+          # Rails' own answer: it subtracts internal and inherited methods, so
+          # an abstract ApplicationMailer reports none and ActiveSupport's
+          # generated `_run_*_callbacks` never appears. `instance_methods(false)`
+          # listed both as deliverable actions. Called bare, like
+          # ControllerIntrospector does - AbstractController::Base has defined
+          # it across the whole supported range, so a fallback here would only
+          # be unreachable code holding the old bug.
+          actions = mailer.action_methods.to_a.map(&:to_s).sort
           next if actions.empty?
 
           {
@@ -248,8 +278,11 @@ module RailsAiContext
         []
       end
 
-      # A mailer's actions are its public instance methods, which is exactly
-      # what `instance_methods(false)` reports on the booted side.
+      # A mailer's actions are its public instance methods, and the AST sees
+      # one file at a time. `action_methods` counts the public methods a mailer
+      # inherits too, so a public helper on a base class is an action the
+      # booted tier reports and this one cannot - the entries are tagged STATIC
+      # for that reason.
       def extract_mailers_from_source
         source_classes(File.join(app.root, "app", "mailers")).filter_map do |name, methods|
           next if name == "ApplicationMailer"

data/lib/rails_ai_context/introspectors/listeners/routes_dsl_listener.rb

@@ -272,7 +272,17 @@ module RailsAiContext
         def emit_dynamic(node)
           return if suppressed?
 
-          @results << { type: :dynamic, macro: node.name, location: node.location.start_line }
+          record = { type: :dynamic, macro: node.name, location: node.location.start_line }
+          # `draw(:admin)` names a file, and Rails resolves it by literal path.
+          # Recording the name is what lets the introspector follow it instead
+          # of writing off everything the file defines.
+          record[:target] = draw_target(node) if node.name == :draw
+          @results << record
+        end
+
+        def draw_target(node)
+          target = extract_first_symbol(node)
+          target unless target == RailsAiContext::Confidence::INFERRED
         end
 
         # Keyword options including hash-rocket string keys, so

data/lib/rails_ai_context/introspectors/model_introspector.rb

@@ -222,7 +222,10 @@ module RailsAiContext
         model.validators.map do |validator|
           {
             kind: validator.kind.to_s,
-            attributes: validator.attributes.map(&:to_s),
+            # `validates_with` registers a bare ActiveModel::Validator, which
+            # has no #attributes - only EachValidator does. Calling it blind
+            # replaced the whole model's answer with one error line.
+            attributes: validator.respond_to?(:attributes) ? Array(validator.attributes).map(&:to_s) : [],
             options: sanitize_options(validator.options)
           }
         end
@@ -332,9 +335,15 @@ module RailsAiContext
       end
 
       def extract_callbacks_from_ast(source_data)
-        source_data[:callbacks].each_with_object({}) do |cb, hash|
-          type = cb[:type].to_s
-          (hash[type] ||= []) << cb[:method]
+        group_callbacks_by_type(source_data[:callbacks])
+      end
+
+      # One shape for both tiers: { "before_validation" => ["normalize"] }.
+      def group_callbacks_by_type(callbacks)
+        Array(callbacks).each_with_object({}) do |cb, hash|
+          next unless cb.is_a?(Hash) && cb[:type]
+
+          (hash[cb[:type].to_s] ||= []) << cb[:method]
         end
       end
 
@@ -576,7 +585,12 @@ module RailsAiContext
           validations: data[:validations],
           scopes: data[:scopes],
           enums: data[:enums],
-          callbacks: data[:callbacks],
+          # 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]),
           macros: data[:macros],
           methods: data[:methods]
         }
@@ -641,7 +655,12 @@ module RailsAiContext
           associations: data[:associations],
           validations: data[:validations],
           scopes: data[:scopes],
-          callbacks: data[:callbacks],
+          # 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]),
           methods: data[:methods]
         }
         collection = macros.find { |m| m[:macro] == :store_in }&.dig(:options, :collection)