rails-ai-context 5.20.2 → 5.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 81eedfa398603e64a27f7555b4288e39a11e41093c3a06450354c2f5cb1d17c5
-  data.tar.gz: 34972bf4259e8e12695f008744111bff94ed7caa93155bd3f8352010e3134c15
+  metadata.gz: e2ccd7eb081bc5f6f34e998978e38d7d9d5282d097818224c10bd56ff4d30c75
+  data.tar.gz: 0bb8a8ad8f57a11a04a41dd2ab9e30f57f25b08382d1b5edca67af0c3db68f38
 SHA512:
-  metadata.gz: c88339dc6c73a5fdb38209d69e61437a6494382c069ae943478e51a265e57b2b847d4cb89f22ef0449c024bdb43185feef7e58a5e92f199c0a0389f4822898ca
-  data.tar.gz: 2f0a283b5691f00d4f49aeed839da56af13e248f566c9a526e3926cbc0c71185cf2e99a9b809d5e316d7e1144826456bb65ea36148493b4102f44b3bf0857584
+  metadata.gz: dadae053988700c4c82e841dc5d18c0c22f6584ceef3616e7a520388e57bea89bb1535dc2ca658b5960d3d5d3a11ecbedc912f69386485412c0d833d1c8d1cfa
+  data.tar.gz: 07bba392bb191112f18cf14e89147b445078d04b404d0bea9f974e148f42f1ef2ee4d83ccacc7049e132dacf2ad0c1ac17fd4079b779d2dd0d6039c739359092

data/CHANGELOG.md

@@ -5,6 +5,144 @@ 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.21.0] - 2026-08-12
+
+### Fixed
+
+- **`get_env` no longer offers a name the app never reads.** An app that builds
+  its variable names by interpolation, the normal shape when it carries several
+  Redis connections, had `#{prefix}URL` reported as a variable name and
+  `defaults[:port]` reported as that variable's default. The scan reads the
+  parser now instead of matching whatever sat between two quotes, so a name
+  that does not exist until runtime is not offered to someone writing a
+  `.env.example`, and a default is printed only when it is a value. Comments
+  drop out for free, including one trailing a line that also reads `ENV`.
+  (#129)
+
+- **`get_controllers` no longer lists `set_locale` as an action.** A controller
+  whose own file defines no public method fell back to `action_methods`, which
+  subtracts inherited methods only as far as the nearest abstract ancestor:
+  everything `ApplicationController` and its concerns define publicly came back
+  as an action, so a two-route controller reported 19 of them. The actions of a
+  thin subclass now come from the source of the ancestor that defines them.
+  Reflection is left for the case that has no source to read, an ancestor this
+  app does not own the file for, which is what a controller inheriting from a
+  gem or an engine looks like. (#130)
+
+- **`get_service_pattern` reports the service's entry point, not a nested
+  class's.** Nesting a query builder inside the service that uses it is a
+  normal way to organise a large one, and the line scan could not see it: it
+  named `QueryBuilder#build` as the entry point of a 312-line service, and a
+  `private` inside a nested class hid the real `call` that followed the nested
+  class's `end`, reporting the service as having no entry point at all. The
+  methods now come from the AST, scoped to the class the file is named for.
+  (#131)
+
+- **`get_test_info` counts tests, not files.** "Test Counts by Category"
+  globbed every `.rb` under a category directory, so four mailer specs sitting
+  beside four mailer previews counted as eight tests. Anything a project keeps
+  next to its specs inflated the number. (#132)
+
+- **`get_concern` finds every concern the app has.** It searched two hardcoded
+  directories while `get_active_support` searched five, so one run answered 80
+  concerns and 81 concerns for the same app, and the mailer concern only the
+  second one found could not be reached by name through the first. Both now
+  read one seam, which discovers `app/*/concerns` the way Rails autoloads it,
+  so an app that keeps `app/serializers/concerns` is covered too. Concerns are
+  grouped and filterable by the directory that owns them. (#133)
+
+- **Namespaced Pundit policies keep their namespace.** Policy names came from
+  the basename, so `app/policies/admin/collection_policy.rb` and
+  `app/policies/collection_policy.rb` both read as `CollectionPolicy`. One name
+  was listed twice and the other class appeared nowhere in the generated
+  context or in `CLAUDE.md`, including the one that defines `destroy?`. (#135)
+
+- **Re-running a release no longer fails on the MCP Registry.** The registry
+  answers a repeat version with a 400, and the publish step had no guard, so
+  re-running a release that had already succeeded turned the workflow red with
+  nothing wrong. It now checks for the version first, the way the RubyGems step
+  already did.
+
+### Changed
+
+- **`config.concern_paths` replaces concern discovery instead of adding to
+  it.** Left unset, which is now the default, every `app/*/concerns` directory
+  is discovered. Setting it means those directories and no others, so it can
+  narrow as well as reach outside `app/`.
+
+## [5.20.3] - 2026-08-11
+
+### Fixed
+
+- **`serve --transport http` no longer answers "Session not found" to about half
+  of all requests.** Rackup hands Puma the host app's `config/puma.rb`, and a
+  real app sets `workers` there, so the transport ran as a cluster - but MCP
+  sessions live in one process's memory, and a forked worker cannot answer a
+  request whose `initialize` a sibling handled. Puma is now pinned to single
+  mode. Both options are load-bearing: refusing the config file still leaves
+  `WEB_CONCURRENCY` able to start a cluster on its own, and pinning the worker
+  count still lets the file's `pidfile` and `preload_app!` through - the pidfile
+  being one this server would otherwise write over the app's own. (#123)
+
+- **A gem's background job is no longer counted as the app's.** `extract_jobs`
+  filtered `ActiveJob::Base.descendants` with a list of framework name
+  prefixes, which no list can keep up with: on an app with 118 Sidekiq workers
+  and no ActiveJob of its own, the generated `CLAUDE.md` read `Async: 1 job`
+  and that job was an indexing worker belonging to a gem. Ownership is now
+  decided by where the class is defined. A class with no source location is
+  kept, because understating what the app runs is the worse mistake. (#120)
+
+- **`get_job_pattern` now names the queues `config/sidekiq.yml` declares.**
+  `extract_sidekiq_config` already read them; holding the result back left the
+  answer describing `app/jobs/` and nothing else, on an app whose sidekiq.yml
+  is the one piece of evidence in reach that async work happens elsewhere. It
+  reaches the job listing as well as the empty-directory message - a count of
+  what `app/jobs/` holds is still a claim about the app's async work, and on an
+  app running most of it through Sidekiq that count is the small half. (#120)
+
+- **The context no longer carries `static_parse` as a database name.**
+  `SchemaIntrospector` writes that placeholder when it reads a dump instead of
+  the connection, and laundering it at each rendering surface left the ones
+  nobody thought of - `.ai-context.json` and `rails://schema` - naming a
+  database that does not exist beside a `multi_database` section in the same
+  file naming the real one. It is now resolved once, where the context is
+  assembled, so nothing downstream has to remember. The raw observation stays
+  under `adapter_source`. (#128)
+
+- **The static tier follows `draw` into `config/routes/*.rb`.** An app that
+  splits its routing table that way kept most of it in files the parser never
+  opened: `--no-boot` answered 94 routes on a 723-route app. Rails resolves
+  `draw(:admin)` by literal path, so following it is a plain file read; the
+  resolved path is confirmed inside `config/routes/` with `realpath` first, so
+  a symlink there cannot reach the rest of the disk. (#127)
+
+- **Every surface that prints a route count says how much of the table it
+  could not expand.** `RouteIntrospector` recorded `dynamic_routes` for
+  constructs it refused to fabricate (`devise_for`, a `draw` whose target is
+  computed or too large to parse) and nothing read it, so `rails_get_routes`,
+  `rails_onboard`, `CLAUDE.md`, the Cursor and Copilot rule files, the markdown
+  context and the rake summary all quoted a partial count as the whole routing
+  table. `RouteCoverage` is the one answer they now share, shaped as a suffix
+  so no call site needs a conditional of its own - nine each having to remember
+  is what produced this. A `draw` whose routes are in the list does not count,
+  whether this pass read the file or an earlier branch did; one stopped by the
+  depth cap, or naming a file too large to parse, does. A drawn file that
+  cannot be parsed costs its own routes rather than the whole section. (#127)
+
+- **The static tier counts an update route once.** Rails registers PATCH and
+  PUT separately for one action and every surface that lists routes merges
+  them, but the static total did not - so the generated files said "8 total"
+  where `rails_get_routes`, which merges for itself, said 7 on the same
+  `resources :posts`. (#127)
+
+### Changed
+
+- `actionmailer` and `puma` are development dependencies now. Without
+  ActionMailer loaded, `ActionMailer::Base` is undefined and every assertion
+  about mailer actions passed over an empty array; the Puma single-mode pin is
+  only testable against Puma's own option semantics. Neither affects the
+  gem's runtime dependencies. (#123, #126)
+
 ## [5.20.2] - 2026-08-11
 
 ### Fixed

data/docs/CONFIGURATION.md

@@ -114,7 +114,7 @@ preset: full
 | `max_search_results` | Integer | `200` | Maximum search results |
 | `max_validate_files` | Integer | `50` | Maximum files for validation |
 | `search_extensions` | Array | `["rb", "js", "erb", "yml", "yaml", "json", "ts", "tsx", "vue", "svelte", "haml", "slim"]` | File extensions to search |
-| `concern_paths` | Array | `["app/models/concerns", "app/controllers/concerns"]` | Paths to scan for concerns |
+| `concern_paths` | Array | `nil` (discovers `app/*/concerns`) | Paths to scan for concerns. Setting it replaces discovery, so it can narrow as well as widen |
 | `frontend_paths` | Array | `nil` (auto-detect) | Override frontend file paths |
 | `extra_app_paths` | Array | `[]` | Extra directories under the app root to treat as application code |
 

data/docs/GUIDE.md

@@ -1285,8 +1285,10 @@ if defined?(RailsAiContext)
     # File extensions for Ruby fallback search
     # config.search_extensions = %w[rb js erb yml yaml json ts tsx vue svelte haml slim]
 
-    # Where to look for concern source files
-    # config.concern_paths = %w[app/models/concerns app/controllers/concerns]
+    # Where to look for concern source files. Left unset, every
+    # app/*/concerns directory is discovered. Setting this replaces
+    # that list, so it can narrow as well as reach outside app/.
+    # config.concern_paths = %w[app/models/concerns lib/concerns]
 
     # --- Live reload ---
 
@@ -1352,7 +1354,7 @@ end
 | `excluded_filters` | Array | `verify_authenticity_token`, etc. | Framework filter names hidden from controller output |
 | `excluded_middleware` | Array | standard Rails middleware | Default middleware hidden from config output |
 | `search_extensions` | Array | `rb js erb yml yaml json ts tsx vue svelte haml slim` | File extensions for Ruby fallback search |
-| `concern_paths` | Array | `app/models/concerns app/controllers/concerns` | Where to look for concern source files |
+| `concern_paths` | Array | `nil` (discovers `app/*/concerns`) | Where to look for concern source files. Setting it replaces discovery |
 
 ### Root file generation
 

data/gemfiles/prism_floor.gemfile

@@ -15,6 +15,8 @@ rails_version = ENV.fetch("RAILS_VERSION", "8.0")
 group :development, :test do
   gem "railties", "~> #{rails_version}.0"
   gem "activerecord", "~> #{rails_version}.0"
+  gem "actionmailer", "~> #{rails_version}.0"
+  gem "puma"
   gem "sqlite3"
   gem "logger"
 end

data/gemfiles/prism_head.gemfile

@@ -14,6 +14,8 @@ rails_version = ENV.fetch("RAILS_VERSION", "8.0")
 group :development, :test do
   gem "railties", "~> #{rails_version}.0"
   gem "activerecord", "~> #{rails_version}.0"
+  gem "actionmailer", "~> #{rails_version}.0"
+  gem "puma"
   gem "sqlite3"
   gem "logger"
 end

data/lib/generators/rails_ai_context/install/install_generator.rb

@@ -311,8 +311,10 @@ module RailsAiContext
             # File extensions for fallback search (when ripgrep unavailable)
             # config.search_extensions = %w[rb js erb yml yaml json ts tsx vue svelte haml slim]
 
-            # Where to look for concern source files
-            # config.concern_paths = %w[app/models/concerns app/controllers/concerns]
+            # Where to look for concern source files. Left unset, every
+            # app/*/concerns directory is discovered. Setting this replaces
+            # that list, so it can narrow as well as reach outside app/.
+            # config.concern_paths = %w[app/models/concerns lib/concerns]
         SECTION
         "Frontend" => <<~SECTION
             # ── Frontend Framework Detection ─────────────────────────────────

data/lib/rails_ai_context/concern_paths.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  # One answer to "where does this app keep its concerns", for every surface
+  # that lists or counts them.
+  #
+  # `GetConcern` hardcoded two directories and `ActiveSupportIntrospector`
+  # hardcoded five, so a single run answered 80 concerns and 81 concerns for
+  # the same app, and the mailer concern only the second one found could not be
+  # reached through the first at all. Neither list matches Rails, which
+  # autoloads these paths by glob - `Rails::Engine::Configuration#paths` adds
+  # `app` with `glob: "{*,*/concerns}"` - so any hardcoded list is one entry
+  # behind an app that keeps `app/serializers/concerns`.
+  module ConcernPaths
+    module_function
+
+    # @param root [String] application root
+    # @return [Array<String>] absolute concern directories that exist
+    def resolve(root)
+      # An app that names its concern directories means those and no others -
+      # the setting has to be able to narrow, or it only ever adds noise. It is
+      # unset by default, which is what asks for discovery.
+      configured = RailsAiContext.configuration.concern_paths
+      dirs =
+        if configured.nil?
+          Dir.glob(File.join(root, "app", "*", "concerns"))
+        else
+          # A path that is already absolute is taken as given; `File.join`
+          # would graft it onto the root and point at nothing.
+          Array(configured).map { |rel| File.absolute_path?(rel) ? rel : File.join(root, rel) }
+        end
+
+      dirs.uniq.select { |dir| Dir.exist?(dir) }.sort
+    end
+
+    # The owner segment names the type: `app/mailers/concerns` holds mailer
+    # concerns. Singular so a filter reads `type: "mailer"`.
+    def type_for(dir)
+      segment = dir[%r{/app/([^/]+)/concerns/?\z}, 1]
+      segment ? segment.singularize : "other"
+    end
+
+    # Source file for a concern named by its constant, or nil.
+    #
+    # @param root [String] application root
+    # @param concern_name [String] constant name, e.g. "BulkMailSettingsConcern"
+    def find_file(root, concern_name)
+      underscore = concern_name.to_s.underscore
+      return nil if underscore.empty? || underscore.include?("..")
+
+      resolve(root)
+        .map { |dir| File.join(dir, "#{underscore}.rb") }
+        .find { |path| File.exist?(path) }
+    end
+  end
+end

data/lib/rails_ai_context/configuration.rb

@@ -230,7 +230,7 @@ module RailsAiContext
 
     # Search and file discovery
     attr_accessor :search_extensions      # File extensions for Ruby fallback search (default: rb,js,erb,yml,yaml,json)
-    attr_accessor :concern_paths          # Where to look for concern source files (default: app/models/concerns)
+    attr_accessor :concern_paths          # Where to look for concern source files (default: nil, discovers app/*/concerns)
 
     # Frontend framework detection (optional overrides - auto-detected if nil)
     attr_accessor :frontend_paths         # User-declared frontend dirs (e.g. ["app/frontend", "../web-client"])
@@ -307,7 +307,7 @@ module RailsAiContext
       @ai_tools                 = nil
       @tool_mode                = :mcp
       @search_extensions        = %w[rb js erb yml yaml json ts tsx vue svelte haml slim]
-      @concern_paths            = %w[app/models/concerns app/controllers/concerns]
+      @concern_paths            = nil
       @frontend_paths           = nil
       @extra_app_paths          = []
       @query_timeout            = 5

data/lib/rails_ai_context/introspector.rb

@@ -48,6 +48,8 @@ module RailsAiContext
       end
       context[:_warnings] = warnings if warnings.any?
 
+      resolve_schema_adapter(context)
+
       context
     end
 
@@ -99,6 +101,41 @@ module RailsAiContext
 
     private
 
+    # `SchemaIntrospector` writes `static_parse` when it read a dump instead of
+    # the connection, and every surface that rendered the section raw named a
+    # database that does not exist. Fixing that one surface at a time meant
+    # `.ai-context.json` and `rails://schema` still disagreed with the
+    # multi_database section of the same file. Resolving it here means the
+    # context never carries the placeholder, so nothing downstream has to
+    # remember. The raw observation stays under `adapter_source` for a reader
+    # that needs to know the schema was parsed rather than observed.
+    #
+    # Runs after the loop: the answer comes from the database config and gem
+    # list, which are sections of this same context.
+    #
+    # Rescued for the same reason the loop above is: this reads two other
+    # sections, and a malformed one raising here would cost the whole context
+    # rather than one entry. The placeholder surviving is the honest failure.
+    def resolve_schema_adapter(context)
+      schema = context[:schema]
+      return unless schema.is_a?(Hash) && !schema[:error]
+      # Only correct a claim that was made. A missing or nil adapter said
+      # nothing about the database, and answering for it would be the
+      # fabrication this method exists to remove.
+      return if schema[:adapter].nil?
+      return unless SchemaAdapter.placeholder?(schema[:adapter])
+
+      # "unknown" is a placeholder too. Swapping one for another buys nothing
+      # and would bury the parse mode that at least says how the schema was read.
+      resolved = SchemaAdapter.label(context)
+      return if SchemaAdapter.placeholder?(resolved)
+
+      schema[:adapter_source] = schema[:adapter]
+      schema[:adapter] = resolved
+    rescue StandardError => e
+      RailsAiContext.log_warn "[rails-ai-context] schema adapter resolution failed: #{e.message}"
+    end
+
     def app_name
       return File.basename(app.root.to_s) if app.is_a?(RailsAiContext::StaticApp)
 

data/lib/rails_ai_context/introspectors/active_support_introspector.rb

@@ -55,19 +55,10 @@ module RailsAiContext
         app.root.to_s
       end
 
-      CONCERN_DIRS = %w[
-        app/models/concerns
-        app/controllers/concerns
-        app/jobs/concerns
-        app/mailers/concerns
-        app/channels/concerns
-      ].freeze
-
       def extract_concerns
         result = {}
-        CONCERN_DIRS.each do |rel_dir|
-          dir = File.join(root, rel_dir)
-          next unless Dir.exist?(dir)
+        ConcernPaths.resolve(root).each do |dir|
+          rel_dir = dir.sub("#{root}/", "")
 
           modules = Dir.glob(File.join(dir, "**/*.rb")).sort.filter_map do |path|
             content = RailsAiContext::SafeFile.read(path) or next

data/lib/rails_ai_context/introspectors/auth_introspector.rb

@@ -132,8 +132,13 @@ module RailsAiContext
         # Pundit
         policies_dir = File.join(root, "app/policies")
         if Dir.exist?(policies_dir)
+          # Named from the path relative to app/policies, not the basename:
+          # Zeitwerk makes admin/collection_policy.rb `Admin::CollectionPolicy`,
+          # and demodulizing it collided with the top-level policy of the same
+          # base name, so one name was listed twice and the other class could
+          # not be reached from the context at all.
           policies = Dir.glob(File.join(policies_dir, "**/*.rb")).map do |f|
-            File.basename(f, ".rb").camelize
+            f.sub("#{policies_dir}/", "").delete_suffix(".rb").camelize
           end.sort
           authz[:pundit] = policies if policies.any?
         end

data/lib/rails_ai_context/introspectors/controller_introspector.rb

@@ -164,18 +164,76 @@ module RailsAiContext
       end
 
       # Prefer source-based parsing for actions - always reflects current file state.
-      # Falls back to reflection for controllers without readable source files.
+      #
+      # `action_methods` used to answer for a controller whose own file defines
+      # no public method, and it cannot: it subtracts inherited methods only as
+      # far as the nearest abstract ancestor, which is ActionController::Base.
+      # Everything ApplicationController and its concerns define publicly came
+      # back as an action, so a two-route controller reported 19 of them, most
+      # named things like `set_locale` and `pundit_user`.
+      #
+      # A thin subclass does still serve actions - its parent defines them - so
+      # the answer comes from the parent's source instead.
       def extract_actions(ctrl, source = nil)
-        if source
-          actions = extract_actions_from_source(source)
-          return actions if actions.any?
-        end
-        ctrl.action_methods.to_a.sort
+        own = extract_actions_from_source(source) if source
+        return own if own&.any?
+
+        inherited, unreadable_ancestor = inherited_actions(ctrl)
+        return inherited if inherited.any?
+
+        # An ancestor exists that this app does not own the source of, so what
+        # it defines is invisible here. `rails g devise:controllers` writes
+        # exactly this: the app owns the file, every action in it is commented
+        # out, and the gem class supplies them. Reflection brings inherited
+        # helpers along, which is worse than the alternative only if the
+        # alternative is not claiming the controller serves nothing.
+        return ctrl.action_methods.to_a.sort if unreadable_ancestor || source.nil?
+
+        # Every ancestor was readable and none defines an action. That is an
+        # answer, and reflection would only overwrite it with helpers.
+        []
       rescue => e
         $stderr.puts "[rails-ai-context] extract_actions failed: #{e.message}" if ENV["DEBUG"]
         []
       end
 
+      # The nearest ancestor in the app that defines actions of its own.
+      #
+      # The walk stops at ApplicationController by convention: it is where an
+      # app puts the helpers every controller shares, not actions, and reading
+      # it is what produced the leak above. A base class that only sets up
+      # filters contributes nothing and the walk continues past it.
+      #
+      # Returns the actions and whether the walk passed an ancestor whose
+      # source it could not read, which is what tells an empty answer apart
+      # from one this app cannot see.
+      def inherited_actions(ctrl)
+        unreadable = false
+        klass = ctrl.superclass
+        while klass&.name && !framework_controller?(klass) && !app_base_controller?(klass)
+          src = read_source(klass)
+          if src
+            actions = extract_actions_from_source(src)
+            return [ actions, unreadable ] if actions.any?
+          else
+            unreadable = true
+          end
+          klass = klass.superclass
+        end
+        [ [], unreadable ]
+      end
+
+      def framework_controller?(klass)
+        return true if klass.name.start_with?("ActionController::", "AbstractController::")
+        return true if klass == ActionController::Base
+        return true if defined?(ActionController::API) && klass == ActionController::API
+        false
+      end
+
+      def app_base_controller?(klass)
+        klass.name == "ApplicationController" || klass.name.end_with?("::ApplicationController")
+      end
+
       def extract_actions_from_source(source)
         ast_result = SourceIntrospector.walk_source(source, {
           methods: Listeners::MethodsListener
@@ -236,11 +294,7 @@ module RailsAiContext
       def collect_source_constraints(ctrl, current_source = nil)
         constraints = {}
         klass = ctrl
-        while klass && klass.name
-          break if klass.name.start_with?("ActionController::", "AbstractController::")
-          break if klass == ActionController::Base
-          break if defined?(ActionController::API) && klass == ActionController::API
-
+        while klass&.name && !framework_controller?(klass)
           src = (klass == ctrl) ? (current_source || read_source(klass)) : read_source(klass)
           if src
             extract_filters_from_source(src).each do |sf|

data/lib/rails_ai_context/introspectors/job_introspector.rb

@@ -2,8 +2,10 @@
 
 module RailsAiContext
   module Introspectors
-    # Discovers background jobs (ActiveJob/Sidekiq), mailers,
-    # and Action Cable channels.
+    # Discovers ActiveJob jobs, mailers, and Action Cable channels. Sidekiq
+    # reaches this only as config/sidekiq.yml: a class that includes
+    # Sidekiq::Worker without subclassing ActiveJob::Base is not a descendant
+    # and does not live in app/jobs/, so neither pass here finds it.
     class JobIntrospector
       extend StaticTier
       static_tier :alternate_source
@@ -52,6 +54,7 @@ module RailsAiContext
         ActiveJob::Base.descendants.filter_map do |job|
           next if job.name.nil? || job.name == "ApplicationJob" ||
                   job.name.start_with?("ActionMailer", "ActiveStorage::", "ActionMailbox::", "Turbo::", "Sentry::")
+          next unless app_defined?(job)
 
           queue = job.queue_name
           queue = "dynamic" if queue.is_a?(Proc)
@@ -67,6 +70,26 @@ module RailsAiContext
         []
       end
 
+      # `descendants` is every ActiveJob subclass in the process, and the name
+      # prefixes above only cover the framework's own - a job from any other gem
+      # was counted as the app's. Where the class is defined answers it for gems
+      # the list has never heard of. A class with no source location stays:
+      # dropping one would understate what the app runs.
+      def app_defined?(job)
+        location = Object.const_source_location(job.name)&.first
+        return true unless location
+
+        File.realpath(location).start_with?("#{app_root_real}/")
+      rescue NameError, ArgumentError, TypeError, SystemCallError
+        true
+      end
+
+      def app_root_real
+        @app_root_real ||= File.realpath(app.root.to_s)
+      rescue SystemCallError
+        @app_root_real = app.root.to_s
+      end
+
       def extract_jobs_from_source
         jobs_dir = File.join(app.root, "app", "jobs")
         return [] unless Dir.exist?(jobs_dir)
@@ -255,10 +278,11 @@ module RailsAiContext
         []
       end
 
-      # A mailer's actions are its public instance methods. The booted side asks
-      # `action_methods`, which also subtracts inherited and internal ones - the
-      # AST cannot see that, so a public helper on a concrete mailer is still
-      # listed here and not there.
+      # A mailer's actions are its public instance methods, and the AST sees
+      # one file at a time. `action_methods` counts the public methods a mailer
+      # inherits too, so a public helper on a base class is an action the
+      # booted tier reports and this one cannot - the entries are tagged STATIC
+      # for that reason.
       def extract_mailers_from_source
         source_classes(File.join(app.root, "app", "mailers")).filter_map do |name, methods|
           next if name == "ApplicationMailer"

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

@@ -45,10 +45,17 @@ module RailsAiContext
             method:      "fetch",
             key:         key,
             has_default: args.size > 1 || !node.block.nil?,
+            # nil unless the fallback is a value that can be printed as one.
+            # `ENV.fetch("PORT", defaults[:port])` has a default, but naming
+            # it `defaults[:port]` puts a Ruby expression where a reader
+            # expects something to copy into a .env file.
+            default:     literal_value(args[1]),
             location:    node.location.start_line
           }
         end
 
+        # An interpolated name has no value at parse time, so it is not a
+        # variable name and this returns nil for it.
         def string_value(node)
           case node
           when Prism::StringNode then node.unescaped
@@ -56,6 +63,18 @@ module RailsAiContext
           else nil
           end
         end
+
+        def literal_value(node)
+          case node
+          when Prism::StringNode  then node.unescaped
+          when Prism::SymbolNode  then ":#{node.value}"
+          when Prism::IntegerNode, Prism::FloatNode then node.value.to_s
+          when Prism::TrueNode    then "true"
+          when Prism::FalseNode   then "false"
+          when Prism::NilNode     then "nil"
+          else nil
+          end
+        end
       end
     end
   end