rails-ai-context 5.30.2 → 5.31.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49493277fcbe8b2da2d183de723ebf3d5f4c85101f5eff5b6a0c89a1ae4340a9
-  data.tar.gz: ebd28661e4d369b526027b8705c599372383796003287160a460ec3e99990632
+  metadata.gz: 44b4fb64c009d96449f8f05375947d6713b07d0a45c7f27e779e0ac271c0bfa6
+  data.tar.gz: d0045d00ef00250f97eeae2ff105b09c7f991a3746c9198bc8126b3e79d8dc2a
 SHA512:
-  metadata.gz: 3a98be099ee6b23ded854a1820714d9450d8ce304dd08c18d12182b7a8f15097f0ca5eb2c3c0db122b313057aed0a9ec3b44b38aae1c0e1a231d1f41b455c6e6
-  data.tar.gz: 0be3021416fc068c9e93bfaabba548a22cb914c6393f1daf6ef9a7892045cf1984efad3d22de132c29b3d83081e796a5f74e868fc8b4f94883912ff7f4562f75
+  metadata.gz: e60a1a843d881a90404c7f87b6a29e829a60210195375c94a90151b82850d749820828b752e9e6f5f60b22dd92bf948bb8275f207c7df801ce954bd9a53705cd
+  data.tar.gz: 4aa95471cb0a3a4ad1cec127db6322b9b0b5d1f39f00826b1c73dd246cf0acfadc51e14f3e9f16b1cd6f3602acb618ee520eadc2b674825d2f95e675dfa7e6c1

data/CHANGELOG.md

@@ -5,6 +5,179 @@ 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.31.0] - 2026-10-05
+
+### Changed
+
+- **A committed placeholder is not a secret.** A file whose name ends in
+  `.example`, `.sample`, `.template` or `.dist` (`.env.example`) is readable by
+  `rails_get_edit_context` and the other file tools, although the default
+  `.env.*` pattern matches it, and `doctor` no longer lists it as unread or
+  says to gitignore it. A `sensitive_patterns` entry that names the file
+  exactly, with no glob characters, still blocks it, and so does a path
+  pattern with a `/` (`.ssh/*` keeps `.ssh/id_rsa.template` blocked).
+  Redaction treats the four suffixes alike. `rails_search_code` now drops
+  sensitive files from ripgrep's output where it used to exclude them by glob,
+  so a sensitive file ripgrep cannot open is not reported as an error and does
+  not send a no-match search through the Ruby fallback. (#267)
+- **`rails_query` on a SQLite file stops at `query_timeout`.** The query runs
+  in a child process with its own read-only connection, which is stopped at the
+  deadline. sqlite3 2.x's `statement_timeout=` interrupts any statement of more
+  than a few thousand steps whatever the value, and the extension holds the GVL
+  while a statement runs, so no in-process limit exists. The child takes the
+  app's `extensions:` and waits on a locked database as the app would. An
+  in-memory database, a platform without `fork`, or a query that needs a
+  function, virtual-table module, collation or encryption key only the app's
+  own connection has runs in-process; the table and EXPLAIN answers then say it
+  ran without a time limit, and CSV output stays plain data. (#256)
+- **`rails_get_callbacks` lists callbacks in the order Rails runs them**: base
+  classes first, a concern's callbacks where its `include` line stands, then
+  the model's own, and a `before_` or `around_` callback with `prepend: true`
+  first. `after_commit` and `after_rollback` list last declared first, as
+  Rails runs them, unless `run_after_transaction_callbacks_in_order_defined`
+  is on (`load_defaults 7.1` or later). The static tier reads that from
+  `config/application.rb` and the initializers, the last line that sets it
+  winning, and when the config does not tell, `rails_get_callbacks` and
+  `rails_get_model_details` say so. A method declared twice under one callback
+  type shows the declaration Rails keeps, the later one, which corrects the
+  5.30.0 entry that said each declaration is shown. A declaration inside a
+  method body counts where the class calls the method, and not at all when
+  nothing does, so an uncalled method that redeclares a callback no longer
+  hides it. A call counts written bare or as `self.name`, made inside a class
+  method it runs, or made from a concern's `included` block. A module joins a
+  class chain once, at the first place the chain adds it: the outermost class
+  that adds it, at its first include there, which can be a call to a class
+  method that includes it. A Concern's `included` block runs there only; a
+  plain `self.included` hook runs on every include. A call runs the definition
+  Ruby's lookup finds as of the call: a module the class prepends to its
+  singleton class, the class's own class methods, then the modules it extends
+  and its concerns' class methods, the last added first, then the same for
+  each base, then what every model has: class methods an initializer writes in
+  `ActiveRecord::Base.class_eval` or a reopened base, the file Rails loads
+  later winning (Canvas's `validates_locale` adds its `before_validation` to
+  Account, User and Course), then the modules mixed into the base. One an
+  initializer writes on `ApplicationRecord` replaces ApplicationRecord's own.
+  A class's own class methods are its `def self.`, an `alias_method` in
+  `class << self` (it runs what its original name ran at the alias), and those
+  a Concern's `included` block or a hook writes on the class (`def self.x` or
+  `class << self`, in the block, in `base.class_eval` or in `class << base`),
+  each from its line where that code runs. A module counts from the line
+  adding it, where that line runs: an `extend`, `singleton_class.include` or
+  `singleton_class.prepend` (which counts as prepended) in the class, in a
+  hook or in a Concern's `included` block, and an `extend` in a class method a
+  call reaches (an `acts_as_x` that extends its methods, whose `self.extended`
+  hook then runs); a plain module's nested `ClassMethods` counts only when
+  something extends it. A module a hook includes runs its own hooks. Two
+  concerns' modules of one name (each concern's `ClassMethods`) stay two: each
+  name is the constant it resolves to where it is written, and one that
+  resolves to nothing no longer hides the other. A `super` runs the next
+  definition, at the `super`. An instance method or a nested class's method of
+  the same name never runs. A module a class method includes joins only when a
+  call reaches that method, and only calls after it see its methods. A nested
+  class's callbacks are its own, and a module nested in the model's file reads
+  like any concern: `include` runs its `included` block, `extend` its methods
+  and `self.extended` only. A module a plugin's lib loads by a glob `require`
+  is read from beside the file naming it, and from its definition rather than
+  an empty namespace stub above it, so OpenProject's journalized models list
+  `save_journals`. A Mongoid document's own callbacks list in the same run
+  order, one in a class method where the document calls it. Neither tier
+  evaluates `send`, `define_singleton_method` or a module included in
+  `class << self` for this, so the list can miss what they register or show
+  the definition they replace. (#253)
+- **A lambda or Proc given to `queue_as` reads as what ActiveJob does with
+  it.** ActiveJob never calls it; it names the queue after the Proc's text.
+  Both tiers now say so, with the source, where the booted tier printed the
+  Proc's address and the static tier called it computed. A `queue_as` block is
+  the computed case and now shows its source too; a block argument
+  (`queue_as(&pick)`) reads as computed in both tiers. The 5.30.0 entry used
+  `queue_as -> { ... }` as its example of a computed queue; that was wrong.
+  (#271)
+- **An MCP stdio session carries nothing but JSON-RPC on stdout for its whole
+  life.** Output written during a tool call (a logger built on first use, as
+  Sidekiq's is, `puts`, a child process) goes to stderr; only boot was guarded
+  before. (#255)
+- **The booted `rails_security_scan` parses in its own process.** Brakeman's
+  forked parse workers could not return a parse error from an app that loads
+  web-console, and the scan failed where the static tier scanned. (#257)
+
+### Fixed
+
+- **A concern's declarations name the module the include resolves to.**
+  `rails_get_callbacks` on OpenProject's WorkPackage lists
+  `after_save :save_journals` from `Acts::Journalized::SaveHooks`, where it
+  said `SaveHooks`.
+- **A module declared in its outer module's file is read from there.**
+  Canvas's `Role::AssociationHelper` lives in role.rb, and its `included`
+  hook adds `before_save :resolve_cross_account_role` to Enrollment and its
+  subclasses, AccountUser and RoleOverride; the static tier called the
+  module unread and missed the callback. `rails_get_callbacks`,
+  `rails_get_model_details` and the controller filters and actions find it
+  there and read that module, not the outer class.
+- **`rails_get_callbacks` lists models of one callback count by name**, so a
+  model gaining a callback no longer moves the sections around it.
+- **A model macro written over `*args` reads each call's own arguments.**
+  The list binds to the call's positionals past the method's other
+  parameters, less the options hash the body takes off the end
+  (`args.extract_options!`), plus literals its leading statements push. A
+  block over the list is read once per item, so Canvas's
+  `validates_locale :locale, :browser_locale, allow_nil: true` lists an
+  inclusion validation on each field with its own `if: :<field>_changed?`, in
+  place of the macro's own row and one on a computed `field`. An options
+  hash, list or parameter the method changes in place (`options[:x] = 1`,
+  `options[:x] ||= 1`, `reverse_merge!`, `delete`) is not read as the call's
+  value. A declaration it decides, the method name included (`before_save
+  name` after `name.strip!`), is held back and listed under "Not decided from
+  the source (the method name or a condition)", the heading that was "Only
+  under a condition the source does not decide".
+- **A `load_defaults` written after `belongs_to_required_by_default = false`
+  turns the default back on** in the static tier, as Rails does, so the
+  implicit presence of a required `belongs_to` is listed. A literal assignment
+  used to win wherever it stood. A value the source cannot evaluate
+  (`ENV.fetch(...) == "true"`), app-wide or in the class, makes the presence
+  conditional on it, named in the answer. A literal `nil` reads as off, as
+  Rails reads it, here and for the commit-order setting. A `belongs_to` with
+  `required: nil` is optional, and `required:` decides over `optional:` when
+  both are written, as in Rails.
+- **`rails_get_callbacks` prints `on:`** for validation callbacks and any
+  callback whose type does not already name the event, before `if:` and
+  `unless:`. (#252)
+- **`rails_performance_check` with `model` and `category` counts only what it
+  lists.** (#265)
+- **`rails_search_docs` caches a fetched guide whole.** A guide with non-ASCII
+  text failed to write in the booted tier and left an empty file that read as a
+  cached guide for 24 hours; the write is now binary and atomic, and an empty
+  cache file is a miss. (#266)
+- **`rails_search_code` trace finds one definition and no sibling of itself**:
+  `qa_ping` no longer matches `def qa_ping?`, `qa_ping!` or `qa_ping=`, and
+  `def self.qa_ping` is left out of its own sibling list, where a setter now
+  appears. Every method-body lookup (concerns, callbacks, actions, conventions)
+  ends a name the same way, and ripgrep and the Ruby fallback agree on
+  non-ASCII text, where any character outside ASCII is part of the name, as
+  Ruby reads it. (#258)
+- **`rails_search_code` call sites skip comment lines** with the rule trace
+  uses, by file type: `#` in Ruby, `//` and `/*` in JS and TS, `/*` in CSS and
+  `//` too in SCSS, Sass and Less, `-#` in Haml, `/` in Slim. A stylesheet
+  line that starts with a `#id` selector is not a call site either. A line
+  holding a live ERB tag is a call site, and a spaced setter call
+  (`obj.qa_ping = 1`) is not a call of `qa_ping`. (#269)
+- **Both search backends read the same excludes file.** The Ruby fallback read
+  `core.excludesFile` from the repository's own config, which ripgrep does not.
+  It now reads what ripgrep 15 reads: `~/.gitconfig`, then the XDG git config,
+  then the default ignore file. (#268)
+- **A `db/structure.sql` table that `INHERITS` reads its parent's columns
+  first, then its own**, with multiple parents, chains, a parent defined later
+  in the file, and `ALTER COLUMN ... SET NOT NULL`/`SET DEFAULT`. A parent in
+  another schema resolves; one the file does not define is named. An index, key
+  or foreign key lands on the table its statement names, schema included. The
+  one-line form read its column type as `integer) INHERITS (...`. (#259)
+- **A Stimulus controller under `app/javascript/controllers` keeps its
+  identifier** when another `controllers` directory holds the same path, and a
+  nested `controllers` directory stays in the name (`admin--controllers--x`).
+  (#264)
+- **`query_allowed_columns` exempts a column from result redaction too**, as
+  it does from the pre-query check. Columns declared with `encrypts` stay
+  redacted. (#270)
+
 ## [5.30.2] - 2026-10-01
 
 ### Changed

data/docs/COMPATIBILITY.md

@@ -217,7 +217,12 @@ Proof sources:
    partition marker, and Discourse, Mastodon, OpenFoodNetwork and Forem
    answering as before. In the v5.30.2 release QA: 14 real apps answered by
    v5.30.1 and by the release branch side by side, and the lab regressions on
-   SQLite in all three tiers, PostgreSQL and MySQL.
+   SQLite in all three tiers, PostgreSQL and MySQL. In the v5.31.0 release QA:
+   a private Rails 8.0 API app booted and static, and Discourse, Mastodon,
+   Forem, OpenFoodNetwork, OpenProject, Consul, Canvas and Errbit answered by
+   v5.30.2 and by the release branch side by side, every changed answer
+   checked against the app's source; the lab regressions on SQLite in all three
+   tiers, PostgreSQL and MySQL; and the unit suite on Ruby 3.1 with Rails 7.0.
 2. Non-crash coverage for every built-in tool including `get_view` in
    `spec/e2e/in_gemfile_install_spec.rb`'s full-tool sweep; output correctness
    (ivar cross-check, render-form detection, partial interfaces) verified
@@ -277,12 +282,21 @@ Postgres instance in `spec/e2e/postgres_install_spec.rb`, opt-in via
   stay marked `[UNAVAILABLE]`. A concern whose file cannot be found, a gem's
   module for example, is named under `Concerns` as not read.
 - **Callbacks are what the file declares.** In both tiers the callback list is
-  what the model file, the app concerns it includes and the classes it
-  inherits from declare. A callback a
-  gem registers on include without an `include` line in the model file (Devise,
-  counter caches, attachment purges) is not listed. Within one type the order
-  is declaration order, the model file first and then its concerns, not the
-  order Rails registered them in; the order across types is Rails' event order.
+  what the model file, the app concerns it includes and the classes it inherits
+  from declare. A callback a gem registers on include without an `include` line
+  in the model file (Devise, counter caches, attachment purges) is not listed.
+  Within one type the order is the order Rails runs them: base classes first, a
+  concern's callbacks where its `include` line stands, then the model's own,
+  and a `before_` or `around_` callback with `prepend: true` first.
+  `after_commit` and `after_rollback` run last declared first unless
+  `run_after_transaction_callbacks_in_order_defined` is on (`load_defaults 7.1`
+  or later; Rails 7.0 has no such setting). The booted tier reads the setting;
+  the static tier reads `load_defaults` and any assignment in
+  `config/application.rb` or an initializer, the last line that sets it
+  winning, and when those do not say, keeps declaration order and the answer
+  says so. The static tier does not read `config/environments/*.rb` for this
+  setting or for `belongs_to_required_by_default`, so a value set per
+  environment is missed. The order across types is Rails' event order.
 - **Concern-style Mongoid documents in runtime results.** Mongoid documents
   are invisible to ActiveRecord reflection, so `ModelIntrospector#call` falls
   back to the same source-parsing pass used in the static tier even when the

data/docs/CONFIGURATION.md

@@ -213,6 +213,9 @@ fits neither that shape nor the conventional one.
 |:-------|:-----|:--------|:------------|
 | `sensitive_patterns` | Array | 34 patterns | File patterns blocked from search/read (`.env*`, `*.env`, `.envrc`, `*.key`, `*.pem`, `config/credentials.yml.enc`, `config/application.yml`, `config/settings.local.yml`, `.ssh/*`, etc.) |
 
+A placeholder such as `.env.example` stays readable unless a path pattern or
+its exact name blocks it; see [SECURITY.md](SECURITY.md).
+
 ### Extensibility
 
 | Option | Type | Default | Description |

data/docs/GUIDE.md

@@ -826,7 +826,13 @@ rails_get_callbacks(model: "Order", detail: "full")
   → Order's callbacks with the actual method source code for each callback
 ```
 
-**Returns:** Callbacks grouped by type, in Rails event order. Includes concern-provided callbacks, with their bodies read from the concern file. Within one type the order is declaration order, not the order Rails registered them in.
+**Returns:** Callbacks grouped by type, in Rails event order. Includes
+concern-provided callbacks, with their bodies read from the concern file.
+Within one type the order is the order Rails runs them, base classes first, a
+`before_` or `around_` callback with `prepend: true` first, and
+`after_commit`/`after_rollback` last declared first unless the app runs them in
+order (`load_defaults 7.1`). A method declared again shows once with the later
+declaration's conditions.
 
 ### rails_get_helper_methods
 

data/docs/INTROSPECTORS.md

@@ -186,7 +186,7 @@ It runs a single-pass Dispatcher that walks the AST once and feeds events to all
 | CallbacksListener | All AR callback types including `around_*`, `after_touch`, `after_initialize` and `after_find`; `after_commit` with `on:` resolution; a callback object by its constant, a block as `[inline_block]`; `if:`/`unless:` kept as the source wrote them, and the options of an enclosing `with_options` block |
 | MacrosListener | `encrypts`, `normalizes`, `delegate`, `has_secure_password`, `serialize`, `store`, `has_one_attached`, `has_many_attached`, `has_rich_text`, `generates_token_for`, `attribute` |
 | MethodsListener | `def`/`def self.`, visibility tracking, parameter extraction, `class << self`; `include_initialize: true` adds the constructor a caller reports on its own |
-| MixinsListener | `include`, `prepend`, `extend`, flagging the ones that reach the ancestor chain |
+| MixinsListener | `include`, `prepend`, `extend`, `singleton_class.include` and `singleton_class.prepend` (`singleton_class.extend` is not read), flagging the ones that reach the ancestor chain, as reflection reports them |
 
 ### The targeted-walk listeners
 
@@ -214,8 +214,13 @@ Passed to `SourceIntrospector.walk(path, key => Listener)` when a specific file
 | MailboxRoutingListener | Action Mailbox `routing` and processing callbacks |
 | ModelReferenceListener | Model constants used in controllers: `Post.find`, `params.require(:post)`, ivar writes |
 | VariantCallListener | `variant` calls (ChainedCallListener with `:variant` preset) |
+| ProcLiteralListener | Proc literals: line, source, assigned constant |
 | MethodCallListener | Call sites by name or pattern anywhere in a file, inside a `def`, a lambda or a block included, with arguments, options, receiver and line. Used by the Turbo introspector for broadcast calls and by `ActionFilters` for the skip macros |
 
+`GenericMacroListener.new(*names, block_source: [:name])` adds `block`, the
+one-line source of the block those macros are given. ProcLiteralListener is
+what the job introspector reads a `queue_as` Proc with.
+
 ### Adding a listener
 
 1. Subclass `BaseListener` in `lib/rails_ai_context/introspectors/listeners/`. Use its helpers rather than re-reading nodes: `extract_symbol_args`, `extract_keyword_options`, `extract_arg_values` (source-slice fallback for expressions like `2.hours`), `extract_keyword_sources`, `extract_keyword_nodes`, `keyword_hash`, `constant_path_string`.

data/docs/SECURITY.md

@@ -66,10 +66,23 @@ After validation, the query runs inside a transaction:
 |:---------|:----------|
 | PostgreSQL | `SET TRANSACTION READ ONLY` + `SET LOCAL statement_timeout` |
 | MySQL | `SET TRANSACTION READ ONLY` + `MAX_EXECUTION_TIME` hint |
-| SQLite | `PRAGMA query_only = ON` + progress handler for timeout |
+| SQLite | A read-only connection in a child process, killed at timeout |
 
 All queries execute inside a transaction, then rollback (even if they could write, they can't).
 
+A SQLite query runs in-process under `PRAGMA query_only = ON`, with no time
+limit, for an in-memory database, on a platform without `fork`, or when it
+needs a function, virtual-table module, collation or encryption key only the
+app's own connection has. The table and EXPLAIN answers then say so; CSV output
+stays plain data.
+
+On sqlite3 1.x a query fails at its timeout, with the statement-timeout error,
+when another connection in the same process held an exclusive lock on a
+rollback-journal database as it started (`BEGIN EXCLUSIVE`): the child
+inherits that lock record and it never clears. A lock held
+by another process is waited on as usual, and an open write transaction or any
+lock in WAL mode does not block it.
+
 ### Layer 3 - Row limit
 
 - Default: 100 rows
@@ -90,6 +103,9 @@ If one of your own columns merely looks sensitive (an `oauth_applications.secret
 config.query_allowed_columns = %w[secret]
 ```
 
+The exemption covers the results too: an allowed name comes back unredacted. A
+column declared with `encrypts` stays `[FILTERED]` either way.
+
 ### Environment guard
 
 > [!WARNING]
@@ -115,6 +131,12 @@ config/mongoid.yml config/redis.yml
 .ssh/* .aws/credentials .aws/config .netrc .pgpass .my.cnf
 ```
 
+A placeholder whose name ends in `.example`, `.sample`, `.template` or
+`.dist` (`.env.example`) is committed to be read, so a basename glob such as
+`.env.*` does not block it. A pattern that names it exactly, with no glob
+characters, still does, and so does a path pattern (one with a `/`, such as
+`.ssh/*`), which covers everything under it.
+
 ### AI context file exclusions
 
 Search also excludes generated AI context files to prevent circular references:

data/docs/TOOLS.md

@@ -179,8 +179,17 @@ Concerns as `[UNAVAILABLE]` rather than dropped.
 Callbacks grouped by type, in Rails event order, with source code. The list
 covers concern-declared callbacks too, with the body read from the concern
 file, and the "From Concerns" section says which concern declared each one.
-Within one type the order is declaration order (the model file first, then
-its concerns), not the order Rails registered them in.
+Within one type the order is the order Rails runs them: base classes first, a
+concern's callbacks where its `include` line stands, then the model's own, and
+a `before_` or `around_` callback with `prepend: true` first. `after_commit`
+and `after_rollback` are last declared first unless the app turns on
+`run_after_transaction_callbacks_in_order_defined` (`load_defaults 7.1`). A
+method declared again for one type shows once, with the later declaration's
+conditions, as Rails keeps it. The order is read from source in both tiers,
+and dynamic dispatch is not evaluated: a callback registered through
+`send(:before_save, ...)`, through a method called with `send` or defined with
+`define_singleton_method`, or through a module included in `class << self` is
+not read, so the list can miss it or show the definition it replaces.
 
 | Parameter | Type | Default | Description |
 |:----------|:-----|:--------|:------------|

data/lib/rails_ai_context/action_filters.rb

@@ -401,11 +401,10 @@ module RailsAiContext
     # A module whose file is not found is taken for a concern.
     def runs_once?(name, root, within)
       root ||= default_root
-      path = root && ConcernPaths.find_file(root.to_s, name, prefer: "controller", within: within.to_s)
-      source = path && SafeFile.read(path)
+      source = root && ConcernPaths.module_source(root.to_s, name, prefer: "controller", within: within.to_s)
       return true unless source
 
-      RunCache.fetch([ :concern_module, path ]) do
+      RunCache.fetch([ :concern_module, source ]) do
         Introspectors::SourceIntrospector.walk_source(source, { mixins: Introspectors::Listeners::MixinsListener })[:mixins]
           .any? { |mixin| mixin[:macro] == :extend && mixin[:name] == "ActiveSupport::Concern" }
       end

data/lib/rails_ai_context/base_mixins.rb

@@ -6,6 +6,8 @@ module RailsAiContext
   module BaseMixins
     # `path` is nil when the declaring file is not the app's (a gem's module).
     Mixin = Struct.new(:name, :path, :macro)
+    # A base body's statements, the base it runs in, and its file's place in load order (sorted, as Rails loads initializers).
+    Body = Struct.new(:statements, :target, :order)
 
     TARGETS = %w[ActiveRecord::Base ApplicationRecord].freeze
     HOOK = :active_record
@@ -21,12 +23,22 @@ module RailsAiContext
       RunCache.fetch([ :base_mixins, root ]) { discover(root) }
     end
 
-    def discover(root)
-      scanned_files(root).flat_map do |file|
-        source = SafeFile.read(file)
-        next [] unless source && MARKERS.any? { |marker| source.include?(marker) }
+    # Each model base body the app writes outside app/models, where a `def self.x` or
+    # `class << self` defines a class method every model under that base has.
+    # @return [Array<Body>]
+    def bodies(root)
+      root = File.expand_path(root.to_s)
+      RunCache.fetch([ :base_bodies, root ]) do
+        marked(root).each_with_index.flat_map do |(_, tree), order|
+          base_bodies(tree).map { |statements, target, _| Body.new(statements, target, order) }
+        end
+      end
+    rescue StandardError => e
+      RailsAiContext.debug_fail(e, [], label: "BaseMixins.bodies")
+    end
 
-        tree = AstCache.parse(file).value
+    def discover(root)
+      marked(root).flat_map do |file, tree|
         mixed_in(tree).map { |macro, name| Mixin.new(name, declaring_file(root, name, file), macro) }
       end.uniq(&:name)
     rescue StandardError => e
@@ -34,6 +46,15 @@ module RailsAiContext
     end
     private_class_method :discover
 
+    # [file, tree] for each scanned file that names a model base.
+    def marked(root)
+      scanned_files(root).filter_map do |file|
+        source = SafeFile.read(file)
+        [ file, AstCache.parse(file).value ] if source && MARKERS.any? { |marker| source.include?(marker) }
+      end
+    end
+    private_class_method :marked
+
     # Everywhere the app configures itself but app/models: a model file's includes are
     # its own, and the model walk reads that file already.
     def scanned_files(root)
@@ -50,25 +71,31 @@ module RailsAiContext
     private_class_method :scanned_files
 
     # [macro, constant] for each module the tree mixes into a model base:
-    # sent to it, run in its `on_load` hook, or written in its reopened body.
+    # sent to it, run in its `on_load` hook, or written in its own body.
     def mixed_in(tree)
       Introspectors::AstWalk.each(tree).flat_map do |node|
         next [] unless node.is_a?(Prism::CallNode)
         next hook_mixins(node) if hook?(node)
 
         target?(node.receiver) ? mixin_calls(node) : []
-      end + reopened_mixins(tree)
+      end + base_bodies(tree).reject(&:last).flat_map(&:first).flat_map { |call| call.is_a?(Prism::CallNode) && call.receiver.nil? ? mixin_calls(call) : [] }
     end
 
-    # `class ActiveRecord::Base; include X; end`, however the namespace is written.
-    def reopened_mixins(tree)
-      Introspectors::DeclaredConstant.constants(tree).flat_map do |name, node|
-        next [] unless node.is_a?(Prism::ClassNode) && TARGETS.include?(name) && node.body
+    # [statements, base, hook?] for each body a base runs as self: `class ActiveRecord::Base` reopened
+    # however the namespace is written, `ActiveRecord::Base.class_eval do`, and an `on_load` block.
+    def base_bodies(tree)
+      reopened = Introspectors::DeclaredConstant.constants(tree).filter_map do |name, node|
+        [ node.body, name, false ] if node.is_a?(Prism::ClassNode) && TARGETS.include?(name)
+      end
+      evaluated = Introspectors::AstWalk.each(tree).filter_map do |node|
+        next unless node.is_a?(Prism::CallNode) && node.block
+        next [ node.block.body, TARGETS.first, true ] if hook?(node)
 
-        node.body.body.flat_map { |call| call.is_a?(Prism::CallNode) && call.receiver.nil? ? mixin_calls(call) : [] }
+        [ node.block.body, node.receiver.slice.delete_prefix("::"), false ] if %i[class_eval class_exec].include?(node.name) && target?(node.receiver)
       end
+      (reopened + evaluated).filter_map { |body, *rest| [ body.body, *rest ] if body.is_a?(Prism::StatementsNode) }
     end
-    private_class_method :reopened_mixins
+    private_class_method :base_bodies
 
     # Inside `on_load(:active_record) { ... }` the block runs in the base.
     def hook_mixins(node)
@@ -109,11 +136,12 @@ module RailsAiContext
     private_class_method :constants
 
     # Past Zeitwerk's path, a plugin's module sits in a lib file its init.rb
-    # requires, under a name its path does not spell.
+    # requires, under a name its path does not spell; a namespace stub is not it.
     def declaring_file(root, name, file)
-      ConcernPaths.find_file(root, name) ||
+      ConcernPaths.find_file(root, name, outer: false) ||
         ([ file ] + required_files(root, file, 2)).find do |candidate|
-          Introspectors::DeclaredConstant.module_node(AstCache.parse(candidate).value, name)
+          node = Introspectors::DeclaredConstant.module_node(AstCache.parse(candidate).value, name)
+          node && !Introspectors::DeclaredConstant.stub?(node)
         end
     rescue StandardError => e
       RailsAiContext.debug_fail(e, nil, label: "BaseMixins.declaring_file #{name}")