rails-ai-context 5.33.0 → 5.34.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a60b2bc0a9f71133c2dc0889ba870868f49aa923b2e3d5cfbf7f7a34c0085e38
-  data.tar.gz: 7bf500ba0442bf338e3f3a41ab655b23589db53890814958d8e9e19561839040
+  metadata.gz: b06974567f2b7098d9bdd1eccb11438d8327271fe07efeb986a2ca8004c0eede
+  data.tar.gz: 8ad3f24358bbc9e83c73baa1fbd99c5ae5ed0113aa7d5b9cc4f8f69088281236
 SHA512:
-  metadata.gz: e29f4af14f4ad58165140901245da44490887fc9bde26a2fcdf6432d2156e108332e89b4ed067752591c9e2ac3b2a05d686db42986ac05d120aeeada013481cd
-  data.tar.gz: b426dbf26ab302bd85d4755b5bc11dce2f22b0f0a3d9bd109604910c366fe90848ffd216235e2ea77a0e2e5c6999cb5910f3ea23d09edc96a110c1952687abc0
+  metadata.gz: 06f3deab68deafc795d5574fb3acbfcf9a2f4a2f568036aef7b12089ff8cff5249b15139eceff6a843d89e5d1e7840c84ea3ad3c37cab8be92e5b79f1b1300ba
+  data.tar.gz: 6a3fcbbf27a9aad384875a84d6a863f54d5643858db4ffa6a36be7b9e58b2a05ccdab080af4219318a46da5ba5f89b3aacde36afaa55b4650e9820016d2b259f

data/CHANGELOG.md

@@ -5,6 +5,222 @@ 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.34.1] - 2026-10-12
+
+### Changed
+
+- **The repository tracks `CLAUDE.md`.** It points at `AGENTS.md`, and the
+  gem ships it beside the `AGENTS.md` and `CONTEXT.md` it already shipped.
+  The code is v5.34.0's.
+- **The glossary defines strong params and notable gems.** `CONTEXT.md` says
+  what makes a method strong params and which gems count as notable, and
+  ADR-0006 records why a strong params call is read as the method Ruby
+  would run.
+
+## [5.34.0] - 2026-10-12
+
+### Security
+
+- **A tracked log's diff hides its credentials.** `rails_review_changes`
+  read a `.log` file's diff as source, which filters a Bearer or Basic value
+  only at 16 characters, so a short one showed in clear. A log file shown as
+  a file, logrotate's dated and `.old` ones and a `.log.bak` included, now
+  gets what `rails_read_logs` filters.
+- **A Digest or Token Authorization header is filtered with all its
+  parameters.** A Digest header in a log kept its `response=` hash, also
+  inside an inspected hash whose value escapes its quotes, and a Token
+  header kept every parameter after `token=` (and came out as
+  `Authorization: [FILTERED]]` when unquoted).
+- **An Authorization value after an unquoted name and `=` or `=>` is
+  filtered.** A log line from an env dump (`HTTP_AUTHORIZATION=Basic ...`)
+  or a debug line (`Authorization => Bearer ...`) kept a short credential in
+  clear, in `rails_read_logs` and in a tracked log's diff. A switch's value
+  (`skip_authorization = true`) stays, and in a query string only the value
+  goes.
+
+### Added
+
+- **A static model answer names the plugin patch modules it did not
+  read.** An app plugin that adds to a core model through its own DSL
+  (OpenProject's `patches %i[WorkPackage]`, which includes
+  `<Plugin>::Patches::WorkPackagePatch` in `to_prepare`) gave a
+  `rails_get_model_details` answer with none of what the patches add and no
+  sign anything was left out. A module named `*::Patches::<Model>Patch` in
+  the app's, its code roots' or its in-repo gems' `lib` is now named in one
+  `[UNAVAILABLE]` line, the way `rails_get_controllers` names an included
+  module it did not read.
+- **`rails_get_model_details` names each `has_attached_file` attachment
+  under Macros.**
+- **The controller listing marks `permit!` and names a parent's strong
+  params.** The listing marks `permit!` as the per-action view did, and
+  strong params a parent controller in the app defines are listed with the
+  parent named, unless the controller defines an instance method of that
+  name itself.
+
+### Changed
+
+- **Notable gems are the ones the app names, and a Rails framework only when
+  the app loads it.** Every lockfile entry counted, so `onboard`, the gems
+  tool and the context files listed `activestorage` for an app that leaves
+  `active_storage/engine` commented out (it is in the lock because `rails`
+  pulls it in) and `jwt` for an app that only has it through oauth2 and
+  googleauth. A notable gem now counts when the Gemfile names it, when a
+  gemspec or path gem the Gemfile pulls in depends on it, when it is a Rails
+  engine or OmniAuth that another gem brings in (gds-sso mounts OmniAuth in
+  the app), or, for a framework `rails` pulls in, when
+  config/application.rb loads it (`rails/all`, its railtie, or a
+  `config.<framework>` line). Rails 6's `sprockets-rails` is one of those
+  frameworks; on Rails 7 and later a gem that pulls it in loads it, so it
+  counts.
+- **Static routes leave out a block from a routing method they cannot read,
+  and say so.** A route drawn inside a method the app defines (a helper
+  that wraps `scope(path: "api/v1", module: "api/v1")`, versionist's
+  `api_version`) was drawn at the top level, so `rails_get_routes` gave a
+  two-route controller seven routes it does not have and gave the namespaced
+  controller none. Such a block is now counted among the constructs not
+  expanded, and a controller with no route says one may be missing behind
+  them. Blocks that draw in place are drawn as before: Rails'
+  `constraints` and `defaults`, Devise's `devise_scope` and
+  `authenticate`, and route_translator's `localized`; Rails' `nested` block
+  is drawn under its parent's path.
+- **Strong params are the methods that return permitted params.** Any `def
+  *_params` was listed, so a method that builds associations counted while
+  `article_params_json`, which calls `permit`, did not. A method named
+  `*_params` now counts when it calls `permit`, `permit!` or `expect` on
+  params (directly, through a local or an ivar, on each item a block walks,
+  or on `ActionController::Parameters.new`), or when what it returns comes
+  from `super` (`super.merge(...)`), another strong params method (a call
+  runs the nearest class's method of that name, so one the controller or a
+  parent class defines counts whatever its name, such as Mastodon's
+  `params_slice`; any other named `*_params` or `permitted_*`, such as a
+  concern's or Pundit's `permitted_attributes(@post)`; and Devise's
+  `devise_parameter_sanitizer`), or a call given the whole params
+  (`PermittedAttributes::Enterprise.new(params).call`); a `before_action`
+  that writes into another one's params is not one. A method of any other
+  name counts only when it returns the permitted params themselves, through
+  a local, an `if`, a `case` or an explicit `return`, so a helper that
+  permits to build a URL, or to read one value, is left out. An action that
+  permits inline is left out, a public `*_params` helper is kept, `permit!`
+  on a `slice` lists the keys it slices, a computed filter
+  (`settings_attributes: UserSettings.keys`) is shown as written, not as a
+  scalar, and a key `require` computes is not printed as one.
+
+### Fixed
+
+- **A primary key's function default shows.** `id: :uuid, default: -> {
+  "gen_random_uuid()" }` on a `create_table` line gave the `id` row an empty
+  Default in `rails_get_schema` and `rails_get_model_details`, booted and
+  static, which reads as "no default". The booted tier now reads a column's
+  `default_function`, leaving out only a serial column's own sequence as
+  the dump does, and schema.rb, structure.sql and the migration replay give
+  the key the default its line declares.
+- **Two bare `validates_with` lines are both listed.** The second one was
+  dropped because the two shared a dedup key with no validator class in it.
+- **A `validates_with` class a concern nests is listed once.** The source
+  name `DateValidator` never matched the class Ruby resolves,
+  `DateValidation::DateValidator`, so reflection listed it again and the
+  validation count was one too high.
+- **A model whose table the database lacks is not marked verified.**
+  `rails_get_model_details` printed `[VERIFIED]` and `**Table:** \`tags\``
+  for a model with no `tags` table, and `onboard` and the context files
+  named the table too. Each now says `` `tags` not found `` where a live
+  listing lacks the table, and the tool guide's examples pass over such a
+  model. A database read from its dump, a secondary one included, is not
+  taken at its word, since a dump can leave out a view, and nor is the
+  primary's listing for a model on a connection of its own.
+- **Callbacks on a chain a library defines are listed.** Paperclip's
+  `before_file_validate` and `after_post_process` were missing from
+  `rails_get_model_details` and `rails_get_callbacks`, booted too, because
+  only Active Record's own callback names were read. A call on a chain the
+  booted model really has, or one `define_model_callbacks` in the same file
+  declares, is now listed.
+- **A macro inside `translation_class.class_eval` is not the model's own.**
+  It is listed under "Declared on another class", as one in a concern's
+  `translation_class.instance_eval` already was; two declared on one line
+  are both listed, and a modifier's condition is not listed as one.
+- **The static tier keeps a model whose parent comes from a gem.**
+  `class Tag < ActsAsTaggableOn::Tag` was "Model 'Tag' not found". A class
+  in app/models on a parent the app does not define is now a model when a
+  database's dump holds a table it would read, one of the parent's names
+  (`ahoy_messages` for `EmailMessage < Ahoy::Message`) or its own, the
+  primary's first, and, with no schema to ask or another database's dump
+  not on disk, when it declares associations or scopes. Wherever the schema
+  can be read, an ActiveHash class that declares `has_many` stays out, and a
+  class on a framework class (`ActiveRecord::Relation`) is never one. The
+  table comes from the parent as Rails' single table inheritance decides, or
+  a line says the parent sets it.
+- **A filtered routes answer names the other paths an engine is mounted
+  at.** An engine mounted three times showed only its first mount and that
+  mount's helpers.
+- **Migration replay applies `change_column`'s options.** `null:`,
+  `default:`, `limit:`, `precision:` and `scale:` given to `change_column`
+  were dropped, so a column relaxed to `null: true` stayed NOT NULL. The
+  replay now records the sizes a migration declares as the dump writes
+  them: an integer limit picks smallint or bigint on PostgreSQL and MySQL,
+  a datetime keeps any precision but the default 6, MySQL sizes a text or
+  blob by its limit, and a size the dump leaves out stays out. A type-only
+  `change_column` keeps null and default on PostgreSQL and MySQL and resets
+  them on SQLite, as each adapter does.
+- **Migration replay keeps a partial index's condition.** A Symbol
+  `where: :schedule_manually` and the `where:` of a `t.references ...,
+  index: { where: ... }` were dropped, so a partial index read as a full one.
+  An index's `using:`, `order:`, `opclass:` and the rest are kept too.
+- **A gem installed under the app root is not the app's code.** With the
+  bundle in vendor/bundle, `onboard` listed a gem's ActiveJob class
+  (`Chewy::Strategy::ActiveJob::Worker`) as the app's background job.
+- **The engine works in an app with an `AI` or `MCP` acronym.** The app's
+  loader and router camelize with the app's inflections: `inflect.acronym
+  "AI"` made Zeitwerk expect `RailsAIContext::McpController` and
+  `inflect.acronym "MCP"` `RailsAiContext::MCPController`, so
+  `bin/rails zeitwerk:check` and any eager load failed once the gem was in
+  the Gemfile; the mounted endpoint answered with an error (a 404 on Rails
+  7.0 after the first request), and a production boot with eager loading
+  failed. The controller is now kept out of the app's loader and routed as
+  a class, which `bin/rails routes` shows as an inline handler.
+- **`rails ai:context` runs in an app with its own top-level
+  `print_result`.** The gem's rake helpers were top-level methods guarded by
+  `unless defined?`, so an app's `print_result` in lib/tasks ran instead and
+  the task aborted. They now live in a module.
+- **A byte-size label does not depend on the app's I18n.**
+  `rails_read_logs` threw its whole answer away when an app's I18n backend
+  raised after a failed boot (Discourse's backend queries the database),
+  and `rails_runtime_info` and `rails_get_test_info` could do the same.
+- **The static fallback loads after a Bundler.setup that failed part way.**
+  An app that activates a gem before `bundler/setup` (Consul's
+  `require "sassc-embedded"`) at a version its lock does not pin made
+  Bundler raise after it had marked activesupport loaded but before it added
+  the load paths, so the standalone CLI and `serve` died with `cannot load
+  such file -- active_support/core_ext/string/inflections` instead of
+  serving static answers.
+- **The controller count is the app's own, the same from rake and from the
+  generator.** A gem's controller was listed whenever something had loaded
+  it, which flipflop's dashboard does in a generator boot and not in a rake
+  one, so the install wrote "Controllers (99)" and `rails ai:context` wrote
+  "(97)" and `ai:doctor` called the files stale. A `*_controller.rb` that
+  declares only a module was listed as a controller too, and one that names
+  another controller (`GoogleController = OAuth2Controller`) is listed as
+  its alias, with its actions.
+- **A module in app/policies is not a policy.** `onboard` counted
+  `module Authorizer`, which nests a helper class, among the Pundit
+  policies. A policy is now the class its file is named for.
+- **`rails_review_changes` does not count the install's context files as
+  code.** `app/models/AGENTS.md` was "1 model" and
+  `app/controllers/AGENTS.md` "1 controller".
+- **Statements on one line replay in source order on every platform.** Ruby's
+  sort is not stable, so with a dozen statements in a migration a one-line
+  `change_table(:t) { |t| t.change ... }` could apply its `t.change` before
+  the block opened and lose it, and on Windows it did. A route with many
+  paths drew them in the same unordered way.
+- **Ties keep their order in every list.** Where two entries sort equal, the
+  answer depended on the platform's sort: `onboard`'s key flows and
+  `rails_get_conventions`' key directories could name different controllers
+  and folders, `rails_validate` named a different five Brakeman warnings,
+  `rails_search_docs` a different top five, and helpers, tables, queues,
+  N+1 risks, security warnings, SQLite table stats, shared examples and a
+  session's queries came out shuffled. A one-line `create_table` in a
+  schema.rb that also holds a `# Could not dump table` comment gave its
+  columns to the wrong table.
+
 ## [5.33.0] - 2026-10-11
 
 ### Security

data/CLAUDE.md

@@ -0,0 +1,3 @@
+# rails-ai-context
+
+Project instructions live in `AGENTS.md`, which is committed and shared. Read it.

data/CONTEXT.md

@@ -66,7 +66,7 @@ The other half of the same problem is the reverse trip. Once a name is the decla
 
 ## Table name
 
-The table a model reads. Rails builds it as `table_name_prefix` + the demodulized class name, pluralized unless `pluralize_table_names` is off, + `table_name_suffix`, unless the class assigns one itself or is an STI child, which reads its parent's. The static tier answers the same order from source: an explicit `self.table_name =`, else the table of the model it inherits from, else the prefix and suffix the enclosing modules declare around the file's own basename. That basename is pluralized unless the class, then its superclass chain, then the app sets `pluralize_table_names = false`. The app-wide affixes and pluralize setting come from `ActiveRecordSettings`, which reads config/application.rb, the environment file, the initializers and `on_load(:active_record)` blocks. Never the underscored constant - that turns `Admin::ActionLog` into `admin/action_logs` and `OAuthClientConfig` into `o_auth_client_configs`, neither of which is a table.
+The table a model reads. Rails builds it as `table_name_prefix` + the demodulized class name, pluralized unless `pluralize_table_names` is off, + `table_name_suffix`, unless the class assigns one itself or is an STI child, which reads its parent's. The static tier answers the same order from source: an explicit `self.table_name =`, else the table of the model it inherits from, else the prefix and suffix the enclosing modules declare around the file's own basename. That basename is pluralized unless the class, then its superclass chain, then the app sets `pluralize_table_names = false`. A class on a parent the app does not define (`Tag < ActsAsTaggableOn::Tag`) reads the parent's table, which the static tier takes from the dumps: the one table the primary's schema holds among the parent's names and the class's own, else the one another database's dump holds. The app-wide affixes and pluralize setting come from `ActiveRecordSettings`, which reads config/application.rb, the environment file, the initializers and `on_load(:active_record)` blocks. Never the underscored constant as an answer - that turns `Admin::ActionLog` into `admin/action_logs` and `OAuthClientConfig` into `o_auth_client_configs`, neither of which is a table; a gem parent's underscored name is only a candidate the schema must hold.
 
 `TableName` reads the five declarations of one class body (`table_name`, `table_name_prefix`, `table_name_suffix`, `pluralize_table_names` and `primary_key`) and holds the two derivations; walking the namespace and the superclass chain belongs to the caller, because only it has the other files. A reader that starts from a model name instead of a file asks `TableName.for_model_name`, which takes the table the model tier already recorded before falling back to the convention. A module prefix declared outside the model directories is still invisible, an engine's in `lib/**/engine.rb` aside, so the answer stays [STATIC].
 
@@ -153,6 +153,18 @@ Which filters a controller runs, and which of them a given action runs. `ActionF
 
 **What it cannot see is stated rather than guessed.** The walk reads `ApplicationController`'s file by the one name Rails fixes, so its filters are in the chain; a parent the listing does not hold and the app has no file for - a gem-owned base other than Devise's or Doorkeeper's (there the walk resumes at the parent the initializer names), or one an inflection renames - still ends the walk. `docs/COMPATIBILITY.md` says both halves.
 
+## Strong params
+
+A controller method that returns permitted params: it calls `permit`, `permit!` or `expect` on params, or returns what `super`, another strong params method, or a call handed the whole params gives back. What it returns makes one, never its name: a `*_params` method that builds associations is not one. A controller has its own and each superclass's that no nearer class redefines.
+
+**A call reaches the method Ruby would run.** That is the nearest class in the controller's chain that defines the name, so a parent's helper counts whatever it is called (Mastodon's `params_slice`), a child that redefines it decides for every class above it, and a class method or a nested class's method of that name redefines nothing. A name none of the controller's classes defines, a concern's, a gem's or Pundit's, is taken at its `*_params` or `permitted_*` name. ADR-0006 records why.
+
+**An action and a strong params method can be one method.** An action that permits inline is an action, not strong params. A public `*_params` method that permits is strong params, and since Rails can dispatch to it, the **Action** reading lists it too.
+
+## Notable gem
+
+A gem the context calls out because it shapes how the app is built, counted only when the app itself runs it: the Gemfile names it (or a gemspec or path gem it pulls in does), it hooks into Rails on its own whichever gem brings it (a railtie or an engine, and OmniAuth), or it is a Rails framework the app loads. A gem that sits in the lockfile only because another gem needs it is not one.
+
 ## Payload
 
 The introspection context hash, in the sense consumers read it. `Payload` is the reading side: a section guard and pinned list readers whose key pairs a spec checks against the producing introspector's own output, so a renamed key fails a test instead of silently emptying a section everywhere. Facts rendered from it live once (`SectionFacts`); membership judgments are applied at the introspector seam, and readers trust the payload rather than re-filtering it.

data/README.md

@@ -4,9 +4,9 @@
 
 *Give your AI coding assistant ground truth about your Rails app*
 
-[![Gem Version](https://img.shields.io/gem/v/rails-ai-context?style=flat-square&color=brightgreen)](https://rubygems.org/gems/rails-ai-context)
-[![Downloads](https://img.shields.io/gem/dt/rails-ai-context?style=flat-square&color=blue)](https://rubygems.org/gems/rails-ai-context)
-[![CI](https://img.shields.io/github/actions/workflow/status/crisnahine/rails-ai-context/ci.yml?branch=main&style=flat-square&label=CI)](https://github.com/crisnahine/rails-ai-context/actions)
+[![Gem Version](https://img.shields.io/gem/v/rails-ai-context?style=flat-square&color=brightgreen&cacheSeconds=21600)](https://rubygems.org/gems/rails-ai-context)
+[![Downloads](https://img.shields.io/gem/dt/rails-ai-context?style=flat-square&color=blue&cacheSeconds=21600)](https://rubygems.org/gems/rails-ai-context)
+[![CI](https://github.com/crisnahine/rails-ai-context/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/crisnahine/rails-ai-context/actions/workflows/ci.yml)
 [![MCP Registry](https://img.shields.io/badge/MCP_Registry-listed-green?style=flat-square)](https://registry.modelcontextprotocol.io)
 [![Ruby](https://img.shields.io/badge/Ruby-3.1_to_4.0-CC342D?style=flat-square&logo=ruby&logoColor=white)](https://github.com/crisnahine/rails-ai-context)
 [![Rails](https://img.shields.io/badge/Rails-7.0_to_8.1-CC0000?style=flat-square&logo=rubyonrails&logoColor=white)](https://github.com/crisnahine/rails-ai-context)

data/app/controllers/rails_ai_context/mcp_controller.rb

@@ -169,8 +169,6 @@ module RailsAiContext
     end
 
     class << self
-      # The transport outlives this class, which the app's reloader replaces
-      # on every edit in development (McpEdge.engine_transport).
       def mcp_transport
         McpEdge.engine_transport
       end

data/config/routes.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 RailsAiContext::Engine.routes.draw do
-  # The engine is not namespace-isolated, so the controller must be
-  # referenced by its full path or Rails resolves a top-level McpController.
-  match "/", to: "rails_ai_context/mcp#handle", via: :all
+  # The class, not "rails_ai_context/mcp", which the router camelizes with the app's inflections.
+  match "/", to: RailsAiContext::McpController.action(:handle), via: :all
 end

data/docs/ARCHITECTURE.md

@@ -26,7 +26,7 @@ graph TD
         subgraph engine["Introspection Engine"]
             direction LR
             I["Introspectors\n40 modules\nPresets\nCached"]
-            AST["AST Engine\nPrism\n44 listeners\nConfidence tags"]
+            AST["AST Engine\nPrism\n45 listeners\nConfidence tags"]
             H["Hydration Layer\nSchema hints\ninjected into\ntool responses"]
         end
 

data/docs/COMPATIBILITY.md

@@ -283,6 +283,19 @@ Proof sources:
    changed every 0.3 seconds; the pre-commit hook installed and run by real
    commits in an app's own repository, a monorepo's folder and a submodule;
    and the unit suite and the E2E harness on Linux, macOS and Windows.
+   In the v5.34.0 release QA: the 21 apps of the v5.33.0 acceptance run
+   (Mastodon, OpenProject, Discourse, Canvas, Forem, Whitehall, Consul, Open
+   Food Network, Diaspora, Errbit, Huginn, Plots2, a private app and the small
+   blogs), 11 booted and 10 static, their answers compared with v5.33.0's,
+   and their strong params and model tables compared again after the last
+   fix; a fresh Rails 8.1 and a fresh Rails 7.0 app through the install,
+   `ai:context` twice, `zeitwerk:check` with the engine mounted, MCP over the
+   mounted HTTP endpoint and stdio, and the standalone CLI; an app that loads
+   a gem before `bundler/setup`; and the unit suite and the E2E harness on
+   Linux, macOS and Windows.
+   In the v5.34.1 release QA: the gem built from the release commit and its
+   file list read, and the unit suite and the E2E harness on Linux, macOS and
+   Windows; the code is v5.34.0's.
 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

data/docs/INTROSPECTORS.md

@@ -183,8 +183,8 @@ It runs a single-pass Dispatcher that walks the AST once and feeds events to all
 | ValidationsListener | `validates`, `validates_*_of`, custom `validate :method`, under the options of an enclosing `with_options` block |
 | ScopesListener | `scope :name, -> { ... }`, `lambda { ... }` and the block form; a scope declared in an `each` over a literal list, inline or a constant the file assigns (`KINDS.each { \|k\| scope k, -> { ... } }`), as one scope per element, tagged `[INFERRED]` |
 | EnumsListener | Rails 7+ and legacy enum syntax, prefix/suffix options |
-| CallbacksListener | All AR callback types including `around_*`, `after_touch`, `after_initialize` and `after_find`; `after_commit` with `on:` resolution; a callback object as the source wrote it (`Normalizer`, `Normalizer.new`), a block as `[inline_block]` with its declaration as written; `if:`/`unless:` kept as the source wrote them, and the options of an enclosing `with_options` block; the commit callbacks turbo-rails' `broadcasts`, `broadcasts_to`, `broadcasts_refreshes` and `broadcasts_refreshes_to` declare, each with the method it runs |
-| MacrosListener | (each attribute macro and `has_secure_password` with its keyword options as written, under `written`) `encrypts`, `normalizes`, `delegate`, `has_secure_password`, `serialize`, `store`, `has_one_attached`, `has_many_attached`, `has_rich_text`, `generates_token_for`, `attribute`, `alias_attribute`, `store_accessor`, `self.ignored_columns`, `has_secure_token`, `accepts_nested_attributes_for`, `attr_readonly`, `query_constraints`, the turbo-rails broadcast macros (`broadcasts`, `broadcasts_to`, `broadcasts_refreshes`, `broadcasts_refreshes_to`), `connects_to` as written (a child carries its base's, with the base's name under `declared_in`), the class settings `self.inheritance_column`/`store_full_sti_class`/`strict_loading_by_default`/`implicit_order_column`/`locking_column =` as written, an `aasm` block's states, initial state, events and transitions, and model gems' class macros (`GEM_MACROS`: `has_paper_trail`, `friendly_id`, `mount_uploader`, `monetize`, `pg_search_scope`, `acts_as_list` and others) as written, without their block |
+| CallbacksListener | All AR callback types including `around_*`, `after_touch`, `after_initialize` and `after_find`; `after_commit` with `on:` resolution; a callback object as the source wrote it (`Normalizer`, `Normalizer.new`), a block as `[inline_block]` with its declaration as written; `if:`/`unless:` kept as the source wrote them, and the options of an enclosing `with_options` block; the commit callbacks turbo-rails' `broadcasts`, `broadcasts_to`, `broadcasts_refreshes` and `broadcasts_refreshes_to` declare, each with the method it runs; `before_`/`after_`/`around_<event>` on a chain `define_model_callbacks` makes, kept when the same file defines it (honouring `only:`), and for a chain a library defines elsewhere (Paperclip's `before_<attachment>_validate`, `after_post_process`) only when the model walk asks, so the booted tier keeps the ones whose chain the model's `__callbacks` holds |
+| MacrosListener | (each attribute macro and `has_secure_password` with its keyword options as written, under `written`) `encrypts`, `normalizes`, `delegate`, `has_secure_password`, `serialize`, `store`, `has_one_attached`, `has_many_attached`, `has_rich_text`, `generates_token_for`, `attribute`, `alias_attribute`, `store_accessor`, `self.ignored_columns`, `has_secure_token`, `accepts_nested_attributes_for`, `attr_readonly`, `query_constraints`, the turbo-rails broadcast macros (`broadcasts`, `broadcasts_to`, `broadcasts_refreshes`, `broadcasts_refreshes_to`), `connects_to` as written (a child carries its base's, with the base's name under `declared_in`), the class settings `self.inheritance_column`/`store_full_sti_class`/`strict_loading_by_default`/`implicit_order_column`/`locking_column =` as written, an `aasm` block's states, initial state, events and transitions, and model gems' class macros (`GEM_MACROS`: `has_paper_trail`, `friendly_id`, `mount_uploader`, `monetize`, `pg_search_scope`, `acts_as_list` and others) as written, without their block (Paperclip's `has_attached_file` by its name and attachment only) |
 | MethodsListener | `def`/`def self.`, visibility tracking, parameter extraction, `class << self`, the methods `delegate` and Forwardable's `def_delegators`/`def_delegator` define (public unless `private: true`, and with no `end_location`, since a delegation has no body), and the methods `alias`, `alias_method`, `attr_*`, `define_method` with a literal name, `class_attribute` and `cattr_*`/`mattr_*` define (an alias keeps its original's visibility and parameters; Active Support's accessors are public on the class and, unless an option turns them off, on instances); each `def` carries `offset`/`end_offset`, which `SourceIntrospector.outside_defs` pairs against a call's `offset` to tell a call on the same line as a def from one inside it; a `Struct.new`/`Class.new`/`Module.new`/`Data.define` block assigned to a constant is that constant's body, and a `def self.x` in `included do` is marked `class_methods_block` like a `def x` in `class_methods do`; `include_initialize: true` adds the constructor a caller reports on its own |
 | 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. GitLab's `prepend_mod_with("Note")`, `include_mod_with`, `extend_mod_with` and their `_mod` forms record `EE::Note` and `JH::Note` flagged `edition`; `ConcernMembership.owned_by` keeps one only where the app has its file, and credits `Note.prepend X` to Note |
 
@@ -194,6 +194,7 @@ Passed to `SourceIntrospector.walk(path, key => Listener)` when a specific file
 
 | Listener | What it detects |
 |:---------|:---------------|
+| ForeignEvalsListener | A class body's blocks evaluated on another receiver (`translation_class.class_eval do`, `other.instance_eval do`), outside any `def`, with every outermost call inside by the line it starts on, an `if`/`unless` condition left out. The model walk passes it beside the default listeners (`ModelIntrospector::MODEL_LISTENERS`) and moves what the blocks declare to "Declared on another class" |
 | GenericMacroListener | Any receiver-less macro you name: `GenericMacroListener.new(:devise, :rate_limit)`; `any_receiver: true` also counts `base.macro`, as a mixin's `self.included(base)` hook writes it. Returns args, values (with a source-slice fallback), options, option values and option nodes, `proc_lines` (the line each block, `->`, `lambda {}`, `proc {}` or `Proc.new {}` argument opens on, as `Proc#source_location` gives it), plus the nesting: `parent_offset` is the offset of the target macro call whose block this one sits in, paired against each call's own `offset` rather than its line |
 | ConditionalMacroListener | GenericMacroListener plus `condition`, the `if`/`unless`/`case` branches the call sits under (`BranchConditions`), as `if Rails.env.test?`. Controller filters read it through FilterMacroListener, so `before_action :x if Rails.env.test?` is listed with its condition |
 | FilterMacroListener | ConditionalMacroListener plus `callbacks`, what each positional argument adds, named at its node: `[:name, x]` for a symbol, string or class, `[:object, Klass]` for an instance (`Class` for an anonymous class), `[:lambda]` for `-> {}` or `lambda {}`, `[:block]` for a proc, `[:unread, source]` for anything else. Used by `ControllerFilters`, so the static tier names each callback as the booted tier does |
@@ -217,7 +218,7 @@ Passed to `SourceIntrospector.walk(path, key => Listener)` when a specific file
 | SchemaDslListener | `schema.rb`: `create_table`, `t.string`, `t.column`, `t.index`, `add_foreign_key`, `create_enum`, `create_schema`, `create_view`, `create_virtual_table`, the `ActiveRecord::Schema[x.y]` version stamp (a nil one for the unstamped `Schema.define` of Rails before 7.0), and the comment the dumper writes for a table it could not describe. Names drop `public.` unless `raw_names:` is set, which SchemaReader uses to name them against the search path |
 | MigrationDslListener | Migration DSL: `create_table`, `add_column`, `add_index`, `add_reference`, and friends |
 | MigrationReplayListener | What a replay needs beside the DSL: `def down`, `down`/`revert` blocks, and `t.timestamps` |
-| RoutesDslListener | `config/routes.rb`, resolving namespace/scope/resources nesting into flat routes (a `controller:` with a leading slash is absolute, as in Rails); routing concerns (`concern` definitions replayed at each `concerns:` site), `with_options` defaults merged under each inner call, `match ... via:` (or the `via:` of an enclosing `scope`) as one route answering each verb it names (`GET|POST`, and `ANY` for `via: :all`, as the booted table has it), the controller a `scope(controller:)` or a route's own `controller:` names (with Rails' `a/b` shorthand when no action is given), and the `as:`, `param:`, `module:`, `path:` and `only:`/`except:` options. A block drawn through an app class (`ApiRouteSet::V1.draw(self) do`) takes the path and `as:` prefixes that class's `self.prefix` and `mapper_prefix` return as literals, or a literal prefix argument; a class whose prefix is not a literal, and that class's own `resources`, are counted as unexpanded. Routes drawn into an engine's table (`Spree::Core::Engine.routes.draw`) sit under the engine's namespace and carry `engine:`, which the route introspector files under that engine's mount, apart from the app's count. A file pulled in by `draw` is walked inside the scope its `draw` sits in, once per scope that draws it, so `draw :api` under `namespace :api` and `scope module: :v1` routes to `api/v1/...` at `/api/...` |
+| RoutesDslListener | `config/routes.rb`, resolving namespace/scope/resources nesting into flat routes (a `controller:` with a leading slash is absolute, as in Rails); routing concerns (`concern` definitions replayed at each `concerns:` site), `with_options` defaults merged under each inner call, `match ... via:` (or the `via:` of an enclosing `scope`) as one route answering each verb it names (`GET|POST`, and `ANY` for `via: :all`, as the booted table has it), the controller a `scope(controller:)` or a route's own `controller:` names (with Rails' `a/b` shorthand when no action is given), and the `as:`, `param:`, `module:`, `path:` and `only:`/`except:` options. A block drawn through an app class (`ApiRouteSet::V1.draw(self) do`) takes the path and `as:` prefixes that class's `self.prefix` and `mapper_prefix` return as literals, or a literal prefix argument; a class whose prefix is not a literal, and that class's own `resources`, are counted as unexpanded. Routes drawn into an engine's table (`Spree::Core::Engine.routes.draw`) sit under the engine's namespace and carry `engine:`, which the route introspector files under that engine's mount, apart from the app's count. A file pulled in by `draw` is walked inside the scope its `draw` sits in, once per scope that draws it, so `draw :api` under `namespace :api` and `scope module: :v1` routes to `api/v1/...` at `/api/...`. A resource's `nested do` block draws under the parent's nested path, as a direct child would. A block from any other method draws in place only for `constraints`, `defaults`, Devise's `devise_scope`/`as`/`authenticate`/`authenticated`/`unauthenticated` and route_translator's `localized`; any other block that holds routes (an app's `api_v1 do`, versionist's `api_version`) may scope them in a way the walk cannot see, so its routes are left out and the block is counted once as unexpanded |
 | MountListener | `mount Sidekiq::Web, at: "/sidekiq"`, the hash form, and a Rack app attached with `match "/metrics", to: MetricsApp` - `mount` is that call with a name derived. Paths carry the enclosing `namespace`/`scope` prefix; a scope whose own name is an expression yields no path rather than an unprefixed one, and `scope path: nil` adds no segment. A mounted app built by a call on a constant (`Flipper::UI.app(Flipper)`) is named by that call, arguments off. A mount under `if`/`unless`/`case` carries that `condition` |
 | GemfileDslListener | `gem "name", "version"`, `group :development do ... end` and `eval_gemfile "path"` (a literal or `File.expand_path("x", __dir__)`) with the groups around it; `ruby "3.3.6"` with its `engine:` and `engine_version:`; an `:unknown_gems` entry for `gemspec` and for a `gem` or `eval_gemfile` whose argument is not a literal |
 | RakeTaskDslListener | `namespace` (with the span its block covers), `desc`, `task`, `multitask` in `.rake` files |

data/docs/SECURITY.md

@@ -406,7 +406,7 @@ Both answer the hosts the app's `config.hosts` allows, judged by Rails' own Host
 
 `auto_mount` is `false` by default, and the engine exists only where you mount it. Mount it guarded, `if defined?(RailsAiContext::Engine)`, so the routes file still loads where the gem is not installed.
 
-The engine builds one transport per process, under a mutex, and keeps it outside the controller class, which the app's reloader replaces on every edit in development; a session lasts across edits.
+The engine builds one transport per process, under a mutex, outside the controller class, and the app's code reloader never replaces that class, so a session lasts across edits in development.
 
 ---
 

data/docs/TOOLS.md

@@ -95,7 +95,7 @@ ripgrep follows no symlink while it walks, so a directory linked in from the app
 
 Without ripgrep on the PATH, the Ruby fallback returns the rows ripgrep would, context lines and the line cap included, from the files ripgrep would search: no hidden files, no other symlinks followed, no binary files (a NUL byte in the first 64 KiB), and ignore files read with ripgrep's precedence, where the file type decides before depth: any `.rgignore`, then any `.ignore`, then any `.gitignore`, then `.git/info/exclude`, then the global excludes file, the deepest file first within a type. `.ignore` and `.rgignore` apply everywhere, including the directories above the app; the git files apply only inside a repository and only as far up as the nearest `.git` (a file for a worktree or submodule), whose `info/exclude` is the only one read. Patterns match case-sensitively.
 
-Redaction treats a value under a secret-named key as a secret unless it is clearly something else: shorter than eight characters (four under a password-type key: `password`, `passwd`, `pass`, `pin`, `passphrase`, Redis's `requirepass` and `masterauth`, the `MYSQL_PWD` and `REDISCLI_AUTH` the mysql and redis-cli clients read, and a long password word that ends a name with another joined on before it, as Postgres's `PGPASSWORD` and a camel-cased `userPassword` have), containing whitespace (a message; not under `passphrase`), a URL, an email address or a hostname (not under a password-type key), a URL query (`?mode=safe`) or a path (two slashes, no `+` or `=`), a placeholder (`<token>`, `${VAR}`, `%{var}`, a `{name}` slot, `xxxx`, `your-...`, `put-your-key-here`), a version (`2.4.1`, `v2`) or a date, an HTTP header name (`X-Api-Key`; not under a password-type key), an env name (capitals joined by `_`, led by `_` or `HTTP_` or naming a secret word, like `_DISCOURSE_API`), a name spelled from a secret word (`user_api_key`; not under a password-type key, where `admin_password` is the password), the key's own name in any case (an enum's `password: 'password'`, `currentPassword: "current_password"`), a switch's value (`true`, `false`, `null`), or not ASCII. Keys ending `_url`, `_error`, `_use`, `_file`, `_dir`, `_id` and the like (in camel case too: `tokenType`) describe a secret rather than hold one, and so does a Stimulus target, action, controller, outlet or class (`password_visibility_target`). A quoted name joined by dashes, a header or an attribute, reads with its dashes as underscores, so `"X-Api-Key" => "..."` and `req["x-auth-token"] = "..."` hold an API key and a token, while `"Content-Type"` names no secret. A camel-cased name with `Secret` or `Token` among its words (`accessToken`, `clientSecret`, `jwtSecretKey`) is a secret's name, as JSON and JavaScript spell `access_token`, in source and in a log line. A call or block whose first argument names a secret holds its value too (`ENV.fetch("SECRET_KEY_BASE", "...")`, `let(:api_key) { "..." }`, `option :client_secret, default: "..."`, a `credentials.fetch` default); a ternary's `? "a" : "b"` is two values, not a key and its value. Under a name that ends in `_KEY`, `Key` or `key` without a secret word (`ALGOLIA_ADMIN_KEY`, `apiKey`), a value is filtered only when it looks like a credential: a run of 16+ characters mixing letters and digits, or a known token format; a cache or i18n key (`views/posts/1`, `users.index.title`), a storage key (`wp-content/uploads/...`), a word, a path or a header name is kept. Log lines use the same rule. An unquoted `NAME=value` with a secret-named name, in any file (shell, Dockerfile `ENV`, compose, env, code), a flag (`--password=...`, `--requirepass=...`) included, has its value filtered unless it is `$VAR`, `${...}`, `#{...}` or ERB; the value ends at the first quote, bracket, `&`, `,`, `;` or space, so in a URL query (`?token=...&page=2`) only the value goes. A secret-named flag's value given as the next word (`redis-server --requirepass ...`, `--token ...`) is filtered, bare or quoted, when it has a digit and would be filtered under that name, so a word (`the --password option`), a metavariable (`--token TOKEN`), a variable, ERB, another flag, a `--no-...` switch, a path (`~/.ssh/id_ed25519`, `./keys/deploy.pem`, `keys/deploy.pem`) or a `name=value` list (BuildKit's `--secret id=...,env=...`) stays. A `:name=` setter symbol, a `(?<=name=` lookbehind and a regex's wildcard (`/--password=.+/`) are not assignments. The credential after an auth scheme (`Bearer`, `Basic`, `Token`), under an `Authorization` key, in a curl line or a cassette, is filtered in any file when it is shaped like one: 16 or more letters and digits, both, read past a UUID's dashes and base64's `+`, `/` and `=`; the scheme stays, and `Bearer #{token}`, `Bearer YOUR_TOKEN` and `Basic realm=...` hold no credential. A log line's `Authorization` header goes whole in every spelling: `Authorization: Basic ...`, a quoted value, a hash or JSON key, `HTTP_AUTHORIZATION`. In an example file (`*.example`, `*.sample`, `*.template`) a value under a secret-named key is kept only when it is plainly a placeholder: a placeholder shape above, or up to 20 characters of words with no digits (`changeme`, `your_password_here`). Locale files are filtered only for credential formats. In a YAML or JSON file read whole, a mapping a secret's name names holds that secret in its `value`: Heroku's `app.json` (`"STRIPE_SECRET_KEY": { "value": "..." }`, on one line or several), a YAML `api_token:` over `value: ...`, and a `render.yaml` or Kubernetes entry named by a sibling (`- key: CLIENT_SECRET`, `- name: API_TOKEN`) over its `value:`; a boolean, and the next entry's value, stay. A YAML key written as a Ruby symbol (`:password:` in `config/sidekiq.yml`) reads as its name.
+Redaction treats a value under a secret-named key as a secret unless it is clearly something else: shorter than eight characters (four under a password-type key: `password`, `passwd`, `pass`, `pin`, `passphrase`, Redis's `requirepass` and `masterauth`, the `MYSQL_PWD` and `REDISCLI_AUTH` the mysql and redis-cli clients read, and a long password word that ends a name with another joined on before it, as Postgres's `PGPASSWORD` and a camel-cased `userPassword` have), containing whitespace (a message; not under `passphrase`), a URL, an email address or a hostname (not under a password-type key), a URL query (`?mode=safe`) or a path (two slashes, no `+` or `=`), a placeholder (`<token>`, `${VAR}`, `%{var}`, a `{name}` slot, `xxxx`, `your-...`, `put-your-key-here`), a version (`2.4.1`, `v2`) or a date, an HTTP header name (`X-Api-Key`; not under a password-type key), an env name (capitals joined by `_`, led by `_` or `HTTP_` or naming a secret word, like `_DISCOURSE_API`), a name spelled from a secret word (`user_api_key`; not under a password-type key, where `admin_password` is the password), the key's own name in any case (an enum's `password: 'password'`, `currentPassword: "current_password"`), a switch's value (`true`, `false`, `null`), or not ASCII. Keys ending `_url`, `_error`, `_use`, `_file`, `_dir`, `_id` and the like (in camel case too: `tokenType`) describe a secret rather than hold one, and so does a Stimulus target, action, controller, outlet or class (`password_visibility_target`). A quoted name joined by dashes, a header or an attribute, reads with its dashes as underscores, so `"X-Api-Key" => "..."` and `req["x-auth-token"] = "..."` hold an API key and a token, while `"Content-Type"` names no secret. A camel-cased name with `Secret` or `Token` among its words (`accessToken`, `clientSecret`, `jwtSecretKey`) is a secret's name, as JSON and JavaScript spell `access_token`, in source and in a log line. A call or block whose first argument names a secret holds its value too (`ENV.fetch("SECRET_KEY_BASE", "...")`, `let(:api_key) { "..." }`, `option :client_secret, default: "..."`, a `credentials.fetch` default); a ternary's `? "a" : "b"` is two values, not a key and its value. Under a name that ends in `_KEY`, `Key` or `key` without a secret word (`ALGOLIA_ADMIN_KEY`, `apiKey`), a value is filtered only when it looks like a credential: a run of 16+ characters mixing letters and digits, or a known token format; a cache or i18n key (`views/posts/1`, `users.index.title`), a storage key (`wp-content/uploads/...`), a word, a path or a header name is kept. Log lines use the same rule. An unquoted `NAME=value` with a secret-named name, in any file (shell, Dockerfile `ENV`, compose, env, code), a flag (`--password=...`, `--requirepass=...`) included, has its value filtered unless it is `$VAR`, `${...}`, `#{...}` or ERB; the value ends at the first quote, bracket, `&`, `,`, `;` or space, so in a URL query (`?token=...&page=2`) only the value goes. A secret-named flag's value given as the next word (`redis-server --requirepass ...`, `--token ...`) is filtered, bare or quoted, when it has a digit and would be filtered under that name, so a word (`the --password option`), a metavariable (`--token TOKEN`), a variable, ERB, another flag, a `--no-...` switch, a path (`~/.ssh/id_ed25519`, `./keys/deploy.pem`, `keys/deploy.pem`) or a `name=value` list (BuildKit's `--secret id=...,env=...`) stays. A `:name=` setter symbol, a `(?<=name=` lookbehind and a regex's wildcard (`/--password=.+/`) are not assignments. The credential after an auth scheme (`Bearer`, `Basic`, `Token`), under an `Authorization` key, in a curl line or a cassette, is filtered in any file when it is shaped like one: 16 or more letters and digits, both, read past a UUID's dashes and base64's `+`, `/` and `=`; the scheme stays, and `Bearer #{token}`, `Bearer YOUR_TOKEN` and `Basic realm=...` hold no credential. A log line's `Authorization` header goes whole in every spelling: `Authorization: Basic ...`, a quoted value, a hash or JSON key, `HTTP_AUTHORIZATION`, an unquoted name with `=` or `=>` (`HTTP_AUTHORIZATION=Basic ...`, `Authorization => Bearer ...`), and a `Token` or `Digest` header with all its parameters; a switch's value (`skip_authorization = true`) stays. A log file shown as a file (a tracked log in a `rails_review_changes` diff, rotated or kept ones like `.log.1`, `.log-20261001`, `.log.old` and `.log.bak` included) gets the same filtering a log line does. In an example file (`*.example`, `*.sample`, `*.template`) a value under a secret-named key is kept only when it is plainly a placeholder: a placeholder shape above, or up to 20 characters of words with no digits (`changeme`, `your_password_here`). Locale files are filtered only for credential formats. In a YAML or JSON file read whole, a mapping a secret's name names holds that secret in its `value`: Heroku's `app.json` (`"STRIPE_SECRET_KEY": { "value": "..." }`, on one line or several), a YAML `api_token:` over `value: ...`, and a `render.yaml` or Kubernetes entry named by a sibling (`- key: CLIENT_SECRET`, `- name: API_TOKEN`) over its `value:`; a boolean, and the next entry's value, stay. A YAML key written as a Ruby symbol (`:password:` in `config/sidekiq.yml`) reads as its name.
 
 ### `rails_get_edit_context`
 
@@ -254,6 +254,8 @@ defined, so was never mixed in.
 
 Controller actions with inherited filters, render map, strong params. Includes schema hints for referenced models.
 
+Strong params are the methods that return permitted params. A method named `*_params` counts when it calls `permit`, `permit!` or `expect` on params (directly, through a local or an ivar, on each item a block walks, or on `ActionController::Parameters.new`), or when what it returns comes from `super` (`super.merge(...)`), another strong params method (a call runs the nearest class's method of that name, so one the controller or a parent class defines counts whatever its name, such as `params_slice(:min_id)`; any other named `*_params` or `permitted_*`, such as a concern's or Pundit's `permitted_attributes(@post)`; and Devise's `devise_parameter_sanitizer`), or a call given the whole params (`Filter.new(params).call`), so a `before_action` that writes into another one's params is not one; a method of another name counts only when it returns the permitted params themselves. A parent controller's strong params are listed with the parent named unless the controller defines an instance method of that name itself, `permit!` is marked, and an action that permits inline is not one. A file that names another controller (`GoogleController = OAuth2Controller`) is listed as its alias, with that controller's actions. [ADR-0006](adr/0006-strong-params-resolve-as-ruby-runs.md) records why a call is read as the nearest class's method.
+
 Rails counts every public method that a concern or a parent controller gives among a controller's actions. A `page_info` in a concern that `ApplicationController` includes is an action of each controller. An app keeps the helpers its controllers share in such places, so the action lists take one of these methods only where a route names it for that controller, booted or not. An `action` lookup also finds one that no route names, under the rules the lists apply: no callback, no name that starts with `_` or ends in `?` or `!`, and no required argument. The answer reads the method from the file that defines it. It names the parent controller under **Inherited** when the method comes from one, and says under **Not listed** why the lists leave the method out. A private `def` of the same name lower down hides the method, as it does from Rails.
 
 | Parameter | Type | Default | Description |
@@ -490,6 +492,11 @@ Database config, auth framework, assets, cache, queue, Action Cable. The `use` a
 Notable gems with versions, categories, and config file locations. A config
 location is printed only when the app has that file, and an initializer is
 found under a load-order prefix too (`config/initializers/3_omniauth.rb`).
+A notable gem counts when the Gemfile names it, when a gemspec or path gem the
+Gemfile pulls in depends on it, when it is a Rails engine or OmniAuth that
+another gem brings in, or, for a framework `rails` pulls in, when
+config/application.rb loads it; a gem the lockfile holds only for another
+gem's own use is left out.
 
 | Parameter | Type | Default | Description |
 |:----------|:-----|:--------|:------------|

data/docs/adr/0006-strong-params-resolve-as-ruby-runs.md

@@ -0,0 +1,10 @@
+# Strong params resolve a call as Ruby would run it
+
+Status: accepted
+
+A strong params method can return another one's answer (`params_slice(:min_id).merge(page: true)`), so whether it counts depends on what the call reaches. We decide that the way Ruby dispatches: across the controller's classes the nearest one defining the name wins, and a method counts when the one it reaches is strong params, found as a least fixpoint over the whole chain. Only a name none of those classes defines (a concern's, a gem's, Pundit's) falls back to the `*_params` or `permitted_*` name.
+
+## Considered Options
+
+- **Each file on its own, any other name taken at its name.** Cheap and simple, and the rule until the last fixes before v5.34.0, where a real-app check and two review rounds found wrong answers it could not fix without another special case: a parent's helper named `params_slice` dropped, a parent's non-strong `*_params` counted, a child's redefinition of a grandparent's helper ignored, a class method of the same name hiding the parent's. Do not go back to it to save the chain walk; the cost is one memoized read per source.
+- **Reading concerns as classes in the chain.** Ruby puts an included module between a class and its parent, so a concern's method does win. We take a concern's name instead, because listing a concern's strong params is a new answer no surface has asked for.

data/lib/rails_ai_context/app_kind.rb

@@ -22,19 +22,32 @@ module RailsAiContext
       RailsAiContext::Introspectors::GemfileGems.names(root.to_s).intersect?(names)
     end
 
-    ACTIVE_RECORD_REQUIRES = %w[rails/all active_record/railtie active_record].freeze
+    # The file config/application.rb requires to load each framework gem, the list rails/all requires
+    # (Sprockets until 7.0).
+    FRAMEWORK_RAILTIES = {
+      "activerecord" => "active_record/railtie", "activestorage" => "active_storage/engine",
+      "actionmailer" => "action_mailer/railtie", "actionmailbox" => "action_mailbox/engine",
+      "actiontext" => "action_text/engine", "actioncable" => "action_cable/engine", "activejob" => "active_job/railtie",
+      "sprockets-rails" => "sprockets/railtie"
+    }.freeze
+    private_constant :FRAMEWORK_RAILTIES
 
-    # False only when config/application.rb picks its frameworks railtie by
-    # railtie and leaves Active Record's out (a require, or a list it requires
-    # in a loop) and never configures it; a file it cannot read is taken to load it.
     def active_record?(root)
+      loads_framework?(root, "activerecord")
+    end
+
+    # Whether config/application.rb loads this framework: not when it picks its frameworks railtie by railtie
+    # (a require, or a list it requires in a loop) and leaves this one out; a file it cannot read loads it.
+    def loads_framework?(root, gem_name)
+      railtie = FRAMEWORK_RAILTIES[gem_name] or return false
+      framework = File.dirname(railtie)
       source = RailsAiContext::SafeFile.read(File.join(root.to_s, "config", "application.rb"))
       tree = source && RailsAiContext::AstCache.parse_string(source)
       return true unless tree && tree.errors.empty?
 
       nodes = Introspectors::AstWalk.each(tree.value).to_a
       strings = nodes.grep(Prism::StringNode).map(&:unescaped)
-      return true if strings.intersect?(ACTIVE_RECORD_REQUIRES) || nodes.grep(Prism::CallNode).any? { |n| n.name == :active_record }
+      return true if strings.intersect?([ "rails/all", railtie, framework ]) || nodes.grep(Prism::CallNode).any? { |n| n.name == framework.to_sym }
 
       strings.none? { |s| s.end_with?("/railtie", "/engine") }
     rescue StandardError, ScriptError

data/lib/rails_ai_context/cli/entry_boot.rb

@@ -151,11 +151,14 @@ module RailsAiContext
         Outcome.new(tier: :booted, reason: nil, messages: messages)
       end
 
-      # Splices the stripped load paths back, minus what a completed Bundler.setup pinned.
+      # Splices the stripped load paths back, minus what a completed Bundler.setup pinned, default gems included.
+      # A setup that raised part way marked gems loaded without their paths, so those are spliced too.
       def self.require_gem_without_app!
         preboot_gem_specs.each do |name, spec|
-          next if Gem.loaded_specs.key?(name)
+          loaded = Gem.loaded_specs[name]
+          next if loaded && (loaded.default_gem? || loaded.full_require_paths.all? { |p| $LOAD_PATH.include?(p) })
 
+          Gem.loaded_specs[name] = spec
           spec.full_require_paths.each { |p| $LOAD_PATH.unshift(p) unless $LOAD_PATH.include?(p) }
         end
         require "rails_ai_context"

data/lib/rails_ai_context/engine.rb

@@ -2,6 +2,13 @@
 
 module RailsAiContext
   class Engine < ::Rails::Engine
+    # The app's loader would camelize the controller's path with the app's inflections, and an
+    # acronym ("AI", "MCP") names a constant the file does not define, so Ruby autoloads it instead.
+    initializer "rails_ai_context.controller" do
+      Rails.autoloaders.main.ignore(root.join("app/controllers").to_s)
+      RailsAiContext.autoload(:McpController, root.join("app/controllers/rails_ai_context/mcp_controller").to_s)
+    end
+
     # The YAML is the base a configure block overrides key by key, so it has
     # to be in place before config/initializers runs.
     initializer "rails_ai_context.config_file", before: :load_config_initializers do |_app|

data/lib/rails_ai_context/gem_lock.rb

@@ -17,7 +17,9 @@ module RailsAiContext
   module GemLock
     MAX_SIZE = 5 * 1024 * 1024
     SPEC_LINE = /\A {4}(\S+) \(([^)]+)\)\s*\z/
-    DEPENDENCY_LINE = /\A {2}(\S+?)!?(?: \(.*\))?\s*\z/
+    SPEC_DEPENDENCY_LINE = /\A {6}(\S+)/
+    # Bundler puts the "!" of a gem from its own source after the requirement: "sidekiq-pro (= 8.0.3)!".
+    DEPENDENCY_LINE = /\A {2}(\S+?)!?(?: \(.*\))?!?\s*\z/
     # Bundler writes a non-CRuby engine after the version: "ruby 3.1.4p0 (jruby 9.4.8.0)".
     RUBY_LINE = /\A\s+ruby (\S+)(?: \((\S+) ([^)]+)\))?/
     REMOTE_LINE = /\A {2}remote: (.+?)\s*\z/
@@ -297,6 +299,8 @@ module RailsAiContext
       in_path = false
       in_git = false
       path_remotes = []
+      path_dependencies = {}
+      spec_name = nil
       sources = {}
       specs_section = false
       content.each_line do |line|
@@ -317,7 +321,10 @@ module RailsAiContext
           # per platform. The text before the first hyphen is the version; a
           # prerelease tag ("1.70.0-beta1") is dropped along with the platform.
           versions[match[1]] ||= match[2].split("-", 2).first
+          spec_name = match[1]
           sources[match[1]] ||= if in_path then [ :path, path_remotes.last ] elsif in_git then [ :git ] else [ :gem ] end
+        elsif in_specs && in_path && spec_name && (match = line.match(SPEC_DEPENDENCY_LINE))
+          (path_dependencies[spec_name] ||= []) << match[1]
         elsif (match = line.match(RUBY_LINE)) && match[1].match?(PLAIN_VERSION)
           ruby_version = [ match[1], engine_name(match[2], match[3]) ]
         end
@@ -327,6 +334,8 @@ module RailsAiContext
       # and answering it as an app with no gems denies every gem it holds.
       return Spec.new({}, reason: "#{File.basename(path)} has no specs section") unless specs_section
 
+      # A gemspec or `path:` gem the Gemfile names brings its runtime dependencies in as the Gemfile's own, as Bundler resolves them.
+      path_dependencies.each { |name, deps| direct.merge(deps) if direct.include?(name) }
       facts = gemfile(bundle)
       Spec.new(versions, **declared_ruby(ruby_version, root, bundle, facts), direct: direct, path_remotes: path_remotes,
                sources: sources)

data/lib/rails_ai_context/introspectors/active_record_settings.rb

@@ -41,7 +41,7 @@ module RailsAiContext
       end
 
       def collect(settings, found)
-        settings.sort_by { |entry, _| entry[:location] }.each do |entry, name|
+        settings.sort_by.with_index { |(entry, _), i| [ entry[:location], i ] }.each do |entry, name|
           allowed = SETTINGS[name]
           next unless entry[:assignment] && allowed