rails-ai-context 5.2.0 → 5.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a1dd01df89a380a86e14436ae9275c5db3f88b0e4fc56ea6df7d308f2c468472
-  data.tar.gz: 6f2efe8319fa533b8ea19cc0ace32460b24cb9b96873af0956c4b126041cd14b
+  metadata.gz: 43e8a71c793404bd950627b8f3319b4e909a0ba7a2cfe937a8d1027e2ede4af0
+  data.tar.gz: f296960edc1f3f336e90b9549618fd4b48d51d31330d95a65de9304ba47aa0af
 SHA512:
-  metadata.gz: 1447735cb99e717f1fa43a1fa54cc89fe1d6e0a836fcf156a7a66cede53c321328fbe4088a0c72103d91fe9c49de88f537cb59cddcbe1782773416892f76c728
-  data.tar.gz: 57b9e93748454c414563d453661eb4b51f94a063f15ac12a7073d6695b3cbc1e7fb1db323be3972ac1f830c1b21d73fcc65dc8fc1d5f170c8787cd9c8031881d
+  metadata.gz: bc10e825ef820ad955e89ded454469104160f954b967958866876794b1c114d9b708564e99781f1252cf4faa683d468bf5143823ee3418080de43ef745508ab2
+  data.tar.gz: 127d4159c5d88da79ae7fcb7389ffb84cca28621e0181da7b7e495e6af6fe0f8c0073b37dff3087a67be78c236e6f09e36aaef82e070461406e8a2027d88d2a8

data/CHANGELOG.md

@@ -5,6 +5,61 @@ 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.4.0] — 2026-04-08
+
+### Added — Phase 3: Dynamic VFS & Live Resource Architecture (Ground Truth Engine Blueprint #39)
+
+Live Virtual File System replaces static resource handling. Every MCP resource is introspected fresh on every request — zero stale data.
+
+- **VFS URI Dispatcher** (`lib/rails_ai_context/vfs.rb`) — Pattern-matched routing for `rails-ai-context://` URIs. Resolves models, controllers, controller actions, views, and routes. Each call introspects fresh. Path traversal protection for view reads.
+
+- **4 new MCP Resource Templates:**
+  - `rails-ai-context://controllers/{name}` — controller details with actions, filters, strong params
+  - `rails-ai-context://controllers/{name}/{action}` — action source code and applicable filters
+  - `rails-ai-context://views/{path}` — view template content (path traversal protected)
+  - `rails-ai-context://routes/{controller}` — live route map filtered by controller name
+
+- **MCP Controller** (`app/controllers/rails_ai_context/mcp_controller.rb`) — Native Rails controller for Streamable HTTP transport. Alternative to Rack middleware — integrates with Rails routing, authentication, and middleware stack. Mount via `mount RailsAiContext::Engine, at: "/mcp"`.
+
+- **output_schema on all 38 tools** — Default `MCP::Tool::OutputSchema` set via `BaseTool.inherited` hook. Every tool now declares its output format in the MCP protocol. Individual tools can override with custom schemas.
+
+- **Instrumentation** (`lib/rails_ai_context/instrumentation.rb`) — Bridges MCP gem instrumentation to `ActiveSupport::Notifications`. Events: `rails_ai_context.tools.call`, `rails_ai_context.resources.read`, etc. Subscribe with standard Rails notification patterns.
+
+- **Server instructions** — MCP server now includes `instructions:` field describing the ground truth engine capabilities.
+
+- **Enhanced LiveReload** — Full cache sweep on file changes via `reset_all_caches!` (includes AST, tool, and fingerprint caches).
+
+- **82 new specs** covering VFS resolution (models, controllers, actions, views, routes), instrumentation callback, McpController (thread safety, delegation, subclass isolation), resource templates (5 total), output_schema on all 38 tools, and server configuration.
+
+## [5.3.0] — 2026-04-07
+
+### Added — Phase 2: Cross-Tool Semantic Hydration (Ground Truth Engine Blueprint #38)
+
+Controller and view tools now automatically inject schema hints for referenced models, eliminating the need for follow-up tool calls.
+
+- **SchemaHint** (`lib/rails_ai_context/schema_hint.rb`) — Immutable `Data.define` value object carrying model ground truth: table, columns, associations, validations, primary key, and `[VERIFIED]`/`[INFERRED]` confidence tag.
+
+- **HydrationResult** — Wraps hints + warnings for downstream formatting.
+
+- **SchemaHintBuilder** (`lib/rails_ai_context/hydrators/schema_hint_builder.rb`) — Resolves model names to `SchemaHint` objects from cached introspection context. Case-insensitive lookup, batch builder with configurable cap.
+
+- **HydrationFormatter** (`lib/rails_ai_context/hydrators/hydration_formatter.rb`) — Renders `SchemaHint` objects as compact Markdown `## Schema Hints` sections with columns (capped at 10), associations, and validations.
+
+- **ControllerHydrator** (`lib/rails_ai_context/hydrators/controller_hydrator.rb`) — Parses controller source via Prism AST to detect model references (constant receivers, `params.require` keys, ivar writes), then builds schema hints.
+
+- **ViewHydrator** (`lib/rails_ai_context/hydrators/view_hydrator.rb`) — Maps instance variable names to models by convention (`@post` → `Post`, `@posts` → `Post`). Filters framework ivars (page, query, flash, etc.).
+
+- **ModelReferenceListener** (`lib/rails_ai_context/introspectors/listeners/model_reference_listener.rb`) — Prism Dispatcher listener for controller-specific model detection. Not registered in `LISTENER_MAP` — used standalone by `ControllerHydrator`.
+
+- **Tool integrations:**
+  - `GetControllers` — schema hints injected into both action source and controller overview
+  - `GetContext` — hydrates combined controller+view ivars in action context mode
+  - `GetView` — hydrates instance variables from view templates in standard detail
+
+- **Configuration:** `hydration_enabled` (default: true), `hydration_max_hints` (default: 5). Both YAML-configurable.
+
+- **65 new specs** covering SchemaHint, HydrationResult, SchemaHintBuilder, HydrationFormatter, ModelReferenceListener, ControllerHydrator, ViewHydrator, tool-level hydration integration (GetControllers, GetView), and configuration (defaults, YAML loading, max_hints propagation).
+
 ## [5.2.0] — 2026-04-07
 
 ### Added — Phase 1: Prism AST Foundation (Ground Truth Engine Blueprint #36)

data/README.md

@@ -17,9 +17,10 @@
 [![Downloads](https://img.shields.io/gem/dt/rails-ai-context?color=blue)](https://rubygems.org/gems/rails-ai-context)
 [![CI](https://github.com/crisnahine/rails-ai-context/actions/workflows/ci.yml/badge.svg)](https://github.com/crisnahine/rails-ai-context/actions)
 [![MCP Registry](https://img.shields.io/badge/MCP_Registry-listed-green)](https://registry.modelcontextprotocol.io)
+<br>
 [![Ruby](https://img.shields.io/badge/Ruby-3.2%20%7C%203.3%20%7C%203.4-CC342D)](https://github.com/crisnahine/rails-ai-context)
 [![Rails](https://img.shields.io/badge/Rails-7.1%20%7C%207.2%20%7C%208.0-CC0000)](https://github.com/crisnahine/rails-ai-context)
-[![Tests](https://img.shields.io/badge/Tests-1668%20passing-brightgreen)](https://github.com/crisnahine/rails-ai-context/actions)
+[![Tests](https://img.shields.io/badge/Tests-1813%20passing-brightgreen)](https://github.com/crisnahine/rails-ai-context/actions)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 
 </div>
@@ -66,7 +67,7 @@ rails-ai-context serve    # start MCP server
 
 </div>
 
-Now your AI doesn't guess — it **asks your app directly.** 38 tools that query your schema, models, routes, controllers, views, and conventions on demand. Model introspection uses Prism AST parsing — every result carries a `[VERIFIED]` or `[INFERRED]` confidence tag so AI knows what's ground truth and what needs runtime checking.
+Now your AI doesn't guess — it **asks your app directly.** 38 tools and 5 resource templates that query your schema, models, routes, controllers, views, and conventions on demand. Model introspection uses Prism AST parsing — every result carries a `[VERIFIED]` or `[INFERRED]` confidence tag so AI knows what's ground truth and what needs runtime checking.
 
 <br>
 
@@ -122,13 +123,13 @@ Compare what AI outputs with and without these tools wired in. The difference is
 
 <br>
 
-## Two ways to use it
+## Three ways to use it
 
 <table>
 <tr>
-<td width="50%">
+<td width="33%">
 
-### MCP Server
+### MCP Server (stdio)
 
 AI calls tools directly via the protocol. Auto-discovered through `.mcp.json`.
 
@@ -143,7 +144,21 @@ rails ai:serve
 ```
 
 </td>
-<td width="50%">
+<td width="33%">
+
+### MCP Server (HTTP)
+
+Mount inside your Rails app — inherits routing, auth, and middleware.
+
+```ruby
+# config/routes.rb
+mount RailsAiContext::Engine, at: "/mcp"
+```
+
+Native Rails controller transport. No separate process needed.
+
+</td>
+<td width="33%">
 
 ### CLI
 
@@ -342,6 +357,22 @@ Every tool is **read-only** and returns data verified against your actual app
 
 <br>
 
+## Live Resources (VFS)
+
+AI clients can also read structured data through **resource templates** — `rails-ai-context://` URIs that introspect fresh on every request. Zero stale data.
+
+| Resource Template | What it returns |
+|:------------------|:---------------|
+| `rails-ai-context://controllers/{name}` | Actions, inherited filters, strong params |
+| `rails-ai-context://controllers/{name}/{action}` | Action source code with applicable filters |
+| `rails-ai-context://views/{path}` | View template content (path traversal protected) |
+| `rails-ai-context://routes/{controller}` | Live route map filtered by controller |
+| `rails://models/{name}` | Per-model details: associations, validations, schema |
+
+Plus 9 static resources (schema, routes, conventions, gems, controllers, config, tests, migrations, engines) that AI clients read directly.
+
+<br>
+
 ## Anti-Hallucination Protocol
 
 Every generated context file ships with **6 rules that force AI verification** before writing code. The protocol targets the exact cognitive failures that produce confident-wrong code: statistical priors overriding observed facts, pattern completion beating verification, stale context lies.
@@ -376,14 +407,15 @@ Enabled by default. Disable with `config.anti_hallucination_rules = false` if yo
 ┌─────────────────────────────────────────────────────────┐
 │  rails-ai-context                                        │
 │  Prism AST parsing. Cached. Confidence-tagged results.    │
+│  VFS: rails-ai-context:// URIs introspected fresh.        │
 └────────┬──────────────────┬──────────────┬──────────────┘
          │                  │              │
          ▼                  ▼              ▼
 ┌──────────────────┐ ┌────────────┐ ┌────────────────────┐
 │  Static Files     │ │  MCP Server │ │  CLI Tools          │
 │  CLAUDE.md        │ │  38 tools   │ │  Same 38 tools      │
-│  .cursor/rules/   │ │  stdio/HTTP │ │  No server needed   │
-│  .github/instr... │ │  .mcp.json  │ │  rails 'ai:tool[X]' │
+│  .cursor/rules/   │ │  5 templates│ │  No server needed   │
+│  .github/instr... │ │  stdio/HTTP │ │  rails 'ai:tool[X]' │
 └──────────────────┘ └────────────┘ └────────────────────┘
 ```
 
@@ -458,6 +490,20 @@ end
 
 <br>
 
+## Observability
+
+Every MCP tool call and resource read fires an `ActiveSupport::Notifications` event. Subscribe with standard Rails patterns:
+
+```ruby
+ActiveSupport::Notifications.subscribe("rails_ai_context.tools.call") do |event|
+  Rails.logger.info "[MCP] #{event.payload[:method]} — #{event.duration}ms"
+end
+```
+
+Events: `rails_ai_context.tools.call`, `rails_ai_context.resources.read`, and more. All 38 tools declare `output_schema` in the MCP protocol, so clients know the response format before calling.
+
+<br>
+
 ## Requirements
 
 - **Ruby** >= 3.2 &nbsp;&nbsp; **Rails** >= 7.1
@@ -472,7 +518,7 @@ end
 ## About
 
 Built by a Rails developer with 10+ years of production experience.<br>
-1668 tests. 38 tools. 31 introspectors. Standalone or in-Gemfile.<br>
+1813 tests. 38 tools. 5 resource templates. 31 introspectors. Standalone or in-Gemfile.<br>
 MIT licensed. [Contributions welcome.](CONTRIBUTING.md)
 
 <br>

data/app/controllers/rails_ai_context/mcp_controller.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  # Rails controller for serving MCP over Streamable HTTP.
+  # Alternative to the Rack middleware — integrates with Rails routing,
+  # authentication, and middleware stack.
+  #
+  # Mount in routes: mount RailsAiContext::Engine, at: "/mcp"
+  class McpController < ActionController::API
+    def handle
+      rack_response = self.class.mcp_transport.handle_request(request)
+      self.status = rack_response[0]
+      rack_response[1].each { |k, v| response.headers[k] = v }
+      self.response_body = rack_response[2]
+    end
+
+    class << self
+      # Class-level memoization — transport persists across requests.
+      # Thread-safe: MCP::Server and transport are stateless for reads.
+      def mcp_transport
+        @mcp_transport || @transport_mutex.synchronize do
+          @mcp_transport ||= begin
+            server = RailsAiContext::Server.new(Rails.application, transport: :http).build
+            MCP::Server::Transports::StreamableHTTPTransport.new(server)
+          end
+        end
+      end
+
+      def reset_transport!
+        @transport_mutex.synchronize { @mcp_transport = nil }
+      end
+
+      private
+
+      def inherited(subclass)
+        super
+        subclass.instance_variable_set(:@transport_mutex, Mutex.new)
+      end
+    end
+
+    @transport_mutex = Mutex.new
+  end
+end

data/config/routes.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+RailsAiContext::Engine.routes.draw do
+  match "/", to: "mcp#handle", via: :all
+end

data/docs/GUIDE.md

@@ -431,7 +431,7 @@ rails_get_routes(detail: "standard", limit: 20, offset: 100)
 
 ### rails_get_controllers
 
-Returns controller details: actions, filters, strong params, concerns.
+Returns controller details: actions, filters, strong params, concerns. Automatically includes **Schema Hints** for models referenced in the controller (via Prism AST detection).
 
 **Parameters:**
 
@@ -549,7 +549,7 @@ rails_get_stimulus(detail: "full")
 
 ### rails_get_view
 
-Returns view template contents, partials, and Stimulus controller references.
+Returns view template contents, partials, and Stimulus controller references. In standard detail, includes **Schema Hints** for models inferred from instance variables.
 
 **Parameters:**
 
@@ -946,7 +946,7 @@ rails_get_turbo_map(controller: "messages", detail: "full")
 
 ### rails_get_context
 
-Get cross-layer context in a single call — combines schema, model, controller, routes, views, stimulus, and tests. Use when you need full context for implementing a feature or modifying an action.
+Get cross-layer context in a single call — combines schema, model, controller, routes, views, stimulus, and tests. Automatically includes **Schema Hints** for models referenced in controller/view code. Use when you need full context for implementing a feature or modifying an action.
 
 **Parameters:**
 
@@ -1010,6 +1010,17 @@ In addition to tools, the gem registers static MCP resources that AI clients can
 | `rails://engines` | Mounted engines with paths and descriptions (JSON) |
 | `rails://models/{name}` | Per-model details (resource template) |
 
+### Dynamic Resource Templates (VFS)
+
+Live resources introspected fresh on every request — zero stale data:
+
+| Resource Template | Description |
+|-------------------|-------------|
+| `rails-ai-context://controllers/{name}` | Controller details with actions, filters, strong params |
+| `rails-ai-context://controllers/{name}/{action}` | Specific action source code and applicable filters |
+| `rails-ai-context://views/{path}` | View template content (path traversal protected) |
+| `rails-ai-context://routes` | Live route map (optionally filter by controller) |
+
 ---
 
 ## MCP Server Setup
@@ -1126,6 +1137,17 @@ end
 
 Both transports are **read-only** — they expose the same 38 tools and never modify your app.
 
+### Controller Transport (Alternative)
+
+For tighter Rails integration (authentication, routing, middleware stack), mount the engine instead of using Rack middleware:
+
+```ruby
+# config/routes.rb
+mount RailsAiContext::Engine, at: "/mcp"
+```
+
+This provides a native Rails controller (`RailsAiContext::McpController`) that delegates to the Streamable HTTP transport.
+
 ---
 
 ## Configuration — All Options
@@ -1275,6 +1297,8 @@ end
 | `server_version` | String | gem version | MCP server version |
 | `generate_root_files` | Boolean | `true` | Generate root files (CLAUDE.md, etc.) — set `false` for split rules only |
 | `anti_hallucination_rules` | Boolean | `true` | Embed 6-rule Anti-Hallucination Protocol in generated context files — set `false` to skip |
+| `hydration_enabled` | Boolean | `true` | Inject schema hints into controller/view tool responses |
+| `hydration_max_hints` | Integer | `5` | Max schema hints per tool response |
 | `max_file_size` | Integer | `5_000_000` | Per-file read limit for tools (5MB) |
 | `max_test_file_size` | Integer | `1_000_000` | Test file read limit (1MB) |
 | `max_schema_file_size` | Integer | `10_000_000` | schema.rb / structure.sql parse limit (10MB) |

data/lib/rails_ai_context/configuration.rb

@@ -23,6 +23,7 @@ module RailsAiContext
       max_view_file_size max_search_results max_validate_files
       query_timeout query_row_limit query_redacted_columns allow_query_in_production
       log_lines introspectors
+      hydration_enabled hydration_max_hints
     ].freeze
 
     # Load configuration from a YAML file, applying values to the current config instance.
@@ -211,6 +212,10 @@ module RailsAiContext
     # Log reading settings (rails_read_logs)
     attr_accessor :log_lines                  # Default lines to tail (default: 50)
 
+    # Hydration: inject schema hints into controller/view tool responses
+    attr_accessor :hydration_enabled          # Enable/disable hydration (default: true)
+    attr_accessor :hydration_max_hints        # Max schema hints per response (default: 5)
+
     def initialize
       @server_name         = "rails-ai-context"
       @introspectors       = PRESETS[:full].dup
@@ -267,6 +272,8 @@ module RailsAiContext
       ]
       @allow_query_in_production = false
       @log_lines                = 50
+      @hydration_enabled        = true
+      @hydration_max_hints      = 5
     end
 
     def preset=(name)

data/lib/rails_ai_context/hydration_result.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  # Wraps hydration output: hints for detected models + any warnings.
+  HydrationResult = Data.define(:hints, :warnings) do
+    def initialize(hints: [], warnings: [])
+      super
+    end
+
+    def any?
+      hints.any?
+    end
+  end
+end

data/lib/rails_ai_context/hydrators/controller_hydrator.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  module Hydrators
+    # Parses a controller source file via Prism AST, detects model
+    # references, and builds SchemaHint objects for each detected model.
+    class ControllerHydrator
+      # Hydrate a controller file with schema hints.
+      # Returns a HydrationResult with hints for all detected models.
+      def self.call(source_path, context:)
+        return HydrationResult.new unless source_path && File.exist?(source_path)
+        return HydrationResult.new if File.size(source_path) > RailsAiContext.configuration.max_file_size
+
+        model_names = detect_model_references(source_path)
+        return HydrationResult.new if model_names.empty?
+
+        hints = SchemaHintBuilder.build_many(model_names, context: context, max: RailsAiContext.configuration.hydration_max_hints)
+
+        warnings = []
+        unresolved = model_names - hints.map(&:model_name)
+        unresolved.each do |name|
+          warnings << "Model '#{name}' referenced but not found in introspection data"
+        end
+
+        HydrationResult.new(hints: hints, warnings: warnings)
+      rescue => e
+        $stderr.puts "[rails-ai-context] ControllerHydrator failed: #{e.message}" if ENV["DEBUG"]
+        HydrationResult.new
+      end
+
+      # Detect model names referenced in a controller source file using Prism AST.
+      def self.detect_model_references(source_path)
+        parse_result = AstCache.parse(source_path)
+        dispatcher = Prism::Dispatcher.new
+        listener = Introspectors::Listeners::ModelReferenceListener.new
+
+        events = []
+        events << :on_call_node_enter if listener.respond_to?(:on_call_node_enter)
+        events << :on_instance_variable_write_node_enter if listener.respond_to?(:on_instance_variable_write_node_enter)
+        dispatcher.register(listener, *events)
+
+        dispatcher.dispatch(parse_result.value)
+        listener.results
+      rescue => e
+        $stderr.puts "[rails-ai-context] detect_model_references failed: #{e.message}" if ENV["DEBUG"]
+        []
+      end
+      private_class_method :detect_model_references
+    end
+  end
+end

data/lib/rails_ai_context/hydrators/hydration_formatter.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  module Hydrators
+    # Formats SchemaHint objects into Markdown for tool output.
+    class HydrationFormatter
+      # Format a HydrationResult into a Markdown section.
+      def self.format(hydration_result)
+        return "" unless hydration_result&.any?
+
+        lines = [ "## Schema Hints", "" ]
+        hydration_result.hints.each do |hint|
+          lines << format_hint(hint)
+          lines << ""
+        end
+
+        if hydration_result.warnings.any?
+          hydration_result.warnings.each { |w| lines << "_#{w}_" }
+          lines << ""
+        end
+
+        lines.join("\n")
+      end
+
+      # Format a single SchemaHint as a compact Markdown block.
+      def self.format_hint(hint)
+        lines = []
+        lines << "### #{hint.model_name} #{hint.confidence}"
+        lines << "**Table:** `#{hint.table_name}` (pk: `#{hint.primary_key}`)"
+
+        if hint.columns.any?
+          col_summary = hint.columns.first(10).map { |c|
+            "`#{c[:name]}` #{c[:type]}#{c[:null] == false ? ' NOT NULL' : ''}"
+          }
+          col_summary << "... #{hint.columns.size - 10} more" if hint.columns.size > 10
+          lines << "**Columns:** #{col_summary.join(', ')}"
+        end
+
+        if hint.associations.any?
+          assoc_list = hint.associations.map { |a| "`#{a[:type]}` :#{a[:name]}" }
+          lines << "**Associations:** #{assoc_list.join(', ')}"
+        end
+
+        if hint.validations.any?
+          val_list = hint.validations.map { |v|
+            attrs = v[:attributes]&.join(", ") || ""
+            "#{v[:kind]}(#{attrs})"
+          }
+          lines << "**Validations:** #{val_list.join(', ')}"
+        end
+
+        lines.join("\n")
+      end
+    end
+  end
+end

data/lib/rails_ai_context/hydrators/schema_hint_builder.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  module Hydrators
+    # Builds SchemaHint objects from cached introspection context.
+    # Single point of truth for resolving a model name into a
+    # structured hydration payload.
+    class SchemaHintBuilder
+      # Build a SchemaHint for a single model name.
+      # Returns nil if the model is not found in context.
+      def self.build(model_name, context:)
+        models_data = context[:models]
+        schema_data = context[:schema]
+        return nil unless models_data.is_a?(Hash) && schema_data.is_a?(Hash)
+
+        # Find model in models context (case-insensitive)
+        model_key = models_data.keys.find { |k| k.to_s.casecmp?(model_name) }
+        return nil unless model_key
+
+        model_info = models_data[model_key]
+        return nil unless model_info.is_a?(Hash)
+
+        table_name = model_info[:table_name]
+        table_data = schema_data.dig(:tables, table_name) if table_name
+
+        columns = if table_data
+          (table_data[:columns] || []).map do |col|
+            { name: col[:name], type: col[:type], null: col[:null] }.compact
+          end
+        else
+          []
+        end
+
+        associations = (model_info[:associations] || []).map do |assoc|
+          {
+            name: assoc[:name],
+            type: assoc[:type],
+            class_name: assoc[:class_name],
+            foreign_key: assoc[:foreign_key]
+          }.compact
+        end
+
+        validations = (model_info[:validations] || []).map do |val|
+          {
+            kind: val[:kind],
+            attributes: val[:attributes]
+          }.compact
+        end
+
+        primary_key = table_data&.dig(:primary_key) || "id"
+
+        # Confidence: verified if we have both model data and schema table
+        confidence = table_data ? "[VERIFIED]" : "[INFERRED]"
+
+        SchemaHint.new(
+          model_name: model_key.to_s,
+          table_name: table_name.to_s,
+          columns: columns,
+          associations: associations,
+          validations: validations,
+          primary_key: primary_key.to_s,
+          confidence: confidence
+        )
+      end
+
+      # Build SchemaHints for multiple model names.
+      # Returns only the ones that resolved successfully.
+      def self.build_many(model_names, context:, max: 5)
+        model_names.first(max).filter_map { |name| build(name, context: context) }
+      end
+    end
+  end
+end

data/lib/rails_ai_context/hydrators/view_hydrator.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  module Hydrators
+    # Resolves instance variable references in views to model schema hints.
+    # Maps @post → Post, @posts → Post (singularized), etc.
+    class ViewHydrator
+      # Hydrate view instance variables with schema hints.
+      # ivar_names: array of instance variable names (without @) used in a view.
+      # Returns a HydrationResult with hints for resolved models.
+      def self.call(ivar_names, context:)
+        return HydrationResult.new if ivar_names.nil? || ivar_names.empty?
+
+        model_names = ivar_names.filter_map { |ivar| ivar_to_model_name(ivar) }.uniq
+        return HydrationResult.new if model_names.empty?
+
+        hints = SchemaHintBuilder.build_many(model_names, context: context, max: RailsAiContext.configuration.hydration_max_hints)
+
+        warnings = []
+        unresolved = model_names - hints.map(&:model_name)
+        unresolved.each do |name|
+          warnings << "@#{name.underscore} used in view but '#{name}' model not found"
+        end
+
+        HydrationResult.new(hints: hints, warnings: warnings)
+      rescue => e
+        $stderr.puts "[rails-ai-context] ViewHydrator failed: #{e.message}" if ENV["DEBUG"]
+        HydrationResult.new
+      end
+
+      # Convert an instance variable name to a model name by convention.
+      # @post → "Post", @posts → "Post", @current_user → "User"
+      def self.ivar_to_model_name(ivar_name)
+        name = ivar_name.to_s
+        # Skip framework/common non-model ivars
+        return nil if SKIP_IVARS.include?(name)
+
+        # Singularize and classify: "posts" → "Post", "order_items" → "OrderItem"
+        name.singularize.camelize
+      rescue StandardError
+        nil
+      end
+      private_class_method :ivar_to_model_name
+
+      SKIP_IVARS = %w[
+        page per_page total_count total_pages
+        query search filter sort order
+        flash notice alert errors
+        breadcrumbs tabs menu
+        title description meta
+        current_page pagy
+        output_buffer virtual_path _request
+      ].to_set.freeze
+    end
+  end
+end

data/lib/rails_ai_context/instrumentation.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  # Bridges MCP gem instrumentation to ActiveSupport::Notifications.
+  # Enables Rails apps to subscribe to MCP events (tool calls, resource reads, etc.).
+  module Instrumentation
+    EVENT_PREFIX = "rails_ai_context"
+
+    # Returns a lambda for MCP::Configuration#instrumentation_callback.
+    # Instruments each MCP method call as an ActiveSupport::Notifications event.
+    def self.callback
+      ->(data) {
+        return unless defined?(ActiveSupport::Notifications)
+
+        method = data[:method] || "unknown"
+        event_name = "#{EVENT_PREFIX}.#{method.tr("/", ".")}"
+
+        ActiveSupport::Notifications.instrument(event_name, data)
+      }
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module RailsAiContext
+  module Introspectors
+    module Listeners
+      # Prism Dispatcher listener that detects model references in controller source.
+      # Extracts constant names used as method receivers (Post.find, Post.new),
+      # params.require(:post) keys, and instance variable write targets.
+      #
+      # Not registered in SourceIntrospector::LISTENER_MAP — used standalone
+      # by ControllerHydrator since model references are controller-specific.
+      class ModelReferenceListener < BaseListener
+        attr_reader :constant_references, :require_keys, :ivar_models
+
+        def initialize
+          super
+          @constant_references = []
+          @require_keys = []
+          @ivar_models = {}
+        end
+
+        # Detect: Post.find, Post.where, Post.new, Post.create, etc.
+        # Detect: params.require(:post)
+        def on_call_node_enter(node)
+          extract_constant_receiver(node)
+          extract_params_require(node)
+        end
+
+        # Detect: @post = Post.new(...), @post = Post.find(...)
+        def on_instance_variable_write_node_enter(node)
+          extract_ivar_model(node)
+        end
+
+        def results
+          model_names = Set.new
+
+          # Constant receivers: Post.find → "Post"
+          @constant_references.each { |name| model_names << name }
+
+          # params.require(:post) → "Post"
+          @require_keys.each { |key| model_names << key.to_s.classify }
+
+          # @post = Post.new → "Post"
+          @ivar_models.each_value { |name| model_names << name }
+
+          model_names.reject { |n| framework_constant?(n) }.sort
+        end
+
+        private
+
+        def extract_constant_receiver(node)
+          receiver = node.receiver
+          return unless receiver
+
+          case receiver
+          when Prism::ConstantReadNode
+            @constant_references << receiver.name.to_s
+          when Prism::ConstantPathNode
+            # Handles Namespaced::Model.find
+            @constant_references << constant_path_string(receiver)
+          end
+        end
+
+        def extract_params_require(node)
+          return unless node.name == :require
+          receiver = node.receiver
+          return unless receiver.is_a?(Prism::CallNode) && receiver.name == :params && receiver.receiver.nil?
+
+          arg = node.arguments&.arguments&.first
+          case arg
+          when Prism::SymbolNode then @require_keys << arg.value
+          when Prism::StringNode then @require_keys << arg.unescaped
+          end
+        end
+
+        def extract_ivar_model(node)
+          value = node.value
+          return unless value.is_a?(Prism::CallNode)
+
+          receiver = value.receiver
+          name = case receiver
+          when Prism::ConstantReadNode then receiver.name.to_s
+          when Prism::ConstantPathNode then constant_path_string(receiver)
+          end
+          return unless name
+
+          @ivar_models[node.name.to_s] = name
+        end
+
+        FRAMEWORK_CONSTANTS = %w[
+          ApplicationController ActionController ActionDispatch
+          ActiveRecord ActiveSupport Rails ApplicationRecord
+          ActionView ActionMailer ActiveJob ActiveStorage
+          ActionCable ActionMailbox ActionText Turbo
+        ].to_set.freeze
+
+        def framework_constant?(name)
+          root = name.split("::").first
+          FRAMEWORK_CONSTANTS.include?(root)
+        end
+      end
+    end
+  end
+end

data/lib/rails_ai_context/live_reload.rb

@@ -53,7 +53,7 @@ module RailsAiContext
 
       @last_fingerprint = Fingerprinter.compute(app)
 
-      # Invalidate all tool caches
+      # Invalidate all tool caches (includes AstCache.clear)
       Tools::BaseTool.reset_all_caches!
 
       # Build a human-readable change summary

data/lib/rails_ai_context/resources.rb

@@ -70,6 +70,34 @@ module RailsAiContext
       mime_type: "application/json"
     ).freeze
 
+    CONTROLLER_TEMPLATE = MCP::ResourceTemplate.new(
+      uri_template: "rails-ai-context://controllers/{name}",
+      name: "Controller Details",
+      description: "Controller with actions, filters, strong params, and schema hints",
+      mime_type: "application/json"
+    ).freeze
+
+    CONTROLLER_ACTION_TEMPLATE = MCP::ResourceTemplate.new(
+      uri_template: "rails-ai-context://controllers/{name}/{action}",
+      name: "Controller Action",
+      description: "Source code and metadata for a specific controller action",
+      mime_type: "application/json"
+    ).freeze
+
+    VIEW_TEMPLATE = MCP::ResourceTemplate.new(
+      uri_template: "rails-ai-context://views/{path}",
+      name: "View Template",
+      description: "View template content for a specific path relative to app/views",
+      mime_type: "text/html"
+    ).freeze
+
+    ROUTES_TEMPLATE = MCP::ResourceTemplate.new(
+      uri_template: "rails-ai-context://routes/{controller}",
+      name: "Live Routes",
+      description: "Application routes introspected fresh on each request, optionally filtered by controller name",
+      mime_type: "application/json"
+    ).freeze
+
     class << self
       def static_resources
         STATIC_RESOURCES.map do |uri, meta|
@@ -83,7 +111,7 @@ module RailsAiContext
       end
 
       def resource_templates
-        [ MODEL_TEMPLATE ]
+        [ MODEL_TEMPLATE, CONTROLLER_TEMPLATE, CONTROLLER_ACTION_TEMPLATE, VIEW_TEMPLATE, ROUTES_TEMPLATE ]
       end
 
       def register(server)
@@ -100,6 +128,11 @@ module RailsAiContext
 
       def handle_read(params)
         uri = params[:uri]
+
+        # Delegate rails-ai-context:// URIs to the VFS dispatcher
+        return VFS.resolve(uri) if uri.start_with?("#{VFS::SCHEME}://")
+
+        # Legacy rails:// URI handling
         context = RailsAiContext.introspect
 
         if STATIC_RESOURCES.key?(uri)

data/lib/rails_ai_context/schema_hint.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RailsAiContext
+  # Structured hydration payload representing a model's ground truth.
+  # Used by hydrators to inject cross-tool context into controller
+  # and view tool responses. Immutable value object via Data.define.
+  SchemaHint = Data.define(
+    :model_name,    # "Post"
+    :table_name,    # "posts"
+    :columns,       # [{name: "title", type: "string", null: false}, ...]
+    :associations,  # [{name: "comments", type: "has_many", class_name: "Comment"}, ...]
+    :validations,   # [{kind: "presence", attributes: ["title"]}, ...]
+    :primary_key,   # "id"
+    :confidence     # "[VERIFIED]" or "[INFERRED]"
+  ) do
+    def verified?
+      confidence == "[VERIFIED]"
+    end
+
+    def column_names
+      columns.map { |c| c[:name] }
+    end
+
+    def association_names
+      associations.map { |a| a[:name] }
+    end
+  end
+end

data/lib/rails_ai_context/server.rb

@@ -67,11 +67,17 @@ module RailsAiContext
         end
       end
 
+      mcp_config = MCP::Configuration.new(
+        instrumentation_callback: Instrumentation.callback
+      )
+
       server = MCP::Server.new(
         name: config.server_name,
         version: config.server_version,
+        instructions: "Ground truth engine for Rails apps. Live Prism AST introspection. Zero stale data.",
         tools: active_tools(config) + validated_custom_tools,
-        resource_templates: Resources.resource_templates
+        resource_templates: Resources.resource_templates,
+        configuration: mcp_config
       )
 
       Resources.register(server)

data/lib/rails_ai_context/tools/base_tool.rb

@@ -8,6 +8,32 @@ module RailsAiContext
     # Inherits from the official MCP::Tool to get schema validation,
     # annotations, and protocol compliance for free.
     class BaseTool < MCP::Tool
+      # Default output schema for all tools. MCP::Tool.inherited resets
+      # @output_schema_value to nil on each subclass, so we re-set it
+      # via our own inherited hook.
+      DEFAULT_OUTPUT_SCHEMA = MCP::Tool::OutputSchema.new(
+        type: "object",
+        properties: {
+          content: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                type: { type: "string", enum: [ "text" ] },
+                text: { type: "string", description: "Tool response as Markdown-formatted text" }
+              },
+              required: [ "type", "text" ]
+            }
+          }
+        },
+        required: [ "content" ]
+      ).freeze
+
+      def self.inherited(subclass)
+        super
+        subclass.instance_variable_set(:@output_schema_value, DEFAULT_OUTPUT_SCHEMA)
+      end
+
       # Shared cache across all tool subclasses, protected by a Mutex
       # for thread safety in multi-threaded servers (e.g., Puma).
       SHARED_CACHE = { mutex: Mutex.new }

data/lib/rails_ai_context/tools/get_context.rb

@@ -109,6 +109,17 @@ module RailsAiContext
         ivar_check = cross_reference_ivars(ctrl_ivars, view_ivars, rendered_templates: other_templates)
         lines << "" << ivar_check if ivar_check
 
+        # Hydrate: inject schema hints for models referenced in controller + view ivars
+        if RailsAiContext.configuration.hydration_enabled
+          all_ivars = (ctrl_ivars | view_ivars).to_a
+          hydration = Hydrators::ViewHydrator.call(all_ivars, context: cached_context)
+          hydration_text = Hydrators::HydrationFormatter.format(hydration)
+          # Skip if get_controllers already injected schema hints
+          unless hydration_text.empty? || lines.any? { |l| l.include?("## Schema Hints") }
+            lines << "" << hydration_text
+          end
+        end
+
         text_response(lines.join("\n"))
       rescue => e
         text_response("Error assembling context: #{e.message}")

data/lib/rails_ai_context/tools/get_controllers.rb

@@ -285,6 +285,13 @@ module RailsAiContext
           end
         end
 
+        # Hydrate with schema hints for models referenced in this action
+        if RailsAiContext.configuration.hydration_enabled
+          hydration = Hydrators::ControllerHydrator.call(source_path.to_s, context: cached_context)
+          hydration_text = Hydrators::HydrationFormatter.format(hydration)
+          lines << "" << hydration_text unless hydration_text.empty?
+        end
+
         lines.join("\n")
       end
 
@@ -519,6 +526,14 @@ module RailsAiContext
           info[:turbo_stream_actions].each { |a| lines << "- `#{a}`" }
         end
 
+        # Hydrate with schema hints for models referenced in this controller
+        if RailsAiContext.configuration.hydration_enabled
+          source_path = Rails.root.join("app", "controllers", "#{name.underscore}.rb")
+          hydration = Hydrators::ControllerHydrator.call(source_path.to_s, context: cached_context)
+          hydration_text = Hydrators::HydrationFormatter.format(hydration)
+          lines << "" << hydration_text unless hydration_text.empty?
+        end
+
         # Cross-reference hints
         ctrl_path = name.underscore.delete_suffix("_controller")
         model_name = ctrl_path.split("/").last.singularize.camelize

data/lib/rails_ai_context/tools/get_view.rb

@@ -153,6 +153,20 @@ module RailsAiContext
             end
             lines << ""
           end
+
+          # Hydrate: inject schema hints for models inferred from view instance variables
+          if RailsAiContext.configuration.hydration_enabled && controller
+            all_ivars = []
+            templates.each do |path, _meta|
+              content = read_view_content(path)
+              content.scan(/@(\w+)/).flatten.each { |v| all_ivars << v }
+            end
+            all_ivars.uniq!
+            hydration = Hydrators::ViewHydrator.call(all_ivars, context: cached_context)
+            hydration_text = Hydrators::HydrationFormatter.format(hydration)
+            lines << hydration_text << "" unless hydration_text.empty?
+          end
+
           text_response(lines.join("\n"))
 
         when "full"

data/lib/rails_ai_context/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RailsAiContext
-  VERSION = "5.2.0"
+  VERSION = "5.4.0"
 end

data/lib/rails_ai_context/vfs.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require "json"
+
+module RailsAiContext
+  # Virtual File System — pattern-matched URI routing for MCP resources.
+  # Each resolve call introspects fresh (zero stale data).
+  module VFS
+    SCHEME = "rails-ai-context"
+
+    PATTERNS = [
+      { pattern: %r{\Arails-ai-context://controllers/([^/]+)/([^/]+)\z}, handler: :resolve_controller_action },
+      { pattern: %r{\Arails-ai-context://controllers/([^/]+)\z}, handler: :resolve_controller },
+      { pattern: %r{\Arails-ai-context://models/(.+)\z}, handler: :resolve_model },
+      { pattern: %r{\Arails-ai-context://views/(.+)\z}, handler: :resolve_view },
+      { pattern: %r{\Arails-ai-context://routes/(.+)\z}, handler: :resolve_routes }
+    ].freeze
+
+    class << self
+      # Resolve a rails-ai-context:// URI to MCP resource content.
+      # Returns an array of content hashes: [{uri:, mime_type:, text:}]
+      def resolve(uri)
+        PATTERNS.each do |entry|
+          match = uri.match(entry[:pattern])
+          next unless match
+
+          return send(entry[:handler], uri, *match.captures)
+        end
+
+        raise RailsAiContext::Error, "Unknown VFS URI: #{uri}"
+      end
+
+      private
+
+      def resolve_model(uri, name)
+        context = RailsAiContext.introspect
+        models = context[:models] || {}
+
+        # Case-insensitive lookup
+        key = models.keys.find { |k| k.to_s.casecmp?(name) } || name
+        data = models[key]
+
+        unless data
+          available = models.keys.sort.first(20)
+          content = JSON.pretty_generate(error: "Model '#{name}' not found", available: available)
+          return [ { uri: uri, mime_type: "application/json", text: content } ]
+        end
+
+        # Enrich with schema columns if available
+        table_name = data[:table_name]
+        schema = context.dig(:schema, :tables, table_name) if table_name
+        enriched = data.merge(schema: schema).compact
+
+        [ { uri: uri, mime_type: "application/json", text: JSON.pretty_generate(enriched) } ]
+      end
+
+      def resolve_controller(uri, name)
+        context = RailsAiContext.introspect
+        controllers = context.dig(:controllers, :controllers) || {}
+
+        # Flexible matching: "posts", "PostsController", "postscontroller"
+        input_snake = name.underscore.delete_suffix("_controller")
+        key = controllers.keys.find { |k|
+          k.underscore.delete_suffix("_controller") == input_snake ||
+            k.downcase.delete_suffix("controller") == name.downcase.delete_suffix("controller")
+        }
+
+        unless key
+          available = controllers.keys.sort.first(20)
+          content = JSON.pretty_generate(error: "Controller '#{name}' not found", available: available)
+          return [ { uri: uri, mime_type: "application/json", text: content } ]
+        end
+
+        [ { uri: uri, mime_type: "application/json", text: JSON.pretty_generate(controllers[key]) } ]
+      end
+
+      def resolve_controller_action(uri, controller_name, action_name)
+        context = RailsAiContext.introspect
+        controllers = context.dig(:controllers, :controllers) || {}
+
+        input_snake = controller_name.underscore.delete_suffix("_controller")
+        key = controllers.keys.find { |k|
+          k.underscore.delete_suffix("_controller") == input_snake
+        }
+
+        unless key
+          content = JSON.pretty_generate(error: "Controller '#{controller_name}' not found")
+          return [ { uri: uri, mime_type: "application/json", text: content } ]
+        end
+
+        info = controllers[key]
+        actions = info[:actions] || []
+        action = actions.find { |a| a.to_s.casecmp?(action_name) }
+
+        unless action
+          content = JSON.pretty_generate(error: "Action '#{action_name}' not found in #{key}", available: actions)
+          return [ { uri: uri, mime_type: "application/json", text: content } ]
+        end
+
+        # Build action-specific data
+        action_data = {
+          controller: key,
+          action: action.to_s,
+          filters: (info[:filters] || []).select { |f|
+            if f[:only]&.any?
+              f[:only].map(&:to_s).include?(action.to_s)
+            elsif f[:except]&.any?
+              !f[:except].map(&:to_s).include?(action.to_s)
+            else
+              true
+            end
+          },
+          strong_params: info[:strong_params]
+        }.compact
+
+        [ { uri: uri, mime_type: "application/json", text: JSON.pretty_generate(action_data) } ]
+      end
+
+      def resolve_view(uri, path)
+        # Block path traversal
+        if path.include?("..") || path.start_with?("/")
+          raise RailsAiContext::Error, "Path not allowed: #{path}"
+        end
+
+        views_dir = Rails.root.join("app", "views")
+        full_path = views_dir.join(path)
+
+        unless File.exist?(full_path)
+          content = JSON.pretty_generate(error: "View not found: #{path}")
+          return [ { uri: uri, mime_type: "application/json", text: content } ]
+        end
+
+        # Verify resolved path is still under views_dir
+        unless File.realpath(full_path).start_with?(File.realpath(views_dir))
+          raise RailsAiContext::Error, "Path not allowed: #{path}"
+        end
+
+        max_size = RailsAiContext.configuration.max_file_size
+        if File.size(full_path) > max_size
+          content = JSON.pretty_generate(error: "File too large: #{path} (#{File.size(full_path)} bytes)")
+          return [ { uri: uri, mime_type: "application/json", text: content } ]
+        end
+
+        view_content = RailsAiContext::SafeFile.read(full_path) || ""
+        mime = path.end_with?(".rb") ? "text/x-ruby" : "text/html"
+        [ { uri: uri, mime_type: mime, text: view_content } ]
+      end
+
+      def resolve_routes(uri, controller)
+        context = RailsAiContext.introspect
+        routes_data = context[:routes] || {}
+
+        filtered = (routes_data[:routes] || []).select { |r|
+          r[:controller].to_s.include?(controller)
+        }
+        data = routes_data.merge(routes: filtered, filtered_by: controller)
+
+        [ { uri: uri, mime_type: "application/json", text: JSON.pretty_generate(data) } ]
+      end
+    end
+  end
+end

data/lib/rails_ai_context.rb

@@ -3,7 +3,7 @@
 require "zeitwerk"
 
 loader = Zeitwerk::Loader.for_gem(warn_on_extra_files: false)
-loader.inflector.inflect("devops_introspector" => "DevOpsIntrospector", "cli" => "CLI")
+loader.inflector.inflect("devops_introspector" => "DevOpsIntrospector", "cli" => "CLI", "vfs" => "VFS")
 loader.ignore("#{__dir__}/generators")
 loader.ignore("#{__dir__}/rails-ai-context.rb")
 loader.setup

data/server.json

@@ -7,12 +7,12 @@
     "url": "https://github.com/crisnahine/rails-ai-context",
     "source": "github"
   },
-  "version": "5.2.0",
+  "version": "5.4.0",
   "packages": [
     {
       "registryType": "mcpb",
-      "identifier": "https://github.com/crisnahine/rails-ai-context/releases/download/v5.2.0/rails-ai-context-mcp.mcpb",
-      "fileSha256": "PENDING_RELEASE_BUILD",
+      "identifier": "https://github.com/crisnahine/rails-ai-context/releases/download/v5.4.0/rails-ai-context-mcp.mcpb",
+      "fileSha256": "0000000000000000000000000000000000000000000000000000000000000000",
       "transport": {
         "type": "stdio"
       }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-ai-context
 version: !ruby/object:Gem::Version
-  version: 5.2.0
+  version: 5.4.0
 platform: ruby
 authors:
 - crisnahine
@@ -207,6 +207,8 @@ files:
 - README.md
 - Rakefile
 - SECURITY.md
+- app/controllers/rails_ai_context/mcp_controller.rb
+- config/routes.rb
 - demo/demo-trace.gif
 - demo/demo-trace.tape
 - demo/demo.gif
@@ -224,6 +226,12 @@ files:
 - lib/rails_ai_context/doctor.rb
 - lib/rails_ai_context/engine.rb
 - lib/rails_ai_context/fingerprinter.rb
+- lib/rails_ai_context/hydration_result.rb
+- lib/rails_ai_context/hydrators/controller_hydrator.rb
+- lib/rails_ai_context/hydrators/hydration_formatter.rb
+- lib/rails_ai_context/hydrators/schema_hint_builder.rb
+- lib/rails_ai_context/hydrators/view_hydrator.rb
+- lib/rails_ai_context/instrumentation.rb
 - lib/rails_ai_context/introspector.rb
 - lib/rails_ai_context/introspectors/action_mailbox_introspector.rb
 - lib/rails_ai_context/introspectors/action_text_introspector.rb
@@ -248,6 +256,7 @@ files:
 - lib/rails_ai_context/introspectors/listeners/enums_listener.rb
 - lib/rails_ai_context/introspectors/listeners/macros_listener.rb
 - lib/rails_ai_context/introspectors/listeners/methods_listener.rb
+- lib/rails_ai_context/introspectors/listeners/model_reference_listener.rb
 - lib/rails_ai_context/introspectors/listeners/scopes_listener.rb
 - lib/rails_ai_context/introspectors/listeners/validations_listener.rb
 - lib/rails_ai_context/introspectors/middleware_introspector.rb
@@ -270,6 +279,7 @@ files:
 - lib/rails_ai_context/middleware.rb
 - lib/rails_ai_context/resources.rb
 - lib/rails_ai_context/safe_file.rb
+- lib/rails_ai_context/schema_hint.rb
 - lib/rails_ai_context/serializers/claude_rules_serializer.rb
 - lib/rails_ai_context/serializers/claude_serializer.rb
 - lib/rails_ai_context/serializers/compact_serializer_helper.rb
@@ -326,6 +336,7 @@ files:
 - lib/rails_ai_context/tools/session_context.rb
 - lib/rails_ai_context/tools/validate.rb
 - lib/rails_ai_context/version.rb
+- lib/rails_ai_context/vfs.rb
 - lib/rails_ai_context/watcher.rb
 - server.json
 homepage: https://github.com/crisnahine/rails-ai-context