rails-ai-context 5.36.1 → 5.36.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ae3eb5f18027a0abe6cf4a8872f9ecce9fb792109ab243b9b7edbba3558cb6d
-  data.tar.gz: c6c7b740f4e18e494a371215c99c05bad848ed43ebf1f84f24020ad4348612ac
+  metadata.gz: ecc8cfb0b751983a682c2a2c0bd2082216595b83f12f679d190506425d60ae48
+  data.tar.gz: e0674fed2e5f40ebe3f33166c59d9c17bcd5c5160352100cf8b38d87a73387a4
 SHA512:
-  metadata.gz: fe22c7af7f32d7aa16abdc3b6534653614f3e38fc25a1406c5e29ab9dbb0cf609878fd633210cb3006352007b156d5eaba887db3d1e9ad53cec0ae57357622c0
-  data.tar.gz: 6b0aff79f555f43322eab5c3c81ebcc8a7477a8674891d1f3d2988a47cd23044db5383aacbbd6db3ec15cdeb882dc37b5af4e9cb98c73f1150ba8c73d55cf283
+  metadata.gz: c78d50c7e050632c88f60e901a8805ed5d397f2f12fb9412fa7ac64af1ed3921ff776486a8e4912f0a5a531e6a90661ca6d7b35def872bc4cd11215bde2941b0
+  data.tar.gz: 0b597f6cc7372007cb84936ac62f2ca893791622c62a667ea4601b545c73a9719949f3abfc09fd8fe75fe2e143fb1bfa5a4bbf82ee47e4f5fca6d293392c5b9d

data/CHANGELOG.md

@@ -5,6 +5,100 @@ 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.36.3] - 2026-10-15
+
+### Fixed
+
+- **`rails_diagnose` names an instance variable receiver with its `@`, and takes it from the line the error names.**
+  `@widget.name` read as `widget`, so the advice named a variable the action does
+  not have. The receiver also came from the first call of the method in the file,
+  not from the line. A line that does not call the method on a plain name now
+  gets no receiver instead of another line's. 5.36.2 and earlier versions had the
+  gap.
+- **`rails_generate_test` says which sign-in helper names it looked for.** The
+  TODO read "this app's tests define no sign-in helper" for a suite that signs in
+  through a helper with another name. It now reads "no `sign_in` or `log_in`
+  helper in this app's test helpers".
+- **A `change_table` migration lists what its block does.** `rails://migrations`
+  showed `"actions": []` for a migration that adds columns through
+  `change_table`, and `migration_stats` left it out of `total_add_column`. The
+  table calls in the block (`t.string`, `t.references`, `t.index`, `t.remove` and
+  the others) are read from the AST. A `create_table` block's columns are not
+  counted.
+- **`rails_search_code` trace says how many sibling methods and internal calls it
+  left out.** It listed 10 siblings and 15 internal calls and stopped. The list
+  now ends with "_...and N more_".
+- **`rails_get_job_pattern` reads sidekiq-scheduler entries from every
+  `config/sidekiq*.yml`.** A schedule kept in `config/sidekiq_production.yml`,
+  one file per environment, showed no `Schedule`, so a worker that runs every
+  night read like dead code. Each file's entry is shown with its file name.
+- **`rails_get_config(section:"conventions")` counts the rake tasks of
+  `lib/tasks` and the templates of `app/views`.** The directory counts took
+  `.rb` files only: `lib/tasks` read 2 files for 67, and `app/views` never
+  appeared.
+- **`rails_get_test_info` counts only `*_spec.rb` under `spec/` in an RSpec
+  suite.** A `*_test.rb` helper in `spec/support` was counted as a test file. A
+  Minitest suite still counts both `*_spec.rb` and `*_test.rb`.
+- **`rails_migration_advisor` writes a reference and a new table with the key
+  type the app uses.** On a schema of `id: :uuid` tables, `add_reference` made a
+  bigint column that PostgreSQL refuses to key to a uuid, and `create_table`
+  made the one bigint table. `add_reference` and `t.references` take the key type
+  of the table they point at (the app's type when the schema lacks that table),
+  and `create_table` takes the type most of the app's tables share.
+- **`rails_review_changes` matches `files` by whole path or directory.**
+  `files: ["Gemfile"]` also returned `Gemfile.lock`. A directory such as
+  `app/models` still matches the files under it.
+- **`rails_analyze_feature` says which directories it stopped reading.** It reads
+  the first 500 files of a directory, and a service, view or test past that was
+  missed with no word. The answer now ends with the directories it did not
+  finish. The "first 500 scanned" note no longer shows when exactly 500 files were
+  read.
+
+## [5.36.2] - 2026-10-15
+
+### Fixed
+
+- **`rails_onboard` and `rails_get_schema` name every database
+  `rails_performance_check` names.** A database database.yml configures with no
+  dump on disk and no migrations of its own, or with `database_tasks: false` and
+  no committed dump, was left out of both. `rails_onboard` now lists it as
+  "(tables not read)", and `rails_get_schema` says why: "Its tables are not
+  listed: db/extra_schema.rb is not on disk". A replica stays out of all three,
+  and so does a database whose dump is the primary's. The schema rules file
+  gives the primary no heading of its own when it is the only database with
+  tables. For a `schema_dump` the gem cannot follow, the reason now reads
+  "`schema_dump` in its database.yml entry names no file to read" on
+  `rails_get_schema` and `rails_performance_check`. 5.36.1 and earlier versions
+  had the gap.
+- **On the static tier a model of the primary database whose table db/schema.rb
+  does not declare says so.** `rails_get_model_details`, `rails_onboard` and the
+  generated files named the conventional table, `widgets`, with no word that
+  db/schema.rb holds no such table, and model details pointed to
+  `rails_get_schema` for it. They now answer "`widgets` missing from
+  db/schema.rb", and model details leaves out the pointer for a table it says is
+  missing. A model whose table or database the static tier cannot be sure of is
+  left unjudged: one of another database, one on a connection of its own
+  (`establish_connection` in its class or a base), one whose table name a
+  computed `table_name`, affix or `pluralize_table_names` shapes, one with a
+  concern or base the static tier could not read, a table in another schema, and
+  tables read from db/structure.sql or the migrations, since a replay can miss a
+  table raw SQL creates. 5.36.1 and earlier versions had the gap.
+- **The static tier reads the table name prefix of a module whose name camelize
+  does not give.** A module file such as app/models/sdg.rb that declares
+  `module SDG` with `table_name_prefix` was keyed as `Sdg`, so `SDG::Goal` got
+  the table `goals` where Rails reads `sdg_goals`. The module is now named as it
+  declares itself. 5.36.1 and earlier versions had the gap.
+- **The static tier builds no table name from an affix it could not read.**
+  `ActiveRecord::Base.table_name_prefix = ENV.fetch("P", "")` gave every model a
+  table such as `[INFERRED]widgets`. An affix or `pluralize_table_names` the app
+  computes is now left out of the guessed name, and a later computed assignment
+  hides an earlier literal one, as it does when the app runs. 5.36.1 and earlier
+  versions had the gap.
+- **`rails_session_context(mark:)` says a tool skip_tools turned off is turned
+  off.** It answered "Unknown tool" for a tool the gem has, where a call of the
+  tool says it is turned off. Both now give the same answer, by the tool's full
+  or short name. 5.36.1 and earlier versions had the gap.
+
 ## [5.36.1] - 2026-10-15
 
 ### Fixed

data/docs/COMPATIBILITY.md

@@ -327,6 +327,19 @@ Proof sources:
    published code on PostgreSQL 13 to 18, MySQL 8.0 and 8.4 and MariaDB 10.6
    and 11.4, the booted and static mailer lists compared on one app, and the
    unit suite and the E2E harness on Linux, macOS and Windows.
+   In the v5.36.2 release QA: each fix's example failing on the v5.36.1 code;
+   the issues' repros run through the CLI on a minimal app on the v5.36.1 code
+   and on the fix; the static answers of 13 corpus apps compared between the
+   two; MariaDB 10.6 and 11.4 through mysql2 built against MariaDB's client
+   library on Linux; `rails_runtime_info` against a real Sidekiq and Redis; and
+   the unit suite and the E2E harness on Linux, macOS and Windows.
+   In the v5.36.3 release QA: each fix's example failing on the v5.36.2 code;
+   the issues' repros run through the CLI on a minimal app, and on copies of two
+   large apps (both in the static tier, one also booted) against counts taken
+   from their files; the introspector, tool and integration specs on Ruby 3.1
+   with Rails 7.0 and 7.2, Ruby 3.3 with Rails 7.1, Ruby 3.4 with Rails 8.0 and
+   8.1, and Ruby 4.0 with Rails 8.1; and the unit suite and the E2E harness on
+   Linux, macOS and Windows.
 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

@@ -184,7 +184,7 @@ It runs a single-pass Dispatcher that walks the AST once and feeds events to all
 | 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; `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) |
+| 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`), `establish_connection` (on the static tier a model whose class or base calls it is on a connection of its own), 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 |
 
@@ -271,7 +271,7 @@ same wherever it is asked. Those live as their own modules under
 | `ActionPresence` | Whether a controller has an action: the public methods and `define_method` names of the controller, its ancestors up to Rails' base and the modules they include, the templates at each ancestor's view prefix, and the ancestors or modules no app source holds, which leave a missing action unverified. `rails_validate` and `rails_generate_test` both ask it |
 | `ControllerSettings` | The layout a controller renders in (declared on it or an ancestor, else the `layouts/<controller_path>` file Rails finds by name, walking up the chain) and the `allow_browser`, `protect_from_forgery`, `add_flash_types`, `default_form_builder` and `wrap_parameters` calls it and its ancestors make. `rails_get_controllers` and `rails_get_view` both ask it |
 | `TableName` | The table a model reads, from its own declarations |
-| `ActiveRecordSettings` | What config/application.rb, the environment file and the initializers set on Active Record: the table affixes, `pluralize_table_names` and `schema_format`, in the order Rails applies them. Read once per introspection run or tool call |
+| `ActiveRecordSettings` | What config/application.rb, the environment file and the initializers set on Active Record: the table affixes, `pluralize_table_names` and `schema_format`, in the order Rails applies them, and which of them an assignment gives a value only the running app computes. Read once per introspection run or tool call |
 | `HabtmJoinTables` | The join tables every `has_and_belongs_to_many` under the app's code and lib names, lib patches and engines included, for the schema's model-less table warning |
 | `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 |
 | `CallSiteExpansion` | What one call of a mixin's macro-declaring method declares. `attachable :receipt, has_one: true` runs `def attachable(name, opts = {})`, whose body declares `has_one name` or `has_many name` by `opts[:has_one]`: the parameters bind to the call's literal arguments, and a branch (`if`, `unless`, `case`) the literals decide is taken alone. Where they cannot decide, what every way through declares alike is listed once; the rest, a lone `if`'s body included, comes back under `:conditional` with its condition and is not counted. A block the method evaluates on another receiver (`other.instance_eval`) comes back under `:foreign`, named with the receiver and any condition it runs under |
@@ -285,7 +285,7 @@ same wherever it is asked. Those live as their own modules under
 | `ModuleAliases` | Which app file a bare JS import specifier names: tsconfig/jsconfig `compilerOptions.paths` followed through `extends` (relative files and installed packages), and a vite/webpack/rspack `resolve.alias` written as a literal object. The Stimulus scan uses it to tie a registration or a base class to the controller file it imports |
 | `HelperNames` | The helper methods a view can call: every method the app's helper modules define in every code root, and those of a module they `include`, found through the app's autoload roots (`lib` among them) or in its enclosing namespace's file (`CanonicalURL::Helpers` in `canonical_url.rb`). `rails_get_partial_interface` uses it so a helper call is not read as a local |
 | `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` |
-| `RecurringSchedules` | The recurring tasks each scheduler reads from its own file: Solid Queue's `config/recurring.yml`, sidekiq-cron's `config/schedule.yml`, sidekiq-scheduler's section of `config/sidekiq.yml`, GoodJob's `config.good_job.cron` and whenever's `config/schedule.rb`. The job introspector hands it its own config walk, so a file it also reads for queue or mailer settings is walked once |
+| `RecurringSchedules` | The recurring tasks each scheduler reads from its own file: Solid Queue's `config/recurring.yml`, sidekiq-cron's `config/schedule.yml`, sidekiq-scheduler's section of each `config/sidekiq*.yml`, GoodJob's `config.good_job.cron` and whenever's `config/schedule.rb`. The job introspector hands it its own config walk, so a file it also reads for queue or mailer settings is walked once |
 | `AdminResources` | The models an admin gem exposes (ActiveAdmin, Trestle, Administrate, Avo, Madmin), from the folder each gem's generator writes to, with ActiveAdmin's `permit_params`. `rails_get_config(section:"conventions")` and `rails_analyze_feature` both ask it |
 | `SchemaDumpPath` | The primary database's dump file as `DatabaseTasks.schema_dump_path` names it: `database.yml`'s `schema_dump` in the configured `schema_format`, then each format's default file, and the secondary databases' dumps. Every schema reader, the doctor and the pending-migration check ask it |
 | `ApartmentConfig` | The models an Apartment initializer keeps in the shared schema (`excluded_models`), or the source of a list the file computes. The model introspector asks it to say which models get one table per tenant |

data/docs/TOOLS.md

@@ -143,14 +143,15 @@ Narrative app walkthrough for getting up to speed. The stack line counts the
 tables of every database the app's own schema dumps declare, as
 `rails_get_schema` reads them; the databases Rails 8 gives Solid Queue, Solid
 Cache and Solid Cable get one line, without their tables. A database whose
-dump was not read is named with "(tables not read)" and left out of the table
-count, and the summary says so: "5 tables in 2 databases, the warehouse
-database not read". It ends with the app's custom rake tasks (Rakefile,
-`lib/tasks`, `rakelib`), each with its arguments, description and file: the
-first 15 at `standard`, every one at `full`.
-Then the app's own generators under `lib/generators` (the `bin/rails generate`
-command and its USAGE line), the `lib/templates` files that replace a built-in
-generator's template, and the Railties under `lib/` with their initializers.
+dump was not read, or that has no dump on disk and no migrations of its own,
+is named with "(tables not read)" and left out of the table count, and the
+summary says so: "5 tables in 2 databases, the warehouse database not read".
+It ends with the app's custom rake tasks (Rakefile, `lib/tasks`, `rakelib`),
+each with its arguments, description and file: the first 15 at `standard`,
+every one at `full`. Then the app's own generators under `lib/generators` (the
+`bin/rails generate` command and its USAGE line), the `lib/templates` files
+that replace a built-in generator's template, and the Railties under `lib/`
+with their initializers.
 
 | Parameter | Type | Default | Description |
 |:----------|:-----|:--------|:------------|
@@ -176,10 +177,12 @@ The other databases are listed after the primary's tables: every database any
 environment in `config/database.yml` configures, so a Rails 8 app's queue,
 cache and cable dumps are read even where only production configures them,
 then any committed dump no environment names. A dump too large to read, or
-holding no tables, is named with the reason. A secondary's dump is read from
-its own path, else from the other format's file under its name
-(`db/queue_schema.rb` or `db/queue_structure.sql`), whatever `database_tasks`
-or `schema_format` says.
+holding no tables, is named with the reason, and so is a database with no dump
+on disk and no migrations of its own, one with `database_tasks: false`
+included. A replica is not listed. A secondary's dump is read from its own
+path, else from the other format's file under its name (`db/queue_schema.rb`
+or `db/queue_structure.sql`), whatever `database_tasks` or `schema_format`
+says.
 
 A database only another environment configures carries a mark, as in
 `cache (production only)`, and a first database that is not named `primary`
@@ -204,7 +207,7 @@ composite unique index; `[in index after x]` marks a column that only trails
 
 ### `rails_get_model_details`
 
-AST-parsed model internals. The model heading and each scope carry a confidence tag: `[VERIFIED]` or `[INFERRED]` on a booted app, `[STATIC]` without a boot. The method list says how many of the model's methods it is showing.
+AST-parsed model internals. The model heading and each scope carry a confidence tag: `[VERIFIED]` or `[INFERRED]` on a booted app, `[STATIC]` without a boot. The method list says how many of the model's methods it is showing. On the static tier a model of the primary database whose table db/schema.rb does not declare says so: "`widgets` missing from db/schema.rb".
 
 | Parameter | Type | Default | Description |
 |:----------|:-----|:--------|:------------|
@@ -481,8 +484,8 @@ database's name is read whatever `database_tasks` or `schema_dump` says. A
 database whose tables could not be read is listed under **Not checked** with
 the reason: its dump is not on disk or is over `max_schema_file_size`, or its
 `config/database.yml` entry turns `database_tasks` or `schema_dump` off and no
-dump is on disk, or "`schema_dump` in its database.yml entry names no file this
-check reads". A database another environment configures carries its mark:
+dump is on disk, or "`schema_dump` in its database.yml entry names no file to
+read". A database another environment configures carries its mark:
 `**Not checked:** warehouse (production only, db/warehouse_schema.rb is not on disk)`.
 
 | Parameter | Type | Default | Description |
@@ -823,7 +826,7 @@ Each diff passes through the redaction every tool's source does, read as the fil
 | Parameter | Type | Default | Description |
 |:----------|:-----|:--------|:------------|
 | `ref` | string | `HEAD` | Git ref to diff against: a branch, a tag, `HEAD~3` or a commit SHA. `HEAD` reviews uncommitted changes. Any other ref reviews the commits since HEAD left it, as a pull request does: the file list and each file's diff run from the commit the two last shared to HEAD. A ref that names no commit is refused |
-| `files` | array | - | Review only these changed files (omit for all) |
+| `files` | array | - | Review only these changed files, or the changed files under these directories (omit for all). A path matches whole, so `Gemfile` is not `Gemfile.lock` |
 
 ### `rails_runtime_info`
 
@@ -852,7 +855,7 @@ Session-aware context tracking across tool calls within a conversation. Pass `ac
 | Parameter | Type | Default | Description |
 |:----------|:-----|:--------|:------------|
 | `action` | enum | - | `status` (queried tools with timestamps), `summary` (short recap), `reset` (clear this conversation's record) |
-| `mark` | string | - | Record a tool and its params as already queried (e.g., `get_schema:users`). The tool must be one the server has; a short name such as `schema` is taken. A retired name such as `get_gems` is recorded as `rails_get_config` with its section |
+| `mark` | string | - | Record a tool and its params as already queried (e.g., `get_schema:users`). The tool must be one the server has; a short name such as `schema` is taken, and a tool skip_tools turned off answers that it is turned off. A retired name such as `get_gems` is recorded as `rails_get_config` with its section |
 
 Each conversation has its own record: over HTTP, one server process serves every client, and each client's `Mcp-Session-Id` keeps its calls, and its `reset`, to itself. A tool that answers by calling others (`rails_get_context`, `rails_diagnose`, `rails_review_changes`) is recorded as the one call the client made.
 

data/lib/rails_ai_context/app_databases.rb

@@ -50,6 +50,21 @@ module RailsAiContext
         AppDatabases.settings_of(config)
       end
 
+      # Why there is no dump of this database to read, or nil when its dump is on disk.
+      def missing_dump(root)
+        return no_dump_reason unless dump
+        return nil if File.exist?(dump.path)
+
+        "#{dump.path.delete_prefix("#{root.to_s.chomp('/')}/")} is not on disk"
+      end
+
+      private def no_dump_reason
+        return "its database.yml entry turns `database_tasks` off, so Rails writes it no dump" unless tasks
+        return "its database.yml entry turns `schema_dump` off, so Rails writes it no dump" unless settings["schema_dump"]
+
+        "`schema_dump` in its database.yml entry names no file to read"
+      end
+
       # Raises Unreachable, naming the database, when no connection to it answers.
       def with_connection(&block)
         with_pool do |pool|

data/lib/rails_ai_context/cli/tool_runner.rb

@@ -146,6 +146,12 @@ module RailsAiContext
         [ name, "rails_#{name}", "rails_get_#{name}" ]
       end
 
+      # The turned-off answer when skip_tools lists the tool a typed name spells, nil otherwise.
+      def self.turned_off_message(name)
+        skipped = candidate_names(name) & Server.skipped_tools
+        Server.skipped_tool_message(skipped.first) if skipped.any?
+      end
+
       private
 
       # The schema a call is checked against, as InputSchema#to_h gives it on every
@@ -178,8 +184,8 @@ module RailsAiContext
         found = tools.find { |t| self.class.short_name(t.tool_name) == name }
         return [ found, nil ] if found
 
-        skipped = self.class.candidate_names(name) & Server.skipped_tools
-        raise ToolNotFoundError, Server.skipped_tool_message(skipped.first) if skipped.any?
+        skipped = self.class.turned_off_message(name)
+        raise ToolNotFoundError, skipped if skipped
 
         # Fuzzy suggestion
         short_names = (tools.map(&:tool_name) | Server.retired_names).map { |tool_name| self.class.short_name(tool_name) }

data/lib/rails_ai_context/introspectors/active_record_settings.rb

@@ -15,7 +15,16 @@ module RailsAiContext
 
       # {table_name_prefix: "op_", schema_format: :sql}
       def for(root)
-        return {} unless root
+        read_once(root).first
+      end
+
+      # The settings an assignment gives a value only the running app computes, such as `ENV.fetch`.
+      def unread(root)
+        read_once(root).last
+      end
+
+      def read_once(root)
+        return [ {}, [] ] unless root
 
         root = File.expand_path(root.to_s)
         RunCache.fetch([ :active_record_settings, root ]) { read(root) }
@@ -27,30 +36,41 @@ module RailsAiContext
         files = [ File.join(root, "config", "application.rb"), File.join(root, "config", "environments", "#{RailsAiContext.environment_name}.rb") ]
         files = files.select { |path| File.file?(path) } + PathResolver.initializer_paths(root)
         listeners = { config: -> { Listeners::ConfigAssignmentListener.new }, base: -> { Listeners::ConfigAssignmentListener.new(BASE_ROOTS) } }
-        configured = {}
-        direct = {}
+        configured, configured_unread, direct, direct_unread = {}, Set.new, {}, Set.new
         files.each do |file|
           walked = SourceIntrospector.walk(file, listeners)
-          collect(Array(walked[:config]).filter_map { |entry| [ entry, entry[:path].last ] if entry[:path].size == 2 && entry[:path].first == :active_record }, configured)
-          collect(Array(walked[:base]).filter_map { |entry| [ entry, entry[:path].first ] if entry[:path].size == 1 }, direct)
+          collect(Array(walked[:config]).filter_map { |entry| [ entry, entry[:path].last ] if entry[:path].size == 2 && entry[:path].first == :active_record }, configured, configured_unread)
+          collect(Array(walked[:base]).filter_map { |entry| [ entry, entry[:path].first ] if entry[:path].size == 1 }, direct, direct_unread)
+        end
+        MODULE_SETTINGS.each do |name|
+          next unless configured.key?(name) || configured_unread.include?(name)
+
+          direct.delete(name)
+          direct_unread.delete(name)
         end
-        MODULE_SETTINGS.each { |name| direct.delete(name) if configured.key?(name) }
-        configured.merge(direct)
+        [ configured.except(*direct_unread).merge(direct), (configured_unread - direct.keys | direct_unread).to_a ]
       rescue StandardError, ScriptError => e
-        RailsAiContext.debug_fail(e, {}, label: "active_record_settings")
+        RailsAiContext.debug_fail(e, [ {}, [] ], label: "active_record_settings")
       end
 
-      def collect(settings, found)
+      # A later table setting the reader cannot read hides an earlier literal one, since it runs after it.
+      def collect(settings, found, unread)
         settings.sort_by.with_index { |(entry, _), i| [ entry[:location], i ] }.each do |entry, name|
           allowed = SETTINGS[name]
           next unless entry[:assignment] && allowed
 
           value = entry[:value]
-          found[name] = value if allowed.is_a?(Array) ? allowed.include?(value) : value.is_a?(allowed)
+          if allowed.is_a?(Array) ? allowed.include?(value) : value.is_a?(allowed) && entry[:literal]
+            found[name] = value
+            unread.delete(name)
+          elsif TableName::TABLE_SETTINGS.include?(name)
+            found.delete(name)
+            unread << name
+          end
         end
       end
 
-      private_class_method :read, :collect
+      private_class_method :read_once, :read, :collect
     end
   end
 end

data/lib/rails_ai_context/introspectors/convention_introspector.rb

@@ -172,6 +172,14 @@ module RailsAiContext
         RailsAiContext.debug_fail(e, false, label: "uses_async_queries?")
       end
 
+      # Files a directory holds besides Ruby, which SourceScan leaves out.
+      NON_RUBY_FILES = {
+        "app/javascript" => "**/*.js",
+        "app/javascript/controllers" => "**/*.js",
+        "app/views" => "**/*.{erb,haml,slim,jbuilder,builder}",
+        "lib/tasks" => "**/*.rake"
+      }.freeze
+
       def scan_directory_structure
         important_dirs = %w[
           app/models app/controllers app/views app/jobs
@@ -190,7 +198,8 @@ module RailsAiContext
         # carries file counts, so the biggest code area had no number anywhere.
         (important_dirs | app_child_dirs).each_with_object({}) do |dir, hash|
           count = SourceScan.paths(root, kind: dir, skip_concerns: false).count
-          count += Dir.glob(File.join(root, dir, "**/*.js")).size if dir.include?("javascript")
+          glob = NON_RUBY_FILES[dir]
+          count += PathResolver.dirs_for(root, dir).sum { |path| Dir.glob(File.join(path, glob)).size } if glob
 
           hash[dir] = count if count > 0
         end

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

@@ -107,6 +107,8 @@ module RailsAiContext
             open_aasm(node) if node.block || node.arguments
           elsif GEM_MACROS.include?(node.name)
             record_gem_macro(node)
+          elsif node.name == :establish_connection
+            @results << { macro: :establish_connection, location: node.location.start_line }
           elsif node.name == :connects_to
             # Under a condition the app may never call it, so no table is routed to its database.
             condition = current_condition

data/lib/rails_ai_context/introspectors/migration_introspector.rb

@@ -121,7 +121,32 @@ module RailsAiContext
           add_foreign_key remove_foreign_key
           add_timestamps create_join_table enable_extension execute
           add_check_constraint remove_check_constraint
-        ].select { |action| content.include?(action) }
+        ].select { |action| content.include?(action) } | change_table_actions(content)
+      end
+
+      # What each table call in a change_table block does; a column type adds a column, any other call does nothing.
+      CHANGE_TABLE_CALLS = {
+        index: "add_index", remove_index: "remove_index", remove: "remove_column", remove_timestamps: "remove_column",
+        remove_references: "remove_reference", remove_belongs_to: "remove_reference", references: "add_reference",
+        belongs_to: "add_reference", timestamps: "add_timestamps", rename: "rename_column", change: "change_column",
+        change_default: "change_column_default", change_null: "change_column_null", foreign_key: "add_foreign_key",
+        remove_foreign_key: "remove_foreign_key", check_constraint: "add_check_constraint",
+        remove_check_constraint: "remove_check_constraint"
+      }.freeze
+      COLUMN_CALLS = (Listeners::SchemaDslListener::COLUMN_TYPES.map(&:to_sym) + [ :column ] - CHANGE_TABLE_CALLS.keys).freeze
+
+      # A table call counts only inside a change_table block: the listener links each call to the block that encloses it.
+      def change_table_actions(content)
+        return [] unless content.include?("change_table")
+
+        hits = SourceIntrospector.walk_source(content, {
+          change_table: -> { Listeners::GenericMacroListener.new(:change_table, *CHANGE_TABLE_CALLS.keys, *COLUMN_CALLS, any_receiver: true) }
+        })[:change_table]
+        blocks = hits.select { |hit| hit[:macro] == :change_table }.to_set { |hit| hit[:offset] }
+        return [] if blocks.empty?
+
+        inside = hits.select { |hit| blocks.include?(hit[:parent_offset]) }
+        [ "change_table" ] | inside.map { |hit| CHANGE_TABLE_CALLS.fetch(hit[:macro], "add_column") }
       end
     end
   end

data/lib/rails_ai_context/introspectors/model_introspector.rb

@@ -111,7 +111,7 @@ module RailsAiContext
           # the rescue meant to contain the first.
           outside = outside_parent(class_name, candidates)
           table = resolve_table_name(class_name, candidates, outside: outside)
-          table_set_by = outside unless table
+          table_set_by = table ? unread_table_setting(class_name, candidates) : outside
           result[class_name] = static_model_details(candidate[:path], class_name, file: candidate[:file],
                                                     table_name: table, table_set_by: table_set_by,
                                                     primary_key: resolve_primary_key(class_name, candidates),
@@ -227,7 +227,8 @@ module RailsAiContext
             path_name = SourceScan.concerns_name(record.path_name, source)
             declarations = DeclaredConstant.declarations(source, path_name: path_name)
             declaration = DeclaredConstant.declaration_for(declarations, path_name)
-            class_name = declaration&.name || path_name
+            # A module file is named as it declares itself: camelize knows none of the app's acronyms.
+            class_name = declaration&.name || DeclaredConstant.resolve(source, path_name)
             # Two files can declare one class (an app reopening a model to add methods);
             # the one that names a superclass defines the model.
             previous = found[class_name]
@@ -535,6 +536,48 @@ module RailsAiContext
         candidates.dig(class_name, key) || ActiveRecordSettings.for(app.root)[key] || ""
       end
 
+      # The setting that shapes this class's table with a value only the running app computes, such as
+      # "SDG.table_name_prefix", read in the order resolve_table_name reads them; nil when each was read.
+      def unread_table_setting(class_name, candidates, seen = [])
+        return nil if seen.include?(class_name) || candidates.dig(class_name, :table_name)
+        return "#{class_name}.table_name" if unread_setting?(candidates, class_name, :table_name)
+
+        parent = sti_parent(class_name, candidates, seen)
+        inherited = parent && resolve_table_name(parent, candidates, seen + [ class_name ])
+        return unread_table_setting(parent, candidates, seen + [ class_name ]) unless inherited.nil? || inherited.empty?
+
+        unread_affix(class_name, candidates, :table_name_prefix) || unread_affix(class_name, candidates, :table_name_suffix) ||
+          unread_class_setting(class_name, candidates, :pluralize_table_names)
+      end
+
+      def unread_affix(class_name, candidates, key)
+        scope = class_name.split("::")[0..-2]
+        while scope.any?
+          namespace = scope.join("::")
+          return "#{namespace}.#{key}" if unread_setting?(candidates, namespace, key)
+          return nil if candidates.dig(namespace, key) || (key == :table_name_prefix && isolated_prefixes[namespace])
+
+          scope.pop
+        end
+        unread_class_setting(class_name, candidates, key)
+      end
+
+      # A class attribute: the class's own, else its superclass chain's, else the app's.
+      def unread_class_setting(class_name, candidates, key, seen = [])
+        return "#{class_name}.#{key}" if unread_setting?(candidates, class_name, key)
+        return nil unless candidates.dig(class_name, key).nil?
+
+        parent = candidates.dig(class_name, :superclass)
+        resolved = parent && !seen.include?(class_name) && resolve_superclass(parent, class_name, candidates)
+        return unread_class_setting(resolved, candidates, key, seen + [ class_name ]) if resolved && candidates.key?(resolved)
+
+        "ActiveRecord::Base.#{key}" if ActiveRecordSettings.unread(app.root).include?(key)
+      end
+
+      def unread_setting?(candidates, scope, key)
+        Array(candidates.dig(scope, :unread_settings)).include?(key)
+      end
+
       def isolated_prefixes
         @isolated_prefixes ||= TableName.namespace_prefixes(app.root)
       end
@@ -722,7 +765,8 @@ module RailsAiContext
         detailed = extract_detailed_macros_from_ast(source_data)
         details.merge!(detailed)
         details[:ignored_columns] = model.ignored_columns.map(&:to_s).presence
-        details[:own_connection] = true if own_connection?(model, details)
+        # Reflection answers here, over an `establish_connection` the source walk read.
+        details[:own_connection] = (true if own_connection?(model, details))
 
         details.compact
       end
@@ -1357,6 +1401,8 @@ module RailsAiContext
             (macros[:model_settings] ||= {})[m[:setting]] = m[:value]
           elsif macro == :connects_to
             macros[:database] = { connects_to: m[:text], condition: m[:condition], declared_in: m[:declared_in], writing: m[:writing] }.compact
+          elsif macro == :establish_connection
+            macros[:own_connection] = true
           elsif macro == :gem_macro
             (macros[:gem_macros] ||= []) << m.slice(:text, :adds)
           elsif macro == :aasm

data/lib/rails_ai_context/introspectors/performance_introspector.rb

@@ -60,11 +60,11 @@ module RailsAiContext
 
       # { tables:, foreign_keys: } from the database's dump, or { reason: } saying why there is none to read.
       def read_dump(db)
-        return { reason: no_dump_reason(db) } unless db.dump
+        reason = db.missing_dump(root)
+        return { reason: reason } if reason
 
         path = db.dump.path
         shown = path.delete_prefix("#{root.to_s.chomp('/')}/")
-        return { reason: "#{shown} is not on disk" } unless File.exist?(path)
 
         content = SafeFile.read(path, max_size: RailsAiContext.configuration.max_schema_file_size)
         return { reason: "#{shown} is over max_schema_file_size" } unless content
@@ -75,13 +75,6 @@ module RailsAiContext
           foreign_keys: tables.values.flat_map { |table| Array(table[:foreign_keys]).map { |fk| { from: fk[:from_table], to: fk[:to_table], column: fk[:column] } } } }
       end
 
-      def no_dump_reason(db)
-        return "its database.yml entry turns `database_tasks` off, so Rails writes it no dump" unless db.tasks
-        return "its database.yml entry turns `schema_dump` off, so Rails writes it no dump" unless db.settings["schema_dump"]
-
-        "`schema_dump` in its database.yml entry names no file this check reads"
-      end
-
       # The models section when the run has one; otherwise the model tier is
       # asked directly, which is what a standalone call costs.
       def resolved_models

data/lib/rails_ai_context/introspectors/recurring_schedules.rb

@@ -26,24 +26,28 @@ module RailsAiContext
         end
       end
 
+      SIDEKIQ_CRON_FILES = %w[config/schedule.yml config/schedule.yaml config/sidekiq_cron.yml].freeze
+
       def sidekiq_cron(root)
-        %w[config/schedule.yml config/schedule.yaml config/sidekiq_cron.yml].flat_map do |file|
+        SIDEKIQ_CRON_FILES.flat_map do |file|
           named_tasks(yaml(root, file)).filter_map { |name, options| task(file, name, options, :cron) }
         end
       end
 
       # sidekiq-scheduler runs a job by its entry's name when no class is given.
+      # Sidekiq starts from any file `-C` names, and apps keep one per environment.
       def sidekiq_scheduler(root)
-        file = "config/sidekiq.yml"
-        data = yaml(root, file)
-        return [] unless data.is_a?(Hash)
+        (Dir.glob("config/sidekiq*.{yml,yaml}", base: root.to_s).sort - SIDEKIQ_CRON_FILES).flat_map do |file|
+          data = yaml(root, file)
+          next [] unless data.is_a?(Hash)
 
-        section = data["scheduler"].is_a?(Hash) ? data["scheduler"]["schedule"] : data["schedule"]
-        named_tasks(section).filter_map do |name, options|
-          next unless options.is_a?(Hash)
+          section = data["scheduler"].is_a?(Hash) ? data["scheduler"]["schedule"] : data["schedule"]
+          named_tasks(section).filter_map do |name, options|
+            next unless options.is_a?(Hash)
 
-          kind = SCHEDULER_KEYS.find { |key| options.key?(key.to_s) } or next
-          task(file, name, { "class" => name }.merge(options), kind)
+            kind = SCHEDULER_KEYS.find { |key| options.key?(key.to_s) } or next
+            task(file, name, { "class" => name }.merge(options), kind)
+          end
         end
       end
 

data/lib/rails_ai_context/introspectors/schema_introspector.rb

@@ -589,7 +589,8 @@ module RailsAiContext
           return { unavailable: "this app uses Mongoid; ActiveRecord schema introspection does not apply" }
         end
 
-        if secondary_database_dumps.any?
+        # A database with no file on disk says nothing of where the app keeps its tables.
+        if secondary_database_dumps.any? { |_, db| db.key?(:dump) || db.key?(:migrations_paths) }
           return { total_tables: 0, tables: {}, note: "The primary database has no tables yet: no #{relative_dump_path(schema_dump_name)} or migrations found." }
         end
 
@@ -636,6 +637,7 @@ module RailsAiContext
           found[name] = parsed.merge(database_files(path, migrate_dir_for_dump(path)))
         end
         replay_secondary_migrations(dumps, unread)
+        add_databases_with_nothing_to_read(dumps)
         unread.each do |name, (path, state)|
           dumps[name] ||= { tables: {}, total_tables: 0, note: "#{relative_dump_path(path)} #{state}, so its tables are not listed" }
                           .merge(database_files(path, migrate_dir_for_dump(path)), state == NO_TABLES ? {} : { unread: true })
@@ -644,6 +646,17 @@ module RailsAiContext
         dumps.sort_by { |name, _| names.index(name) || names.size }.to_h
       end
 
+      # A database with no dump on disk and no migrations of its own is still one of the app's: its entry says why.
+      def add_databases_with_nothing_to_read(dumps)
+        primary = dump_candidates.map(&:last)
+        app_databases.each do |db|
+          next if db.primary || db.replica || dumps.key?(db.name) || primary.include?(db.dump&.path)
+
+          reason = db.missing_dump(app.root)
+          dumps[db.name] = { tables: {}, total_tables: 0, unread: true, note: "Its tables are not listed: #{reason}" } if reason
+        end
+      end
+
       # Where a secondary database's schema lives, app-relative, so a rule
       # file can name its dump and the migrations directories it has.
       def database_files(dump, migrate_dirs)

data/lib/rails_ai_context/introspectors/table_name.rb

@@ -19,6 +19,7 @@ module RailsAiContext
       module_function
 
       NONE = { table_name: nil, table_name_prefix: nil, table_name_suffix: nil, pluralize_table_names: nil, primary_key: nil }.freeze
+      TABLE_SETTINGS = %i[table_name table_name_prefix table_name_suffix pluralize_table_names].freeze
 
       # {"RssPolling" => "rss_polling_"}: the engine prefix no model file says.
       # ponytail: reads `lib/**/engine.rb` only; walk lib wholesale if an app needs more.
@@ -38,14 +39,17 @@ module RailsAiContext
       #
       # @param source [String] the file's source
       # @param name [String] the qualified name of the class or module
-      # @return [Hash] the five, each nil when this scope declares none
+      # @return [Hash] the five, each nil when this scope declares none, and under `unread_settings`
+      #   the table settings it declares with a value only the running app computes
       # @param root [String, nil] the app, whose configured affixes a table
       #   name interpolating table_name_prefix or table_name_suffix reads
       def declarations(source, name, root = nil)
         read(source, name) do |body|
           own = { table_name_prefix: affix(body, :table_name_prefix), table_name_suffix: affix(body, :table_name_suffix) }
-          { table_name: assigned(body, :table_name=) || interpolated(body, own, root) }.merge(own)
-            .merge(pluralize_table_names: boolean_assigned(body, :pluralize_table_names=), primary_key: primary_key_assigned(body))
+          read = { table_name: assigned(body, :table_name=) || interpolated(body, own, root) }.merge(own)
+                 .merge(pluralize_table_names: boolean_assigned(body, :pluralize_table_names=), primary_key: primary_key_assigned(body))
+          unread = TABLE_SETTINGS.select { |setting| read[setting].nil? && declares?(body, setting) }
+          unread.any? ? read.merge(unread_settings: unread) : read
         end || NONE
       end
 
@@ -227,6 +231,13 @@ module RailsAiContext
         names if names.all?
       end
 
+      def declares?(body, setting)
+        body.any? do |node|
+          ((node.is_a?(Prism::CallNode) && node.name == :"#{setting}=") || (node.is_a?(Prism::DefNode) && node.name == setting)) &&
+            node.receiver.is_a?(Prism::SelfNode)
+        end
+      end
+
       def boolean_assigned(body, name)
         call = body.find do |node|
           node.is_a?(Prism::CallNode) && node.name == name && node.receiver.is_a?(Prism::SelfNode)
@@ -286,7 +297,7 @@ module RailsAiContext
       end
 
       private_class_method :affix, :read, :body_of, :built_body, :descend, :statements, :segment,
-                           :assigned, :boolean_assigned, :primary_key_assigned, :returned, :literal, :read_namespace_prefixes,
+                           :assigned, :declares?, :boolean_assigned, :primary_key_assigned, :returned, :literal, :read_namespace_prefixes,
                            :interpolated, :affixed_node, :affix_read,
                            :engine_files, :collect_isolate_calls
     end

data/lib/rails_ai_context/introspectors/test_introspector.rb

@@ -10,8 +10,6 @@ module RailsAiContext
       extend StaticTier
       static_tier :files_only
 
-      TEST_FILE_GLOB = "*_{spec,test}.rb"
-
       # An engine's test/dummy is tested by the engine's suite.
       def suite_root
         @suite_root ||= PathResolver.test_root(root)
@@ -56,6 +54,17 @@ module RailsAiContext
         RailsAiContext.debug_fail(e, "unknown", label: "detect_framework")
       end
 
+      # RSpec runs *_spec.rb only, so a *_test.rb under spec/ is a helper.
+      def test_file_glob(base)
+        base == "spec" && rspec_suite? ? "*_spec.rb" : "*_{spec,test}.rb"
+      end
+
+      def rspec_suite?
+        return @rspec_suite if defined?(@rspec_suite)
+
+        @rspec_suite = RailsAiContext::TestFramework.suites(suite_root).include?("rspec")
+      end
+
       # First listed wins: an app holding the same thing under spec/ and test/
       # reports one location, not both. `detect_system_tests` deliberately
       # answers the other way.
@@ -247,7 +256,7 @@ module RailsAiContext
           dir = File.join(suite_root, rel)
           next unless Dir.exist?(dir)
 
-          count = Dir.glob(File.join(dir, "**/#{TEST_FILE_GLOB}")).size
+          count = Dir.glob(File.join(dir, "**/#{test_file_glob(rel.split("/").first)}")).size
           [ rel, count ] if count > 0
         end
         return nil if rows.empty?
@@ -479,11 +488,11 @@ module RailsAiContext
             dir = File.join(base_dir, entry)
             next unless File.directory?(dir)
 
-            count = Dir.glob(File.join(dir, "**/#{TEST_FILE_GLOB}")).size
+            count = Dir.glob(File.join(dir, "**/#{test_file_glob(base)}")).size
             rows[entry] << [ "#{base}/#{entry}", count ] if count > 0
           end
 
-          loose = Dir.glob(File.join(base_dir, TEST_FILE_GLOB)).size
+          loose = Dir.glob(File.join(base_dir, test_file_glob(base))).size
           rows[base] << [ base, loose ] if loose > 0
         end
 

data/lib/rails_ai_context/payload.rb

@@ -217,11 +217,16 @@ module RailsAiContext
       return [] unless model.is_a?(Hash) && model[:table_name]
 
       found = table_holders(schema, model[:table_name]).map { |db, _, data| [ db || "primary", data ] }
-      writing = model.dig(:database, :writing)&.to_s || ("primary" unless model[:database])
+      writing = writing_database(model)
       written = found.select { |db, _| db == writing }.first(1)
       written.any? ? written : found
     end
 
+    # The database a model writes to, "primary" with no connects_to, nil where the static tier cannot tell.
+    def writing_database(model)
+      model.dig(:database, :writing)&.to_s || ("primary" unless model[:database])
+    end
+
     def model_databases(schema, model)
       model_tables(schema, model).map(&:first)
     end
@@ -261,6 +266,18 @@ module RailsAiContext
       model_tables(schema, model).empty?
     end
 
+    # The primary's schema.rb, such as "db/schema.rb", when the static tier read its tables from it and it leaves out
+    # the table of a model on the primary. Nil otherwise: no other dump or replay is judged.
+    def table_absent_from(schema, model)
+      return unless model.is_a?(Hash) && model[:table_name] && !model[:table_name].to_s.include?(".") && !model[:own_connection]
+      return unless writing_database(model) == "primary"
+      # A setting, concern or base the static tier could not read may set the table name.
+      return if model[:table_set_by] || Array(model[:concerns_unread]).any? || Array(model[:bases_unread]).any?
+      return unless schema.is_a?(Hash) && parsed_schema?(schema) && model_tables(schema, model).empty?
+
+      schema[:declared_in]
+    end
+
     # Why the primary's dump leaves out a schema-qualified table, or nil.
     def missing_qualified_table(schema, name)
       return unless schema.is_a?(Hash) && parsed_schema?(schema) && name.to_s.include?(".")

data/lib/rails_ai_context/serializers/claude_rules_serializer.rb

@@ -45,8 +45,9 @@ module RailsAiContext
         lines.join("\n")
       end
 
-      # Every database's tables, the primary's first. With more than one, each
-      # gets a heading, since a table name can be in two of them. A database
+      # Every database's tables, the primary's first. Each gets a heading unless the
+      # primary is the only one, since a table name can be in two and a lone other
+      # database is not the one a reader assumes. A database
       # a Rails framework keeps to itself (Rails 8's queue, cache and cable)
       # is no part of it: its tables are the framework's, CLAUDE.md names it,
       # and its dump says nothing this listing would help with.
@@ -66,9 +67,10 @@ module RailsAiContext
         live = " Use #{tool_ref("rails_get_schema", 'table:"name"', "table=name")} for live data." if served?("rails_get_schema")
         lines << "_Snapshot - may be stale after migrations.#{live}_"
 
+        primary_alone = databases.size == 1 && databases.first.first.nil?
         databases.each do |name, tables|
           lines << ""
-          lines.concat(database_heading_lines(name, tables, secondary)) if secondary.any?
+          lines.concat(database_heading_lines(name, tables, secondary)) unless primary_alone
           lines.concat(table_reference_lines(tables, name, schema))
         end
 

data/lib/rails_ai_context/serializers/section_facts.rb

@@ -122,10 +122,13 @@ module RailsAiContext
         buckets
       end
 
-      # The table a model reads when it is not plainly named: missing from a live listing, or set by
-      # a parent the static tier did not read. Nil otherwise.
+      # The table a model reads when it is not plainly named: missing from a live listing or the dump,
+      # or set by a parent the static tier did not read. Nil otherwise.
       def table_note(schema, model_data)
         return "`#{model_data[:table_name]}` not found" if Payload.missing_table?(schema, model_data)
+        if (source = Payload.table_absent_from(schema, model_data))
+          return "`#{model_data[:table_name]}` missing from #{source}"
+        end
         return nil if model_data[:table_name] || !model_data[:table_set_by]
 
         "set by `#{model_data[:table_set_by]}`, which the static tier did not read"

data/lib/rails_ai_context/tools/analyze_feature.rb

@@ -62,23 +62,24 @@ module RailsAiContext
         pattern = feature.downcase
         root = rails_app.root.to_s
         lines = [ "# Feature Analysis: #{feature}", "" ]
+        unread = Set.new
 
         matched_models = discover_models(ctx, pattern, lines)
         discover_controllers(ctx, pattern, lines)
         discover_routes(ctx, pattern, lines)
-        discover_services(root, pattern, lines)
+        discover_services(root, pattern, lines, unread)
         discover_admin(root, pattern, lines)
         discover_jobs(ctx, pattern, lines)
-        discover_views(ctx, root, pattern, lines)
+        discover_views(ctx, root, pattern, lines, unread)
         discover_stimulus(ctx, pattern, lines)
-        _feature_tests, all_tests, tests_truncated = discover_tests(root, pattern, lines)
+        _feature_tests, all_tests, tests_truncated = discover_tests(root, pattern, lines, unread)
         discover_related_models(ctx, matched_models, lines)
         discover_concerns(ctx, matched_models, lines)
         discover_callbacks(ctx, matched_models, lines)
         discover_channels(ctx, pattern, lines)
         discover_mailers(ctx, pattern, lines)
-        discover_env_dependencies(root, pattern, matched_models, lines)
-        discover_test_gaps(root, pattern, matched_models, ctx, all_tests || [], lines, truncated: tests_truncated)
+        discover_env_dependencies(root, pattern, matched_models, lines, unread)
+        discover_test_gaps(root, pattern, matched_models, ctx, all_tests || [], lines, unread, truncated: tests_truncated)
         discover_components(ctx, pattern, lines)
 
         # For auth-related keywords, also discover auth gems
@@ -96,10 +97,17 @@ module RailsAiContext
         # If nothing was discovered, return a clean "no match" with real suggestions
         has_content = lines.any? { |l| l.start_with?("## ") || l.start_with?("### ") }
         unless has_content
-          return text_response("No matches found for '#{echo_input(feature)}'. No models, controllers, routes, services, or views match this keyword.#{model_names_hint(ctx)}")
+          return text_response("No matches found for '#{echo_input(feature)}'. No models, controllers, routes, services, or views match this keyword.#{model_names_hint(ctx)}#{unread_note(unread)}")
         end
 
-        text_response(lines.join("\n"))
+        text_response(lines.join("\n") + unread_note(unread))
+      end
+
+      # Files past MAX_SCAN_FILES in a directory are never read, so a section that is missing may only be unread.
+      def self.unread_note(unread)
+        return "" if unread.empty?
+
+        "\n\n_Only the first #{MAX_SCAN_FILES} files of a directory are read, so any past them in #{unread.sort.join(', ')} were not checked._"
       end
 
       # The names a keyword that matched nothing could have been.
@@ -115,6 +123,13 @@ module RailsAiContext
       class << self
         private
 
+        # The first MAX_SCAN_FILES of a glob; a directory holding more goes into `unread`.
+        def capped_glob(dir, pattern, real_root, label, unread)
+          files = safe_glob(dir, pattern, real_root)
+          unread << label if files.size > MAX_SCAN_FILES
+          files.first(MAX_SCAN_FILES)
+        end
+
         # A conditional skip names the condition it is taken out on.
         def inherited_filter_label(filter)
           "#{filter[:name]}#{Serializers::SectionFacts.filter_origin(filter)}" \
@@ -260,13 +275,13 @@ module RailsAiContext
         end
 
         # --- AF1: Services ---
-        def discover_services(root, pattern, lines)
+        def discover_services(root, pattern, lines, unread)
           dir = File.join(root, "app", "services")
           return unless Dir.exist?(dir)
 
           real_root = File.realpath(root).to_s
           real_dir = File.realpath(dir).to_s
-          candidates = safe_glob(dir, "**/*.rb", real_root).first(MAX_SCAN_FILES)
+          candidates = capped_glob(dir, "**/*.rb", real_root, "app/services", unread)
           # Prefer basename match (fast, no file read) and only fall back to
           # a content scan for files whose basename doesn't match. This
           # avoids reading every service file's full contents on large apps.
@@ -287,7 +302,7 @@ module RailsAiContext
           named = services.select { |s| s[:name] }
           callers, callers_truncated = GetServicePattern.callers_of(named.to_h { |s| [ s[:name], s[:path] ] }, real_root)
 
-          lines << "## Services (#{found.size}#{candidates.size == MAX_SCAN_FILES ? " - first #{MAX_SCAN_FILES} scanned" : ""})"
+          lines << "## Services (#{found.size}#{unread.include?("app/services") ? " - first #{MAX_SCAN_FILES} scanned" : ""})"
           services.each do |service|
             relative = service[:path].sub("#{real_root}/", "")
             methods = service[:name] ? service_methods(service[:source], service[:name]) : []
@@ -353,19 +368,19 @@ module RailsAiContext
         end
 
         # --- AF3: Views + Partials ---
-        def discover_views(ctx, root, pattern, lines)
+        def discover_views(ctx, root, pattern, lines, unread)
           views_dir = File.join(root, "app", "views")
           return unless Dir.exist?(views_dir)
 
           real_root = File.realpath(root).to_s
           real_views_dir = File.realpath(views_dir).to_s
-          candidates = safe_glob(views_dir, "**/*.{erb,haml,slim,jbuilder}", real_root).first(MAX_SCAN_FILES)
+          candidates = capped_glob(views_dir, "**/*.{erb,haml,slim,jbuilder}", real_root, "app/views", unread)
           found = candidates.select do |path|
             feature_word_match?(path.sub("#{real_views_dir}/", ""), pattern)
           end
           return if found.empty?
 
-          lines << "## Views (#{found.size}#{candidates.size == MAX_SCAN_FILES ? " - first #{MAX_SCAN_FILES} scanned" : ""})"
+          lines << "## Views (#{found.size}#{unread.include?("app/views") ? " - first #{MAX_SCAN_FILES} scanned" : ""})"
           found.each do |path|
             relative = path.sub("#{real_views_dir}/", "")
             source = RailsAiContext::SafeFile.read(path) or next
@@ -439,7 +454,7 @@ module RailsAiContext
         # @return [Array(Array<String>, Array<String>, Boolean)] the tests the
         #   feature word names, every test read (relative to the suite's root),
         #   and whether a glob stopped at MAX_SCAN_FILES
-        def discover_tests(root, pattern, lines)
+        def discover_tests(root, pattern, lines, unread)
           real_root = File.realpath(root).to_s
           found = []
           all = []
@@ -449,8 +464,7 @@ module RailsAiContext
           real_base = File.realpath(base).to_s
           [ File.join(base, "spec"), File.join(base, "test") ].each do |dir|
             next unless Dir.exist?(dir)
-            suffix_glob = safe_glob(dir, "**/*_{test,spec}.rb", real_base).first(MAX_SCAN_FILES)
-            truncated = true if suffix_glob.size == MAX_SCAN_FILES
+            suffix_glob = capped_glob(dir, "**/*_{test,spec}.rb", real_base, File.basename(dir), unread)
             # The path, not the basename: the gap checker below matches this
             # way for the same reason, and a spec whose feature word is a
             # directory (billing/invoices/create_spec.rb) is the normal shape
@@ -458,13 +472,13 @@ module RailsAiContext
             suffix_glob.each do |path|
               found << path if feature_word_match?(relative_test_name(path, real_base), pattern)
             end
-            prefix_glob = safe_glob(dir, "**/{test,spec}_*.rb", real_base).first(MAX_SCAN_FILES)
-            truncated = true if prefix_glob.size == MAX_SCAN_FILES
+            prefix_glob = capped_glob(dir, "**/{test,spec}_*.rb", real_base, File.basename(dir), unread)
             prefix_glob.each do |path|
               found << path if feature_word_match?(relative_test_name(path, real_base), pattern)
             end
             all.concat(suffix_glob, prefix_glob)
           end
+          truncated = unread.include?("spec") || unread.include?("test")
           found.uniq!
           all = all.uniq.map { |path| path.delete_prefix("#{real_base}/") }
           return [ found, all, truncated ] if found.empty?
@@ -486,7 +500,7 @@ module RailsAiContext
         end
 
         # --- Test coverage gaps ---
-        def discover_test_gaps(root, pattern, matched_models, ctx, test_files, lines, truncated: false)
+        def discover_test_gaps(root, pattern, matched_models, ctx, test_files, lines, unread, truncated: false)
           # A gap is a claim that something has no test, and a scan that stopped
           # at MAX_SCAN_FILES cannot make it: Discourse has 1,672 spec files, so
           # the first 500 missed the ones that cover the feature and every
@@ -526,7 +540,7 @@ module RailsAiContext
             path_dir = File.join(root, "app", dir)
             next unless Dir.exist?(path_dir)
 
-            safe_glob(path_dir, "**/*.rb", real_root).first(MAX_SCAN_FILES).each do |path|
+            capped_glob(path_dir, "**/*.rb", real_root, "app/#{dir}", unread).each do |path|
               snake = File.basename(path, ".rb")
               next unless feature_word_match?(snake, pattern)
               next if test_basenames.any? { |t| t.include?(snake) }
@@ -653,17 +667,14 @@ module RailsAiContext
         end
 
         # --- AF9: Environment Dependencies ---
-        def discover_env_dependencies(root, pattern, matched_models, lines)
+        def discover_env_dependencies(root, pattern, matched_models, lines, unread)
           # Scan services, jobs, and model files for ENV references
           real_root = File.realpath(root).to_s
           dirs = %w[app/services app/jobs].map { |d| File.join(root, d) }.select { |d| Dir.exist?(d) }
           env_vars = Set.new
-          truncated = false
 
           dirs.each do |dir|
-            candidates = safe_glob(dir, "**/*.rb", real_root).first(MAX_SCAN_FILES)
-            truncated = true if candidates.size == MAX_SCAN_FILES
-            candidates.each do |path|
+            capped_glob(dir, "**/*.rb", real_root, dir.delete_prefix("#{root}/"), unread).each do |path|
               next unless feature_word_match?(File.basename(path, ".rb"), pattern) || feature_word_match?(path, pattern)
               source = RailsAiContext::SafeFile.read(path) or next
               source.scan(/ENV\[["']([^"']+)["']\]|ENV\.fetch\(["']([^"']+)["']\)/).each do |m|
@@ -673,6 +684,7 @@ module RailsAiContext
           end
           return if env_vars.empty?
 
+          truncated = dirs.any? { |dir| unread.include?(dir.delete_prefix("#{root}/")) }
           header = "## Environment Dependencies#{truncated ? " (first #{MAX_SCAN_FILES} per dir scanned)" : ""}"
           lines << header
           env_vars.sort.each { |v| lines << "- `#{v}`" }

data/lib/rails_ai_context/tools/diagnose.rb

@@ -186,7 +186,7 @@ module RailsAiContext
         # Likely cause - enriched with specific inference when possible
         lines << "## Likely Cause"
         lines << classification[:likely]
-        specific = infer_specific_cause(parsed, classification, file, action)
+        specific = infer_specific_cause(parsed, classification, file, action, line)
         lines << "" << "**Specific:** #{specific}" if specific
         lines << ""
 
@@ -614,8 +614,18 @@ module RailsAiContext
           lines << "## #{title}" << "_Could not load: #{e.message}_" << ""
         end
 
+        # Regex because a lone source line is no program a listener can walk.
+        def nil_receiver(file, line, method)
+          call = /((?:@@?|\$)?\w+)\.#{Regexp.escape(method)}(?![\w?!])/
+          located = RailsAiContext::SafePath.locate(file, under: rails_app.root.to_s)
+          failing = line.to_i.positive? && located.ok? && RailsAiContext::SafeFile.read(located.realpath).to_s.lines[line.to_i - 1]
+          return failing[call, 1] if failing
+
+          response_text(compose(GetEditContext, file: file, near: method))[call, 1]
+        end
+
         # Infer a specific diagnosis from the error + context
-        def infer_specific_cause(parsed, classification, file, action)
+        def infer_specific_cause(parsed, classification, file, action, line = nil)
           msg = parsed[:message].to_s
           method = parsed[:method_name]
 
@@ -629,12 +639,8 @@ module RailsAiContext
             # Check if calling on an association
             if method && file
               begin
-                ctx = compose(GetEditContext, file: file, near: method)
-                code = response_text(ctx)
-                # Find the receiver: something.method_name
-                receiver_match = code.match(/(\w+)\.#{Regexp.escape(method)}/)
-                if receiver_match
-                  receiver = receiver_match[1]
+                receiver = nil_receiver(file, line, method)
+                if receiver
                   return "`#{receiver}` is nil when `.#{method}` is called. " \
                          "This variable may not be set in all code paths - check if it's assigned before use, " \
                          "or use `#{receiver}&.#{method}` for safe navigation."

data/lib/rails_ai_context/tools/generate_test.rb

@@ -793,7 +793,7 @@ module RailsAiContext
             names = res[:login].map { |login| login[:filter][:name] }.join(" and ")
             "this app's #{res[:helper]} is not known to get a request past #{names}, so send what #{names} checks"
           else
-            "this app's tests define no sign-in helper, so sign a user in first the way the app's login does"
+            "no `sign_in` or `log_in` helper in this app's test helpers, so sign a user in first the way the app's login does"
           end
           [ "  # TODO: #{login_phrase(ctrl_class, res)}, so each request here is redirected or refused until the test signs in: #{how}." ]
         end

data/lib/rails_ai_context/tools/get_model_details.rb

@@ -578,7 +578,7 @@ module RailsAiContext
         # Only a controller the app has: the conventional name is a guess, and
         # a hint naming a class that does not exist sends the reader nowhere.
         controller_name = Payload.controller_for_route_key(cached_context, name.underscore.pluralize)&.first
-        add_next_hint(lines, (pointer("rails_get_schema", %(table:"#{data[:table_name]}"), "for columns/indexes") if data[:table_name]),
+        add_next_hint(lines, (pointer("rails_get_schema", %(table:"#{data[:table_name]}"), "for columns/indexes") if data[:table_name] && !note),
                       (pointer("rails_get_controllers", %(controller:"#{controller_name}"), "for actions") if controller_name),
                       pointer("rails_analyze_feature", %(feature:"#{name}"), "for full-stack view"))
 

data/lib/rails_ai_context/tools/migration_advisor.rb

@@ -570,7 +570,7 @@ module RailsAiContext
           lines << "```ruby"
           lines << "class Add#{written.camelize}To#{table.camelize} < ActiveRecord::Migration[#{rails_version}]"
           lines << "  def change"
-          lines << "    add_reference :#{table}, :#{reference}#{foreign_key}"
+          lines << "    add_reference :#{table}, :#{reference}#{key_type_option(schema, to_table)}#{foreign_key}"
           lines << "  end"
           lines << "end"
           lines << "```"
@@ -617,6 +617,27 @@ module RailsAiContext
           Payload.schema_tables(schema).any? { |_, table, _| table.to_s == name.to_s }
         end
 
+        # The primary key type of a table when it is not the integer Rails defaults to.
+        def custom_key_type(table_data)
+          keys = Array(table_data && table_data[:columns]).select { |c| c[:primary_key] }
+          type = keys.first[:type].to_s if keys.size == 1
+          type unless type.nil? || %w[bigint integer].include?(type)
+        end
+
+        # ", type: :uuid" for a reference to a table keyed that way; a table the schema lacks is keyed as the app's tables are.
+        def key_type_option(schema, to_table)
+          target = to_table && schema_known?(schema) && Payload.schema_table(schema, to_table)
+          type = target ? custom_key_type(target) : app_key_type(schema)
+          type ? ", type: :#{type}" : ""
+        end
+
+        # The key type more than half of the app's tables share, when it is not Rails' default.
+        def app_key_type(schema)
+          tables = schema.is_a?(Hash) && schema[:tables].is_a?(Hash) ? schema[:tables].values : []
+          type, count = tables.map { |data| custom_key_type(data) }.tally.max_by(&:last)
+          type if type && count * 2 > tables.size
+        end
+
         def generate_change_type(table, column, type, options)
           return [ "**Error:** column and type are required" ] unless column && type
 
@@ -667,7 +688,9 @@ module RailsAiContext
           lines << "```ruby"
           lines << "class Create#{table.camelize} < ActiveRecord::Migration[#{rails_version}]"
           lines << "  def change"
-          lines << "    create_table :#{table} do |t|"
+          schema = cached_context[:schema]
+          key_type = app_key_type(schema)
+          lines << "    create_table :#{table}#{", id: :#{key_type}" if key_type} do |t|"
 
           if columns_str
             columns_str.split(",").each do |col|
@@ -675,7 +698,7 @@ module RailsAiContext
               name = parts[0]&.strip
               type = parts[1]&.strip || "string"
               if type == "references"
-                lines << "      t.references :#{name}, foreign_key: true"
+                lines << "      t.references :#{name}#{key_type_option(schema, name.to_s.pluralize)}, foreign_key: true"
               else
                 lines << "      t.#{type} :#{name}"
               end

data/lib/rails_ai_context/tools/review_changes.rb

@@ -21,7 +21,7 @@ module RailsAiContext
           files: {
             type: "array",
             items: { type: "string" },
-            description: "Filter to specific files (relative to Rails root). Omit to review all changed files."
+            description: "Filter to files or directories (relative to Rails root). Omit to review all changed files."
           }
         }
       )
@@ -91,7 +91,7 @@ module RailsAiContext
         end
 
         changed = get_changed_files(base, root)
-        changed = changed.select { |f| files.any? { |filter| f.include?(filter) } } if files&.any?
+        changed = changed.select { |f| files.any? { |filter| path_matches?(f, filter) } } if files&.any?
 
         if changed.empty?
           return text_response("No changes found for ref '#{echo_input(ref)}'.#{files ? " Filter: #{echo_input(files.join(', '))}" : ""}")
@@ -214,6 +214,12 @@ module RailsAiContext
           status.success? && !prefix.strip.empty?
         end
 
+        # A filter names one file or a directory, never part of a name: `Gemfile` is not `Gemfile.lock`.
+        def path_matches?(path, filter)
+          wanted = filter.delete_prefix("./").chomp("/")
+          path == wanted || path.start_with?("#{wanted}/")
+        end
+
         # The Ruby folders count only Ruby files: the install writes app/models/AGENTS.md beside the models.
         def classify_file(path)
           case path

data/lib/rails_ai_context/tools/search_code.rb

@@ -23,6 +23,11 @@ module RailsAiContext
       BINARY_PROBE_BYTES = 64 * 1024
 
       TEST_DIRS = %w[test/ spec/ features/].freeze
+
+      # A trace lists this many internal calls and sibling methods, then says how many it left out.
+      INTERNAL_CALLS_SHOWN = 15
+      SIBLINGS_SHOWN = 10
+
       MATCH_FIELD_SEPARATOR = "\x1f"
       # A comment line by the file's own syntax. `#{` and ` * ` are Ruby code;
       # `#id` is a selector in a stylesheet and an element in Haml or Slim.
@@ -768,7 +773,8 @@ module RailsAiContext
 
               if internal_calls.any?
                 lines << "" << "## Calls internally"
-                internal_calls.first(15).each { |c| lines << "- `#{c}`" }
+                internal_calls.first(INTERNAL_CALLS_SHOWN).each { |c| lines << "- `#{c}`" }
+                lines << "- _...and #{internal_calls.size - INTERNAL_CALLS_SHOWN} more_" if internal_calls.size > INTERNAL_CALLS_SHOWN
               end
             end
 
@@ -776,7 +782,8 @@ module RailsAiContext
             siblings = extract_sibling_methods(File.join(root, r[:file]), cleaned)
             if siblings.any?
               lines << "" << "## Sibling methods (same file)"
-              siblings.first(10).each { |s| lines << "- `#{s}`" }
+              siblings.first(SIBLINGS_SHOWN).each { |s| lines << "- `#{s}`" }
+              lines << "- _...and #{siblings.size - SIBLINGS_SHOWN} more_" if siblings.size > SIBLINGS_SHOWN
             end
 
             lines << ""

data/lib/rails_ai_context/tools/session_context.rb

@@ -91,6 +91,9 @@ module RailsAiContext
           usage = "Pass `tool:params`, e.g. `get_schema:users`."
           return "`mark` names no tool. #{usage}" if name.to_s.empty?
 
+          skipped = RailsAiContext::CLI::ToolRunner.turned_off_message(name)
+          return skipped if skipped
+
           names = RailsAiContext::Server.exposed_tools.map(&:tool_name) | RailsAiContext::Server.retired_names
           short_names = names.map { |tool_name| RailsAiContext::CLI::ToolRunner.short_name(tool_name) }
           suggestion = find_closest_match(name, short_names)

data/lib/rails_ai_context/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RailsAiContext
-  VERSION = "5.36.1"
+  VERSION = "5.36.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-ai-context
 version: !ruby/object:Gem::Version
-  version: 5.36.1
+  version: 5.36.3
 platform: ruby
 authors:
 - crisnahine