ruby_llm-agents 3.15.1 → 3.16.0

data/app/views/ruby_llm/agents/shared/query_timeout.html.erb

@@ -0,0 +1,18 @@
+<div class="flex items-center gap-3 mb-6">
+  <span class="text-[10px] font-medium text-gray-400 dark:text-gray-600 uppercase tracking-widest font-mono">query timed out</span>
+  <div class="flex-1 border-t border-gray-200 dark:border-gray-800"></div>
+</div>
+
+<div class="font-mono text-xs space-y-3" role="alert">
+  <p class="text-gray-900 dark:text-gray-100">
+    This view needed more than <%= @query_timeout %>s of database time, so the query was cancelled.
+  </p>
+  <p class="text-gray-500 dark:text-gray-400">
+    It aggregates every execution in the selected range. Try a shorter time range or a narrower filter.
+    The limit is <code class="text-gray-700 dark:text-gray-300">config.dashboard_query_timeout</code>.
+  </p>
+  <p>
+    <%= link_to "← back to dashboard", ruby_llm_agents.root_path,
+        class: "text-gray-400 dark:text-gray-500 hover:text-gray-700 dark:hover:text-gray-300 focus:outline-none focus:underline" %>
+  </p>
+</div>

data/app/views/ruby_llm/agents/system_config/show.html.erb

@@ -106,6 +106,10 @@
     <span class="w-36 flex-shrink-0 text-gray-500 dark:text-gray-400">recent limit</span>
     <span class="text-gray-900 dark:text-gray-200"><%= @config.recent_executions_limit %></span>
   </div>
+  <div class="flex items-center gap-3 py-0.5">
+    <span class="w-36 flex-shrink-0 text-gray-500 dark:text-gray-400">query timeout</span>
+    <span class="text-gray-900 dark:text-gray-200"><%= @config.dashboard_query_timeout ? "#{@config.dashboard_query_timeout}s" : "off" %></span>
+  </div>
   <div class="flex items-center gap-3 py-0.5">
     <span class="w-36 flex-shrink-0 text-gray-500 dark:text-gray-400">parent controller</span>
     <span class="text-gray-900 dark:text-gray-200"><%= @config.dashboard_parent_controller %></span>

data/app/views/ruby_llm/agents/tenants/index.html.erb

@@ -51,7 +51,7 @@
         class: "w-20 flex-shrink-0 text-right hidden sm:block hover:text-gray-600 dark:hover:text-gray-300 #{sort_active.call('monthly_limit')}" %>
     <%= link_to "enforcement#{sort_arrow.call('enforcement')}".html_safe, sort_url.call("enforcement"),
         class: "w-16 flex-shrink-0 hidden md:block hover:text-gray-600 dark:hover:text-gray-300 #{sort_active.call('enforcement')}" %>
-    <span class="w-16 flex-shrink-0 text-right hidden md:block">cost</span>
+    <span class="w-16 flex-shrink-0 text-right hidden md:block" title="Cost this month">cost/mo</span>
     <span class="w-24 flex-shrink-0 text-right">last run</span>
   </div>
 

data/app/views/ruby_llm/agents/tenants/show.html.erb

@@ -8,7 +8,7 @@
   total_executions = @usage_stats[:total_executions]
   total_cost = @usage_stats[:total_cost]
   total_tokens = @usage_stats[:total_tokens]
-  success_count = @tenant.executions.where(status: "success").count
+  success_count = @usage_stats[:success_count]
   success_rate = total_executions > 0 ? (success_count.to_f / total_executions * 100).round : 100
 
   has_any_limit = @tenant.effective_daily_limit || @tenant.effective_monthly_limit ||
@@ -64,6 +64,7 @@
   <!-- Right: stats -->
   <div class="flex-shrink-0 text-right font-mono text-xs text-gray-400 dark:text-gray-500 space-y-1">
     <div class="flex items-center justify-end gap-x-4">
+      <span class="text-gray-300 dark:text-gray-700">this month</span>
       <span><span class="text-gray-800 dark:text-gray-200"><%= number_with_delimiter(total_executions) %></span> runs</span>
       <span class="<%= success_rate >= 95 ? 'text-green-500' : success_rate >= 80 ? 'text-yellow-500' : 'text-red-500' %>"><%= success_rate %>% ok</span>
       <span><span class="text-gray-800 dark:text-gray-200">$<%= number_with_precision(total_cost, precision: 4) %></span> cost</span>
@@ -127,10 +128,10 @@
   <% if @error_count > 0 %>
     <div class="mt-3 font-mono text-xs text-gray-500 dark:text-gray-400">
       <span class="text-red-500">$<%= number_with_precision(@error_cost, precision: 4) %></span>
-      wasted on <span class="text-red-500"><%= number_with_delimiter(@error_count) %></span> failed executions
+      wasted on <span class="text-red-500"><%= number_with_delimiter(@error_count) %></span> failed executions this month
       <% error_pct = total_cost.to_f > 0 ? (@error_cost.to_f / total_cost * 100).round(1) : 0 %>
       <% if error_pct > 0 %>
-        (<%= error_pct %>% of total cost)
+        (<%= error_pct %>% of this month's cost)
       <% end %>
     </div>
   <% end %>
@@ -321,7 +322,7 @@
 <% if @usage_by_agent.present? %>
   <!-- ── usage by agent ──────────────────── -->
   <div class="flex items-center gap-3 mt-6 mb-3">
-    <span class="text-[10px] font-medium text-gray-400 dark:text-gray-600 uppercase tracking-widest font-mono">usage by agent</span>
+    <span class="text-[10px] font-medium text-gray-400 dark:text-gray-600 uppercase tracking-widest font-mono">usage by agent &middot; this month</span>
     <div class="flex-1 border-t border-gray-200 dark:border-gray-800"></div>
   </div>
 
@@ -359,7 +360,7 @@
 <% if @usage_by_model.present? %>
   <!-- ── usage by model ──────────────────── -->
   <div class="flex items-center gap-3 mt-6 mb-3">
-    <span class="text-[10px] font-medium text-gray-400 dark:text-gray-600 uppercase tracking-widest font-mono">usage by model</span>
+    <span class="text-[10px] font-medium text-gray-400 dark:text-gray-600 uppercase tracking-widest font-mono">usage by model &middot; this month</span>
     <div class="flex-1 border-t border-gray-200 dark:border-gray-800"></div>
   </div>
 

data/config/routes.rb

@@ -2,7 +2,7 @@
 
 RubyLLM::Agents::Engine.routes.draw do
   root to: "dashboard#index"
-  get "chart_data", to: "dashboard#chart_data"
+  get "chart_data", to: "dashboard#chart_data", defaults: {format: :json}
 
   resources :agents, only: [:index, :show, :update] do
     member do
@@ -26,6 +26,6 @@ RubyLLM::Agents::Engine.routes.draw do
   end
 
   get "analytics", to: "analytics#index", as: :analytics
-  get "analytics/chart_data", to: "analytics#chart_data", as: :analytics_chart_data
+  get "analytics/chart_data", to: "analytics#chart_data", as: :analytics_chart_data, defaults: {format: :json}
   resource :system_config, only: [:show], controller: "system_config"
 end

data/lib/generators/ruby_llm_agents/templates/add_executions_analytics_index_migration.rb.tt

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# Migration to add the covering index behind the dashboard's aggregate queries
+#
+# Dashboard, analytics and agent stats all aggregate executions over a time
+# range, reading a handful of narrow columns from each row. Fetching those
+# rows from the table drags the wide ones along (metadata JSON, in practice
+# most of each row), so the cost of every figure grows with the size of the
+# range: seconds for 30 days on a table with millions of executions.
+#
+# This index stores the aggregated columns next to created_at, so those
+# queries are answered from the index alone. PostgreSQL keeps them out of the
+# key with INCLUDE; SQLite takes them as trailing key columns.
+#
+# The index is built CONCURRENTLY on PostgreSQL so executions keep being
+# recorded while it builds. On a large table that takes a while; an
+# interrupted build leaves an invalid index behind, which re-running this
+# migration replaces.
+class AddExecutionsAnalyticsIndex < ActiveRecord::Migration<%= migration_version %>
+  disable_ddl_transaction!
+
+  TABLE = :ruby_llm_agents_executions
+  INDEX = "idx_executions_analytics"
+  COVERED = %i[
+    agent_type model_id chosen_model_id status error_class tenant_id parent_execution_id
+    total_cost total_tokens input_tokens output_tokens duration_ms cache_hit streaming
+  ].freeze
+
+  def up
+    covered = COVERED.select { |column| column_exists?(TABLE, column) }
+
+    case connection.adapter_name.downcase
+    when /postg/
+      execute "DROP INDEX CONCURRENTLY IF EXISTS #{INDEX}"
+      execute "CREATE INDEX CONCURRENTLY #{INDEX} ON #{TABLE} (created_at) INCLUDE (#{covered.join(", ")})"
+    when /sqlite/
+      add_index TABLE, [:created_at, *covered], name: INDEX, if_not_exists: true
+    else
+      say "Skipping #{INDEX}: covering index is only defined for PostgreSQL and SQLite"
+    end
+  end
+
+  def down
+    if connection.adapter_name.downcase.include?("postg")
+      execute "DROP INDEX CONCURRENTLY IF EXISTS #{INDEX}"
+    else
+      remove_index TABLE, name: INDEX, if_exists: true
+    end
+  end
+end

data/lib/generators/ruby_llm_agents/templates/add_root_execution_list_index_migration.rb.tt

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# Migration to add the index behind the executions dashboard list
+#
+# The list page runs `WHERE parent_execution_id IS NULL ORDER BY created_at DESC`
+# plus a COUNT over the same predicate. With only the single-column
+# parent_execution_id and created_at indexes available, the planner has to pick
+# one and filter the rest, which degrades to a sequential scan once child
+# executions make up a meaningful share of the table.
+class AddRootExecutionListIndex < ActiveRecord::Migration<%= migration_version %>
+  def change
+    add_index :ruby_llm_agents_executions, [:parent_execution_id, :created_at],
+              name: "idx_executions_parent_created_at",
+              if_not_exists: true
+  end
+end

data/lib/generators/ruby_llm_agents/templates/initializer.rb.tt

@@ -132,6 +132,11 @@ RubyLLM::Agents.configure do |config|
   # Number of recent executions shown on the dashboard home
   # config.recent_executions_limit = 10
 
+  # Seconds a single dashboard query may run before the database cancels it
+  # (PostgreSQL only). Keeps a wide time range on a large executions table from
+  # tying up a web worker and the database; nil disables it.
+  # config.dashboard_query_timeout = 5
+
   # ============================================
   # Reliability Defaults
   # ============================================

data/lib/generators/ruby_llm_agents/templates/migration.rb.tt

@@ -76,11 +76,37 @@ class CreateRubyLLMAgentsExecutions < ActiveRecord::Migration<%= migration_versi
     add_index :ruby_llm_agents_executions, :trace_id
     add_index :ruby_llm_agents_executions, :request_id
     add_index :ruby_llm_agents_executions, :parent_execution_id
+    add_index :ruby_llm_agents_executions, [:parent_execution_id, :created_at]
     add_index :ruby_llm_agents_executions, :root_execution_id
     add_index :ruby_llm_agents_executions, [:status, :created_at]
     add_index :ruby_llm_agents_executions, [:model_id, :status]
     add_index :ruby_llm_agents_executions, [:cache_hit, :created_at]
 
+    # Covering index behind the dashboard's aggregate queries. They read a
+    # time range and only these columns, so with this index they are answered
+    # without fetching the (much wider) table rows. PostgreSQL keeps the extra
+    # columns out of the key with INCLUDE; SQLite takes them as key columns.
+    analytics_columns = %w[
+      agent_type model_id chosen_model_id status error_class tenant_id parent_execution_id
+      total_cost total_tokens input_tokens output_tokens duration_ms cache_hit streaming
+    ]
+    case connection.adapter_name.downcase
+    when /postg/
+      reversible do |dir|
+        dir.up do
+          execute "CREATE INDEX idx_executions_analytics ON ruby_llm_agents_executions " \
+                  "(created_at) INCLUDE (#{analytics_columns.join(", ")})"
+        end
+        # Dropped explicitly: both this and the plain created_at index are
+        # keyed on created_at alone, so reverting that one by column would
+        # otherwise be ambiguous.
+        dir.down { execute "DROP INDEX IF EXISTS idx_executions_analytics" }
+      end
+    when /sqlite/
+      add_index :ruby_llm_agents_executions, ["created_at", *analytics_columns],
+                name: "idx_executions_analytics"
+    end
+
     # Foreign keys for execution hierarchy
     add_foreign_key :ruby_llm_agents_executions, :ruby_llm_agents_executions,
                     column: :parent_execution_id, on_delete: :nullify

data/lib/generators/ruby_llm_agents/upgrade_generator.rb

@@ -117,6 +117,44 @@ module RubyLlmAgents
       )
     end
 
+    # Add the composite index behind the executions dashboard list
+    def create_add_root_execution_list_index_migration
+      unless table_exists?(:ruby_llm_agents_executions)
+        say_status :skip, "executions table does not exist yet", :yellow
+        return
+      end
+
+      if index_exists?(:ruby_llm_agents_executions, [:parent_execution_id, :created_at])
+        say_status :skip, "root execution list index already exists", :yellow
+        return
+      end
+
+      say_status :upgrade, "Adding root execution list index", :blue
+      migration_template(
+        "add_root_execution_list_index_migration.rb.tt",
+        File.join(db_migrate_path, "add_root_execution_list_index.rb")
+      )
+    end
+
+    # Add the covering index behind the dashboard's aggregate queries
+    def create_add_executions_analytics_index_migration
+      unless table_exists?(:ruby_llm_agents_executions)
+        say_status :skip, "executions table does not exist yet", :yellow
+        return
+      end
+
+      if index_name_exists?(:ruby_llm_agents_executions, "idx_executions_analytics")
+        say_status :skip, "executions analytics index already exists", :yellow
+        return
+      end
+
+      say_status :upgrade, "Adding executions analytics index", :blue
+      migration_template(
+        "add_executions_analytics_index_migration.rb.tt",
+        File.join(db_migrate_path, "add_executions_analytics_index.rb")
+      )
+    end
+
     # Create overrides table for dashboard-managed agent settings
     def create_overrides_migration
       if table_exists?(:ruby_llm_agents_overrides)
@@ -231,5 +269,11 @@ module RubyLlmAgents
     rescue
       false
     end
+
+    def index_name_exists?(table, name)
+      ActiveRecord::Base.connection.index_name_exists?(table, name)
+    rescue
+      false
+    end
   end
 end

data/lib/ruby_llm/agents/core/configuration.rb

@@ -109,6 +109,14 @@ module RubyLLM
       #   Number of recent executions shown on the dashboard home.
       #   @return [Integer] Limit for recent executions (default: 10)
 
+      # @!attribute [rw] dashboard_query_timeout
+      #   Seconds a single dashboard query may run before the database cancels
+      #   it. A cancelled query renders a "narrow the time range" notice
+      #   instead of leaving the request (and the database) grinding on a scan
+      #   of the whole executions table. Enforced on PostgreSQL only; a
+      #   stricter statement_timeout already set on the connection wins.
+      #   @return [Numeric, nil] Timeout in seconds, or nil to disable (default: 5)
+
       # @!attribute [rw] job_retry_attempts
       #   Number of retry attempts for the async logging job on failure.
       #   @return [Integer] Retry attempts (default: 3)
@@ -494,6 +502,7 @@ module RubyLLM
         :anomaly_duration_threshold,
         :per_page,
         :recent_executions_limit,
+        :dashboard_query_timeout,
         :job_retry_attempts,
         :messages_summary_max_length,
         :dashboard_auth,
@@ -560,6 +569,15 @@ module RubyLLM
         @recent_executions_limit = value
       end
 
+      # Sets dashboard_query_timeout with validation
+      #
+      # @param value [Numeric, nil] Seconds (must be > 0), or nil to disable
+      # @raise [ArgumentError] If value is not positive
+      def dashboard_query_timeout=(value)
+        validate_positive!(:dashboard_query_timeout, value) unless value.nil?
+        @dashboard_query_timeout = value
+      end
+
       # Sets job_retry_attempts with validation
       #
       # @param value [Integer] Retry attempts (must be >= 0)
@@ -702,6 +720,7 @@ module RubyLLM
         @basic_auth_password = nil
         @per_page = 25
         @recent_executions_limit = 10
+        @dashboard_query_timeout = 5
         @job_retry_attempts = 3
 
         # Reliability defaults (all disabled by default for backward compatibility)
@@ -1031,6 +1050,7 @@ module RubyLLM
           dashboard: {
             per_page: per_page,
             recent_executions_limit: recent_executions_limit,
+            dashboard_query_timeout: dashboard_query_timeout,
             dashboard_parent_controller: dashboard_parent_controller,
             basic_auth_username: basic_auth_username,
             dashboard_auth: dashboard_auth&.class&.name

data/lib/ruby_llm/agents/core/version.rb

@@ -4,6 +4,6 @@ module RubyLLM
   module Agents
     # Current version of the RubyLLM::Agents gem
     # @return [String] Semantic version string
-    VERSION = "3.15.1"
+    VERSION = "3.16.0"
   end
 end

data/lib/ruby_llm/agents/pipeline/middleware/instrumentation.rb

@@ -172,6 +172,12 @@ module RubyLLM
           # Falls back to creating a new record if the initial record is nil.
           # Errors are re-raised to allow the ensure block to handle them.
           #
+          # The record is locked and reloaded before updating: the instance
+          # held here was created when the pipeline started and may be stale —
+          # a concurrent transition (e.g. operator cancellation or a timeout
+          # sweep) can have written a terminal status in the meantime, and the
+          # completion must not overwrite it.
+          #
           # @param execution [Execution, nil] The execution record to update
           # @param context [Context] The execution context
           # @param status [String] Final status ("success", "error", "timeout")
@@ -188,7 +194,7 @@ module RubyLLM
             end
 
             update_data = build_completion_data(context, status)
-            execution.update!(update_data)
+            return unless complete_running_execution(execution, update_data)
 
             # Save detail data (prompts, responses, tool calls, etc.)
             save_execution_details(execution, context, status)
@@ -197,6 +203,31 @@ module RubyLLM
             raise # Re-raise for ensure block to handle via mark_execution_failed!
           end
 
+          # Applies the completion update unless the execution already left
+          # "running" state.
+          #
+          # Locks the row and reloads it, so the status check and the update
+          # are atomic with respect to concurrent status transitions: whichever
+          # side wins the row lock first keeps the row. A completion that finds
+          # a terminal status is dropped instead of overwriting it.
+          #
+          # @param execution [Execution] The execution record to update
+          # @param update_data [Hash] The completion attributes
+          # @return [Boolean] Whether the completion update was applied
+          def complete_running_execution(execution, update_data)
+            return execution.update!(update_data) unless execution.persisted?
+
+            execution.with_lock do
+              if execution.status == "running"
+                execution.update!(update_data)
+                true
+              else
+                debug("Skipped completion for execution #{execution.id}: already #{execution.status}")
+                false
+              end
+            end
+          end
+
           # Emergency fallback to mark execution as failed
           #
           # Uses update_all to bypass ActiveRecord callbacks and validations,
@@ -431,6 +462,13 @@ module RubyLLM
               data[:attempts_count] = context[:reliability_attempts].size
             end
 
+            # Carry the tracker request_id/tags that
+            # build_running_execution_data injected through the metadata
+            # rebuild — otherwise a completed execution loses them. Only
+            # merge into a rebuild that actually produced metadata: when
+            # none did, the running record's metadata stays untouched.
+            inject_tracker_data(context, data) if data[:metadata]
+
             data
           end
 

data/lib/ruby_llm/agents/rails/engine.rb

@@ -53,6 +53,7 @@ module RubyLLM
           layout "ruby_llm/agents/application"
           helper RubyLLM::Agents::ApplicationHelper
           before_action :authenticate_dashboard!
+          around_action :limit_query_time, if: -> { request.get? }
 
           rescue_from ::ActiveRecord::StatementInvalid do |e|
             if e.message.include?("ruby_llm_agents_")
@@ -65,8 +66,54 @@ module RubyLLM
             end
           end
 
+          # Declared after the StatementInvalid handler so it wins: a cancelled
+          # query is a StatementInvalid too, and must not be reported as a
+          # pending migration.
+          rescue_from ::ActiveRecord::QueryCanceled do
+            @query_timeout = RubyLLM::Agents.configuration.dashboard_query_timeout
+
+            if request.format.json?
+              render json: {error: "query_timeout"}, status: :service_unavailable
+            else
+              render "ruby_llm/agents/shared/query_timeout", formats: [:html], status: :service_unavailable
+            end
+          end
+
           private
 
+          # Runs the page under config.dashboard_query_timeout
+          #
+          # Every dashboard page aggregates over a user-chosen window of the
+          # executions table. Without a ceiling, a wide window on a large
+          # table keeps running after the web server has timed the request
+          # out — the user sees a 500 and the database keeps scanning. With
+          # it, the database cancels the query and the QueryCanceled handler
+          # above explains what to narrow.
+          #
+          # @return [void]
+          # @api private
+          def limit_query_time(&block)
+            RubyLLM::Agents::Execution.with_statement_timeout(
+              RubyLLM::Agents.configuration.dashboard_query_timeout, &block
+            )
+          end
+
+          # Caches an expensive dashboard aggregate for a short while
+          #
+          # Dashboard figures are read far more often than they meaningfully
+          # change (reloads, pagination, several people watching the same
+          # page), and each one is a scan of a time window. The current
+          # tenant is always part of the key.
+          #
+          # @param key [Array] Identifies the figure and its filters
+          # @param expires_in [ActiveSupport::Duration] How stale it may get
+          # @return [Object] The block's value (nil is cached too)
+          # @api private
+          def cached_stats(*key, expires_in: 1.minute, &block)
+            Rails.cache.fetch(["ruby_llm_agents", "stats", current_tenant_id, *key],
+              expires_in: expires_in, race_condition_ttl: 10.seconds, &block)
+          end
+
           # Authenticates dashboard access using configured method
           #
           # Authentication priority:
@@ -160,18 +207,12 @@ module RubyLLM
           # configured name; legacy or string-only tenants fall back to the raw
           # tenant_id so nothing disappears from the filter.
           #
-          # Two queries total — one DISTINCT pluck on executions, one pluck on
-          # tenants — regardless of how many tenant_ids exist.
-          #
           # @return [Array<Hash>] Entries shaped as { value:, label: }
           # @api public
           def available_tenants
             return @available_tenants if defined?(@available_tenants)
 
-            tenant_ids = RubyLLM::Agents::Execution
-              .where.not(tenant_id: nil)
-              .distinct
-              .pluck(:tenant_id)
+            tenant_ids = cached_filter_options(:tenant_id)
 
             names_by_id = RubyLLM::Agents::Tenant
               .where(tenant_id: tenant_ids)
@@ -183,6 +224,45 @@ module RubyLLM
               .sort_by { |t| t[:label].downcase }
           end
           helper_method :available_tenants
+
+          # Distinct agent types in the execution history, sorted
+          #
+          # @return [Array<String>]
+          # @api public
+          def available_agent_types
+            cached_filter_options(:agent_type)
+          end
+
+          # Distinct model IDs in the execution history, sorted
+          #
+          # @return [Array<String>]
+          # @api public
+          def available_model_ids
+            cached_filter_options(:model_id)
+          end
+
+          # Distinct values of an executions column, for a filter dropdown
+          #
+          # Read with Execution.distinct_values, which walks the column's
+          # index rather than scanning the table, and cached on top of that:
+          # the lists only change when a brand-new agent, model or tenant
+          # appears, and several pages need two or three of them per request.
+          # A new value shows up in the dropdown within five minutes;
+          # filtering by it via URL params works immediately.
+          #
+          # The lists are deliberately not narrowed to the current tenant.
+          # Doing so means reading every one of that tenant's executions, and
+          # agent and model names are application configuration rather than
+          # tenant data.
+          #
+          # @param column [Symbol] :agent_type, :model_id or :tenant_id
+          # @return [Array<String>]
+          # @api private
+          def cached_filter_options(column)
+            Rails.cache.fetch(["ruby_llm_agents", "filter_options", column], expires_in: 5.minutes) do
+              RubyLLM::Agents::Execution.distinct_values(column)
+            end
+          end
         end)
       end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_llm-agents
 version: !ruby/object:Gem::Version
-  version: 3.15.1
+  version: 3.16.0
 platform: ruby
 authors:
 - adham90
@@ -90,6 +90,7 @@ files:
 - app/models/ruby_llm/agents/agent_override.rb
 - app/models/ruby_llm/agents/execution.rb
 - app/models/ruby_llm/agents/execution/analytics.rb
+- app/models/ruby_llm/agents/execution/breakdown.rb
 - app/models/ruby_llm/agents/execution/metrics.rb
 - app/models/ruby_llm/agents/execution/replayable.rb
 - app/models/ruby_llm/agents/execution/scopes.rb
@@ -131,11 +132,13 @@ files:
 - app/views/ruby_llm/agents/shared/_doc_link.html.erb
 - app/views/ruby_llm/agents/shared/_executions_table.html.erb
 - app/views/ruby_llm/agents/shared/_filter_dropdown.html.erb
+- app/views/ruby_llm/agents/shared/_pagination.html.erb
 - app/views/ruby_llm/agents/shared/_select_dropdown.html.erb
 - app/views/ruby_llm/agents/shared/_sortable_header.html.erb
 - app/views/ruby_llm/agents/shared/_status_badge.html.erb
 - app/views/ruby_llm/agents/shared/_status_dot.html.erb
 - app/views/ruby_llm/agents/shared/_tenant_filter.html.erb
+- app/views/ruby_llm/agents/shared/query_timeout.html.erb
 - app/views/ruby_llm/agents/system_config/show.html.erb
 - app/views/ruby_llm/agents/tenants/_form.html.erb
 - app/views/ruby_llm/agents/tenants/edit.html.erb
@@ -165,8 +168,10 @@ files:
 - lib/generators/ruby_llm_agents/templates/add_caching_migration.rb.tt
 - lib/generators/ruby_llm_agents/templates/add_dashboard_performance_indexes_migration.rb.tt
 - lib/generators/ruby_llm_agents/templates/add_execution_type_migration.rb.tt
+- lib/generators/ruby_llm_agents/templates/add_executions_analytics_index_migration.rb.tt
 - lib/generators/ruby_llm_agents/templates/add_finish_reason_migration.rb.tt
 - lib/generators/ruby_llm_agents/templates/add_prompts_migration.rb.tt
+- lib/generators/ruby_llm_agents/templates/add_root_execution_list_index_migration.rb.tt
 - lib/generators/ruby_llm_agents/templates/add_routing_migration.rb.tt
 - lib/generators/ruby_llm_agents/templates/add_streaming_migration.rb.tt
 - lib/generators/ruby_llm_agents/templates/add_tenant_to_executions_migration.rb.tt
@@ -359,7 +364,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.7
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Agent framework for building LLM-powered agents with RubyLLM
 test_files: []