rails-ai-context 5.35.0 → 5.35.2

data/lib/rails_ai_context/tools/get_schema.rb

@@ -115,9 +115,8 @@ module RailsAiContext
             end
             # Cross-reference hint for AI: suggest next tool call
             model_refs = models_for_table([ table_key, listed_as ], models_data, schema: schema, database: (databases.first if databases.size == 1))
-            if model_refs.any?
-              output += "\n\n_Next: `rails_get_model_details(model:\"#{model_refs.first}\")` for associations, validations, scopes._"
-            end
+            hint = next_hint(pointer("rails_get_model_details", %(model:"#{model_refs.first}"), "for associations, validations, scopes.")) if model_refs.any?
+            output += "\n\n#{hint}" if hint
             return text_response(output)
           end
 
@@ -142,7 +141,7 @@ module RailsAiContext
             end
             coverage = model_coverage_lines(tables, models_data, schema)
             lines.concat([ "" ] + coverage) if coverage.any?
-            lines.concat(secondary_databases_lines(schema))
+            lines.concat(secondary_databases_lines(schema, ctx))
             if page[:offset] + page[:limit] < total
               lines << "" << "_Showing #{paginated.size} of #{total}. Use `offset:#{page[:offset] + page[:limit]}` for more, or `table:\"name\"` for full detail._"
               lines << "_cache_key: #{cache_key}_"
@@ -254,7 +253,7 @@ module RailsAiContext
 
             coverage = model_coverage_lines(tables, models_data, schema)
             lines.concat(coverage + [ "" ]) if coverage.any?
-            lines.concat(secondary_databases_lines(schema))
+            lines.concat(secondary_databases_lines(schema, ctx))
             if page[:offset] + page[:limit] < total
               lines << "_Showing #{paginated.size} of #{total}. Use `offset:#{page[:offset] + page[:limit]}` for more._"
             end
@@ -278,7 +277,7 @@ module RailsAiContext
             end
             coverage = model_coverage_lines(tables, models_data, schema)
             lines.concat(coverage + [ "" ]) if coverage.any?
-            lines.concat(secondary_databases_lines(schema))
+            lines.concat(secondary_databases_lines(schema, ctx))
             if page[:offset] + page[:limit] < total
               lines << "_Showing #{paginated.size} of #{total}. Use `offset:#{page[:offset] + page[:limit]}` for more._"
               lines << "_cache_key: #{cache_key}_"
@@ -439,15 +438,18 @@ module RailsAiContext
       # cache, cable) to its own schema/structure file. This tool targets the
       # primary database's tables in detail, so secondaries get a compact
       # one-line-per-database summary rather than full column detail.
-      private_class_method def self.secondary_databases_lines(schema)
+      private_class_method def self.secondary_databases_lines(schema, ctx)
         secondary = schema[:secondary_databases]
         return [] unless secondary
 
         lines = [ "", "## Secondary databases", "" ]
         secondary.each do |name, db|
+          label = "**#{name}**#{Payload.named_database_mark(ctx, name)}"
+          next lines << "- #{label}: #{db[:note]}" if db[:tables].blank?
+
           pending = Array(db[:pending_migrations])
           pending_text = pending.any? ? "; pending migrations: #{pending_phrase(pending)}" : ""
-          lines << "- **#{name}**: #{Introspectors::SchemaConventions.relations_phrase(db[:tables])} (#{db[:tables].keys.join(', ')}) - #{db[:note]}#{pending_text}"
+          lines << "- #{label}: #{Introspectors::SchemaConventions.relations_phrase(db[:tables])} (#{db[:tables].keys.join(', ')}) - #{db[:note]}#{pending_text}"
         end
         lines
       end

data/lib/rails_ai_context/tools/get_service_pattern.rb

@@ -46,9 +46,10 @@ module RailsAiContext
 
         # A module in a concerns directory is a concern, not a service; the generated files'
         # Services line uses the same rule.
-        service_files = service_dirs.flat_map { |d| safe_glob(d, "**/*.rb", real_root) }.uniq.sort
-          .reject { |f| Introspectors::ServiceClasses.concern?(relative_under(f, real_service_dirs)) }
-        return no_services_response if service_files.empty?
+        concern_files, service_files = service_dirs.flat_map { |d| safe_glob(d, "**/*.rb", real_root) }.uniq.sort
+          .partition { |f| Introspectors::ServiceClasses.concern?(relative_under(f, real_service_dirs)) }
+        concerns = concern_files.map { |f| { path: f, left_out: :concern } }
+        return no_services_response([ left_out_note(concerns, real_service_dirs) ].compact) if service_files.empty?
 
         # One lookup for the whole call: it walks the service tree on first
         # use and only a class whose superclass is not ActiveInteraction::Base
@@ -59,7 +60,7 @@ module RailsAiContext
           return format_single_service(service, service_files, real_service_dirs, real_root, lookup)
         end
 
-        format_service_listing(service_files, real_service_dirs, real_root, detail, lookup)
+        format_service_listing(service_files, real_service_dirs, real_root, detail, lookup, concerns)
       end
 
       # A service lives under app/services, a pack, an in-repo engine or a
@@ -71,8 +72,8 @@ module RailsAiContext
       end
 
       private_class_method def self.format_single_service(service, service_files, service_dirs, root, lookup)
-        records = without_mixins(match_service_files(service, service_files, service_dirs)
-          .filter_map { |f| service_record(f, service_dirs, lookup) }, root)
+        records = classified(match_service_files(service, service_files, service_dirs), service_dirs, root, lookup)
+          .reject { |r| r[:left_out] }
         matches = records.map { |r| r[:path] }
 
         if matches.size > 1
@@ -182,12 +183,11 @@ module RailsAiContext
           end
         end
         if scan_truncated
-          lines << "" << "_The caller scan stopped after #{count_phrase(MAX_CALLER_SCAN_FILES, "file")}; " \
-                        "run `rails_search_code(pattern:\"#{class_name}\")` for the rest._"
+          search = pointer("rails_search_code", %(pattern:"#{class_name}"))
+          lines << "" << "_The caller scan stopped after #{count_phrase(MAX_CALLER_SCAN_FILES, "file")}#{"; run #{search} for the rest" if search}._"
         end
 
-        # Cross-reference hints
-        lines << "" << "_Next: `rails_search_code(pattern:\"#{class_name}\")` for all references_"
+        add_next_hint(lines, pointer("rails_search_code", %(pattern:"#{class_name}"), "for all references"))
 
         text_response(lines.join("\n"))
       end
@@ -195,17 +195,25 @@ module RailsAiContext
       # The classes the listing counts before it sets the bases apart. The by-name
       # lookup reads the same list, so it never answers what the listing leaves out.
       private_class_method def self.service_records(service_files, service_dirs, root, lookup)
-        without_mixins(service_files.filter_map { |file| service_record(file, service_dirs, lookup) }, root)
+        classified(service_files, service_dirs, root, lookup).reject { |r| r[:left_out] }
+      end
+
+      # Every file with the one reason it is no service, if any. The listing's
+      # count and its note of what it left out both read this.
+      private_class_method def self.classified(files, service_dirs, root, lookup)
+        tag_mixins(files.map { |file| service_record(file, service_dirs, lookup) }, root)
       end
 
       private_class_method def self.service_record(file, service_dirs, lookup)
         source = safe_read(file)
         # Kept unread so a by-name lookup can say the file is too large.
         return { path: file } unless source
-        return if Introspectors::ServiceClasses.concern?(nil, source)
+        return { path: file, left_out: :concern } if Introspectors::ServiceClasses.concern?(nil, source)
 
         class_name, superclass, nesting = name_and_superclass(source, file, service_dirs)
-        return if Introspectors::ServiceClasses.mailer?(source, class_name, superclass, lookup)
+        if Introspectors::ServiceClasses.mailer?(source, class_name, superclass, lookup)
+          return { path: file, class_name: class_name, left_out: :mailer }
+        end
 
         { path: file, source: source, class_name: class_name, superclass: superclass, nesting: nesting,
           entryless: Introspectors::ServiceClasses.entryless_module?(source, class_name) }
@@ -213,16 +221,45 @@ module RailsAiContext
 
       # A module other classes mix in is a concern in all but directory, and
       # the generated files' Services line leaves it out by the same rule.
-      private_class_method def self.without_mixins(records, root)
+      private_class_method def self.tag_mixins(records, root)
         entryless = records.select { |r| r[:entryless] }.map { |r| r[:class_name] }
         return records if entryless.empty?
 
         mixins = Introspectors::ServiceClasses.mixed_in(root, entryless)
-        records.reject { |r| mixins.include?(r[:class_name]) }
+        records.map { |r| r[:entryless] && mixins.include?(r[:class_name]) ? r.merge(left_out: :mixin) : r }
       end
 
-      private_class_method def self.format_service_listing(service_files, service_dirs, root, detail, lookup)
-        read = service_records(service_files, service_dirs, root, lookup).select { |record| record[:source] }.map do |record|
+      LEFT_OUT_NAMES_PER_KIND = 5
+      LEFT_OUT_KINDS = {
+        base: [ "base class", " (named above)" ],
+        concern: [ "concern", "" ],
+        mixin: [ "module", " with no entry point that other code mixes in" ],
+        mailer: [ "mailer", "" ],
+        unread: [ "file", " too large to read" ]
+      }.freeze
+
+      # The heading counts services and a reader counts files, so the files
+      # that are no service are counted by kind beside it.
+      private_class_method def self.left_out_note(records, service_dirs)
+        left_out = records.select { |r| r[:left_out] }
+        return nil if left_out.empty?
+
+        kinds = LEFT_OUT_KINDS.filter_map do |kind, (noun, suffix)|
+          of_kind = left_out.select { |r| r[:left_out] == kind }
+          next if of_kind.empty?
+
+          names = of_kind.map { |r| r[:class_name] || constant_for(r[:path], service_dirs) }.sort
+          more = names.size - LEFT_OUT_NAMES_PER_KIND
+          named = kind == :base ? "" : " (#{names.first(LEFT_OUT_NAMES_PER_KIND).join(', ')}#{" and #{more} more" if more.positive?})"
+          "#{count_phrase(of_kind.size, noun)}#{suffix}#{named}"
+        end
+        "_#{left_out.size} of the #{count_phrase(records.size, "Ruby file")} under the service directories " \
+          "#{left_out.size == 1 ? 'is' : 'are'} left out: #{kinds.join(', ')}._"
+      end
+
+      private_class_method def self.format_service_listing(service_files, service_dirs, root, detail, lookup, concerns)
+        records = concerns + classified(service_files, service_dirs, root, lookup).map { |r| r[:source] || r[:left_out] ? r : r.merge(left_out: :unread) }
+        read = records.reject { |record| record[:left_out] }.map do |record|
           [ record, *class_interface(record[:source], constant_for(record[:path], service_dirs)) ]
         end
         # A listed parent's macros are already read, so its children's constructors reuse them.
@@ -247,15 +284,15 @@ module RailsAiContext
 
         bases = base_class_names(service_data)
         service_data = service_data.reject { |s| bases.include?(s[:class_name]) }
+        notes = [ bases_note("services", bases),
+                  left_out_note(records.map { |r| bases.include?(r[:class_name]) && !r[:left_out] ? r.merge(left_out: :base) : r }, service_dirs) ].compact
         # A directory of base classes alone has no service anybody calls, and
         # still names the bases it left out.
-        return no_services_response(bases) if service_data.empty?
+        return no_services_response(notes) if service_data.empty?
 
         total = service_data.size
         lines = [ "# Service Objects (#{total})", "" ]
-        if bases.any?
-          lines << bases_note("services", bases) << ""
-        end
+        lines.push(*notes, "") if notes.any?
 
         # Pattern detection
         detected = detect_common_pattern(pattern_stats(service_data))
@@ -314,9 +351,8 @@ module RailsAiContext
         stats
       end
 
-      private_class_method def self.no_services_response(bases = [])
-        text_response([ "A services directory exists but contains no service objects.",
-                        bases_note("services", bases) ].compact.join("\n\n"))
+      private_class_method def self.no_services_response(notes = [])
+        text_response([ "A services directory exists but contains no service objects.", *notes.join("\n").presence ].join("\n\n"))
       end
 
       # A base class is not a service a caller invokes: counted as one it

data/lib/rails_ai_context/tools/get_turbo_map.rb

@@ -23,7 +23,7 @@ module RailsAiContext
       )
 
       guide_row(
-        order: 19,
+        order: 18,
         mcp: "rails_get_turbo_map",
         summary: "Turbo Stream/Frame wiring + mismatch warnings"
       )

data/lib/rails_ai_context/tools/migration_advisor.rb

@@ -43,7 +43,7 @@ module RailsAiContext
       )
 
       guide_row(
-        order: 28,
+        order: 25,
         mcp: "rails_migration_advisor(action:\"X\", table:\"Y\")",
         cli_args: "action=X table=Y",
         summary: "Generate migration code, flag irreversible ops"
@@ -123,7 +123,7 @@ module RailsAiContext
         end
         # What the app's migrations already hold: a file the generator's name
         # collides with, and a pending one that makes the same change.
-        prior = prior_migration_lines(action, table, column, rename_to, type, migration_files_for(target), pending_versions(schema, databases))
+        prior = prior_migration_lines(action, table, column, rename_to, type, migration_files_for(target), pending_versions(schema, table, databases))
         lines.concat(prior)
         # The generator refuses a name another migration has, so its command is not offered.
         target = false if prior.any? { |line| line.start_with?("**Warning:** Another migration is already named") }
@@ -190,8 +190,8 @@ module RailsAiContext
         end
 
         # The versions not yet run on that database; nil when unknown.
-        def pending_versions(schema, databases)
-          pending = if databases.empty? || databases.include?("primary")
+        def pending_versions(schema, table, databases)
+          pending = if on_primary?(table)
             schema&.dig(:pending_migrations)
           else
             schema&.dig(:secondary_databases, databases.first, :pending_migrations)
@@ -325,11 +325,14 @@ module RailsAiContext
         # [lines, target]: target is nil for the primary, false when no environment configures the
         # database, else the generator's --database flag and the RAILS_ENV that configures it.
         def database_option(table, databases)
-          return [ [], nil ] if databases.empty? || databases.include?("primary")
+          return [ [], nil ] if on_primary?(table)
 
-          yml = RailsAiContext::DatabaseYml
           root = rails_app.root
-          found = databases.to_h { |db| [ db, (entry = yml.entry(root, db)) ? [ nil, entry ] : yml.elsewhere(root, db) ] }.compact
+          listed = RailsAiContext::AppDatabases.for(root)
+          found = databases.filter_map do |name|
+            db = listed[name]
+            [ name, [ (db.environments unless db.here), db.settings ] ] if db&.config
+          end.to_h
           if found.empty?
             note = "**Database:** `#{table}` is in the #{databases.join(", ")} dump, which no environment in config/database.yml configures: " \
                    "no `--database` reaches it, and a migration generated here runs on the primary."
@@ -337,13 +340,15 @@ module RailsAiContext
           end
 
           names = found.keys
-          env_name = found.values.first.first
+          elsewhere = found.values.first.first
+          env_name = elsewhere&.first
+          configuring = "#{RailsAiContext::AppDatabases.environment_phrase(elsewhere)} #{elsewhere.one? ? "configures" : "configure"}" if elsewhere
           configured = Array(found.values.first.last["migrations_paths"])
           dirs = configured.any? ? configured.map { |path| File.expand_path(path, root.to_s) } : [ File.join(root.to_s, "db", "#{names.first}_migrate") ]
           target = { flag: " --database #{names.first}", env: env_name, dirs: dirs }
           paths = configured.join(", ")
-          note = "**Database:** `#{table}` is in #{[ names[0..-2].join(", "), names.last ].reject(&:empty?).join(" and ")}," \
-                 "#{" which #{env_name} configures and this environment does not," if env_name} not the primary database: generate with #{"`RAILS_ENV=#{env_name}` and " if env_name}`#{target[:flag].strip}` " \
+          note = "**Database:** `#{table}` is in #{[ names[0..-2].join(", "), names.last ].reject(&:empty?).join(" and ")}" \
+                 "#{", which #{configuring} and this environment does not" if env_name}: generate with #{"`RAILS_ENV=#{env_name}` and " if env_name}`#{target[:flag].strip}` " \
                  "so the migration lands in #{env_name && !paths.empty? ? paths : "that database's migrations_paths"} and " \
                  "#{"#{env_name}'s " if env_name}`bin/rails db:migrate` runs it there."
           groups = found.group_by { |_, (_, entry)| Array(entry["migrations_paths"]) }
@@ -397,11 +402,10 @@ module RailsAiContext
           lines
         end
 
-        # NOT NULL with no default has no value for the rows already there, so
-        # the migration fails on a table that holds any. The row count is the
-        # database's own estimate when the app is booted.
+        # NOT NULL with no default fails on a table that holds rows. The row count is the booted
+        # primary's own estimate, so a table only another database holds has none.
         def not_null_warning(table, column)
-          stats = Array(Payload.section(cached_context, :database_stats)&.dig(:tables)).find { |t| t[:table].to_s == table }
+          stats = (Array(Payload.section(cached_context, :database_stats)&.dig(:tables)).find { |t| t[:table].to_s == table } if on_primary?(table))
           rows = stats&.dig(:approximate_rows)
           held = if rows.nil? then "if `#{table}` holds any rows"
           elsif stats[:at_least] then "as `#{table}` holds at least #{count_phrase(rows, "row")}"
@@ -505,10 +509,13 @@ module RailsAiContext
           lines << "```"
           lines << ""
           lines << "**Reversible:** Yes"
-          lines << if mysql_adapter?
+          lines << case family(table).key
+          when :mysql
             "**Note:** MySQL/MariaDB add indexes to InnoDB tables via online DDL by default (`ALGORITHM=INPLACE`, no table lock) - there's no `algorithm: :concurrently` equivalent to reach for here (that option is PostgreSQL-only; Rails raises `ArgumentError` if you pass it on this adapter)."
-          else
+          when :postgresql
             "**Note:** For large tables, consider `algorithm: :concurrently` (PostgreSQL) to avoid locking"
+          else
+            "**Note:** Building an index on a large table can block writes while it runs."
           end
           lines
         end
@@ -708,21 +715,22 @@ module RailsAiContext
             ]
           when "change_type"
             [
-              "**`change_column` (type change) blocks writes** on Postgres for the duration of the table rewrite, which can be hours on large tables.",
+              "**`change_column` (type change) blocks writes**#{" on Postgres" if family(table).postgresql?} for the duration of the table rewrite, which can be hours on large tables.",
               "Safer pattern: add a new column with the new type, backfill, dual-write, swap, drop the old column."
             ]
           when "add_index"
             # strong_migrations only requires algorithm: :concurrently on
             # PostgreSQL (its ACCESS EXCLUSIVE lock is the problem) - it
             # doesn't flag plain add_index on MySQL/MariaDB or SQLite at all.
-            if postgresql_adapter? && !options.to_s.include?("concurrently")
+            if family(table).postgresql? && !options.to_s.include?("concurrently")
               [
                 "**`add_index` without `algorithm: :concurrently`** acquires an `ACCESS EXCLUSIVE` lock on Postgres and blocks writes.",
                 "Use `add_index :#{table}, :#{column}, algorithm: :concurrently` and add `disable_ddl_transaction!` at the top of the migration."
               ]
             end
           when "add_association"
-            if mysql_adapter?
+            case family(table).key
+            when :mysql
               [
                 "**`add_foreign_key` blocks writes on both tables while validating existing rows.** MySQL/MariaDB has no `validate: false` + separate-validation two-step like Postgres.",
                 "If you're certain all rows are valid, wrap in `safety_assured` and drop `foreign_key_checks` for the duration:",
@@ -730,18 +738,24 @@ module RailsAiContext
                 "  2. `add_foreign_key :#{table}, :#{column}`",
                 "  3. `execute \"SET SESSION foreign_key_checks = 1\"`"
               ]
-            else
+            when :postgresql
               [
                 "**`add_foreign_key` validates existing rows by default**, which acquires a `SHARE ROW EXCLUSIVE` lock on both tables.",
                 "Safer two-step pattern:",
                 "  1. `add_foreign_key :#{table}, :#{column}, validate: false` (lock-free)",
                 "  2. In a separate migration: `validate_foreign_key :#{table}, :#{column}`"
               ]
+            else
+              [ "**`add_foreign_key` validates existing rows by default**, which can block writes on both tables while it runs." ]
             end
           when "add_column"
             if options.to_s.match?(/null:\s*false/) && !options.to_s.include?("default:")
               [
-                "**Adding a `NOT NULL` column without a default rewrites the table** on older Postgres and fails on existing rows.",
+                if family(table).postgresql?
+                  "**Adding a `NOT NULL` column without a default rewrites the table** on older Postgres and fails on existing rows."
+                else
+                  "**Adding a `NOT NULL` column without a default** needs a value for every existing row."
+                end,
                 "Safer pattern: add the column nullable, backfill in batches, then add the NOT NULL constraint with `change_column_null`."
               ]
             end
@@ -806,7 +820,8 @@ module RailsAiContext
           end
           return [ "", "## Code that names `#{column}`", "", "_No line in app/, lib/ or config/ names it._" ] if found.empty?
 
-          more = found.size > MENTION_CAP ? [ "- _...and #{found.size - MENTION_CAP} more; `rails_search_code(pattern:\"#{column}\", exact_match:true)` lists them all_" ] : []
+          search = pointer("rails_search_code", %(pattern:"#{column}", exact_match:true), "lists them all")
+          more = found.size > MENTION_CAP ? [ "- _...and #{found.size - MENTION_CAP} more#{"; #{search}" if search}_" ] : []
           [ "", "## Code that names `#{column}` (#{count_phrase(found.size, "line")})", "" ] + found.first(MENTION_CAP) + more
         rescue => e
           RailsAiContext.debug_fail(e, [], label: "column_mention_lines")
@@ -908,19 +923,19 @@ module RailsAiContext
           parts.join(".")
         end
 
-        # Locking/DDL advice differs by adapter (MySQL's online DDL vs
-        # Postgres's ACCESS EXCLUSIVE locks), so callers need to know which
-        # family the app is actually running before printing lock advice.
-        def current_adapter
-          cached_context.dig(:schema, :adapter).to_s
-        end
+        # The family of the database that holds the table, since locking advice differs by family.
+        # An undecided database is no family and gets advice that names no database.
+        def family(table)
+          return RailsAiContext::DatabaseFamily.of(cached_context.dig(:schema, :adapter).to_s) if on_primary?(table)
 
-        def mysql_adapter?
-          current_adapter.match?(/mysql|trilogy/i)
+          held_in = Payload.schema_databases(Payload.section(cached_context, :schema), table)
+          RailsAiContext::AppDatabases.for(rails_app.root)[held_in.first]&.family || RailsAiContext::DatabaseFamily.of(nil)
         end
 
-        def postgresql_adapter?
-          current_adapter.match?(/postg/i)
+        # A table no database holds yet goes to the primary. Another database can carry the name "primary".
+        def on_primary?(table)
+          holders = Payload.table_holders(Payload.section(cached_context, :schema), table)
+          holders.empty? || holders.any? { |database, _, _| database.nil? }
         end
       end
     end

data/lib/rails_ai_context/tools/onboard.rb

@@ -7,20 +7,18 @@ module RailsAiContext
       description "Get a narrative walkthrough of the Rails application - stack, data model, authentication, key flows, " \
         "background jobs, frontend, testing, getting started instructions, and the app's custom rake tasks, generators and Railties. " \
         "Use when: first encountering a project, onboarding a new developer, or orienting an AI agent. " \
-        "Key params: detail (quick/standard/full)."
+        "Key params: detail (summary/standard/full)."
 
       input_schema(
         properties: {
-          detail: {
-            type: "string",
-            enum: %w[quick standard full],
-            description: "Detail level. quick: 1-paragraph overview. standard: structured walkthrough (default). full: all subsystems included."
-          }
+          detail: RailsAiContext::DetailLevel.schema(
+            "Detail level. summary: 1-paragraph overview. standard: structured walkthrough (default). full: all subsystems included."
+          )
         }
       )
 
       guide_row(
-        order: 37,
+        order: 32,
         mcp: "rails_onboard(detail:\"standard\")",
         cli_args: "detail=standard",
         summary: "Narrative app walkthrough for new developers or AI agents"
@@ -41,24 +39,20 @@ module RailsAiContext
         ctx = cached_context
 
         body = case detail
-        when "quick"
-          compose_quick(ctx)
-        when "full"
+        when RailsAiContext::DetailLevel::SUMMARY
+          compose_summary(ctx)
+        when RailsAiContext::DetailLevel::FULL
           compose_full(ctx)
         else
           compose_standard(ctx)
         end
         text_response(body, suffix: introspection_warnings_note(ctx))
-      rescue => e
-        text_response("Onboard error: #{e.message}")
       end
 
       class << self
         private
 
-        # ── Quick: single paragraph ──────────────────────────────────────
-
-        def compose_quick(ctx)
+        def compose_summary(ctx)
           app = ctx[:app_name] || "This Rails app"
 
           ruby = ruby_phrase(ctx)
@@ -74,11 +68,15 @@ module RailsAiContext
           stats = []
           schema = Payload.section(ctx, :schema)
           if schema
-            own = own_secondary_databases(ctx, schema)
+            unread, own = own_secondary_databases(ctx, schema).partition { |db| db[:unread] }
             table_count = schema[:total_tables].to_i + own.sum { |db| db[:tables] }
             if table_count > 0
               stats << count_phrase(table_count, "table") + (own.any? ? " in #{count_phrase(own.size + 1, "database")}" : "")
             end
+            if unread.any?
+              stats << "the #{unread.map { |db| db[:name] }.to_sentence(two_words_connector: " and ", last_word_connector: " and ")} " \
+                       "#{unread.one? ? 'database' : 'databases'} not read"
+            end
           end
 
           models = Payload.models(ctx)
@@ -142,7 +140,7 @@ module RailsAiContext
             db = "#{adapter} (#{count_phrase(schema[:total_tables].to_i, 'table')})"
             # Every database the app's own dumps declare, as rails_get_schema reads them.
             own_secondary_databases(ctx, schema).each do |other|
-              db += ", plus the #{other[:name]} database#{" on #{other[:adapter]}" if other[:adapter]} (#{count_phrase(other[:tables], 'table')})"
+              db += ", plus the #{other[:name]} database#{Payload.named_database_mark(ctx, other[:name])}#{" on #{other[:adapter]}" if other[:adapter]} (#{other[:unread] ? 'tables not read' : count_phrase(other[:tables], 'table')})"
             end
           elsif RailsAiContext::AppKind.mongoid?(rails_app.root)
             database = RailsAiContext::AppKind.mongoid_database(rails_app.root)
@@ -156,7 +154,11 @@ module RailsAiContext
           lines << "#{ctx[:app_name]} is a Rails#{" #{rails}" if rails} application#{ruby_clause(ctx)} #{db ? "on #{db}" : "without Active Record"}."
           solid = schema ? solid_databases(schema) : {}
           if solid.any?
-            lines << "#{solid.values.uniq.to_sentence} keep#{"s" if solid.values.uniq.one?} their tables in databases of their own: #{solid.keys.join(", ")}."
+            frameworks = solid.values.uniq
+            keep, own = frameworks.one? ? [ "keeps its", "its own" ] : [ "keep their", "their own" ]
+            place = solid.one? ? "a database of #{own}" : "databases of #{own}"
+            names = solid.keys.map { |name| "#{name}#{Payload.named_database_mark(ctx, name)}" }
+            lines << "#{frameworks.to_sentence(last_word_connector: " and ")} #{keep} tables in #{place}: #{names.join(", ")}."
           end
           unread = unread_bundle(rails)
           lines << unread if unread
@@ -185,15 +187,13 @@ module RailsAiContext
           Payload.framework_databases(schema).to_h { |name, info| [ name.to_s, Payload.database_framework(info) ] }
         end
 
-        # The app's own databases besides the primary, as its schema dumps
-        # declare them: metrics71's analytics database on SQLite went
-        # uncounted beside its PostgreSQL primary. Each is
-        # { name:, adapter:, tables: }, the adapter nil when database.yml does not say.
+        # The app's own databases besides the primary, as its schema dumps declare them. The adapter is nil when
+        # database.yml does not say; `unread` marks a dump that could not be read, whose table count is no count.
         def own_secondary_databases(ctx, schema)
-          configured = Array(Payload.section(ctx, :multi_database)&.dig(:databases)).grep(Hash).to_h { |d| [ d[:name].to_s, d ] }
+          configured = Payload.databases(ctx).to_h { |d| [ d[:name].to_s, d ] }
           Payload.app_databases(schema).map do |name, db|
             { name: name.to_s, adapter: RailsAiContext::SchemaAdapter.database_label(configured[name.to_s]),
-              tables: (db[:total_tables] || db[:tables].size).to_i }
+              tables: (db[:total_tables] || db[:tables].size).to_i, unread: db[:unread] }
           end
         end
 

data/lib/rails_ai_context/tools/performance_check.rb

@@ -38,7 +38,7 @@ module RailsAiContext
       )
 
       guide_row(
-        order: 26,
+        order: 23,
         mcp: "rails_performance_check(model:\"X\")",
         cli_args: "model=X",
         summary: "N+1 risks, missing indexes, Model.all anti-patterns"
@@ -72,6 +72,12 @@ module RailsAiContext
 
           lines << "**Total issues found:** #{filtered_count}"
           lines << ""
+          unchecked = Array(data[:unchecked_databases])
+          if unchecked.any?
+            said = unchecked.map { |db| "#{db[:name]} (#{[ Payload.named_scope_words(cached_context, db[:name]), db[:reason] ].compact.join(', ')})" }
+            lines << "**Not checked:** #{said.join(', ')}"
+            lines << ""
+          end
 
           if RailsAiContext::DetailLevel.summary?(detail)
             kept.each do |name, items|
@@ -163,6 +169,13 @@ module RailsAiContext
           " (#{item[:controller]}#{action}#{view})"
         end
 
+        # " (queue database)", and where only another environment configures it, " (queue database, production only)".
+        def database_tag(name)
+          return "" unless name
+
+          " (#{[ "#{name} database", Payload.named_scope_words(cached_context, name) ].compact.join(", ")})"
+        end
+
         def render_section(title, items, model_filter, detail)
           return [] unless items&.any?
 
@@ -172,7 +185,7 @@ module RailsAiContext
           lines = [ "## #{title} (#{filtered.size})", "" ]
 
           filtered.each do |item|
-            lines << "- **#{item[:model] || item[:table] || "Unknown"}**"
+            lines << "- **#{item[:model] || item[:table] || "Unknown"}**#{database_tag(item[:database])}"
             lines << "  #{item[:suggestion]}" if item[:suggestion]
             if RailsAiContext::DetailLevel.full?(detail)
               lines << "  Controller: #{item[:controller]}" if item[:controller]