rails-ai-context 5.28.0 → 5.29.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 78848e75315236681b6b31bba337665e75a143d862d2d1ff828f48f50b1756f5
-  data.tar.gz: 8af5164b8ee4ea9900d82450d2a74905dcf1b831c02d7ba95c5c869274c18e9e
+  metadata.gz: f036023367c149fd14eb8bc96106167cbd0c4ec7f042673930c74472a7caf44e
+  data.tar.gz: 1289481c7e5749263b762ebb9cc41a25504b4355896fd2215d2916e669132b34
 SHA512:
-  metadata.gz: 6dbfa116e75a4675314e6c4a06ada6c2c7d7b8c7f0d9fb5ca0abe9945add65f1729b0101200debf5c25ea2190e66b57f41761b4307d8414d77ccfc62dc292e9d
-  data.tar.gz: 86984bc5566480da28d88b7ef475138bb85c9ba459fcd87e58f8a4afd03239a365ee30d032412701291ec0bd60f7f0e0cccfa882fee0150e6baed74c966a33b1
+  metadata.gz: 5ad0b4e2f8096894ceec5a5c9989472173e8fabd98c38b1e9fc5e4e0ac3b7d90ad49473d6808f592f5d5b0c6ca9c6a897d7d2d6d79a064bbff0b6a44da19a0aa
+  data.tar.gz: ea624bf293f2e40a49d0d62579ca10c224200ab9e0f6681cdeb3f62955a599024a9ced4179f701f907d0b6ab9c55d5240ba595243a428b7b3920d47aade0b8d2

data/CHANGELOG.md

@@ -5,6 +5,185 @@ 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.29.0] - 2026-09-23
+
+Twenty-three QA reports against v5.27.0, each one a wrong answer a reader
+could act on, plus what eight review rounds found in the fixes themselves.
+
+### Added
+
+- **Model payloads carry method counts and the model's own methods
+  uncapped.** `instance_method_count`, `class_method_count` and
+  `source_instance_methods` sit beside the capped `instance_methods` and
+  `class_methods` lists, on both tiers, so a reader can tell a cut list from
+  a whole one.
+- **The schema payload carries `declared_tables`**, what `db/schema.rb`
+  declares, on both tiers: nil for an app whose tables come from
+  `structure.sql` or the migrations.
+
+### Changed
+
+- **"Mounted Engines" is "Mounted Apps" everywhere it is printed**: the
+  `engines`, `routes` and `onboard` tools, the generated context files, and
+  the MCP `rails://engines` resource name. The stack overview line reads
+  `Mounted:` rather than `Engines:`. Half of what the list holds are plain
+  Rack apps. The payload key stays `mounted_engines`.
+- **A mount whose path the source does not spell out carries `path: nil`**
+  rather than the string `"unknown"`, and is printed without a path.
+- **`routes` reads a blank `controller` as no filter**, and a name that
+  normalizes to nothing (`_controller`) as matching nothing, where the empty
+  string used to match every route key.
+
+### Fixed
+
+- **A Sidekiq worker answers to its own name, and the bracket carries the
+  limit that governs it.** `job:"Billing::Invoices::CreateWorker"` answered
+  "No jobs found" for a worker the same tool had just listed, because the
+  single-job lookup read the ActiveJob list only. It reads both lists now, and
+  a name in neither is a not-found that names what exists. The listing prints
+  its "workers the introspector did not see" caveat whenever it prints
+  workers, rather than only when `config/sidekiq.yml` happens to exist, and a
+  `sidekiq_throttle` prints under the worker it throttles - 438 of 522 workers
+  on one app declared one and none of them showed it.
+- **onboard's async section reads the workers out of the hash it already
+  had.** The section counted jobs, mailers and channels, so an app whose
+  background work is 522 Sidekiq workers read as "4 mailers." and the section
+  disappeared entirely when workers were the only async code. The "not
+  covered" line no longer prints next to a worker list it contradicts.
+- **What an ActiveInteraction declares is read in one place.** A filter
+  declared inside another filter's block (`string :title` inside `hash
+  :order_params do`) is a key of that hash, not an input of the class:
+  `service_pattern` showed four inputs where `.filters` has two, and
+  `generate_test` passed the other two to `.run`, which drops them silently. A
+  subclass of the app's own base interaction is an interaction too, with its
+  parent's filters first, so `generate_test` stops emitting `.call`, which
+  `ActiveInteraction::Base` does not define. `GenericMacroListener` records
+  each call's own offset and its enclosing call's, which is what both tools
+  pair filters by.
+- **generate_test names the constant the file declares.** A path camelizes
+  through Ruby's inflector, which has not read the app's
+  `config/initializers/inflections.rb` on the static tier, so
+  `ai_reports/build.rb` gave `AiReports::Build` where the app defines
+  `AIReports::Build` - a constant nothing defines, in a spec that dies on
+  load.
+- **service_pattern looks for callers where the app keeps code.** The scan
+  named six `app/` directories, so a caller in `app/tools` or under `lib/` was
+  invisible. It reads every `app/` and `lib/` tree, plus whatever else a
+  booted app autoloads from, and says when the twenty-entry cap or its own
+  file ceiling left the list partial.
+- **schema tells a missing migration from a typo.** Booted, a table declared
+  in `db/schema.rb` and absent from the connected database answered "Did you
+  mean 'comments'?". The payload carries the declared tables beside the live
+  ones, so the answer names the migration that has not run, and the listing
+  header says the two counts disagree instead of pairing a live table count
+  with the file's version stamp.
+- **A validator under app/models/concerns is not a concern.** The type came
+  from the directory alone, so 37 `ActiveModel::Validator` subclasses on one
+  app were listed as model concerns used by nothing. They are listed as
+  validators - following the app's own validator base class, not one level of
+  compare - and looked up by the `validates_with`, or the validation option,
+  that wires them, in a model or in a concern's `included` block. The keys
+  `validates` reads for itself (`on:`, `if:` and the like) name no
+  validator.
+- **dependency_graph counts both header numbers over the same models.** The
+  model count was app-wide and the association count covered the fifty nodes
+  that survived the cap. Both are app-wide now, and the truncation note says
+  how many of the associations the cut graph draws.
+- **get_context reads the views Rails would resolve.** It handed `GetView`
+  the last segment of the controller path, so `Api::V1::Admin::OrdersController`
+  picked up `app/views/orders`, a directory of templates a background service
+  renders. The answer names the directory its views came from, and a
+  flat-directory fallback is labelled as one.
+- **analyze_feature finds a test by its path.** A spec whose feature word is a
+  directory (`spec/services/billing/invoices/create_spec.rb`) was dropped,
+  while the gap checker beside it already matched on the path. The suite's
+  own words stay out of the match - the `spec/` root, the type directory it
+  files a test under (`models/`, `requests/`), and the `_spec` suffix - so
+  `--feature models` is not every model spec.
+- **routes answers an exact controller key with its own routes.** A substring
+  filter returned a nested sibling's routes too (`api/v1/admin/orders` swept
+  in `api/v1/admin/orders/ai_data`), and `get_context` inherited it. A short
+  name still matches every controller that carries it.
+- **A template at the root of app/views is listed.** Its filename became a
+  directory group that matched nothing, so the header counted a file the body
+  never printed, and the controller-miss hint suggested a directory that does
+  not exist.
+- **A word in a quoted string is not an instance variable.** `view` reported
+  a chat handle inside a Ruby string literal as a template's ivar; the reader
+  strips string literals and keeps interpolation, in ERB tags and in the
+  Ruby template handlers (Jbuilder, Builder, `.ruby`), and `get_view`'s
+  hydrator reads through the same method. Whichever quote opens first owns
+  the literal, so an apostrophe inside `"Don't"` does not swallow the ivar
+  beside it.
+- **env_config tells a re-assignment from a tuple.** Two unconditional
+  assignments of one key rendered as `:file, :test`, which reads exactly like
+  `:mem_cache_store, { pool_size: 5 }`. The winner is named, with what it
+  overrode.
+- **env keeps one default per call site.** One label for every site said a
+  variable was optional while one of its reads was `ENV.fetch` with no
+  default, which raises `KeyError`. A fetch whose fallback is an expression
+  says its default is computed at runtime rather than claiming it has none,
+  and an `ENV["X"]` read says it is nil when unset, apart from the fetch
+  that raises.
+- **A Rack app attached with `match ... to:` is found.** `mount` is that call
+  with a name derived, and the exact-path form is what an app writes when an
+  unanchored mount would swallow a sibling path. It reaches `engines` and
+  `routes`, which names the mounted apps it counts instead of calling them
+  engine mounts, and the booted tier lists every Rack endpoint rather than
+  `Rails::Engine` subclasses alone. A mount inside a `namespace` or `scope`
+  carries that prefix; one whose enclosing scope, or its `path:`, is an expression is listed
+  with no path rather than an unprefixed one, and every list prints it
+  without one. `engines` follows every file `config/routes.rb` draws,
+  through the walk the static `routes` answer uses, so on the static tier
+  the two name one set of mounted apps; booted, `routes` reads the live
+  route table. `engines`, `onboard`, the MCP resource and the
+  generated context files head the same list "Mounted Apps", because half of
+  what it holds are not engines. On the static tier a `match ... to: SomeApp`
+  is counted once, as the mount it is, rather than also as a construct the
+  walk could not expand, and so are `get "/status" => StatusApp` and
+  `mount ActionCable.server => "/cable"`, which the walk did not see at all.
+- **config calls a zero-byte initializer empty** rather than "all commented
+  out".
+- **Smaller corrections in the same pass.** `validate_semantics` asks the
+  loaded model class before calling a callback method missing, and on the
+  static tier makes no claim once the payload's method list was cut at its
+  cap, so an inherited method past the cap is no longer reported as missing.
+  `get_controllers` points
+  `rails_get_view` at the controller's full path rather than its last segment,
+  which is the directory Rails resolves. The stack overview's `Engines:` line
+  is `Mounted:`, because half of what it lists are plain Rack apps.
+- **diagnose stops reading a display cap as a model's whole interface.** A
+  method past the thirtieth was reported as not existing, in the same answer
+  whose Method Trace printed its definition. Booted, diagnose asks the loaded
+  model class, which knows a concern's methods and a gem's as well as the
+  model's own. Statically, the model's own methods travel uncapped beside the
+  capped display list, and where a concern or a parent could define the
+  method the answer declines rather than guesses. `model_details` says how
+  many of the model's methods it is showing.
+- **A CamelCase controller name resolves everywhere.** The needle was
+  downcased without being underscored, so "GiftCards" never equalled the
+  route key's own "gift_cards": `Payload.find_controller` missed it, and every
+  tool that resolves a controller through it missed it too. One normalization
+  now serves the payload, the routes tool and the MCP resource, and the
+  resource answers a name that resolves to nothing with an error naming what
+  exists rather than a zero-route success document.
+- **security_scan runs the brakeman the machine has.** The app's bundle
+  narrows the load path, so a machine with brakeman installed was told to add
+  it to the Gemfile while the other tier scanned the same app. When the
+  in-process require fails and the gem is installed, the scan runs it as its
+  own process outside the bundle - reading the report from a file of its own,
+  since a gem manager's binstub can print to stdout first - and renders the
+  result the same way, with a line saying which brakeman answered and from
+  where. When the outside run writes no report, the answer carries the last
+  line brakeman printed about why. With no brakeman anywhere, the message
+  says that instead of guessing, and the availability answer is keyed by
+  tier rather than decided once per process.
+- **An exact search with a space keeps its context lines on ripgrep 13.**
+  The literal was escaped with Ruby's `\ `, which ripgrep 13 (Ubuntu 22.04,
+  Debian 12) rejects, so the search fell back to the Ruby scan and dropped
+  context lines and files with no listed extension. The space goes through
+  unescaped now, which both engines read the same way.
+
 ## [5.28.0] - 2026-09-22
 
 Thirty-six changes an architecture survey of v5.27.0 asked for, nine of them

data/CONTEXT.md

@@ -88,6 +88,43 @@ Three senses inside the gem, and the payload one is wider than either everyday R
 
 The callable interface of a class as this gem reports it: the class's own public instance methods - a class nested in the same file is a separate owner, not part of the interface - minus framework-shaped `_` names, read source-first, with reflection minus the app-owned base as the honest fallback. `ActionResolver` is the one answer; controller and mailer are configurations of it, and a channel's "stream methods" are a narrower selection of the same reading.
 
+## Mounted app
+
+A Rack app the routing table attaches at a path, engine or not. `mount App =>
+"/path"` is `match("/path", to: App, via: :all, anchor: false)` with a name
+derived, so both spellings build the same endpoint and both are this. The
+payload key is `mounted_engines` for the sections that predate the widening;
+what it holds is every controller-less, non-dynamic endpoint the route set
+carries, which is what the count beside it has always counted.
+
+Distinct from a **Rails engine**, which is a `Rails::Engine` subclass whether
+or not anything mounts it, and which `rails_get_engines` lists separately under
+its loaded classes. The record key is `engine:` for the same reason the section
+key is `mounted_engines:` - it predates the widening, and what it holds is the
+mounted app's constant, engine or not.
+
+## Interaction filter
+
+What an ActiveInteraction service declares as its interface, and not the
+**filter chain** above, which is controllers. `Interaction` is the one answer
+for both tools that read it (`rails_get_service_pattern`,
+`rails_generate_test`), because a static answer that differs from the booted
+one is the divergence the module exists to end.
+
+**A nested filter is not an input.** `string :title` inside `hash
+:order_params do ... end` is a key of that hash: it never reaches `.filters`,
+and handing it to `.run` as a keyword argument is dropped without a word. So
+nesting is kept on the record rather than flattened, and only the top level is
+an input.
+
+**The chain is the class's, not the file's.** An interaction is often a
+subclass of the app's own base interaction rather than of
+`ActiveInteraction::Base`, and its filters are then the parent's first and its
+own after, which is the order `.filters` answers in. Following that chain needs
+the parent's source, which only the caller can find, so it arrives as
+`lookup` - a callable from a constant name to that class's source, and nil to
+stop at the one file.
+
 ## Filter chain
 
 Which filters a controller runs, and which of them a given action runs. `ActionFilters` is the one answer, and every controller surface reads its filter line from there, so no two answers can disagree about what a class inherits or skips. `for_controller` answers about the class; `for` answers about one of its actions. Both return `own`, `inherited` and `skipped`.

data/docs/INTROSPECTORS.md

@@ -126,7 +126,7 @@ end
 
 | Introspector | Key | What it extracts |
 |:-------------|:----|:-----------------|
-| JobIntrospector | `:jobs` | Background jobs, Sidekiq workers under `app/workers`, and mailers: queue, retries, `sidekiq_options`, schedules, and the `file:` each one is defined in |
+| JobIntrospector | `:jobs` | Background jobs, Sidekiq workers under `app/workers`, and mailers: queue, retries, `sidekiq_options`, any `sidekiq_throttle`, schedules, and the `file:` each one is defined in |
 | RakeTaskIntrospector | `:rake_tasks` | Custom rake tasks |
 
 ### Security & Auth
@@ -193,7 +193,7 @@ Passed to `SourceIntrospector.walk(path, key => Listener)` when a specific file
 
 | Listener | What it detects |
 |:---------|:---------------|
-| GenericMacroListener | Any receiver-less macro you name: `GenericMacroListener.new(:devise, :rate_limit)`. Returns args, values (with a source-slice fallback), options, option values and option nodes |
+| GenericMacroListener | Any receiver-less macro you name: `GenericMacroListener.new(:devise, :rate_limit)`. Returns args, values (with a source-slice fallback), options, option values and option nodes, 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 |
 | ChainedCallListener | Calls on a receiver: `ChainedCallListener.new(:includes)`, or `receiver: :inflect` to pin the receiver. Reports the receiver name |
 | ConfigAssignmentListener | `config.key = value` and `config.a.b = value` in initializers and `config/environments/*.rb`, plus bare `config.jwt do ... end` section references. Takes a root name (`:config` by default, e.g. `:DatabaseCleaner`) |
 | ClassDefinitionListener | Class definitions with their superclass, namespaces resolved |
@@ -202,7 +202,7 @@ Passed to `SourceIntrospector.walk(path, key => Listener)` when a specific file
 | SchemaDslListener | `schema.rb`: `create_table`, `t.string`, `t.index`, `add_foreign_key`, `create_enum` |
 | MigrationDslListener | Migration DSL: `create_table`, `add_column`, `add_index`, `add_reference`, and friends |
 | RoutesDslListener | `config/routes.rb`, resolving namespace/scope/resources nesting into flat routes; routing concerns (`concern` definitions replayed at each `concerns:` site), `with_options` defaults merged under each inner call, and the `as:`, `param:`, `module:`, `path:` and `only:`/`except:` options |
-| MountListener | `mount Sidekiq::Web, at: "/sidekiq"` and the hash form |
+| 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 |
 | GemfileDslListener | `gem "name", "version"` and `group :development do ... end` |
 | RakeTaskDslListener | `namespace`, `desc`, `task` in `.rake` files |
 | EnvAccessListener | `ENV["KEY"]`, `ENV.fetch("KEY")`, `ENV.fetch("KEY", default)` |
@@ -233,6 +233,19 @@ Regex is the right tool, and stays, for:
 
 Every remaining regex over `.rb` content carries a one-line comment saying which of these it is. If you add one without a reason, convert it instead.
 
+### Readers built on the listeners
+
+Some questions take more than one walk to answer, and the answer has to be the
+same wherever it is asked. Those live as their own modules under
+`Introspectors/`, and a tool calls one rather than repeating the walk:
+
+| Module | What it answers |
+|:-------|:---------------|
+| `DeclaredConstant` | The constant a source file calls its own class, against the one its path camelizes to |
+| `TableName` | The table a model reads, from its own declarations |
+| `SuperclassChain` | What a class inherits from, followed through the app's own sources: the chain from a file's class up to a named base, and the constant-to-source lookup over the app's autoload roots that walks it |
+| `Interaction` | Whether a class runs as an ActiveInteraction, following its superclass chain through the app's own sources, and the filters it takes - inherited ones first, one per name, each carrying the filters nested inside its block. See the **Interaction filter** entry in `CONTEXT.md` |
+
 ### Confidence tagging
 
 Every AST result carries a confidence tag:

data/docs/TOOLS.md

@@ -116,7 +116,7 @@ Full-stack feature analysis: models + controllers + routes + services + jobs + v
 
 ### `rails_get_context`
 
-Composite context: schema + model + controller + routes + views for a resource.
+Composite context: schema + model + controller + routes + views for a resource. Views come from the directory Rails resolves for the controller; a flat-directory fallback is labelled.
 
 | Parameter | Type | Default | Description |
 |:----------|:-----|:--------|:------------|
@@ -140,7 +140,10 @@ Narrative app walkthrough for getting up to speed.
 
 ### `rails_get_schema`
 
-Database schema with column types, indexes, defaults, encrypted hints.
+Database schema with column types, indexes, defaults, encrypted hints. Booted,
+a table `db/schema.rb` declares and the connected database does not have is
+named as a migration that has not run, and the listing header says when the
+two table counts disagree.
 
 | Parameter | Type | Default | Description |
 |:----------|:-----|:--------|:------------|
@@ -149,7 +152,7 @@ Database schema with column types, indexes, defaults, encrypted hints.
 
 ### `rails_get_model_details`
 
-AST-parsed model internals. Every result carries `[VERIFIED]` or `[INFERRED]` confidence tag.
+AST-parsed model internals. Every result carries `[VERIFIED]` or `[INFERRED]` confidence tag. The method list says how many of the model's methods it is showing.
 
 | Parameter | Type | Default | Description |
 |:----------|:-----|:--------|:------------|
@@ -176,7 +179,10 @@ its concerns), not the order Rails registered them in.
 
 ### `rails_get_concern`
 
-Concern methods, source code, and which models include it.
+Concern methods, source code, and which models include it. A class under
+`app/models/concerns` that subclasses `ActiveModel::Validator` is listed as a
+validator rather than a concern, and its users are the models that name it in
+`validates_with`.
 
 | Parameter | Type | Default | Description |
 |:----------|:-----|:--------|:------------|
@@ -201,7 +207,11 @@ Controller actions with inherited filters, render map, strong params. Includes s
 
 ### `rails_get_routes`
 
-Routes with code-ready helpers (`post_path(@record)`) and required params.
+Routes with code-ready helpers (`post_path(@record)`) and required params. A
+fully qualified controller key answers with its own routes only; a short name
+still matches every controller that carries it. Rack apps attached with `mount`
+or `match ... to:` are named with the path they answer on, when the source
+spells one out.
 
 | Parameter | Type | Default | Description |
 |:----------|:-----|:--------|:------------|
@@ -216,7 +226,7 @@ Routes with code-ready helpers (`post_path(@record)`) and required params.
 
 ### `rails_get_view`
 
-View templates with instance variables, Turbo frames, Stimulus controllers, partial locals. Includes schema hints for detected ivars.
+View templates with instance variables, Turbo frames, Stimulus controllers, partial locals. Includes schema hints for detected ivars. A template directly under `app/views` is grouped as `(app/views root)`, which `path:` reaches and `controller:` does not.
 
 | Parameter | Type | Default | Description |
 |:----------|:-----|:--------|:------------|
@@ -299,7 +309,9 @@ Brakeman static analysis: SQL injection, XSS, mass assignment, command injection
 |:----------|:-----|:--------|:------------|
 | `detail` | enum | `standard` | `summary`, `standard`, `full` |
 
-> Requires the `brakeman` gem. Gracefully reports "not installed" if missing.
+> Requires the `brakeman` gem. When it cannot be loaded, the answer says which
+> case it is: brakeman is nowhere on the machine, or it is installed and the
+> app's bundle does not carry it, which `--no-boot` scans around.
 
 ### `rails_performance_check`
 
@@ -349,7 +361,7 @@ Notable gems with versions, categories, and config file locations.
 
 ### `rails_get_env`
 
-Environment variables + credentials keys (values are never exposed). Scans `.rb`, `.rake`, ERB views and config YAML under `app`, `config` and `lib`; files matching `sensitive_patterns` (`config/database.yml`, credentials, keys) are never read, and the answer says so.
+Environment variables + credentials keys (values are never exposed). Scans `.rb`, `.rake`, ERB views and config YAML under `app`, `config` and `lib`; files matching `sensitive_patterns` (`config/database.yml`, credentials, keys) are never read, and the answer says so. A variable whose call sites pass different defaults is labelled as such rather than with one site's default; `detail:"full"` names each site's.
 
 | Parameter | Type | Default | Description |
 |:----------|:-----|:--------|:------------|
@@ -365,7 +377,12 @@ Application and framework helpers with view cross-references.
 
 ### `rails_get_service_pattern`
 
-Service object interface, dependencies, side effects, callers.
+Service object interface, dependencies, side effects, callers. An
+ActiveInteraction's inputs include the ones it inherits, with the filters
+nested inside a `hash` filter shown under it. Callers are read from every
+`app/` and `lib/` tree, and on a booted app from any other directory it
+autoloads, and the page says when the twenty-caller display cap or the scan's
+own file ceiling left the list partial.
 
 | Parameter | Type | Default | Description |
 |:----------|:-----|:--------|:------------|
@@ -376,7 +393,9 @@ Service object interface, dependencies, side effects, callers.
 
 Background job queue, retries, guard clauses, broadcasts, schedules. Sidekiq
 workers under `app/workers` are listed alongside the ActiveJob jobs, with
-their `sidekiq_options` and `perform` signature.
+their `sidekiq_options`, any `sidekiq_throttle`, and the `perform` signature. A
+worker that inherits its Sidekiq mixin from a base worker is one of them, and
+`job:` answers a worker name as well as a job name.
 
 | Parameter | Type | Default | Description |
 |:----------|:-----|:--------|:------------|
@@ -414,7 +433,7 @@ ActionMailer mailers: every mailer class with its delivery actions and delivery
 
 ### `rails_get_engines`
 
-Rails engines: engines mounted in `config/routes.rb` (with known-engine descriptions) and loaded engine classes with route/model counts.
+What `config/routes.rb` mounts - engines and plain Rack apps alike, with known-engine descriptions, each with the path it answers on when the source spells one out - and loaded engine classes with route/model counts.
 
 *No parameters.*
 
@@ -506,7 +525,7 @@ Reverse file tail with level filtering and sensitive data redaction.
 
 ### `rails_diagnose`
 
-One-call error diagnosis with classification, context, git blame, and log correlation.
+One-call error diagnosis with classification, context, git blame, and log correlation. It does not call a method undefined when the model's method list could be missing one - a concern's, a parent's, or anything past the payload's own cap.
 
 | Parameter | Type | Default | Description |
 |:----------|:-----|:--------|:------------|

data/docs/TROUBLESHOOTING.md

@@ -256,6 +256,19 @@ bundle add brakeman --group development
 
 Without it, the tool reports "not installed" but the gem works fine otherwise.
 
+### "Installed on this machine but not in this app's bundle"
+
+The scan runs under the app's own bundle, so a brakeman installed globally is
+not on its load path. The tool falls back on its own: it runs the installed
+brakeman as a separate process outside the bundle and says so under the
+results. This message means that fallback produced no report either - the gem
+is there and the run failed. Run `brakeman` in the app directory to see what
+it hit, or add it to the Gemfile so the scan runs in-process:
+
+```bash
+bundle add brakeman --group development
+```
+
 ---
 
 ## Performance issues

data/lib/rails_ai_context/introspectors/engine_introspector.rb

@@ -66,21 +66,16 @@ module RailsAiContext
 
       private
 
-      def root
-        app.root.to_s
-      end
-
+      # What config/routes.rb and the files it draws mount, on both tiers,
+      # through the route introspector's own walk: on the static tier the
+      # routes section reads the same walk, and booted it reads the live
+      # route table, which also holds what a gem mounts for itself.
       def discover_mounted_engines
-        routes_path = File.join(root, "config/routes.rb")
-        return [] unless File.exist?(routes_path)
-
-        ast_data = SourceIntrospector.walk(routes_path, { mounts: -> { Listeners::MountListener.new } })
         engines = []
 
-        ast_data[:mounts].each do |mount|
+        RouteIntrospector.new(app).static_mounts.each do |mount|
           engine_name = mount[:engine]
-          path = mount[:path] || "unknown"
-          info = { engine: engine_name, path: path }
+          info = { engine: engine_name, path: mount[:path] }
           known = KNOWN_ENGINES[engine_name]
           if known
             info[:category] = known[:category].to_s

data/lib/rails_ai_context/introspectors/env_config_introspector.rb

@@ -98,17 +98,39 @@ module RailsAiContext
       end
 
       # `:memory_store if Rails.root.join(...).exist?, else :null_store`.
+      #
+      # Two unconditional assignments of one key are not branches: Rails runs
+      # both lines and the last one wins. Comma-joining them read exactly like
+      # a single assignment whose value is a comma list
+      # (`:mem_cache_store, { pool_size: 5 }`), so the winner is named and the
+      # assignment it overrode is named after it.
       def branch_values(entries)
         return one_line(entries.first[:source].to_s) if entries.size == 1
 
-        entries.map do |entry|
+        unconditional, conditional = entries.partition { |entry| entry[:condition].nil? }
+        rendered = conditional.map { |entry|
           value = one_line(entry[:source].to_s)
-          case entry[:condition]
-          when nil then value
-          when "else" then "else #{value}"
-          else "#{value} if #{entry[:condition]}"
-          end
-        end.uniq.join(", ")
+          text = entry[:condition] == "else" ? "else #{value}" : "#{value} if #{entry[:condition]}"
+          [ entry[:location].to_i, text ]
+        }
+
+        if unconditional.any?
+          # The last line the file runs is the value in force, whatever ran
+          # before it, so the winner is taken before any de-duplication - a
+          # value that repeats is still the one that ran last.
+          winner = unconditional.last
+          overridden = unconditional[0..-2].map { |entry| one_line(entry[:source].to_s) }.uniq
+          overridden -= [ one_line(winner[:source].to_s) ]
+          text = one_line(winner[:source].to_s)
+          text += " (overrides #{overridden.join(', ')})" if overridden.any?
+          rendered << [ winner[:location].to_i, text ]
+        end
+
+        # Source order, because that is run order: a conditional assignment
+        # printed after the unconditional one that follows it reads as the
+        # value in force.
+        rendered.each_with_index.sort_by { |(line, _), index| [ line, index ] }
+                .map { |(_, text), _| text }.uniq.join(", ")
       end
 
       # The booted app has already resolved the branch, and two tools reading

data/lib/rails_ai_context/introspectors/interaction.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  module Introspectors
+    # What an ActiveInteraction service declares as its interface: whether the
+    # class is one, and the filters it takes.
+    #
+    # Two things the filter macros alone do not say, and every consumer needs.
+    #
+    # A filter declared inside another filter's block is a key of that filter,
+    # not an input of the class: `string :title` inside `hash :order_params do
+    # ... end` never reaches `.filters`, and passing it to `.run` drops it
+    # silently. So nesting is kept, never flattened.
+    #
+    # An interaction is often a subclass of the app's own base interaction
+    # rather than of ActiveInteraction::Base, and its filters are then its own
+    # plus the ones it inherits, parent's first, which is the order
+    # `.filters` answers in. Following that chain needs the parent's source,
+    # which only the caller can find, so it comes in as `lookup` - a callable
+    # from a constant name to that class's source, or nil to stop at the one
+    # file. `SuperclassChain.lookup_for` builds the one both consumers pass.
+    #
+    # Reading the loaded constant's `.filters` would answer both on a booted
+    # app, but the two consumers (rails_get_service_pattern, rails_generate_test)
+    # answer from source in both tiers, and a static answer that differs from
+    # the booted one is the divergence this module exists to end.
+    module Interaction
+      BASE = "ActiveInteraction::Base"
+
+      # The filter macros ActiveInteraction defines. `interface` and `record`
+      # included: they are filters like any other.
+      FILTERS = %w[
+        array boolean date date_time decimal file float hash integer
+        interface object record string symbol time
+      ].freeze
+
+      # `nested` is the filters declared inside this one's block; `declared_by`
+      # the class that declares it, which is not this file's class for an
+      # inherited one.
+      Filter = Data.define(:macro, :name, :options, :declared_by, :nested)
+
+      module_function
+
+      # @param source [String] the file's source
+      # @param lookup [#call, nil] constant name -> that class's source
+      # @return [Boolean] whether the class this source declares runs as an
+      #   ActiveInteraction
+      def interaction?(source, lookup: nil)
+        chain(source, lookup: lookup).any?
+      end
+
+      # The filters the class takes, inherited ones first, each with the
+      # filters nested inside it.
+      #
+      # @return [Array<Filter>] empty when the source declares no interaction
+      def filters(source, lookup: nil)
+        interface(source, lookup: lookup) || []
+      end
+
+      # Both answers from one walk of the chain, for a caller that needs to
+      # know whether the class is an interaction and what it takes: nil when
+      # it is not one, the filters when it is - and an interaction with no
+      # filters answers [], which is not nil.
+      #
+      # @return [Array<Filter>, nil]
+      def interface(source, lookup: nil)
+        links = chain(source, lookup: lookup)
+        return nil if links.empty?
+
+        one_per_name(links.reverse.flat_map { |link| own_filters(link) })
+      end
+
+      # The classes from ActiveInteraction::Base down to this one, nearest
+      # first, or empty when the chain never reaches it.
+      #
+      # @return [Array<SuperclassChain::Link>]
+      def chain(source, lookup: nil)
+        SuperclassChain.to(source, bases: [ BASE ], lookup: lookup)
+      end
+
+      # `.filters` is a hash keyed by name, so a subclass that redeclares its
+      # parent's filter replaces it and keeps the parent's position. Rendering
+      # both printed the name twice, and generating `run(token: nil, token:
+      # nil)` from it is a duplicate keyword argument.
+      def one_per_name(filters)
+        slots = {}
+        filters.each_with_index do |filter, index|
+          existing = slots[filter.name]
+          slots[filter.name] = [ existing ? existing.first : index, filter ]
+        end
+        slots.values.sort_by(&:first).map(&:last)
+      end
+
+      # The filters one class declares, nested ones attached to the filter
+      # whose block they sit in, paired by the parent call's own offset in the
+      # source.
+      def own_filters(link)
+        records = SourceIntrospector.walk_source(
+          link.source, { filters: -> { Listeners::GenericMacroListener.new(FILTERS) } }
+        )[:filters] || []
+
+        # Children first, so a filter is built once, with what it holds. One
+        # macro call declares one filter that can take a block (`hash :a, :b
+        # do` is not a shape ActiveInteraction accepts), so the call's own
+        # offset names the parent of everything inside it.
+        children = records.group_by { |record| record[:parent_offset] }
+        build_filters(children[nil] || [], children, link.name)
+      end
+
+      def build_filters(records, children, declared_by)
+        records.flat_map do |record|
+          nested = build_filters(children[record[:offset]] || [], children, declared_by)
+          Array(record[:args]).map do |name|
+            Filter.new(
+              macro: record[:macro].to_s,
+              name: name.to_s,
+              options: record[:option_values] || {},
+              declared_by: declared_by,
+              nested: nested
+            )
+          end
+        end
+      end
+      private_class_method :chain, :own_filters, :build_filters, :one_per_name
+    end
+  end
+end