rails-ai-context 5.30.2 → 5.32.0

data/CHANGELOG.md

@@ -5,6 +5,874 @@ 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.32.0] - 2026-10-06
+
+### Added
+
+- **`model_details` lists more of what a model declares.** Under Macros:
+  `attribute` (with its type and default), `alias_attribute`, `has_rich_text`,
+  `strict_loading_by_default`, `implicit_order_column`, `locking_column`,
+  `store_full_sti_class`, `attr_readonly` and `query_constraints`, in both
+  tiers; a setting assigned inside a method or a nested class is not listed as
+  the model's. An STI model names its parent (or a base its subclasses) and its
+  type column, honoring `inheritance_column`, and only where the table has that
+  column (the static tier reads the schema dump). A model whose base class calls
+  `connects_to` gets a Database line with the call as written and the class it
+  comes from, in `model_details` and `get_context`; a call under a condition
+  says `(only if ...)`, and otherwise the model's columns come from the schema
+  of the database it writes to. (#294, #390, #395)
+- **`model_details` lists a model's `default_scope`** at the top of Scopes,
+  declared as the macro or as `def self.default_scope` in the model's own class
+  (not a class or module nested in its file), with `all_queries: true` when
+  declared. A base's default scope comes first, in the order Rails stacks them.
+  (#295)
+- **`model_details` reads common model gems.** An `aasm` machine shows its
+  states, initial state, events and transitions, and `has_paper_trail`,
+  `friendly_id`, `mount_uploader`, `monetize` (with the attribute it adds),
+  `pg_search_scope`, `acts_as_list` and other gem macros get a line each, as
+  written. The static tier lists the `belongs_to` that `acts_as_tenant`
+  declares. A macro written inside a method body or a nested class is not
+  credited to the model, and `aasm.current_state` in a method opens no second
+  machine. (#389)
+- **`model_details` lists each index a Mongoid document declares**, as written,
+  and the fields and indexes its included concerns declare. (#412)
+- **In an Apartment app, `model_details` says where a model's table lives**: in
+  the shared schema (`excluded_models`) or in each tenant's schema, whatever the
+  `Apartment.configure` block calls its parameter. A list built with `+=` or
+  `<<` is named as computed. (#415)
+- **The schema lists views, materialized views and SQLite virtual tables** in
+  both tiers (scenic's schema.rb, structure.sql, the connection), labelled in
+  the listings. The table view shows a view's SQL or a virtual table's module,
+  with its columns by name alone, and the indexes declared on a materialized
+  view. Views and virtual tables are not counted as tables with no model file,
+  and a table the dumper could not write is listed with its reason. Known limit:
+  booted on Rails 7.x with SQLite older than 3.37, a virtual table's shadow
+  tables still list as tables. (#354)
+- **`job_pattern` shows more of how a job runs.** A job's page shows its
+  `queue_with_priority`, `enqueue_after_transaction_commit`, Solid Queue
+  `limits_concurrency` and its enqueue, perform and `after_discard` callbacks;
+  `retry_on` keeps its `queue:`, `priority:` and `jitter:`, and a Sidekiq
+  worker's `sidekiq_retry_in` and `sidekiq_retries_exhausted` blocks are listed
+  under its retries (the worker listing names such a block by its macro only). A
+  priority given as a lambda reads as computed. A job that includes
+  `ActiveJob::Continuable`, itself or through a base, is marked so, with the
+  steps its `perform` runs in order. (#392, #409)
+- **`job_pattern` names the queues Solid Queue's workers poll** in
+  `config/queue.yml` and flags every job queue no worker polls, in the listing
+  and on the job's own page, when the app runs Solid Queue (its config sets
+  `active_job.queue_adapter = :solid_queue`, or sets no adapter and the Gemfile
+  has `solid_queue`). (#396)
+- **delayed_job's `handle_asynchronously` methods are listed** with their
+  options, in `job_pattern` and `model_details`, where `job_pattern` used to say
+  No jobs found. A method a concern wraps is listed under each model that
+  includes the concern, directly or through another concern. (#410)
+- **`mailers` lists Action Mailbox and more mailer settings.** The mailboxes,
+  the routing rules in the order Rails tries them with the mailbox each sends
+  to, and each mailbox's processing callbacks. Each mailer shows its own
+  `default`, `layout`, helpers and callbacks, the template formats of each
+  action and its preview class; the full listing names the queue `deliver_later`
+  uses, the interceptors and observers the config registers, and the mailer
+  preview paths. (#386, #393)
+- **`env` lists environment variables from more places**: the env Kamal's
+  `config/deploy.yml` sets at the top level, for each role
+  (`servers.<role>.env`) and for each `env.tags` tag (secret names, never
+  values, and clear values, except one holding a URL or a key-like token, or
+  under a secret-named variable, which shows as hidden, and one an ERB tag sets,
+  which says so; a `config/deploy.<destination>.yml` is named as not read), the
+  setting keys in the config gem's `config/settings.yml` and
+  `config/settings/<env>.yml` when the bundle has the config gem, each
+  `Anyway::Config` class's attributes with the env names they read (values left
+  out), the ENV names `Rails.app.creds` and `Rails.app.envs` read on Rails 8.2
+  (`require(:stripe_api_key)` is `STRIPE_API_KEY`, nested keys joined by `__`),
+  and the ENV names read in `config.ru`, `db/seeds.rb`, `db/seeds/` and the Ruby
+  scripts in `bin/`. (#397, #398, #404, #417)
+- **`config` lists what runs in front of Rails and what CurrentAttributes
+  holds**: the middleware `config.ru` adds (with the `if` it runs under, and the
+  `map` it sits inside when that map runs the app itself) and the `map` mounts
+  that run their own Rack app, in the static tier too, and each
+  CurrentAttributes class's attributes, their defaults and its reset hooks.
+  (#398, #399)
+- **`env_config` lists the config keys `config/application.rb` sets for every
+  environment** (`config.x` included) and, for each `config_for` call (a name,
+  or `Rails.root.join` of literal parts), the keys its YAML file gives the
+  running environment, or the environment a literal `env:` names. A file on
+  `sensitive_patterns`, outside the app, or over `max_file_size` is named with
+  that reason and its keys are not read. (#394)
+- **`active_support` lists the ActiveSupport::Notifications events the app
+  subscribes to** (`subscribe`, `monotonic_subscribe`, and a Subscriber's
+  `attach_to`, inside the class with or without `self.`, or called on it
+  afterwards) with the file and line of each, in both tiers. An `attach_to`
+  lists one `<method>.<namespace>` event per public method the subscriber
+  defines in that file, and says so in words when it defines none. (#387)
+- **`onboard` lists the app's own tooling**: its custom rake tasks (Rakefile,
+  `lib/tasks`, `rakelib`) with their arguments, the description `rake -T` prints
+  and the file, one entry for a task defined in several places (the first 15 at
+  standard detail, every one at full), its own generators (`bin/rails generate
+  service`), the `lib/templates` files that replace a built-in generator's
+  template, and the Railties under `lib/` with their initializers. (#385, #400)
+- **`onboard` and the gems resource read more Ruby version sources.** A Ruby
+  engine other than CRuby is named from `.ruby-version`, `.tool-versions`, the
+  Gemfile `ruby` line or the lockfile ("declaring JRuby 9.4.8.0 (Ruby
+  3.1.4p0)"), where a `jruby-` `.ruby-version`, or a bare `jruby` one, gave no
+  Ruby at all. A version pinned in mise (`mise.toml`, `mise.local.toml`,
+  `.mise.toml`, `mise/config.toml`, `.mise/config.toml`, `.config/mise.toml` or
+  `.config/mise/config.toml`) is read when no other file names one. (#420, #421)
+- **`controllers` and `view` say which layout a controller renders in**
+  (declared, inherited, set by an app concern it includes, or found by name),
+  and `controllers` lists the `allow_browser`, `protect_from_forgery`,
+  `add_flash_types`, `default_form_builder` and `wrap_parameters` settings it,
+  its ancestors and their app concerns declare. (#337)
+- **`controllers` lists the filters authorization gems add**: cancancan's
+  `load_and_authorize_resource`, `load_resource`, `authorize_resource`,
+  `check_authorization` and `skip_authorization_check`, and acts_as_tenant's
+  `find_tenant_by_subdomain`, in both tiers; one passed `prepend: true` is
+  listed first, where cancancan adds it. Each is read only when the lockfile
+  resolves that gem and no class on the chain defines a class method of the same
+  name. A responders class-level `respond_to :json` shows its formats in both
+  tiers, and a subclass shows the formats its ancestors declare, as responders
+  copies them. (#406, #407)
+- **`view` marks template and partial variants and locales**:
+  `show.html+mobile.erb` is the `mobile` variant of `show`, and
+  `show.fr.html.erb` its `fr` locale. (#408)
+- **`routes` lists the endpoints of a mounted Grape API** under its mount: verb,
+  full path with prefix and version, and declared params, with a `route_param`'s
+  param and a params block before a namespace given to every endpoint inside it.
+  Read from `app/api` and `lib/api` in both tiers; an edit there refreshes the
+  MCP server's cached answer. (#411)
+- **`service_pattern` reads more service shapes.** It reads `app/interactions`
+  and `app/interactors` as well as `app/services` (so does the generated files'
+  Services line), lists an interactor organizer's steps in order, and shows an
+  Initialize line and an Inputs section for a service whose constructor comes
+  from T::Struct `const`/`prop`, Dry::Struct `attribute`, dry-initializer
+  `param`/`option` or the attr_extras initializers. Dry::Struct attributes and
+  dry-initializer params and options an app superclass declares are included,
+  marked with the class they come from. (#402, #403)
+- **`conventions` and `analyze_feature` list the models an admin gem exposes**:
+  ActiveAdmin (with the params it permits), Administrate, Avo (2 and 3 resource
+  naming), Madmin and Trestle. (#405)
+- **`conventions` lists `.standard.yml`, `.erb_lint.yml` (or the older
+  `.erb-lint.yml`), `sorbet/config` and `Steepfile`** under Notable config
+  files, beside `.rubocop.yml`. (#422)
+- **The package manager is found at the JS workspace root.** `frontend_stack`
+  and `conventions` name it when the lockfile sits in a workspace root above the
+  app (never above the git root), and `frontend_stack` says which directory that
+  is. (#401)
+
+### Changed
+
+- **A configured frontend directory outside the app root is read for its
+  manifests.** A `frontend_paths` entry such as `../web-client`, and the JS
+  workspace root above the app, are read for `package.json`, lockfiles and the
+  presence of a bundler config only, plus a configured entry's `tsconfig.json`
+  and the configs it extends inside that directory. `frontend_stack` reports the
+  framework, build tool, package manager and TypeScript settings and names the
+  directory instead of calling the app API-only; an entry inside the app root
+  gets the same build tool and package manager answer. docs/SECURITY.md lists
+  this read under "Frontend roots outside the app". (#377, #401)
+- **An app with no lockfile of its own reads the bundle `config/boot.rb` points
+  at.** In an engine's `test/dummy`, static `onboard`, `gems`, `env` and the
+  Rails version read the Gemfile and lockfile its `BUNDLE_GEMFILE` names when
+  they sit inside the app's git repository; outside one, they say that bundle is
+  not read and name it. docs/SECURITY.md lists this read, and the engine source
+  a booted `test/dummy` reads, under "The bundle config/boot.rb declares" and
+  "The engine an app's test/dummy runs in". (#381, #423)
+- **The controllers payload carries `rate_limits`**, one entry per `rate_limit`
+  call, in place of `rate_limit` and `rate_limit_parsed`. `controllers` prints
+  every limit a controller declares, whole when the call spans lines, and in a
+  controller's own detail each limit an ancestor declares, named by the class
+  that declares it. (#332)
+- **A booted filter an outside module defines carries that module as
+  `from_concern`.** With `include ActiveStorage::SetBlob`, `set_blob` reads
+  `(from ActiveStorage::SetBlob)` and is never labelled as not declared in the
+  controller chain; an `on_load` filter beside it still is. (#293)
+- **A strong params entry's `nested` list keeps a doubly-wrapped list as an
+  inner array.** `params.expect(thing: [items: [[:sku, :qty]]])` carries
+  `"items" => [["sku", "qty"]]`, where it was flattened to the single-hash
+  `["sku", "qty"]`, and the `controllers` summary prints it as
+  `items: [[:sku, :qty]]`. (#333)
+- **The views payload no longer carries `conditional_layouts`.** Each controller
+  entry carries `layout` and `settings` instead. (#337)
+- **The mailboxes payload drops each mailbox's `routing` list** (`{pattern,
+  action}`). A mailbox carries `routed_from`, the patterns that send to it, the
+  section gains a top-level `routes` list (`{pattern, mailbox, file}`) in the
+  order Rails tries them, and a mailbox's `file` is relative to the app root
+  (`app/mailboxes/replies_mailbox.rb`), not to `app/mailboxes`. (#386)
+- **A job's `callbacks` in the jobs payload holds the declarations as written**
+  (`before_perform :log_start`) in place of the bare macro names
+  (`before_perform`). (#392)
+- **A Mongoid model's payload always carries `collection:`**, the `store_in`
+  name or the one Mongoid derives (`admin_shelves`), where it was set only for
+  `store_in`. An embedded document carries `embedded_in:` (its parent class)
+  in its place, and a subclass of a document (`class Ebook < Book`) is a
+  Mongoid model with its root's collection and fields and `parent_model:`,
+  where it was read as an ActiveRecord model with an `ebooks` table. (#382)
+- **`schema --table` JSON for a name that holds different tables in two
+  databases is `{table:, databases: {<name> => table}}`** instead of one table's
+  keys at the top level. (#356)
+- **Views are counted apart from tables.** Schema entries carry `kind:` (`view`,
+  `materialized_view`, `virtual_table`) in JSON, `total_tables` leaves views
+  out, and the schema headers read `116 tables and 2 views`. `onboard` counts
+  tables only. (#354)
+- **`encryption_details` options are the source text.** Each `encrypts` entry
+  carries every option as the file writes it (`"true"`, not `true`), a
+  `normalizes` entry carries its `with:` lambda and other options as written,
+  and `generates_token_for` its `expires_in` as written. (#391)
+- **`concern` lists only what an includer gains under Class Methods**:
+  `class_methods do`, `module ClassMethods`, and a `def self.x` written in
+  `included do`. The module's own `def self.x` and `class << self` methods move
+  to a new Module Methods section, and its `def self.included(base)` (or
+  `extended`, `prepended`) hook is listed under neither. A `def self.x` or
+  `class << self` written inside `class_methods do` belongs to ClassMethods
+  alone, so neither section lists it. (#312)
+- **The tests payload's `factories` carries `unread: true`** when a test helper
+  loads factories from a path built at run time. Its `count` is then the files
+  of the paths that were read, and nil when none was; `test_info` and `onboard`
+  print no file count in that case. (#373)
+- **`search_docs` no longer accepts `source: "api"`**, which never had entries.
+  The valid sources are all, guides, stimulus, turbo and hotwire. (#322)
+- **The auth payload's `has_secure_password` lists only models with the
+  default password.** A named one (`has_secure_password :six_digit_code`) goes
+  under a new `secure_password_digests` key, model => attributes. A class
+  written across several files keeps its password, and a nested class's
+  digest is not credited to the outer model. (#369)
+- **`model_details` Structure sections no longer share a line.** Each section
+  ends on the line before the next one starts, so a 3-line model reads
+  `class definition(1-1) → associations(2-3)` where 5.31.0 printed `(1-2)`.
+- **The schema payload's `declared_tables` includes db/schema.rb's
+  `create_virtual_table` names and the tables it records as "Could not dump
+  table".** The booted `schema` line that compares
+  declared and connected tables counts a virtual table as a table and a view
+  as neither, as the header above it does, so the two numbers match.
+
+### Fixed
+
+- **Three crashes on older or unusual setups are gone.** After a boot that fails
+  inside a Rails 7.0 app's activesupport (Logger not loaded), the static tier
+  answers instead of every tool crashing. Booted tools no longer fail with
+  "wrong number of arguments" on a Rails 7.0 app whose bundle locks zeitwerk
+  2.5; the gem now accepts zeitwerk 2.5. CLI tools no longer crash with
+  Encoding::CompatibilityError on a non-ASCII argument under a C or other
+  non-UTF-8 locale. (#272, #273, #275)
+- **A Sinatra app with `config/environment.rb` and `app/` is not read as a Rails
+  app**; both tiers answer "No Rails app found". With no lockfile, a Gemfile
+  that names neither rails nor railties decides the same before anything boots,
+  so the tree's own `bundler/setup` never runs and never writes a lockfile into
+  it. A tree whose `config/environment.rb` loads but defines no Rails
+  application, with no lockfile to decide, reports a failed boot and answers
+  from the static tier. (#274)
+- **An app without Active Record says so.** `schema` says introspection does not
+  apply, `onboard` no longer says "on unknown", and `model_details` says there
+  is no Active Record model by that name. A sequel-rails app gets "this app uses
+  Sequel; ActiveRecord schema introspection does not apply" instead of id-only
+  tables replayed from Sequel migrations, and a replay behind an empty schema.rb
+  says the dump declares no tables. (#364, #383)
+- **Gems are read from `gems.rb` and `eval_gemfile` files.** An app on `gems.rb`
+  and `gems.locked` reads its gems, Rails version and Ruby version in `gems`,
+  `onboard` and `doctor` as one on `Gemfile` does, and gems declared in a file
+  named by `eval_gemfile` are read, so `env`, `gems`, `helper_methods` and the
+  app-kind checks see them. (#418, #419)
+- **A new Rails 8 app reads right.** `onboard` names the adapter database.yml
+  declares when there are no tables yet, where it said "on unknown"; `schema`
+  lists the solid_queue, solid_cache and solid_cable tables from their own dump
+  files and says the primary database has no tables yet. `onboard --detail full`
+  says "Dockerfile: present." and "Deployment: kamal.", names a `Procfile.dev`
+  on its own line instead of reporting a Procfile, and no longer prints an empty
+  "File Storage & Rich Text" heading. The migrations list names a migration
+  `active_storage:install` or `action_text:install` copied by its class, without
+  the scope suffix. (#276, #280, #281, #284)
+- **`config` reports the Action Cable adapter of the current environment**
+  (solid_cable in a default Rails 8 production, not the development block's
+  async) and keeps the Database line when the environment lists several
+  databases. `observability` reports Rails 8.1's event reporter (`Rails.event`)
+  as available, with its subscriber count. (#285, #286)
+- **`test_info` reads Rails 8.1 test setups.** It and `onboard` name
+  `config/ci.rb` (`rails_ci`), Buildkite, Jenkins and Bitbucket Pipelines as CI,
+  and `test_info` lists the steps `bin/ci` runs. It lists `test/test_helpers`
+  (where the authentication generator puts `SessionTestHelper`) as test helpers,
+  no longer lists `test/helpers` helper tests as helpers, and shows the
+  `parallelize`, `fixtures` and `driven_by` calls. (#277, #287)
+- **Rails 8 generated authentication reads right.** `controllers` no longer
+  drops the authentication filter from every controller: a `skip_before_action`
+  inside a class method (`allow_unauthenticated_access`) applies only where a
+  controller calls that method, with the options the call passes, also through a
+  class method of its base, or of a concern either one includes, that calls it.
+  `conventions` builds the controller test's sign-in from the call the app's
+  tests make (`sign_in_as`), and signs in the app's own users fixture where the
+  tests sign in a variable set elsewhere. (#288, #289)
+- **`read_logs` reads the level a formatter writes**, never a word in the
+  message, and reads Sidekiq's 6/7, 8 (colored) and JSON formats and
+  rails_semantic_logger's one-letter level. It filters by level only when most
+  lines carry a severity; otherwise (Rails' default dev and 8.0+ production
+  formatter) it shows every line and says it cannot filter by level. It reads a
+  rotated log (`file: "development.log.0"`) and lists rotated logs under the
+  available files. (#278, #343)
+- **Static `routes` draws more of what Rails draws.** Shallow nesting,
+  `path_names`, a `new do` block, every path of a multi-path route (Rails 8.1
+  refuses that form, so on 8.1 it counts as not expanded), routes inside
+  `controller :x do`, `options` routes, and the routes of a method defined in a
+  route file, where it is called. A resource whose options are a variable, and a
+  call it cannot expand (`load`, `use_doorkeeper`, `ActiveAdmin.routes(self)`,
+  also inside a `constraints` or `authenticate` block), count as not expanded
+  instead of listing seven actions or vanishing; `direct` and `resolve` are no
+  longer counted, and a lambda mount counts as the booted tier counts it. Routes
+  an initializer adds with `Rails.application.routes.prepend` or `.append` are
+  listed first and last, as Rails draws them, including one registered inside
+  `after_initialize`, which Rails runs before it draws the routes; one
+  registered inside another `on_load` hook counts as not expanded, since that
+  hook may run after the draw. The framework count says it covers only the app's
+  route files, and that routes Rails' own engines and gems draw are read only
+  with the app booted; `onboard`, the rake summary and the generated context
+  files say so beside their route count too. (#283, #325, #326, #328)
+- **A route, mount or filter under a condition carries it.** Static `routes`
+  marks a route under `if`/`unless`, a `case` branch or an `&&`/`||` guard
+  (`case Rails.env`, `Rails.env.development?`, `ENV[...]`) with that condition.
+  A mounted app in the `routes`, `engines` and `onboard` lists and the generated
+  context files, and a controller filter or skip declared under one
+  (`before_action :x if Rails.env.test?`), carry it too, on both tiers; a skip
+  under one leaves the filter in the chain, and the generated files no longer
+  count such a filter as global. (#327)
+- **`routes --detail full` prints each route's constraints and defaults** beside
+  its path, as `bin/rails routes` does, on both tiers, and escapes the `|` in a
+  merged `PATCH|PUT` or `via:` verb so each route stays one table row. (#279,
+  #329)
+- **Engine routes are counted.** Run from a mountable engine's root, `routes`
+  and `onboard` list and count the engine's own routes instead of 0, including
+  an engine whose namespace does not match its path (`PgHero::Engine` in
+  `lib/pghero/engine.rb`). `engines` counts a loaded engine's routes the way
+  `routes` does, PATCH and PUT as one, and counts its redirects and lambdas
+  beside them (`23 routes, 2 redirect or lambda routes`). (#379, #380)
+- **Booted from a mountable engine's `test/dummy`, the engine's own code is
+  read.** `model_details`, `controllers` and the other class listings include
+  the engine's own models and controllers, name their files relative to the app
+  root (`../../app/models/...`), and list and render the views and layouts in
+  the engine's `app/views`; `test_info`, `analyze_feature` and `generate_test`
+  read the engine's test suite. With `--no-boot` the test tools read it too when
+  the engine's bundle is inside the app's git repository. When it is not, the
+  test framework reads "not read" in `test_info`, `onboard` and the generated
+  context, where it said "no tests yet", and a `test_info` model or controller
+  search says the engine's suite was not searched. `controllers` with
+  `--no-boot` from a `test/dummy` says the engine above it is not read, where it
+  listed no controllers and said nothing, and `view` and `partial_interface` say
+  the engine's views are read only with the app booted. (#381)
+- **`view` lists more templates.** Templates with no handler extension
+  (`pwa/service-worker.js`, `pages/about.text`), which Rails renders with its
+  raw handler, are listed and shown, each fenced by what renders it. View paths
+  `config/application.rb` adds to `config.paths["app/views"]` are read, so a
+  template under `app/views/custom` is listed as `posts/show` and an overlay
+  such as `enterprise/app/views` is listed at all; `helper_methods` and
+  `stimulus` read those paths too. On an API-only app that keeps the two mailer
+  layouts `rails new --api` creates, `view` lists them instead of saying
+  `app/views` does not exist. (#282, #338, #346)
+- **`partial_interface` reads strict locals and implicit renders right.** A
+  strict locals comment that ends in `-%>`, has a default with parentheses, or
+  is the empty `locals: ()` (now said to accept no locals) is read. `render
+  @posts` is credited to the partial Rails renders: under the view's controller
+  namespace unless `prefix_partial_path_with_controller_namespace` is off
+  (booted, as ActionView::Base holds it; unbooted, as `config.action_view`,
+  ActionView::Base or an `on_load(:action_view)` block sets it in
+  config/application.rb, the environment file or any initializer), or at the
+  path a model's `to_partial_path` returns when it returns a string literal.
+  `render @post.comments` goes to the partial of the records the association
+  the model declares holds (its `class_name:` when it has one), a chain on a
+  receiver that is no model (`current_user.posts`) goes to the partial of the
+  records it names, a trailing call on a collection (`@posts.first`,
+  `@posts.recent`) keeps that collection's records, and a chain the app's
+  models cannot resolve, or a `through:` association that names its
+  `source:`, is credited to no partial. The `view` tool's `renders:` list
+  reads the call the same way. (#323, #324)
+- **`schema` shows more of each column and table**, in both tiers: precision,
+  scale, limit, the unsigned flag and collation, the table comment, unique
+  constraints, a MySQL text or blob column's size (`size: medium`), index
+  options (using, include, order), foreign key actions with the deferrable mode
+  and `validate: false`, the enabled extensions, the primary key (a composite
+  one as its columns, in `model_details` too, which also names a key the model
+  sets with `self.primary_key =`, and the table's beside it when they differ),
+  and with `--table` the check constraints (a MySQL one without the parentheses
+  MySQL adds), the enum types its columns use with their values, and generated
+  columns with their expressions. A `t.virtual` column is typed by its `type:`
+  in every static source, migration replays included. (#290, #291, #292, #352)
+- **`db/structure.sql` reads like schema.rb.** A structure.sql app gets the
+  column types schema.rb gives the same table (hstore, citext, enum with its
+  type, jsonb, timestamptz, binary, time, integer with its limit, unsigned),
+  plus table and column comments, and its extensions; an index shows its method,
+  order, operator class, prefix lengths and INCLUDE list, and a table its unique
+  constraints. On SQLite, a table with a multi-line foreign key or a dump with
+  no semicolons is read whole, and `sqlite_sequence` is not listed as a table.
+  On MySQL, a `FULLTEXT KEY` or `SPATIAL KEY` line is an index with its type,
+  not a column. (#348, #349, #350)
+- **MySQL column types read as the dumper writes them.** A schema.rb column
+  written as `t.column "kind", "enum('a','b')"` is listed with that type instead
+  of dropped, and the booted tier names MySQL enum, set and timestamp columns
+  the same way. (#351)
+- **A schema.rb dumped with more than one schema names a public table by its
+  bare name** (`users`, not `public.users`), so `--table users` and the `User`
+  model find it; foreign keys, indexes and enum types follow. (#353)
+- **The static tier reads the database the app configures.** The adapter comes
+  from `DATABASE_URL` or `<NAME>_DATABASE_URL` when set, and from a `url:` in
+  database.yml, as Rails merges them, and the replayed schema types its implicit
+  primary keys by that adapter. The schema comes from the dump the app
+  configures: database.yml's `schema_dump` name and `schema_format = :sql`
+  (database.yml on Rails 8.0.3 and later, else
+  `config.active_record.schema_format`, which Rails applies after every
+  initializer, and only then `ActiveRecord.schema_format`); the doctor, schema
+  version, tool guide, onboarding setup command and missing-table messages name
+  the same file, a configured dump over `max_schema_file_size` is reported as
+  too large, and a change to any `.sql` dump under `db/` refreshes the MCP
+  cache. (#355, #357)
+- **The MCP cache, live reload and `watch` cover all of `app/`, `test/` and
+  `spec/`.** An edit to a mailer preview, a fixture, a factory, a spec or any
+  file under `app/` that a tool reads refreshes the cached answer. A bundler's
+  output in `app/assets/builds` does not, and a re-recorded VCR cassette does
+  not either.
+- **A table in a secondary database is found** by `schema --table`,
+  `model_details`, `analyze_feature`, `diagnose`, `migration_advisor`, the
+  controllers schema hint and the model resource. The table view names every
+  database that holds it, and where one name holds different tables in two
+  databases it shows each database's columns and models. `migration_advisor`
+  passes `--database <name>` so the migration lands in that database's
+  migrations_paths. For a database only another environment configures (Rails
+  8's queue, cache and cable outside production), the Run line sets that
+  `RAILS_ENV` and names its migrations_paths; when no environment configures
+  it, no Run line is given. It also leaves out `foreign_key: true` on a reference between
+  tables in different databases. A replica or a `database_tasks: false` entry is
+  not listed as a database of its own. (#356)
+- **Migration replay follows what Rails runs.** It reads migrations in
+  subdirectories of `db/migrate` and in the migrations_paths database.yml sets
+  (for the primary and for a secondary with no dump yet), and the migrations
+  listing, the pending check and `doctor` read the same directories; a migration
+  file symlinked from outside the app is not read, and a secondary database's
+  line in `schema` names its pending migrations. A `revert` block is undone (a
+  nested one runs forward), and `revert SomeMigration` counts as a statement it
+  could not follow. One column is kept when both branches of an `if` declare it,
+  temporary and `if_not_exists` tables are skipped, `as:` and `execute "CREATE
+  TABLE"` tables are read (a heredoc over several lines too), check constraints
+  are replayed, `rename_index` is followed, and `Migration[5.0]` tables get
+  integer keys. An `execute` whose CREATE TABLE is built at run time counts as
+  not replayed. (#360, #361, #362, #363)
+- **Static primary keys and table names read as Rails reads them.** A primary
+  key written as `id: { type: :string, limit: 36 }` is typed `string, limit:
+  36`, and a model whose class, base class or app sets `pluralize_table_names =
+  false` reads its singular table with its columns. (#358, #359)
+- **`model_details` prints every association option** (`as:`, `counter_cache:`,
+  `touch:`, `inverse_of:`, `extend:`, `before_add:`, the foreign key a
+  `has_many` or `has_one` declares and the rest) and an extension block's
+  methods; `callbacks` lists association callbacks; and `--no-boot` reads
+  `required: false` as optional and `query_constraints:` as the foreign key (a
+  `has_many` prints the option). (#296)
+- **`model_details` reads more model declarations.** A `validate do ... end`
+  block is a custom validation with its `on:`/`if:`/`unless:` and first line. An
+  enum shows its `default:` and, with a prefix or suffix, the methods Rails
+  defines (`kind_lead?`). A prefixed delegate names the methods it defines
+  (`owner_name`) and `private: true` is marked. Each store column is listed once
+  with its accessors, including the names `prefix:` and `suffix:` give. Columns
+  dropped with `self.ignored_columns` are left out and listed on an "Ignored
+  columns" line. `encrypts`, `normalizes`, `serialize` and `generates_token_for`
+  show every option (`expires_in: 2.days`, or `never`), and a named
+  `has_secure_password :recovery_password` keeps its name. A Mongoid document's
+  schema hint in `controllers` names its collection and `_id` key instead of an
+  empty table, and a field shows its default. An array constant wrapped in
+  `Ractor.make_shareable` is listed under Constants. A validation, association,
+  scope or enum written in a method nothing calls is not listed. (#302, #305,
+  #306, #307, #309, #382, #391, #414)
+- **`delegated_type`, `has_secure_token` and `accepts_nested_attributes_for` are
+  read.** The static tier lists the polymorphic `belongs_to` that
+  `delegated_type` declares, both tiers name its types (booted asks the model's
+  `<role>_types` when the source names them through a constant, and the static
+  tier names that constant as not read), and `model_details` lists
+  `has_secure_token` and `accepts_nested_attributes_for` under Macros. (#365)
+- **`callbacks` and `model_details` read callbacks as Rails registers them.** A
+  callback the model removes with `skip_callback`, by name or by callback
+  object, is not listed (a conditional skip shows as the negated condition). A
+  callback object (`after_commit AuditTrail`, `before_validation
+  PostNormalizer.new`) prints as the class or expression the model passes. A
+  concern's `prepended do` block applies only to a class that prepends it, and
+  its `included do` block only to one that includes it. (#303, #304, #310)
+- **Models outside `app/models` are found**, in both tiers: in another `app/*`
+  directory such as `app/domain`, or under a path `config/application.rb` adds
+  to `eager_load_paths` or `autoload_paths`, when its superclass is a model. A
+  class there that is not a model is left out even when it does not load, and
+  the lib subdirectories `autoload_lib(ignore:)` names are not read. The static
+  tier also finds models under a symlinked directory or file in `app/models`
+  that points inside the app, a model assigned `Class.new(ApplicationRecord)`
+  with what its block declares (the `self.table_name` it sets included), and
+  reads a job assigned `Class.new(ApplicationJob)`, or a class whose parent is
+  such a base, the same way. An assignment counts only when the file's path
+  names it, so an error constant such as `PaymentError = Class.new(StandardError)`
+  is never listed as a service, serializer or model. The static tier also
+  merges a module prepended after the class body (`Note.prepend(EE::Note)`,
+  GitLab's `prepend_mod_with("Note")`). (#344, #347, #413, #416)
+- **Booted `model_details` no longer credits every model with a gem's base
+  mixins**, such as Kaminari's two modules and `page` and `default_per_page` on
+  the app's abstract base, or on a model that subclasses ActiveRecord::Base
+  itself, which Kaminari reaches the same way. (#371)
+- **Method listings read more of how Ruby defines methods**, in `model_details`,
+  `concern`, `service_pattern` and every tool that reads a file's methods. A
+  `private` inside `class << self` or a `concerning` block no longer hides the
+  public methods and actions after it. `def Widget.x` is a class method,
+  `private_class_method` methods are private, a `def self.x` after `private`
+  stays public, and a `module_function` method is a module method
+  (`self.total(items)`). Methods defined with `alias`, `alias_method`, `attr_*`,
+  `define_method`, `class_attribute` and `cattr_*`/`mattr_*` are listed, an
+  inline `private attr_reader :x` or `protected attr_writer :y` keeping its
+  visibility, and `service_pattern` writes the class-side reader, writer and
+  predicate a `class_attribute` defines with `self.`. A method in a scope or
+  association extension block, a `concern :Name do` block, or a `Struct.new`,
+  `Data.define`, `Class.new` or `Module.new` block is not the enclosing class's;
+  one assigned to a constant is that constant's, and a `Module.new` held in a
+  local is the enclosing class's, where it is included. In `model_details` the
+  methods written with `def` come first, so a long run of delegations no longer
+  pushes them past the 25-row cap. (#297, #298, #308, #388)
+- **A one-line or endless method is cut at its own line.** `callbacks` and
+  `concern --detail full` show `def strip_name; end` or `def wrap_save = yield`
+  under `(line N)` instead of running to the end of the class, and `search_code`
+  trace cuts such a body the same way. (#301)
+- **`search_code` finds more definitions.** Definition and trace modes find
+  `private def x`, `def Widget.x`, `ruby2_keywords def x` and other modifier
+  forms; trace counts a call inside an endless def body as a call site; class
+  mode finds `class Billing::Ledger`, `class ::Top` and a constant assigned
+  `Data.define`, `Struct.new`, `Class.new` or `Module.new`. (#300)
+- **A compact class name resolves its superclass as Ruby does.** `class
+  Api::UsersController < BaseController` gets the top-level `BaseController` as
+  its parent and its filters, on both tiers. The static model list, job chains,
+  service and component base detection, mailer chains and `generate_test` read a
+  compact class the same way, so `class Admin::Thing < Base` is not a model when
+  `Base` is a plain class. (#299)
+- **`concern` lists a class that prepends the concern** under Included By.
+  (#311)
+- **`controllers` lists block, lambda and object filters, in the order Rails
+  adds them to the chain** (after filters run last-declared first). A block or
+  proc filter (`proc {}`, `Proc.new {}`) reads `block (line N)` and a lambda
+  (`-> {}`, `lambda {}`) `lambda (line N)`, or `(line N of <file>)` when
+  written outside the controller's own file (a concern's class method, an
+  ancestor), each with its own `only:`/`except:`, in both tiers; every name a
+  `before_action :a, :b` call gives is listed in the order Rails runs them (a
+  lambda where it stands, the block last); the static tier reads
+  `prepend_after_action`, `prepend_around_action` and `append_around_action`,
+  each prepended filter at the front of the chain; `skip_forgery_protection`
+  shows as the `verify_authenticity_token` skip it is. An object filter
+  (`around_action TimingFilter.new`) reads `TimingFilter (object)` in both
+  tiers, where the booted tier printed a memory address. The booted tier leaves
+  out a block filter Rails or a gem adds (`allow_browser`, `rate_limit`), even
+  when the bundle is installed under the app root. The static tier names a gem
+  module the controller or one of its app bases includes
+  (`include ActiveStorage::SetBlob`) as an included module not read, where a
+  filter it adds would be missing, and leaves out a Rails module whose include
+  adds no filter (`ActionController::Live`). `http_basic_authenticate_with` is a
+  before filter with its `only:`/`except:`, never its credentials. (#293, #332,
+  #335)
+- **`controllers` reads strong params and delegated actions.**
+  `params.expect(user: [tags: []])` reads as an array of scalars, and the
+  summary lists nested keys, arrays and `key: {}` hashes beside the flat
+  permits, a hash that names its keys with only those keys. An action defined
+  with `def_delegators`, `def_delegator` or `delegate` is counted, so
+  `controllers` and `validate` no longer report a route to one as missing.
+  (#333, #334)
+- **`helper_methods` lists the view helpers declared with `helper_method`** in a
+  controller, a controller concern or a lib module the controller includes, each
+  with the class or module that declares it. (#336)
+- **`test_info` reads fixtures and factories where Rails and factory_bot load
+  them.** Fixture files that open with an ERB line or use the `DEFAULTS` alias
+  are read, subfolder sets such as `admin/posts` stay apart, `_fixture` and the
+  labels its `ignore:` names are dropped, and directories a helper adds to
+  `fixture_paths` are read (inside `RSpec.configure do |config|` too, on
+  `ActiveSupport::TestCase` by name, and as a path built from `__dir__` or
+  `__FILE__`); an RSpec `spec/fixtures` no helper loads gives no sets, and a
+  file it cannot parse lists its labels. A fixture file that links out of the
+  app or to a sensitive file is not read, here or by `generate_test` and
+  `conventions`, and a file over `max_test_file_size` is named as too large. A
+  label or value ERB computes (`row_<%= i %>`) is shown as ERB, and such a label
+  is never written as a fixture key. Factories are found in `factories.rb`,
+  `factories/`, `test/factories.rb`, `spec/factories.rb` and each pack's
+  `spec/factories` and `test/factories` (both suites' when both exist). A helper
+  that sets or appends to `FactoryBot.definition_file_paths` is followed when it
+  then calls `FactoryBot.find_definitions` (added to the defaults
+  factory_bot_rails already loaded) or `FactoryBot.reload` (in place of them);
+  `config.factory_bot.definition_file_paths` is not read. Fabrication's
+  fabricators are listed, `onboard` names Fabrication as the data setup of a
+  fabricators-only suite, the generated context lists the fabricators directory,
+  and a Cucumber `features/` tree is counted. (#313, #373)
+- **`i18n` reads the locale files Rails loads.** `.rb` locales are read for
+  their keys (the plural rule and transliteration settings under `i18n.plural`
+  and `i18n.transliterate` are not counted as keys), `.yaml` files Rails ignores
+  are not counted, files `config.i18n.load_path` adds or replaces (`+=`, `<<`,
+  `=`) are listed and counted in both tiers, a sensitive file a `load_path` glob
+  reaches is never read, and the Fallbacks section shows on a booted app whose
+  `config.i18n.fallbacks` sets only default locales. (#314, #315)
+- **Initializers in subdirectories of `config/initializers` are read** for the
+  default locale, middleware, tagged logging, OmniAuth providers, component
+  preview paths, CORS, Rack::Attack, inflections and the shard selector, and
+  `config` lists them by their path, as Rails loads them at any depth. (#316)
+- **`env` and `env_config` list what the app reads.** The environment variable
+  catalog drops `RAILS_EAGER_LOAD` and `RAILS_EVENT_REPORTER`, which Rails never
+  reads, and adds `SECRET_KEY_BASE_DUMMY`, `RAILS_DEVELOPMENT_HOSTS`,
+  `RAILS_GROUPS`, `RAILS_CACHE_ID`, `RAILS_APP_VERSION` and
+  `SOLID_QUEUE_IN_PUMA`. Credentials that decrypt to nothing are said to hold no
+  keys. External services called as `Net::HTTP.get(URI("..."))`,
+  `Net::HTTP.start("host")`, `Faraday.get("...")`, `RestClient`, `HTTP`
+  (http.rb), `Excon`, `Typhoeus` or `URI.open`, and HTTP clients in `lib/` or
+  `config/`, are listed; a loopback, private or unspecified (`0.0.0.0`) IP, a
+  file name handed to a client, and a call in a comment or a string are not.
+  `env_config` lists keys set with `<<`, `+=`/`||=`/`&&=`, an index write
+  (`config.action_dispatch.default_headers["X-Frame-Options"] = "DENY"`), a
+  write through an index read (`config.paths["app/views"] << "x"`), a method
+  call or a block, and not a call whose value is used (`x =
+  config.root.join("tmp")`), a method argument named `config`, or another
+  library's config (`OmniAuth.config.test_mode`). (#317, #318, #319, #320)
+- **`active_support` lists files that sign with
+  `Rails.application.message_verifier`**, `message_verifiers` or
+  `ActiveStorage.verifier`, and not a file that only rescues
+  `MessageVerifier::InvalidSignature` or names one in a comment or a string.
+  (#321)
+- **`search_docs` finds the 21 Rails guides the index lacked** (upgrading,
+  engines, autoloading, error reporting, generators, core extensions and more).
+  A guide newer than the app's Rails links to main and says so, since the app's
+  stable branch has no file for it. (#322)
+- **`frontend_stack` names the asset pipeline and CSS and build tools.** A
+  Propshaft or Sprockets pipeline is named (with Sprockets' `manifest.js` link
+  lines), an app with no JavaScript build is said so, and an app is called
+  API-only only when `config.api_only` is set. webpack, rollup or bun is named
+  as a jsbundling-rails app's build tool, and `conventions` names Rollup and
+  reads bun from the text `bun.lock`. `conventions` and `frontend_stack` name
+  Tailwind CSS or Bootstrap on a `rails new --css` app. (#339, #340, #341)
+- **`validate` checks Ruby syntax with the app's own Ruby grammar** (the running
+  Ruby when booted, the declared one with `--no-boot`, or the running Ruby when
+  the app declares none), so a file valid on Ruby 3.3 is not failed for a rule
+  3.4 added. Ruby 3.1 and 3.2 are checked as 3.3, the oldest grammar prism has.
+  An app that declares JRuby or TruffleRuby and no Ruby version is checked with
+  the running Ruby's grammar, and a syntax error says so. (#342)
+- **`autoload` lists every root Rails autoloads from**: app/models, app/lib,
+  app/services and the rest, other engines' app/* directories, a directory an
+  initializer adds with `push_dir` (with the namespace it loads under),
+  autoload-once paths added through `config.paths`, and directories a loader
+  keeps out of eager loading. (#345)
+- **`job_pattern` reads more queues and schedules.** Channels show their
+  streams, timers and actions without booting, a `periodically` timer with a
+  block is listed in both tiers, and the connection says what it is
+  `identified_by`. A job's schedule comes from the task that runs it (Solid
+  Queue `config/recurring.yml` with its environment, sidekiq-cron,
+  sidekiq-scheduler, GoodJob `config.good_job.cron` including `merge!`,
+  whenever's `config/schedule.rb`); a job named only in a comment is not
+  scheduled, and `--detail full` lists every recurring task, on an app with no
+  job classes too. A schedule an ERB tag builds reads as computed. Without
+  booting, queues are named as ActiveJob names them, with `queue_name_prefix`,
+  `queue_name_delimiter` and `default_queue_name` applied, and a job with no
+  `queue_as` is on the default queue in both tiers. A Resque job's `@queue` (or
+  `def self.queue` when it sets none) and a Que job's `self.queue =` are read,
+  Que::Job subclasses are listed with their `run` signature, and `run` is the
+  entry point of a Que job only. (#330, #331, #366, #374)
+- **`api` names the serialization layer and OpenAPI specs right.** Blueprinter
+  blueprints, Alba resources and RABL templates are named; an Active Job
+  argument serializer and a mixin module the serializers include are not counted
+  as response serializers. A file is an OpenAPI spec only when its top-level
+  `openapi` or `swagger` key holds a version number, found in `public/`, `doc/`,
+  `app/` and `config/` as well; a docs site's `_config.yml` and locale files are
+  not listed. A spec over the per-file read limit is still listed: the check
+  reads only the first 64KB of each candidate. `gems` says rswag-api serves
+  specs from its configured `openapi_root`, and names
+  `config/initializers/rswag_api.rb` when the app has it. (#367, #368, #375)
+- **`onboard` names auth and serialization like the other tools.** An
+  "Authentication & Authorization" section covers Rodauth, Action Policy and
+  Rails 8 generated authentication; the Devise model is named with its modules,
+  those a concern's `included` block adds too; the authentication gem is still
+  named when the only auth finding is policy classes. A named
+  `has_secure_password :six_digit_code` is listed as a digest, not as login,
+  there and in the generated context. The API section names the
+  serialization as `api` does and is left out when there is none. `gems` lists
+  `action_policy` and `rolify` under auth. (#369)
+- **`conventions` names more model patterns**: full-text search, tree structures
+  and soft deletes from `pg_search_scope`, `multisearchable`, `has_ancestry`,
+  `has_closure_tree` and `include Discard::Model`, multi-tenancy from
+  activerecord-multi-tenant, and a `discarded_at` column as soft delete. (#370)
+- **`component_catalog` reads more components.** The usage example for a
+  `renders_many` slot calls the singular setter (`c.with_item do`), and the
+  one for a polymorphic slot calls each setter its `types:` define. A component
+  in the layout
+  `phlex:install` generates types as Phlex, read from its root even outside
+  `app/components` (`app/views/components`), and is named by the constant that
+  renders it (`Components::Badge`). (#372, #378)
+- **`performance_check` no longer suggests `counter_cache: true`** on a
+  `belongs_to` whose count column `counter_culture` already keeps. (#376)
+- **Rake tasks are read whole.** Tasks after a brace-form `namespace(:x) { }`
+  are not put inside it, `task "a:b"` names and `multitask` are listed, and the
+  Rakefile and `rakelib/*.rake` are read; a rake file symlinked out of the app
+  is not. (#384)
+- **A tool failure's `At:` line names a frame outside the app and every gem by
+  its file name and line**, never an absolute path from the answering machine.
+  A frame inside an `eval` names the evaluated file the same way.
+
+## [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