rails-ai-context 5.30.2 → 5.32.0

data/lib/rails_ai_context/tools/get_test_info.rb

@@ -51,7 +51,10 @@ module RailsAiContext
           when "summary"
             lines = [ "# Test Infrastructure", "" ]
             lines << "- **Framework:** #{data[:framework]}"
-            lines << "- **Factories:** #{count_phrase(data[:factories][:count], "file")}" if data[:factories]
+            lines.concat(suite_lines)
+            lines << "- **Factories:** #{RailsAiContext::TestFramework.factory_files_phrase(data[:factories]) || data[:factories][:location]}" if data[:factories]
+            lines << "- **Fabricators:** #{count_phrase(data[:fabricators][:count], "file")}" if data[:fabricators]
+            lines << "- **Cucumber:** #{count_phrase(data[:cucumber][:count], "feature file")}" if data[:cucumber]
             lines << "- **Fixtures:** #{RailsAiContext::TestFramework.fixture_phrase(data[:fixtures])}" if data[:fixtures]
             if data[:test_files]&.any?
               total = data[:test_files].values.sum { |v| v[:count] }
@@ -63,11 +66,15 @@ module RailsAiContext
           when "standard"
             lines = [ "# Test Infrastructure", "" ]
             lines << "- **Framework:** #{data[:framework]}"
-            lines << "- **Factories:** #{data[:factories][:location]} (#{count_phrase(data[:factories][:count], "file")})" if data[:factories]
+            lines.concat(suite_lines)
+            lines << "- **Factories:** #{RailsAiContext::TestFramework.factory_location(data[:factories])}" if data[:factories]
+            lines << "- **Fabricators:** #{data[:fabricators][:location]} (#{count_phrase(data[:fabricators][:count], "file")})" if data[:fabricators]
+            lines << cucumber_line(data[:cucumber]) if data[:cucumber]
             lines << "- **Fixtures:** #{data[:fixtures][:location]} (#{RailsAiContext::TestFramework.fixture_phrase(data[:fixtures])})" if data[:fixtures]
             lines << "- **System tests:** #{data[:system_tests][:location]}" if data[:system_tests]
             lines << "- **CI:** #{data[:ci_config].join(', ')}" if data[:ci_config]&.any?
             lines << "- **Coverage:** #{data[:coverage]}" if data[:coverage]
+            lines.concat(ci_step_lines(data[:ci_steps], data[:ci_steps_dir]))
 
             if data[:test_files]&.any?
               lines << "" << "## Test Files"
@@ -92,35 +99,43 @@ module RailsAiContext
           when "full"
             lines = [ "# Test Infrastructure (Full Detail)", "" ]
             lines << "- **Framework:** #{data[:framework]}"
+            lines.concat(suite_lines)
             lines << "- **CI:** #{data[:ci_config].join(', ')}" if data[:ci_config]&.any?
             lines << "- **Coverage:** #{data[:coverage]}" if data[:coverage]
+            lines << cucumber_line(data[:cucumber]) if data[:cucumber]
+            lines.concat(ci_step_lines(data[:ci_steps], data[:ci_steps_dir]))
 
             lines.concat(trait_lines(data[:factory_traits], 20))
 
             if data[:fixture_names]&.any?
               lines << "" << "## Fixtures"
-              parsed_fixtures = parse_all_fixture_contents
-              if parsed_fixtures.any?
-                parsed_fixtures.each do |file, entries|
-                  lines << "- **#{file}:**"
-                  entries.each do |entry_name, attrs|
-                    attr_str = attrs.map { |k, v| "#{k}: #{v}" }.join(", ")
-                    lines << "  - `#{entry_name}`: #{attr_str}"
-                  end
+              parsed_fixtures = parse_all_fixture_contents(data[:fixtures])
+              data[:fixture_names].each do |set, labels|
+                entries = parsed_fixtures[set.to_s]
+                unless entries.is_a?(Hash)
+                  why = entries == :too_large ? "over the #{max_test_file_size} byte read limit" : "not parsed as YAML"
+                  erb_labels = Array((data[:fixture_erb_labels] || {})[set]).map { |label| "`#{label}` (set by ERB)" }
+                  lines << "- **#{set}:** #{(Array(labels) + erb_labels).join(', ')} _(#{why}; labels only)_"
+                  next
                 end
 
-                # Fixture relationships section
-                relationships = extract_fixture_relationships(parsed_fixtures)
-                if relationships.any?
-                  lines << "" << "## Fixture Relationships"
-                  relationships.each do |parent, children|
-                    lines << "- **#{parent}** ← #{children.join(', ')}"
+                lines << "- **#{set}:**"
+                entries.each do |entry_name, attrs|
+                  attr_str = attrs.map { |k, v| "#{k}: #{erb_shown(v)}" }.join(", ")
+                  label = if RailsAiContext::ConfigYaml.marked?(entry_name.to_s)
+                    "`#{erb_shown(entry_name)}` _(label set by ERB)_"
+                  else
+                    "`#{entry_name}`"
                   end
+                  lines << (attr_str.empty? ? "  - #{label}" : "  - #{label}: #{attr_str}")
                 end
-              else
-                # Fallback to simple names if parsing fails
-                data[:fixture_names].each do |file, names|
-                  lines << "- **#{file}:** #{names.join(', ')}"
+              end
+
+              relationships = extract_fixture_relationships(parsed_fixtures.select { |_, entries| entries.is_a?(Hash) })
+              if relationships.any?
+                lines << "" << "## Fixture Relationships"
+                relationships.each do |parent, children|
+                  lines << "- **#{parent}** ← #{children.join(', ')}"
                 end
               end
             end
@@ -137,6 +152,11 @@ module RailsAiContext
               end
             end
 
+            if data[:fabricator_names]&.any?
+              lines << "" << "## Fabricators"
+              data[:fabricator_names].each { |file, names| lines << "- **#{file}:** #{names.join(', ')}" }
+            end
+
             if data[:test_helper_setup]&.any?
               lines << "" << "## Test Helper Setup"
               data[:test_helper_setup].each { |m| lines << "- `#{m}`" }
@@ -163,6 +183,32 @@ module RailsAiContext
         RailsAiContext.configuration.max_test_file_size
       end
 
+      # An engine's test/dummy is tested by the engine's suite, which every path here is under.
+      private_class_method def self.suite_root
+        RailsAiContext::PathResolver.test_root(rails_app.root.to_s)
+      end
+
+      private_class_method def self.erb_shown(text)
+        RailsAiContext::ConfigYaml.shown(text)
+      end
+
+      private_class_method def self.shown(rel)
+        RailsAiContext::PathResolver.suite_relative(rails_app.root.to_s, rel)
+      end
+
+      private_class_method def self.suite_lines
+        app_root = rails_app.root.to_s
+        if suite_root == app_root
+          return unread_suite_gemfile ? [ "- **Suite:** not read: #{RailsAiContext::GemLock.for(app_root).unread_bundle}" ] : []
+        end
+
+        [ "- **Suite:** the engine's, at `#{RailsAiContext::PathResolver.suite_relative(app_root, ".")}`; the paths below are under it" ]
+      end
+
+      private_class_method def self.unread_suite_gemfile
+        RailsAiContext::TestFramework.unread_gemfile(suite_root) if suite_root == rails_app.root.to_s
+      end
+
       private_class_method def self.find_test_file(name, type, detail = "full")
         # Normalize: accept "Admin::PostsController", "admin/posts", "Posts", "posts" (plural)
         snake = case type
@@ -184,13 +230,13 @@ module RailsAiContext
         refused = refuse_unsafe_paths([ name ])
         return refused if refused
 
-        candidates = RailsAiContext::TestFramework.candidates(rails_app.root.to_s, type, snake, cached_context)
+        candidates = RailsAiContext::TestFramework.candidates(suite_root, type, snake, cached_context)
         exercising = type == :controller ? exercising_tests(snake, candidates) : []
 
         contained = []
         too_large = nil
         candidates.each do |rel|
-          content, resolution = RailsAiContext::SafePath.read(rel, under: rails_app.root.to_s, max_size: max_test_file_size)
+          content, resolution = RailsAiContext::SafePath.read(rel, under: suite_root, max_size: max_test_file_size)
           contained << rel unless ESCAPING_REFUSALS.include?(resolution.refusal)
           too_large ||= resolution if resolution.refusal == :too_large
           next unless content
@@ -198,15 +244,15 @@ module RailsAiContext
           # Summary/standard: return just test names (saves 2000+ tokens vs full source)
           answer = if names_only?(detail)
             listed = examples(content)
-            "# #{rel} (#{count_phrase(listed.size, "test")})\n\n#{listed.join("\n")}"
+            "# #{shown(rel)} (#{count_phrase(listed.size, "test")})\n\n#{listed.join("\n")}"
           else
-            "# #{rel}\n\n```ruby\n#{content}\n```"
+            "# #{shown(rel)}\n\n```ruby\n#{content}\n```"
           end
           return text_response(answer + exercising_section(exercising, "## Also exercised by"))
         end
 
         if too_large
-          return text_response("# #{too_large.relative}\n\n_The test file exists but was not read: #{human_size(File.size(too_large.realpath))} is over " \
+          return text_response("# #{shown(too_large.relative)}\n\n_The test file exists but was not read: #{human_size(File.size(too_large.realpath))} is over " \
                                "`max_test_file_size` (#{human_size(max_test_file_size)})._" +
                                exercising_section(exercising, "## Also exercised by"))
         end
@@ -222,7 +268,9 @@ module RailsAiContext
                                 "or names a sensitive file.")
         end
 
-        empty_response("No test file found for #{name}. Searched: #{contained.join(', ')}#{nearby_tests_hint(contained)}")
+        unread = unread_suite_gemfile
+        unread &&= "\n\nNot searched: the engine's suite at `#{File.dirname(unread)}` is not read, #{RailsAiContext::GemLock.for(suite_root).unread_bundle}."
+        empty_response("No test file found for #{name}. Searched: #{contained.map { |rel| shown(rel) }.join(', ')}#{nearby_tests_hint(contained)}#{unread}")
       end
 
       # Where a controller is driven from outside its own test, and what each
@@ -239,7 +287,7 @@ module RailsAiContext
       #
       # @return [Array<Array(String, String, String)>] [path, kind, source]
       private_class_method def self.exercising_tests(snake, primary)
-        root = rails_app.root.to_s
+        root = suite_root
         real_root = File.realpath(root)
         routes = Array(RouteCoverage.all_by_controller(cached_context[:routes])[snake])
         helpers = routes.filter_map { |route| route[:name] }.uniq
@@ -271,7 +319,7 @@ module RailsAiContext
         lines = heading ? [ "", "", heading, "" ] : [ "", "" ]
         found.first(MAX_EXERCISING).each do |rel, kind, source|
           listed = examples(source)
-          lines << "- `#{rel}` (#{kind}, #{count_phrase(listed.size, "test")})"
+          lines << "- `#{shown(rel)}` (#{kind}, #{count_phrase(listed.size, "test")})"
           listed.each { |test| lines << "  #{test}" } if names
         end
         lines << "- ... #{found.size - MAX_EXERCISING} more" if found.size > MAX_EXERCISING
@@ -306,7 +354,7 @@ module RailsAiContext
       # Nearby test files, to help the agent find the right one. The glob base
       # is the realpath, so a symlinked test directory cannot widen it.
       private_class_method def self.nearby_tests_hint(candidates)
-        root = rails_app.root.to_s
+        root = suite_root
         real_root = File.realpath(root)
 
         nearby = candidates.map { |rel| File.dirname(File.join(root, rel)) }.uniq.flat_map do |dir|
@@ -315,7 +363,7 @@ module RailsAiContext
           real_dir = File.realpath(dir)
           next [] unless RailsAiContext::SafePath.contained?(real_dir, real_root)
 
-          Dir.glob(File.join(real_dir, "*")).map { |f| f.delete_prefix("#{real_root}/") }.first(10)
+          Dir.glob(File.join(real_dir, "*")).map { |f| shown(f.delete_prefix("#{real_root}/")) }.first(10)
         end
 
         nearby.any? ? "\n\nFiles in test directory: #{nearby.join(', ')}" : ""
@@ -323,6 +371,18 @@ module RailsAiContext
         ""
       end
 
+      private_class_method def self.cucumber_line(cucumber)
+        "- **Cucumber:** #{cucumber[:location]} (#{count_phrase(cucumber[:count], "feature file")}, " \
+          "#{count_phrase(cucumber[:step_definitions].to_i, "step definition file")})"
+      end
+
+      private_class_method def self.ci_step_lines(steps, dir)
+        return [] unless steps.is_a?(Array) && steps.any?
+
+        [ "", "## CI Steps (`#{dir}config/ci.rb`, run by `#{dir}bin/ci`)" ] +
+          steps.map { |step| "- #{step[:name]}: `#{step[:command]}`" }
+      end
+
       private_class_method def self.trait_lines(traits, limit)
         return [] unless traits.is_a?(Hash) && traits.any?
 
@@ -364,13 +424,13 @@ module RailsAiContext
           # Detect Devise + sign_in pattern from existing tests
           has_devise = false
           has_sign_in = false
-          test_dir = rails_app.root.join("test").to_s
+          test_dir = File.join(suite_root, "test")
           if Dir.exist?(test_dir)
-            real_root = File.realpath(rails_app.root).to_s
+            real_root = File.realpath(suite_root).to_s
             safe_glob(test_dir, "**/*_test.rb", real_root).first(5).each do |path|
               content = RailsAiContext::SafeFile.read(path) or next
               has_devise = true if content.include?("Devise::Test")
-              has_sign_in = true if content.include?("sign_in")
+              has_sign_in = true if content.match?(/\bsign_in\b/)
             end
           end
 
@@ -433,10 +493,10 @@ module RailsAiContext
       private_class_method def self.parse_factory_details(relative_path)
         # Try common factory locations
         candidates = [
-          rails_app.root.join("spec/factories/#{relative_path}"),
-          rails_app.root.join("test/factories/#{relative_path}"),
-          rails_app.root.join("spec/factories", relative_path),
-          rails_app.root.join("test/factories", relative_path)
+          File.join(suite_root, "spec/factories/#{relative_path}"),
+          File.join(suite_root, "test/factories/#{relative_path}"),
+          File.join(suite_root, "spec/factories", relative_path),
+          File.join(suite_root, "test/factories", relative_path)
         ]
         path = candidates.find { |p| File.exist?(p) }
         return nil unless path
@@ -464,62 +524,68 @@ module RailsAiContext
         RailsAiContext.debug_fail(e, nil, label: "parse_factory_details")
       end
 
-      # Parse a single fixture YAML file, returning a hash of entry_name => filtered attributes
+      FIXTURE_SKIP_KEYS = %w[created_at updated_at id].freeze
+
+      FIXTURE_VALUE_LIMIT = 100
+
+      # A fixture file's labels and their short attributes as text, :too_large
+      # past the read limit, or nil when it was not read or does not parse.
       private_class_method def self.parse_fixture_contents(file_path)
-        return {} unless File.exist?(file_path)
-        return {} if File.size(file_path) > max_test_file_size
-
-        require "yaml"
-        content = RailsAiContext::SafeFile.read(file_path)
-        return {} unless content
-        # Handle ERB-templated fixtures: replace "<%=...%>" (with surrounding quotes) and bare <%...%>
-        content = content.gsub(/"<%=.*?%>"/, '"erb_value"')
-        content = content.gsub(/'<%=.*?%>'/, "'erb_value'")
-        content = content.gsub(/<%.*?%>/, "erb_value")
-        parsed = YAML.safe_load(content, permitted_classes: [ Date, Time, Symbol ]) rescue nil
-        return {} unless parsed.is_a?(Hash)
-
-        skip_keys = %w[created_at updated_at id]
-        entries = {}
-
-        parsed.each do |entry_name, attributes|
-          next unless attributes.is_a?(Hash)
-          filtered = {}
-          attributes.each do |key, value|
-            next if skip_keys.include?(key.to_s)
-            str_value = value.to_s
-            next if str_value.length > 100
-            filtered[key] = value
+        return :too_large if File.size(file_path) > max_test_file_size
+
+        content = RailsAiContext::SafeFile.read(file_path, max_size: max_test_file_size) or return nil
+        parsed = RailsAiContext::FixtureKeys.parse(content) or return nil
+
+        parsed.transform_values do |attributes|
+          attributes.each_with_object({}) do |(key, value), shown|
+            next if FIXTURE_SKIP_KEYS.include?(key.to_s)
+
+            text = short_text(value)
+            shown[key] = text if text
           end
-          entries[entry_name] = filtered if filtered.any?
         end
+      end
 
-        entries
-      rescue => e
-        {}
+      # The value as text when it is short, else nil. A container is sized
+      # before to_s runs, since YAML aliases can nest one into an exponential
+      # string from a few lines.
+      private_class_method def self.short_text(value)
+        budget = FIXTURE_VALUE_LIMIT
+        pending = [ value ]
+        until pending.empty?
+          item = pending.pop
+          case item
+          when Hash then budget -= item.size; pending.concat(item.keys, item.values)
+          when Array then budget -= item.size; pending.concat(item)
+          else budget -= item.to_s.length
+          end
+          return nil if budget.negative?
+        end
+        text = value.to_s
+        text if text.length <= FIXTURE_VALUE_LIMIT
       end
 
-      # Parse all fixture files, returning { "fixture_file" => { entry => attrs } }
-      private_class_method def self.parse_all_fixture_contents
-        fixture_dirs = [
-          rails_app.root.join("test", "fixtures").to_s,
-          rails_app.root.join("spec", "fixtures").to_s
-        ]
-        real_root = File.realpath(rails_app.root).to_s
+      # { set => entries, or nil when unparsed } over the fixture directories
+      # the introspector found, each set named by its path under its directory.
+      private_class_method def self.parse_all_fixture_contents(fixtures)
+        return {} unless fixtures.is_a?(Hash)
 
+        root = suite_root
+        real_root = File.realpath(root)
         results = {}
-        fixture_dirs.each do |dir|
-          next unless Dir.exist?(dir)
-          safe_glob(dir, "**/*.yml", real_root).sort.each do |path|
-            rel_name = File.basename(path, ".yml")
-            entries = parse_fixture_contents(path)
-            results[rel_name] = entries if entries.any?
+        Array(fixtures[:locations]).each do |rel|
+          dir = File.join(root, rel)
+          Dir.glob(File.join(dir, "**", "*.yml")).sort.each do |path|
+            set = path.delete_prefix("#{dir}/").delete_suffix(".yml")
+            next if results.key?(set)
+
+            real = safe_glob_realpath(path, real_root, real_root) or next
+            results[set] = parse_fixture_contents(real)
           end
         end
-
         results
-      rescue => e
-        {}
+      rescue SystemCallError => e
+        RailsAiContext.debug_fail(e, {}, label: "parse_all_fixture_contents")
       end
 
       # Extract relationships: find foreign key references between fixtures
@@ -535,7 +601,11 @@ module RailsAiContext
 
         parsed_fixtures.each do |file, entries|
           entries.each do |entry_name, attrs|
+            entry_name = erb_shown(entry_name)
             attrs.each do |key, value|
+              # An id ERB computes names no row we can see.
+              next if RailsAiContext::ConfigYaml.marked?(value)
+
               # Foreign key pattern: key ends with _id and value matches an entry, or
               # key matches a fixture file name and value is a fixture entry reference
               str_value = value.to_s

data/lib/rails_ai_context/tools/get_view.rb

@@ -75,15 +75,21 @@ module RailsAiContext
             # commonly), so a controller filter that simply doesn't match
             # anything must not be reported as "views don't exist here".
             if templates.empty? && partials.empty?
-              note = api_only_note("app/views")
+              note = api_only_note("app/views", dir: "app/views")
               return text_response(note) if note
             end
 
             all_dirs = view_directories(templates, partials)
             suggestion = find_closest_match(ctrl_lower, all_dirs)
             hint = suggestion ? " Did you mean '#{suggestion}'?" : ""
-            dirs_note = all_dirs.any? ? " Directories with views: #{all_dirs.join(', ')}" : " No view directories found (API-only apps typically have none)."
-            return empty_response("No views for '#{controller}'.#{hint}#{dirs_note}")
+            dirs_note = if all_dirs.any?
+              " Directories with views: #{all_dirs.join(', ')}"
+            elsif layout_files.any?
+              " The app has only layouts, listed by `controller:\"layouts\"`."
+            else
+              " No view directories found (API-only apps typically have none)."
+            end
+            return empty_response([ "No views for '#{controller}'.#{hint}#{dirs_note}", static_engine_views_note ].compact.join("\n\n"))
           end
 
           templates = filtered_templates
@@ -94,7 +100,7 @@ module RailsAiContext
         # genuinely has no views anywhere (as opposed to a filter simply not
         # matching anything, handled above).
         if controller.nil? && templates.empty? && partials.empty?
-          note = api_only_note("app/views")
+          note = api_only_note("app/views", dir: "app/views")
           return text_response(note) if note
         end
 
@@ -103,7 +109,7 @@ module RailsAiContext
         case detail
         when "summary"
           all_dirs = view_groups(templates, partials)
-          lines = views_header_lines(templates, partials, layouts)
+          lines = views_header_lines(templates, partials, layouts, controller: controller)
           all_dirs.each do |ctrl|
             ctrl_templates = views_in_group(templates, ctrl)
             ctrl_partials = views_in_group(partials, ctrl)
@@ -115,10 +121,12 @@ module RailsAiContext
               stim = meta[:stimulus]&.any? ? " stimulus: #{meta[:stimulus].join(', ')}" : ""
               comps = meta[:components]&.any? ? " components: #{meta[:components].join(', ')}" : ""
               phlex_tag = meta[:phlex] ? " [phlex]" : ""
-              lines << "- #{name} (#{count_phrase(meta[:lines], "line")}#{phlex_tag})#{parts}#{comps}#{stim}"
+              alternate = (note = view_alternate_of(name)) ? " #{note}" : ""
+              lines << "- #{name} (#{count_phrase(meta[:lines], "line")}#{phlex_tag})#{alternate}#{parts}#{comps}#{stim}"
             end
             ctrl_partials.sort.each do |name, meta|
-              lines << "- #{name} (#{count_phrase(meta[:lines], "line")})"
+              alternate = (note = view_alternate_of(name)) ? " #{note}" : ""
+              lines << "- #{name} (#{count_phrase(meta[:lines], "line")})#{alternate}"
             end
             lines << ""
           end
@@ -129,7 +137,7 @@ module RailsAiContext
           # want the same file's metadata.
           metadata = Hash.new { |h, name| h[name] = extract_view_metadata(name) }
           all_dirs = view_groups(templates, partials)
-          lines = views_header_lines(templates, partials, layouts)
+          lines = views_header_lines(templates, partials, layouts, controller: controller)
 
           # Form builders and component usage from views introspector
           form_builders = data[:form_builders_detected]
@@ -148,7 +156,7 @@ module RailsAiContext
 
             lines << "## #{group_heading(ctrl)}" unless controller && all_dirs.size == 1
             ctrl_templates.sort.each do |name, meta|
-              detail_parts = []
+              detail_parts = [ view_alternate_of(name) ].compact
               extra = metadata[name]
 
               if meta[:phlex]
@@ -178,7 +186,8 @@ module RailsAiContext
               helpers = meta[:helpers]&.any? ? " helpers: #{meta[:helpers].join(', ')}" : ""
               locals = extract_partial_locals(name, templates)
               locals_str = locals&.any? ? " **locals:** #{locals.join(', ')}" : ""
-              lines << "- #{name} (#{count_phrase(meta[:lines], "line")})#{fields}#{helpers}#{locals_str}"
+              alternate = (note = view_alternate_of(name)) ? " #{note}" : ""
+              lines << "- #{name} (#{count_phrase(meta[:lines], "line")})#{alternate}#{fields}#{helpers}#{locals_str}"
             end
             lines << ""
           end
@@ -198,7 +207,7 @@ module RailsAiContext
 
         when "full"
           if controller
-            lines = [ "# Views: #{controller}/", "" ]
+            lines = [ "# Views: #{controller}/", "", *layout_lines(controller) ]
             # Combine all content first for cross-template Tailwind compression
             all_content = []
             templates.sort.each do |name, _meta|
@@ -208,7 +217,7 @@ module RailsAiContext
               all_content << [ name, strip_svg(read_view_content(name)) ]
             end
             # Compress repeated Tailwind classes across all templates
-            combined = all_content.map { |name, c| "## #{name}\n```erb\n#{c}\n```\n" }.join("\n")
+            combined = all_content.map { |name, c| "## #{name}\n```#{RailsAiContext::ViewFile.fence(name)}\n#{c}\n```\n" }.join("\n")
             combined = compress_tailwind(combined)
             lines << combined
             text_response(lines.join("\n"))
@@ -223,6 +232,7 @@ module RailsAiContext
               count = views_in_group(templates, ctrl).size + views_in_group(partials, ctrl).size
               lines << "- `controller:\"#{ctrl}\"` (#{count_phrase(count, "file")})"
             end
+            lines << "- `controller:\"layouts\"` (#{count_phrase(layouts.size, "layout")})" if layouts.any?
             lines << "" << "_Or use `path:\"controller/action.html.erb\"` for a specific file._"
             text_response(lines.join("\n"))
           end
@@ -263,13 +273,20 @@ module RailsAiContext
 
       # Layouts sit outside the template and partial maps, so a heading naming
       # only those two numbers never added up to the files under app/views.
-      private_class_method def self.views_header_lines(templates, partials, layouts)
+      private_class_method def self.views_header_lines(templates, partials, layouts, controller: nil)
         parts = [ count_phrase(templates.size, "template"), count_phrase(partials.size, "partial") ]
         parts << count_phrase(layouts.size, "layout") if layouts.any?
 
         lines = [ "# Views (#{parts.join(', ')})", "" ]
+        lines << static_engine_views_note << "" if static_engine_views_note
         lines << "_Layouts are listed by `controller:\"layouts\"`._" << "" if layouts.any?
-        lines
+        lines + layout_lines(controller)
+      end
+
+      private_class_method def self.layout_lines(controller)
+        name = controller && RailsAiContext::Payload.find_controller(cached_context, controller)
+        layout = name && Introspectors::ControllerSettings.resolve(cached_context, name, root: rails_app.root.to_s)[:layout]
+        layout ? [ "**Layout:** #{Introspectors::ControllerSettings.layout_phrase(layout)}", "" ] : []
       end
 
       # The template map excludes app/views/layouts, so the directory is the
@@ -293,7 +310,7 @@ module RailsAiContext
           real = located.realpath
           if RailsAiContext::DetailLevel.full?(detail)
             content = RailsAiContext::SafeFile.read(real) || "(error reading)"
-            lines << "## #{relative}" << "```erb" << strip_svg(content) << "```" << ""
+            lines << "## #{relative}" << "```#{RailsAiContext::ViewFile.fence(relative)}" << strip_svg(content) << "```" << ""
           else
             content = RailsAiContext::SafeFile.read(real) || ""
             lines << "- #{relative} (#{count_phrase(content.lines.size, "line")})"
@@ -313,7 +330,7 @@ module RailsAiContext
           siblings = RailsAiContext::ViewFile.each(rails_app.root.to_s, File.join(dir, "*"))
             .map { |_file, relative| relative }.sort.first(10)
           hint = siblings.any? ? " Files in #{dir}/: #{siblings.join(', ')}" : ""
-          return empty_response("View not found: #{path}.#{hint}")
+          return empty_response([ "View not found: #{path}.#{hint}", static_engine_views_note ].compact.join("\n\n"))
         end
         return text_response("Could not read file: #{path}") unless content
 
@@ -325,7 +342,7 @@ module RailsAiContext
         end
 
         content = compress_tailwind(strip_svg(content))
-        text_response("# #{result.relative}\n\n```erb\n#{content}\n```")
+        text_response("# #{result.relative}\n\n```#{RailsAiContext::ViewFile.fence(result.relative)}\n#{content}\n```")
       end
 
       # Strip inline SVG blocks - they're visual noise that buries the signal AI needs.
@@ -426,7 +443,7 @@ module RailsAiContext
 
       private_class_method def self.read_from_disk(controller:, path:, detail:)
         if RailsAiContext::PathResolver.view_dirs(rails_app.root.to_s).empty?
-          note = api_only_note("app/views")
+          note = api_only_note("app/views", dir: "app/views")
           return text_response(note) if note
 
           return text_response("No app/views directory found.")
@@ -457,8 +474,8 @@ module RailsAiContext
         end
 
         templates, partials = files.partition { |f| !File.basename(f).start_with?("_") }
-        lines = views_header_lines(templates, partials, controller ? [] : layout_files)
-        files.each { |f| lines << "- #{f}" }
+        lines = views_header_lines(templates, partials, controller ? [] : layout_files, controller: controller)
+        files.each { |f| lines << [ "- #{f}", view_alternate_of(f) ].compact.join(" - ") }
         text_response(lines.join("\n"))
       end
     end