rails-ai-context 5.36.0 → 5.36.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8ea836548c12d9e6a022ca0e9cb78f471c2144d5b16197ab9493808209c12f74
-  data.tar.gz: 1037665358df3ef107d83530dcec2371728b76df61852c51387b2797eb5bac51
+  metadata.gz: 0a04632cfd1114032ce4434e7e8b99d5f92c81bc9537bf5c65b6c65a3124c278
+  data.tar.gz: 3c5210bcb7ba0fef976a00b1224647588d44556bb8d807cbbc87aca9ff0214ce
 SHA512:
-  metadata.gz: 007d9bbd31542ad5caa6847ce83443fa3d793483cbb93aefcd37dc03c4f4cbf536e51dfd4735ddcf27e0f6dda46b052a95f7f6317d2685f2b2cb8769da349819
-  data.tar.gz: a4815b990a54d309fe3b5a4ce97ab8b7fca7a50841a70825d3aa02378915fe77f0f5465259e3484efb2a8268e959f4877bde376a4617ee461e36e94292eb4301
+  metadata.gz: 41e3246dc1905379a9d39bc4bfb8e95498b752a95f1a96b2e955ad58ca22a06696d0c12fd1b676e7414086cea5e571f772c8638dec36823ee542462dca8f4e64
+  data.tar.gz: ea9ebf310554c650503a9f9b95521988eccbf42286885b294ae86031d8c393a3dc71161ecab3852bb69a17055167b5334669fd0187817c62c73f98ecbf0843c1

data/CHANGELOG.md

@@ -5,6 +5,71 @@ 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.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
+
+- **On PostgreSQL the refusal of a name on the read-only VOLATILE list says the
+  list trusts the server's own function or a C function.** 5.36.0 answered "an
+  extension's C function", narrower than the rule it applies: any C function of
+  that name is trusted, since only a superuser can create one.
+- **The docs say which reads of a `rails_query` call run with no time limit.**
+  `docs/TOOLS.md` and `docs/SECURITY.md` said every statement a call sends is
+  bounded, and the reads of a setting's own value for the settings note, new in
+  5.36.0, are not. They wait on no lock. `docs/SECURITY.md` also said `PRAGMA
+  query_only` is refused by name: a `PRAGMA` statement is no read, and the
+  `pragma_query_only` function is the one refused by name.
+- **`docs/TOOLS.md` says when `rails_get_mailers` names where a mailer's actions
+  come from.** A mailer with no action of its own names a gem base it reaches
+  without passing `ApplicationMailer`, such as `Devise::Mailer`. It names none
+  past `ApplicationMailer` and never Rails' own base, on both tiers, as 5.36.0
+  does. The page said any gem base was named.
+
 ## [5.36.0] - 2026-10-14
 
 ### Security

data/docs/COMPATIBILITY.md

@@ -323,6 +323,16 @@ Proof sources:
    11.4 on Rails 7.0 (mysql2), 8.0 and 8.1 (mysql2 and Trilogy), and on
    PostgreSQL 13, 14, 15, 17 and 18 on Rails 8.0; and the unit suite and the
    E2E harness on Linux, macOS and Windows.
+   In the v5.36.1 release QA: every issue repro of 5.36.0 run again on the
+   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.
 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 |

data/docs/SECURITY.md

@@ -85,7 +85,7 @@ The textual layer cannot see a whole-row serialisation (`SELECT row_to_json(u.*)
 - holds a **whole-row reference** (`alias.*`) to a relation that has a secret column - this closes `row_to_json(u)`, `to_json(u)`, `u::text`, `array_agg(u)`, `json_agg(u)`, `hstore(u)`, `concat(u.*)`, `string_agg(u::text, ...)`, a bare `SELECT u`, and the same through a view, subquery or CTE. An alias is read as the plan prints it, so two aliases that differ only by case are two relations. The planner numbers an alias a statement uses twice (`p_1` for the `p` inside a subquery), and that name stands for its own relation alone. The number is taken off only for the members of an Append or a Merge Append, which is how the partitions of one table are named. The refusal names the relation whose row the statement reads;
 - **uses a secret column** anywhere but as a plain pass-through output - a `ROW(u.*)` the planner expanded into named columns, or a `WHERE` / `ORDER BY` oracle, an ordinal `ORDER BY 3` over a wildcard included. The statement a `postgres_fdw` foreign scan sends to the remote server (the plan's `Remote SQL`) is read the same way, so a condition, a sort or a group on a secret column of a foreign table is refused where the remote server would run it. A column that carries another name on the remote server (the `column_name` option) is told by one more catalog read, made only for a plan that holds a foreign scan. A stated limit: only the remote statement of `postgres_fdw` is read, and another foreign data wrapper prints keys of its own. A join that `postgres_fdw` runs on the remote server has one scan for all its tables, which names them with their aliases in its `Relations` line: they are read from there, so a whole row of one is refused and a column of one is traced and filtered like a local table's;
 - **passes a secret column** through an intermediate the plan's top node does not name - a `MATERIALIZED` CTE, a subquery scan, or a set operation (`INTERSECT` / `EXCEPT`) - so its value would reach a result column that the output-provenance redaction (Layer 4) cannot pin. These are refused, since no redaction could reach them. A column that a scan hands to an aggregate, a join or a Result node is counted only when that node names it, so `count(*)` over a table with a secret column runs, and so does an `EXISTS` inside an `EXISTS`, whose plan puts a Result over the inner scan;
-- names any **VOLATILE function** (`pg_proc.provolatile = 'v'`) outside a short read-only allowlist. `pg_proc` marks a function VOLATILE when its answer may change within one statement, which is as true of a reader of live server state as of a writer, so VOLATILE alone does not mean "changes state". The allowlist holds only built-in functions and extension C functions that write nothing: value generators (`random`, `clock_timestamp`, `gen_random_uuid`, `timeofday`, `uuid_generate_v4`, and `pg_sleep*`, which the statement timeout bounds); the size readers (`pg_total_relation_size`, `pg_relation_size`, `pg_table_size`, `pg_indexes_size`, `pg_database_size`, `pg_tablespace_size`); the lock-table snapshot readers (`pg_lock_status` - what the `pg_locks` view reads - `pg_blocking_pids`, `pg_safe_snapshot_blocking_pids`); and the recovery / WAL-position readers (`pg_is_in_recovery`, `pg_is_wal_replay_paused`, `pg_get_wal_replay_pause_state`, `pg_current_wal_lsn`, `pg_current_wal_insert_lsn`, `pg_current_wal_flush_lsn`, `pg_last_wal_receive_lsn`, `pg_last_wal_replay_lsn`, `pg_last_xact_replay_timestamp`); and `pg_sequence_last_value`, which reads a sequence's stored value the way `SELECT last_value FROM a_sequence` does and is what the `pg_sequences` view reads. A name on the list vouches for the server's own function and an extension's C function alone, such as `uuid_generate_v4`: while the database holds a VOLATILE function of that name in another language outside `pg_catalog`, every call of the name is refused. The functions the statement's text names are checked beside those the plan prints, since a plan prints no row of a `VALUES` list and no `LIMIT` expression. The name after `TABLESAMPLE` is a sampling method, whose handler the statement never calls, so it is not read as a call; the method's arguments and its `REPEATABLE` seed are, as the plan prints them. Anything else VOLATILE is not run, and the refusal says plainly that the function is VOLATILE and outside the read-only list, or, for a name on the list, that the database holds another VOLATILE function of that name. This closes the admin-function family without a name list that has to grow with every PostgreSQL release.
+- names any **VOLATILE function** (`pg_proc.provolatile = 'v'`) outside a short read-only allowlist. `pg_proc` marks a function VOLATILE when its answer may change within one statement, which is as true of a reader of live server state as of a writer, so VOLATILE alone does not mean "changes state". The allowlist holds only built-in functions and extension C functions that write nothing: value generators (`random`, `clock_timestamp`, `gen_random_uuid`, `timeofday`, `uuid_generate_v4`, and `pg_sleep*`, which the statement timeout bounds); the size readers (`pg_total_relation_size`, `pg_relation_size`, `pg_table_size`, `pg_indexes_size`, `pg_database_size`, `pg_tablespace_size`); the lock-table snapshot readers (`pg_lock_status` - what the `pg_locks` view reads - `pg_blocking_pids`, `pg_safe_snapshot_blocking_pids`); and the recovery / WAL-position readers (`pg_is_in_recovery`, `pg_is_wal_replay_paused`, `pg_get_wal_replay_pause_state`, `pg_current_wal_lsn`, `pg_current_wal_insert_lsn`, `pg_current_wal_flush_lsn`, `pg_last_wal_receive_lsn`, `pg_last_wal_replay_lsn`, `pg_last_xact_replay_timestamp`); and `pg_sequence_last_value`, which reads a sequence's stored value the way `SELECT last_value FROM a_sequence` does and is what the `pg_sequences` view reads. A name on the list vouches for the server's own function or a C function alone, such as an extension's `uuid_generate_v4`: while the database holds a VOLATILE function of that name in another language outside `pg_catalog`, every call of the name is refused. The functions the statement's text names are checked beside those the plan prints, since a plan prints no row of a `VALUES` list and no `LIMIT` expression. The name after `TABLESAMPLE` is a sampling method, whose handler the statement never calls, so it is not read as a call; the method's arguments and its `REPEATABLE` seed are, as the plan prints them. Anything else VOLATILE is not run, and the refusal says plainly that the function is VOLATILE and outside the read-only list, or, for a name on the list, that the database holds another VOLATILE function of that name. This closes the admin-function family without a name list that has to grow with every PostgreSQL release.
 
 Every statement except `SHOW` is planned, and an `EXPLAIN` is planned as the statement it explains. `EXPLAIN (GENERIC_PLAN)` is planned with that option too, read as the server reads it (its last value, quoted or not), so a statement with `$1` in it is planned as PostgreSQL 16 and later plan it. A statement whose plan cannot be read does not run: when planning times out the answer is the timeout, when planning fails it is the SQL error, and when the server returns no plan the statement is refused.
 
@@ -148,7 +148,7 @@ What bounds each statement a `rails_query` call sends:
 | The query, and `explain: true` | `statement_timeout`, a wait on a lock included | the session's statement limit, and `lock_wait_timeout` for a wait on a lock | the child process's deadline |
 | The reads beside it: the schema read behind the secret column rule, and on PostgreSQL the plan, its `pg_proc` lookup and the column trace | `statement_timeout`, a wait on a lock included | the session's statement limit, and `lock_wait_timeout` for a wait on a lock | no statement limit; a wait on another writer ends at the connection's busy timeout |
 
-The query has `query_timeout` to itself. The reads beside it share a second `query_timeout`, and each is charged the time it ran, so the statements of a call take about twice `query_timeout` at most. Building the app's context, which a cold call does first, is charged to neither, and so are the gate's checks on the statement's text, which the statement length limit bounds. The schema read is a few statements whatever the number of tables: four at most on MySQL and MariaDB, five on PostgreSQL and six on SQLite. On a SQLite file database where a query process can run, two more reads ask what the app's own connection alone holds, so eight reads come before the statement there. On PostgreSQL a plan that holds a foreign scan adds one catalog read. A statement or a view definition that names another schema or database adds the reads of that one.
+The query has `query_timeout` to itself. The reads beside it share a second `query_timeout`, and each is charged the time it ran, so the statements of a call take about twice `query_timeout` at most. On PostgreSQL, MySQL and MariaDB the reads with no bound are of a setting's own value for the settings note, which wait on no lock. Building the app's context, which a cold call does first, is charged to neither, and so are the gate's checks on the statement's text, which the statement length limit bounds. The schema read is a few statements whatever the number of tables: four at most on MySQL and MariaDB, five on PostgreSQL and six on SQLite. On a SQLite file database where a query process can run, two more reads ask what the app's own connection alone holds, so eight reads come before the statement there. On PostgreSQL a plan that holds a foreign scan adds one catalog read. A statement or a view definition that names another schema or database adds the reads of that one.
 
 A read that runs out of that time ends the call with an error that says which side of the statement it was on:
 
@@ -174,7 +174,7 @@ On PostgreSQL and MySQL the query executes inside a transaction, then rolls back
 
 On a connection that is already inside a transaction (a tool called from a transactional test, a mounted server inside a request's transaction, a transaction the app opened with a raw `BEGIN` that Active Record does not count) the guard leaves that transaction open as it found it, with its writes. PostgreSQL guards inside a savepoint, chosen by the server's own transaction status, so the outer transaction stays writable. MySQL and MariaDB cannot make an open transaction read-only: the server refuses `SET TRANSACTION READ ONLY` inside one, and a `BEGIN` there would commit it, so no `BEGIN` is sent, the statement is not sent, and the answer is "Query failed: MySQL cannot make a transaction that is already open read-only, so the statement was not sent. Run it outside the transaction." SQLite runs the statement on the app's own connection, so it reads the rows of the open transaction. It runs under `PRAGMA query_only = ON`, and the pragma is put back as it was found.
 
-A statement that reads a setting the guard sets for it answers the guard's value: `statement_timeout` and `transaction_read_only` on PostgreSQL, the statement limit (`max_execution_time` or `max_statement_time`) and `lock_wait_timeout` on MySQL and MariaDB. When the statement reads one of them (`SHOW name`, `@@name`, `@@SESSION.name`, `@@LOCAL.name` or `current_setting('name')`, the name backquoted or not), or a `SHOW VARIABLES` row or MariaDB's `information_schema.SESSION_VARIABLES` names one, the answer ends with a note that says so and gives the session's own value, for example "statement_timeout here is the value rails_query sets for each statement it runs. The session's own: statement_timeout 50s." A name used as an alias or a column, one in a string or a comment, and a global value on MySQL and MariaDB get no note. SQLite's `PRAGMA query_only` is refused by name.
+A statement that reads a setting the guard sets for it answers the guard's value: `statement_timeout` and `transaction_read_only` on PostgreSQL, the statement limit (`max_execution_time` or `max_statement_time`) and `lock_wait_timeout` on MySQL and MariaDB. When the statement reads one of them (`SHOW name`, `@@name`, `@@SESSION.name`, `@@LOCAL.name` or `current_setting('name')`, the name backquoted or not), or a `SHOW VARIABLES` row or MariaDB's `information_schema.SESSION_VARIABLES` names one, the answer ends with a note that says so and gives the session's own value, for example "statement_timeout here is the value rails_query sets for each statement it runs. The session's own: statement_timeout 50s." A name used as an alias or a column, one in a string or a comment, and a global value on MySQL and MariaDB get no note. On SQLite a `PRAGMA` statement is no read, and the `pragma_query_only` function is refused by name.
 
 An adapter with no family (SQL Server, Oracle, CockroachDB and any other) is refused: `rails_query` answers with the adapter's name and sends no statement, because it cannot give that database a read-only transaction and a timeout it has verified. The family is read from the database's configuration, so the refusal comes before any connection is opened or verified. CockroachDB's adapter is built on PostgreSQL's, but the adapter's name alone chooses the family, so it is refused too.
 

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 |
@@ -654,7 +657,7 @@ ViewComponent/Phlex components: props, slots, previews, sidecar assets, usage ex
 
 ### `rails_get_mailers`
 
-ActionMailer mailers: every mailer class with its delivery actions and delivery method. The actions include the public methods a mailer inherits from the app's own mailers below `ApplicationMailer`, on both tiers. A mailer that declares no action of its own - one taking them from a gem base or a mixin, or one called through class methods - is listed with where its actions come from. A base other mailers inherit from is not one: it leaves the listing, and a line above names the ones left out. Asked for by name, a base answers with what every mailer below it inherits - its layout, helpers, defaults, callbacks and mixins as the app wrote them, the methods it defines - and which mailers inherit it.
+ActionMailer mailers: every mailer class with its delivery actions and delivery method. The actions include the public methods a mailer inherits from the app's own mailers below `ApplicationMailer`, on both tiers. A mailer that declares no action of its own - one taking them from a gem base or a mixin, or one called through class methods - is listed with where its actions come from when that is a gem base it reaches without passing `ApplicationMailer`, such as `Devise::Mailer`, and never Rails' own base. A base other mailers inherit from is not one: it leaves the listing, and a line above names the ones left out. Asked for by name, a base answers with what every mailer below it inherits - its layout, helpers, defaults, callbacks and mixins as the app wrote them, the methods it defines - and which mailers inherit it.
 
 Each mailer also shows its own `default`, `layout`, `helper` and action and
 deliver callbacks as written, the template formats of each action under
@@ -746,7 +749,7 @@ Safe read-only SQL with layered security: the SQL gate, a PostgreSQL plan check
 
 It runs on PostgreSQL, MySQL (with MariaDB) and SQLite, each with its own read-only transaction and statement timeout. On any other adapter it answers with that adapter's name and runs nothing. A statement that runs past `query_timeout` is answered as a timeout and any other database error as an SQL error. Both are error responses: `isError` over MCP and a non-zero exit on the CLI. So is a database no connection reaches, which the answer names with what to do about it. So are a locked SQLite database and the refusal in production.
 
-On PostgreSQL, MySQL and MariaDB every statement a call sends has a time limit. The query has `query_timeout` to itself and the reads beside it share a second one, so the statements of a call take about twice `query_timeout` at most. On SQLite the query has `query_timeout`, and the reads beside it run on the app's own connection with no statement limit. A SQLite statement that names something the app's connection alone holds, such as a temp table or an attached database, runs on that connection, and its answer says it ran without a time limit. The [security model](SECURITY.md#layer-2---database-level-read-only) says what bounds each statement and lists the stated limits.
+On PostgreSQL, MySQL and MariaDB every statement a call sends has a time limit, apart from the reads of a setting's own value for the settings note, which wait on no lock. The query has `query_timeout` to itself and the reads beside it share a second one, so the statements of a call take about twice `query_timeout` at most. On SQLite the query has `query_timeout`, and the reads beside it run on the app's own connection with no statement limit. A SQLite statement that names something the app's connection alone holds, such as a temp table or an attached database, runs on that connection, and its answer says it ran without a time limit. The [security model](SECURITY.md#layer-2---database-level-read-only) says what bounds each statement and lists the stated limits.
 
 On MySQL, MariaDB and SQLite a statement that names a view whose definition names a secret column is refused. So is a `*` inside a subquery when the statement names a table that holds a secret column, and on SQLite `IN` before a table's name (`x IN t`). On PostgreSQL a materialized view whose definition names a secret column is refused. On SQLite a virtual table that holds a secret column, a shadow table and the page modules are refused, and only the pragma functions that describe the schema or the database file run.
 
@@ -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/job_introspector.rb

@@ -822,14 +822,17 @@ module RailsAiContext
           parent_class: inherited_from(walked, outside&.name) }.reject { |_k, v| v.nil? || v == [] }
       end
 
-      # The parent past the app's own mailers that a mailer with no action of its own takes them from. None past the app
-      # base, whose methods and everything above it are no actions, and none from Rails itself.
-      def inherited_from(walked, outside)
-        return nil if walked.any? { |name| ActionResolver.app_base_name?(name, kind: :mailer) }
+      # The parent past the app's own mailers that a mailer with no action of its own takes its actions from. None past
+      # the app base, whose methods and everything above it are no actions, and none from Rails' own base.
+      def inherited_from(walked, parent_name)
+        return nil if walked.any? { |name| app_mailer_base?(name) }
 
-        name = outside.to_s.delete_prefix("::")
-        name unless name.empty? || name.start_with?("ActionMailer::", "AbstractController::") ||
-                    ActionResolver.app_base_name?(name, kind: :mailer)
+        name = parent_name.to_s.delete_prefix("::")
+        name unless name.empty? || name.start_with?("ActionMailer::", "AbstractController::") || app_mailer_base?(name)
+      end
+
+      def app_mailer_base?(name)
+        ActionResolver.app_base_name?(name, kind: :mailer)
       end
 
       def callable_class_methods(names)
@@ -1191,7 +1194,7 @@ module RailsAiContext
       # gives it; tagged STATIC, since a gem's base or a mixin can add actions only the booted tier sees.
       def mailer_entry(klass, ancestors)
         # The app base's public methods are no actions, as the booted tier subtracts them; its callbacks still filter.
-        action_chain = [ klass, *ancestors.take_while { |declaring| !ActionResolver.app_base_name?(declaring.name, kind: :mailer) } ]
+        action_chain = [ klass, *ancestors.take_while { |declaring| !app_mailer_base?(declaring.name) } ]
         visibility = {}
         action_chain.each do |declaring|
           own = ActionResolver.own_methods(declaring.methods, declaring.name).select { |m| m[:scope] == :instance }

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/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/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/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/sql_gate.rb

@@ -128,6 +128,8 @@ module RailsAiContext
     FROM_LIST_CLAUSES = %w[from join on using].freeze
     CLAUSE_WORDS = %w[select from join on where group order having limit values using returning set union intersect except].freeze
 
+    # A double-quoted bare word, which MySQL under ANSI_QUOTES reads as a name and otherwise as a string.
+    BARE_QUOTED_WORD = /\A"\w+"\z/
     # How a statement reads a session setting by name: SHOW, @@, @@SESSION. or @@LOCAL. (backquoted or not), current_setting('..').
     SETTING_READ = /(?:\bshow\s+(?!global\b)|@@(?!global\s*\.)(?:(?:session|local)\s*\.\s*)?|current_setting\s*\(\s*')`?(\w+)/i
     # A list of the session's settings, which names each in its rows or in the filter the statement puts on it.
@@ -335,9 +337,9 @@ module RailsAiContext
     def self.settings_read(sql, family, rows)
       text = comment_free(sql, family)
       code = mask_quoted(text, family) { true }
-      # MySQL reads a double-quoted span as a string, or under ANSI_QUOTES as a name, which only a bare word can be here.
+      # On MySQL a double-quoted span other than a bare word is a string.
       strings_blanked = mask_quoted(text, family) do |kind, span|
-        kind == :string || (family.mysql? && span.start_with?('"') && !span.match?(/\A"\w+"\z/))
+        kind == :string || (family.mysql? && span.start_with?('"') && !span.match?(BARE_QUOTED_WORD))
       end
       read = text.enum_for(:scan, SETTING_READ).filter_map { $~[1] if code[$~.begin(0)] == text[$~.begin(0)] }
       read += text.scan(/\w+/) + rows.flatten.map(&:to_s) if strings_blanked.match?(SETTINGS_LIST)
@@ -467,7 +469,7 @@ module RailsAiContext
         return never_read_refusal(m.captures.compact.first)
       end
       if (m = listed(SYSTEM_SCHEMAS, mask_quoted(cleaned, :string)))
-        text_only = ->(kind, span) { kind == :string || (span.start_with?('"') && !span.match?(/\A"\w+"\z/)) }
+        text_only = ->(kind, span) { kind == :string || (span.start_with?('"') && !span.match?(BARE_QUOTED_WORD)) }
         return "#{never_read_refusal(m[1])} A name before a dot is read as that schema, so an alias named `#{m[1]}` needs another name." if
           listed(SYSTEM_SCHEMAS, mask_quoted(cleaned, &text_only))
 
@@ -964,7 +966,7 @@ module RailsAiContext
       end
       if (fn = volatile_function(called)) && PG_VOLATILE_ALLOWLIST.include?(fn)
         "Blocked: the database holds a VOLATILE function named #{fn} that rails_query cannot vouch for, so rails_query runs no " \
-          "call of that name. Its list of read-only VOLATILE functions trusts the name for the server's own function or an extension's C function alone."
+          "call of that name. Its list of read-only VOLATILE functions trusts the name for the server's own function or a C function alone."
       elsif fn
         "Blocked: function #{fn} is VOLATILE (pg_proc.provolatile = 'v') and not on " \
           "rails_query's list of read-only VOLATILE functions, so it is not run. Some VOLATILE " \
@@ -1078,7 +1080,7 @@ module RailsAiContext
       exprs.each_with_object(Set.new) { |expr, names| expr.scan(/([A-Za-z_]\w*)\s*\(/) { |(fn)| names << fn.downcase } }
     end
 
-    # A name on the read-only list vouches for the server's own function and C code alone: while the database holds a
+    # A name on the read-only list vouches for the server's own function or a C function alone: while the database holds a
     # VOLATILE function of that name in another language outside pg_catalog, every call of the name is refused.
     def volatile_function(called)
       return nil if called.empty?

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/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.0"
+  VERSION = "5.36.2"
 end

metadata

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