rails-ai-context 5.36.1 → 5.36.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ae3eb5f18027a0abe6cf4a8872f9ecce9fb792109ab243b9b7edbba3558cb6d
-  data.tar.gz: c6c7b740f4e18e494a371215c99c05bad848ed43ebf1f84f24020ad4348612ac
+  metadata.gz: 0a04632cfd1114032ce4434e7e8b99d5f92c81bc9537bf5c65b6c65a3124c278
+  data.tar.gz: 3c5210bcb7ba0fef976a00b1224647588d44556bb8d807cbbc87aca9ff0214ce
 SHA512:
-  metadata.gz: fe22c7af7f32d7aa16abdc3b6534653614f3e38fc25a1406c5e29ab9dbb0cf609878fd633210cb3006352007b156d5eaba887db3d1e9ad53cec0ae57357622c0
-  data.tar.gz: 6b0aff79f555f43322eab5c3c81ebcc8a7477a8674891d1f3d2988a47cd23044db5383aacbbd6db3ec15cdeb882dc37b5af4e9cb98c73f1150ba8c73d55cf283
+  metadata.gz: 41e3246dc1905379a9d39bc4bfb8e95498b752a95f1a96b2e955ad58ca22a06696d0c12fd1b676e7414086cea5e571f772c8638dec36823ee542462dca8f4e64
+  data.tar.gz: ea9ebf310554c650503a9f9b95521988eccbf42286885b294ae86031d8c393a3dc71161ecab3852bb69a17055167b5334669fd0187817c62c73f98ecbf0843c1

data/CHANGELOG.md

@@ -5,6 +5,51 @@ 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

data/docs/COMPATIBILITY.md

@@ -327,6 +327,12 @@ 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.
 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/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 |
@@ -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/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/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.1"
+  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.1
+  version: 5.36.2
 platform: ruby
 authors:
 - crisnahine