actionagent 1.7.2 → 1.8.1

data/app/models/action_agent/sandbox_session.rb

@@ -6,6 +6,7 @@ module ActionAgent
     owned_by :user, :account
 
     belongs_to :agent_template, optional: true
+    has_many :code_sessions, dependent: :destroy
 
     # Session statuses
     enum :status, {
@@ -18,8 +19,14 @@ module ActionAgent
       failed: 6
     }
 
-    # Sandbox types
-    SANDBOX_TYPES = %w[playwright_mcp terminal research].freeze
+    # Sandbox types. +app_runtime+ boots a checkout of one of the owner's
+    # GitHub repositories (see GithubConnection) and exposes that app's own
+    # runtime, so agents and evaluations can use its tools.
+    SANDBOX_TYPES = %w[playwright_mcp terminal research app_runtime].freeze
+
+    # MCP server keys naming a checkout sandbox's app runtime, as an agent's
+    # mcp_servers lists them: "sandbox:<session_id>".
+    RUNTIME_SERVER_PREFIX = "sandbox:"
 
     # Free tier limits
     FREE_TIER_LIMITS = {
@@ -29,9 +36,21 @@ module ActionAgent
       session_duration_minutes: 15
     }.freeze
 
+    # How long a checkout sandbox lives. Booting one (clone, bundle install,
+    # db:prepare) can take minutes, and it is worked in for a while after —
+    # Claude Code sessions, agents using its tools — so the free tier's 15
+    # minutes would expire it about as soon as it was ready.
+    APP_RUNTIME_SESSION_DURATION = 2.hours
+
+    encrypts :runtime_mcp_token if ActionAgent.encrypt_credentials
+
     # Validations
     validates :session_id, presence: true, uniqueness: true
     validates :sandbox_type, inclusion: { in: SANDBOX_TYPES }
+    validates :repository, presence: true, if: :app_runtime?
+    validates :repository_ref, length: { maximum: 255 }, format: { without: /\A-|\s|\.\./, message: "is not a valid git ref" },
+      allow_blank: true
+    validate :repository_available, on: :create, if: :app_runtime?
 
     # Callbacks
     before_validation :generate_session_id, on: :create
@@ -51,6 +70,101 @@ module ActionAgent
       Array(mcp_servers).filter_map { |key| MCPCatalog.find(key) }
     end
 
+    def self.runtime_server_key?(key)
+      key.to_s.start_with?(RUNTIME_SERVER_PREFIX)
+    end
+
+    # The MCP catalog entry for a checkout sandbox's app runtime, looked up
+    # among +owner+'s sessions only. Nil unless the session is live and its
+    # backend reported an endpoint.
+    #
+    # @return [Hash, nil]
+    def self.runtime_server_entry(key, owner:)
+      return nil unless runtime_server_key?(key)
+
+      session = for_owner(owner).find_by(session_id: key.to_s.delete_prefix(RUNTIME_SERVER_PREFIX))
+      session&.runtime_server_entry
+    end
+
+    # The live runtimes in +scope+ (a relation already scoped to an owner) as
+    # MCP server listings: the catalog entry shape MCPCatalog serves, without
+    # the bearer token runtime_server_entry carries for the dispatcher.
+    #
+    # @return [Array<Hash>]
+    def self.runtime_server_listings(scope)
+      scope.active.by_type("app_runtime")
+        .where.not(runtime_mcp_url: [ nil, "" ])
+        .where("expires_at > ?", Time.current)
+        .recent.limit(20)
+        .filter_map(&:runtime_server_listing)
+    end
+
+    def app_runtime?
+      sandbox_type == "app_runtime"
+    end
+
+    def runtime_server_key
+      "#{RUNTIME_SERVER_PREFIX}#{session_id}"
+    end
+
+    # This session's app runtime as an MCP catalog entry — the shape
+    # MCPToolDispatcher reaches servers through.
+    def runtime_server_entry
+      return nil unless app_runtime? && active? && runtime_mcp_url.present?
+
+      {
+        key: runtime_server_key,
+        name: "#{repository}@#{repository_ref} (sandbox)",
+        description: "App runtime booted from a checkout of #{repository}",
+        transport: "streamable_http",
+        url: runtime_mcp_url,
+        headers: runtime_mcp_token.present? ? { "Authorization" => "Bearer #{runtime_mcp_token}" } : {}
+      }
+    end
+
+    # This runtime as a token-free MCP server listing (see
+    # runtime_server_listings), or nil when it is not live.
+    def runtime_server_listing
+      entry = runtime_server_entry or return nil
+
+      entry.except(:headers).merge(
+        command: nil, package: nil, categories: [ "runtime" ], docs_url: nil,
+        sandbox: false, sandbox_type: "app_runtime", first_party: false,
+        requires_credentials: [], tools: [], runtime: true
+      )
+    end
+
+    # What a sandbox backend clones for an app_runtime session: repository,
+    # ref, clone URL and the credentials to fetch it. Nil for any other
+    # sandbox type. Carries the owner's GitHub token, so it goes to the
+    # backend and never into a response.
+    #
+    # @return [Hash, nil]
+    def checkout_spec
+      return nil unless app_runtime?
+
+      github_connection&.checkout_spec(repository, ref: repository_ref)
+    end
+
+    # The GitHub connection whose selection this session's checkout comes
+    # from.
+    def github_connection
+      owners_record(GithubConnection)
+    end
+
+    # Environment the backend passes into an app_runtime checkout, so the
+    # booted app can run Claude Code sessions against it with the owner's
+    # connected credential (Settings -> Integrations). Empty when none is
+    # connected. Secret — for the backend, never a response.
+    #
+    # @return [Hash{String => String}]
+    def runtime_environment(runner: "claude_code")
+      return {} unless app_runtime?
+      return {} unless ProviderKey::CONNECTION_PROVIDERS.include?(runner)
+
+      owners_record(ProviderKey.where(provider: runner))&.runtime_environment || {}
+    end
+
     # Check if session is still valid
     def active?
       !expired? && !failed? && !completed? && expires_at > Time.current
@@ -95,28 +209,42 @@ module ActionAgent
 
       update!(status: :provisioning)
 
-      # In development, run synchronously for immediate feedback
-      if Rails.env.development? || Rails.env.test?
+      # A checkout always boots in the background: cloning and setting up a
+      # real app takes minutes, and a request must not wait on it, in
+      # development either. The client polls the session until it is ready
+      # (or failed). The other types are simulated in development and test,
+      # synchronously for immediate feedback.
+      if !app_runtime? && (Rails.env.development? || Rails.env.test?)
         SandboxProvisionJob.perform_now(id)
       else
         SandboxProvisionJob.perform_later(id)
       end
     end
 
-    # Mark as ready with Cloud Run URL
-    def mark_ready!(cloud_run_url:, cloud_run_job_id: nil)
-      update!(
-        status: :ready,
-        cloud_run_url: cloud_run_url,
-        cloud_run_job_id: cloud_run_job_id
-      )
+    # Mark as ready with Cloud Run URL. A checkout sandbox's backend also
+    # reports the app runtime's MCP endpoint and the token it expects.
+    def mark_ready!(cloud_run_url:, cloud_run_job_id: nil, runtime_mcp_url: nil, runtime_mcp_token: nil)
+      attributes = { status: :ready, cloud_run_url: cloud_run_url, cloud_run_job_id: cloud_run_job_id }
+      attributes[:runtime_mcp_url] = runtime_mcp_url if runtime_mcp_url
+      attributes[:runtime_mcp_token] = runtime_mcp_token if runtime_mcp_token
+      update!(attributes)
     end
 
-    # Expire the session
+    # Expire the session. Its runtime stops being reachable at once — the
+    # endpoint and its token are cleared, so no agent is handed a runtime
+    # that is going away — and the backend's resource is released by
+    # SandboxCleanupJob, which keeps the handle until that succeeds.
+    #
+    # Under the row lock, which reloads the row first: callers (DELETE, the
+    # reaper) loaded this copy earlier, and SandboxProvisionJob may have
+    # marked it ready since. Acting on the stale copy would neither clear the
+    # endpoint it recorded (nil -> nil writes nothing) nor see the handle to
+    # terminate, leaving the booted sandbox running.
     def expire!
-      update!(status: :expired)
-      # Cleanup Cloud Run resources
-      SandboxCleanupJob.perform_later(id) if cloud_run_job_id.present?
+      with_lock { update!(status: :expired, runtime_mcp_url: nil, runtime_mcp_token: nil) }
+      # A checkout with no handle may still have a boot behind it (its job
+      # died mid-boot, say); the cleanup job asks the backend for it.
+      SandboxCleanupJob.perform_later(id) if cloud_run_job_id.present? || app_runtime?
     end
 
     # Summary for API responses
@@ -132,10 +260,30 @@ module ActionAgent
         expires_at: expires_at&.iso8601,
         created_at: created_at.iso8601,
         cloud_run_url: cloud_run_url,
-        mcp_servers: Array(mcp_servers)
+        mcp_servers: Array(mcp_servers),
+        repository: repository,
+        repository_ref: repository_ref,
+        # The key an agent adds to its mcp_servers to use this runtime's
+        # tools; nil until the backend has reported the endpoint.
+        runtime_server_key: runtime_mcp_url.present? ? runtime_server_key : nil,
+        # Why provisioning failed. Scrubbed of the session's secrets when
+        # SandboxProvisionJob stored it.
+        error_message: error_summary
       }
     end
 
+    # A failed boot's message is a one-line reason followed by the tail of
+    # the failing step's log, and the log's last lines usually hold the
+    # actual error — so a long message keeps its head and its end.
+    ERROR_SUMMARY_HEAD = 300
+    ERROR_SUMMARY_TAIL = 1_700
+
+    def error_summary
+      return error_message if error_message.nil? || error_message.length <= ERROR_SUMMARY_HEAD + ERROR_SUMMARY_TAIL
+
+      "#{error_message[0, ERROR_SUMMARY_HEAD]}\n…\n#{error_message[-ERROR_SUMMARY_TAIL..]}"
+    end
+
     # Detailed info including runs
     def details
       summary.merge(
@@ -147,12 +295,41 @@ module ActionAgent
 
     private
 
+    # The owner's record in +scope+, found through that model's own owner
+    # column. GitHub connections and provider keys are account-owned before
+    # user-owned, the opposite of a session, so the session's #owner is not
+    # necessarily theirs.
+    def owners_record(scope)
+      scope = scope.all
+      case scope.klass.owner_association
+      when :account then account_id && scope.find_by(account_id: account_id)
+      when :user then user_id && scope.find_by(user_id: user_id)
+      else scope.first
+      end
+    end
+
+    def repository_available
+      return if repository.blank?
+
+      connection = github_connection
+      if connection.nil?
+        errors.add(:repository, "needs a GitHub connection (Settings -> Integrations)")
+      elsif (repo = connection.repository(repository))
+        # Canonical spelling, and the default branch unless a ref was asked for.
+        self.repository = repo["full_name"]
+        self.repository_ref = repository_ref.presence || repo["default_branch"]
+      else
+        errors.add(:repository, "is not one of the repositories selected in Settings -> Integrations")
+      end
+    end
+
     def generate_session_id
       self.session_id ||= SecureRandom.uuid
     end
 
     def set_expiration
-      self.expires_at ||= FREE_TIER_LIMITS[:session_duration_minutes].minutes.from_now
+      duration = app_runtime? ? APP_RUNTIME_SESSION_DURATION : FREE_TIER_LIMITS[:session_duration_minutes].minutes
+      self.expires_at ||= duration.from_now
       self.max_runs ||= FREE_TIER_LIMITS[:max_runs]
       self.timeout_seconds ||= FREE_TIER_LIMITS[:timeout_seconds]
     end

data/app/serializers/action_agent/evaluation_serializer.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module ActionAgent
+  # Used to render evaluations and their runs for the dashboard's JSON API
+  # (Api::EvaluationsController) and its MCP facade (Api::MCPController), so
+  # both describe an evaluation the same way.
+  #
+  # A run's `number` is its position in its evaluation's history, oldest = 1,
+  # so a client can say "Run #3" and "vs #2".
+  module EvaluationSerializer
+    module_function
+
+    # Returns the evaluation with its latest run in full and just enough of
+    # the run before it to show movement ("+3 passed vs #2") without a
+    # request per evaluation. The headline run — the newest complete one —
+    # rides along in full as `headline_run` when a newer run is pending or
+    # failed, so a page can describe the finished run while showing the
+    # newer one beside it.
+    def evaluation(evaluation)
+      summary = summary(evaluation)
+      latest, previous = recent_runs(evaluation, 2)
+      headline = evaluation.standing_info.headline_run
+      headline = nil if headline.nil? || headline.id == latest&.id
+
+      summary.merge(
+        latest_run: latest ? run(latest, number: summary[:run_count]) : nil,
+        previous_run: previous ? run_summary(previous, number: summary[:run_count] - 1) : nil,
+        headline_run: headline ? run(headline, number: run_number(evaluation, headline)) : nil
+      )
+    end
+
+    # Returns the evaluation's configuration and run count, without its runs,
+    # and where it stands: `headline_run_id` (its newest complete run),
+    # `standing` against the agent's current version (EvaluationStanding),
+    # `archived_at`, and the headline run's passes `per_model`.
+    def summary(evaluation)
+      standing = evaluation.standing_info
+      {
+        id: evaluation.id,
+        name: evaluation.name,
+        agent: { id: evaluation.agent.id, name: evaluation.agent.name, slug: evaluation.agent.slug },
+        judge_kind: evaluation.judge_kind,
+        judge_model: evaluation.judge_model,
+        criteria: evaluation.criteria,
+        compare_models: evaluation.compare_models,
+        config: evaluation.config,
+        sample_size: evaluation.sample_size,
+        scenario_suite: evaluation.scenario_suite?,
+        scenario_count: evaluation.scenarios.size,
+        scenario_groups: evaluation.scenario_suite? ? evaluation.scenario_groups : [],
+        created_at: evaluation.created_at.iso8601,
+        # size reads a preloaded association and COUNTs otherwise.
+        run_count: evaluation.evaluation_runs.size,
+        headline_run_id: standing.headline_run&.id,
+        standing: standing.standing,
+        archived_at: evaluation.archived_at&.iso8601,
+        per_model: standing.per_model
+      }
+    end
+
+    # Returns the run summary plus its scores, selection, models, usage and
+    # error.
+    def run(run, number: nil)
+      run_summary(run, number: number).merge(
+        scores: scores(run),
+        selection: run.selection,
+        models: run.models,
+        usage: run.usage,
+        error_message: run.error_message
+      )
+    end
+
+    # Returns the run's scores with each scenario model summary carrying its
+    # "priced" count (EvaluationRun#model_summaries).
+    def scores(run)
+      summaries = run.model_summaries
+      summaries.empty? ? run.scores : run.scores.merge("_models" => summaries)
+    end
+
+    # Returns the run's status and headline numbers. `sandbox` is the
+    # checkout sandbox the run replayed against, if any: its session id and
+    # checkout, never its token. `agent_version` is the version of the
+    # agent the run scored, and `version_state` whether that is the agent's
+    # current version ("current", "earlier" or "unrecorded").
+    def run_summary(run, number: nil)
+      {
+        id: run.id,
+        number: number,
+        status: run.status,
+        average_score: average_score(run),
+        samples_evaluated: run.samples_evaluated,
+        samples_passed: run.samples_passed,
+        completed_at: run.completed_at&.iso8601,
+        created_at: run.created_at.iso8601,
+        sandbox: run.sandbox,
+        agent_version: run.agent_version_summary,
+        version_state: run.evaluation.standing_info.version_state(run)
+      }
+    end
+
+    # Returns up to +limit+ of the evaluation's runs, newest first. Sorts the
+    # preloaded association when one was loaded rather than issuing one
+    # ORDER BY query per evaluation.
+    def recent_runs(evaluation, limit)
+      runs = evaluation.evaluation_runs
+      if runs.loaded?
+        runs.sort_by { |run| [ run.created_at, run.id ] }.reverse.first(limit)
+      else
+        runs.order(created_at: :desc, id: :desc).limit(limit).to_a
+      end
+    end
+
+    # Returns the run's position in its evaluation's history, oldest = 1 —
+    # counted in the preloaded association when one was loaded.
+    def run_number(evaluation, run)
+      runs = evaluation.evaluation_runs
+      if runs.loaded?
+        runs.count { |other| other.created_at < run.created_at || (other.created_at == run.created_at && other.id <= run.id) }
+      else
+        runs.where("created_at < ? OR (created_at = ? AND id <= ?)", run.created_at, run.created_at, run.id).count
+      end
+    end
+
+    # Returns the run's fix items, or [] when they cannot be built. They are
+    # derived from every persisted result's diagnosis, which older runs
+    # recorded in earlier shapes, so a run they fail for still serves its
+    # results. Without +links+ the item paths are relative to the mount.
+    def fix_items(run, links: nil)
+      links ? run.fix_items(links: links) : run.fix_items
+    rescue StandardError => e
+      Rails.logger.warn(
+        "[ActionAgent] evaluation run #{run.id} fix_items failed: #{e.class}: #{e.message}"
+      )
+      []
+    end
+
+    # Returns the run's average score, or nil when its scores payload cannot
+    # be averaged, so one bad run degrades its own headline number rather
+    # than failing a whole listing.
+    def average_score(run)
+      run.average_score
+    rescue StandardError => e
+      Rails.logger.warn(
+        "[ActionAgent] evaluation run #{run.id} average_score failed: #{e.class}: #{e.message}"
+      )
+      nil
+    end
+  end
+end

data/app/serializers/action_agent/telemetry_trace_serializer.rb

@@ -21,7 +21,16 @@ module ActionAgent
       @trace = trace
     end
 
+    def self.row(trace)
+      new(trace).row
+    end
+
     def summary
+      row.merge(spans: serialized_spans)
+    end
+
+    # The summary without its spans: one line of a trace listing.
+    def row
       {
         id: @trace.id,
         trace_id: @trace.trace_id,
@@ -48,8 +57,7 @@ module ActionAgent
           model: @trace.model,
           input_tokens: @trace.total_input_tokens,
           output_tokens: @trace.total_output_tokens
-        ),
-        spans: serialized_spans
+        )
       }
     end
 

data/app/services/action_agent/agent_execution_service.rb

@@ -113,6 +113,7 @@ module ActionAgent
 
     def call
       @agent_record.ensure_executable!
+      mcp_dispatcher.ensure_extra_servers_live!
       root_span = @root_span = build_root_span
       record_prompt_span(root_span)
       llm_span = root_span.add_span(
@@ -415,9 +416,10 @@ module ActionAgent
     # its reply, so agents can delegate to each other as a tool call. The
     # sub-run is a real AgentRun with its own trace.
     # One dispatcher per run, so every tool call shares the MCP sessions the
-    # first call opens.
+    # first call opens. A run given a checkout sandbox (an evaluation or a
+    # runner run against it) reaches that runtime too.
     def mcp_dispatcher
-      @mcp_dispatcher ||= MCPToolDispatcher.new(@agent_record)
+      @mcp_dispatcher ||= MCPToolDispatcher.new(@agent_record, extra_server_keys: [ @run.try(:sandbox_server_key) ].compact)
     end
 
     # Splits the offered schemas the way `tool_schemas` assembles them, so the

data/app/services/action_agent/agent_scorecard.rb

@@ -32,7 +32,7 @@ module ActionAgent
       avg_durations = windowed.where.not(duration_ms: nil).group(:agent_id).average(:duration_ms)
       token_sums = windowed.group(:agent_id).sum("COALESCE(total_tokens, 0)")
       last_runs = AgentRun.where(agent_id: ids).group(:agent_id).maximum(:created_at)
-      eval_runs = latest_evaluation_runs(ids)
+      evals = evaluation_tiles(ids)
 
       trace_stats = telemetry_stats(ids, window_start)
       trace_last = unclaimed_traces(ids, nil).group(:agent_id).maximum(:timestamp)
@@ -44,7 +44,7 @@ module ActionAgent
         traced = stats[:count].to_i
         total = runs + traced
         succeeded = completed_counts[id].to_i + stats[:ok].to_i
-        eval_run = eval_runs[id]
+        eval_tile = evals[id] || {}
 
         {
           window_days: (WINDOW / 1.day).to_i,
@@ -55,9 +55,13 @@ module ActionAgent
           avg_duration_ms: blended_duration(avg_durations[id], runs, stats[:avg_duration], traced),
           tokens: token_sums[id].to_i + stats[:tokens].to_i,
           cost: costs[id],
-          eval_score: eval_run&.average_score,
-          eval_samples_passed: eval_run&.samples_passed,
-          eval_samples_evaluated: eval_run&.samples_evaluated,
+          # The evaluation tile: the pass rate pooled over the headline runs
+          # of the agent's evaluations that stand against its current version.
+          eval_score: eval_tile[:score],
+          eval_samples_passed: eval_tile[:passed],
+          eval_samples_evaluated: eval_tile[:evaluated],
+          eval_runs: eval_tile[:runs],
+          eval_not_counted: eval_tile[:not_counted],
           last_run_at: [ last_runs[id], trace_last[id] ].compact.max&.iso8601
         }
       end
@@ -170,22 +174,47 @@ module ActionAgent
     end
     private_class_method :blended_duration
 
-    # Latest complete evaluation run per agent. DISTINCT ON would do this in
-    # one pass on PostgreSQL, but it has no portable equivalent, so the
-    # highest id per agent (runs are only ever appended) is selected first
-    # and those rows fetched by id.
-    def self.latest_evaluation_runs(agent_ids)
-      evaluations = Evaluation.table_name
-      runs = EvaluationRun.table_name
-
-      newest = EvaluationRun.complete.joins(:evaluation)
-        .where(evaluations => { agent_id: agent_ids })
-        .group("#{evaluations}.agent_id")
-        .pluck(Arel.sql("#{evaluations}.agent_id"), Arel.sql("MAX(#{runs}.id)"))
-
-      by_run_id = newest.to_h { |agent_id, run_id| [ run_id, agent_id ] }
-      EvaluationRun.where(id: by_run_id.keys).index_by { |run| by_run_id[run.id] }
+    # The evaluation tile per agent: passes pooled over the headline runs
+    # (newest complete run) of its evaluations that are current against the
+    # agent's version or unrecorded, as the Evaluations page pools them —
+    # never a stale suite last run against older code, nor an archived one
+    # — so the tile is the pass rate of the agent as it is now, not a mean
+    # of criterion scores over whatever ran last.
+    #
+    #   { agent_id => { score:, passed:, evaluated:, runs:, not_counted: } }
+    #
+    # `score` is the pooled pass rate 0..1 (nil with nothing to count),
+    # `runs` the headline runs pooled and `not_counted` the evaluations
+    # left out as stale or archived. The newest complete run per evaluation
+    # is selected by id first (runs are only ever appended) and those rows
+    # fetched by id, which runs the same on every database.
+    def self.evaluation_tiles(agent_ids)
+      evaluations = Evaluation.where(agent_id: agent_ids).includes(:agent).to_a
+      return {} if evaluations.empty?
+
+      newest = EvaluationRun.complete.where(evaluation_id: evaluations.map(&:id)).group(:evaluation_id).maximum(:id)
+      runs = EvaluationRun.where(id: newest.values).includes(:agent_version).index_by(&:evaluation_id)
+      EvaluationStanding.preload(evaluations)
+
+      evaluations.group_by(&:agent_id).to_h do |agent_id, mine|
+        tile = { score: nil, passed: 0, evaluated: 0, runs: 0, not_counted: 0 }
+        mine.each do |evaluation|
+          run = runs[evaluation.id]
+          next unless run
+
+          unless evaluation.standing_info.with_headline(run).counted?
+            tile[:not_counted] += 1
+            next
+          end
+
+          tile[:runs] += 1
+          tile[:passed] += run.samples_passed.to_i
+          tile[:evaluated] += run.samples_evaluated.to_i
+        end
+        tile[:score] = (tile[:passed].to_f / tile[:evaluated]).round(3) if tile[:evaluated].positive?
+        [ agent_id, tile ]
+      end
     end
-    private_class_method :latest_evaluation_runs
+    private_class_method :evaluation_tiles
   end
 end

data/app/services/action_agent/agent_tool_roster.rb

@@ -25,7 +25,9 @@ module ActionAgent
   #   offers every agent. These are the roster: +agent.tools+ is what
   #   AgentToolbox turns into function schemas at generation time.
   # * **MCP** — never stored on the roster. Computed from the services the
-  #   agent enables, which is where they are edited.
+  #   agent enables, which is where they are edited. The services are the
+  #   catalog plus the live checkout sandbox runtimes the caller hands in
+  #   (+runtimes:+), which an agent enables under their "sandbox:<id>" keys.
   #
   # Enablement reads the agent's own configuration: +tools+ for the dashboard
   # capabilities and the schema tools, +mcp_servers+ for services and their
@@ -40,13 +42,16 @@ module ActionAgent
     # workspace already talks to, then the rest of the catalog.
     STATUS_RANK = { "active" => 0, "configured" => 1, "available" => 2, "idle" => 3 }.freeze
 
-    attr_reader :agent, :discovery
+    attr_reader :agent, :discovery, :runtimes
 
     # @param agent [ActionAgent::Agent] the agent being edited
     # @param traces [ActiveRecord::Relation] the traces the caller may read
     # @param hours [Integer] the window the usage columns are scoped to
-    def initialize(agent:, traces:, hours: ToolDiscovery::DEFAULT_WINDOW_HOURS)
+    # @param runtimes [Array<Hash>] live checkout sandbox runtimes this agent
+    #   can be given, as SandboxSession.runtime_server_listings returns them
+    def initialize(agent:, traces:, hours: ToolDiscovery::DEFAULT_WINDOW_HOURS, runtimes: [])
       @agent = agent
+      @runtimes = Array(runtimes).index_by { |runtime| runtime[:key] }
       @discovery = ToolDiscovery.new(
         traces: agent.telemetry_traces(traces),
         agents: Agent.where(id: agent.id),
@@ -89,10 +94,10 @@ module ActionAgent
       end
     end
 
-    # The catalog, plus anything this agent's traffic or configuration names
-    # that the catalog doesn't describe.
+    # The catalog and the live runtimes, plus anything this agent's traffic or
+    # configuration names that neither describes.
     def service_keys
-      (MCPCatalog.keys + detected_by_server.keys + configured_servers.keys).uniq
+      (MCPCatalog.keys + runtimes.keys + detected_by_server.keys + configured_servers.keys).uniq
     end
 
     def detected_by_server
@@ -100,7 +105,8 @@ module ActionAgent
     end
 
     def service_row(key)
-      catalog = MCPCatalog.find(key)
+      # A live runtime reads as a known service; its listing carries no token.
+      catalog = MCPCatalog.find(key) || runtimes[key]
       used = detected_by_server[key] || []
       calls = used.sum { |tool| tool[:calls] }
       enabled = configured_servers.key?(key)
@@ -112,6 +118,7 @@ module ActionAgent
         docs_url: catalog&.dig(:docs_url),
         first_party: catalog ? catalog[:first_party] : false,
         known: !catalog.nil?,
+        runtime: SandboxSession.runtime_server_key?(key),
         transport: transport_label(catalog),
         status: service_status(calls, enabled, catalog),
         enabled: enabled,
@@ -125,12 +132,16 @@ module ActionAgent
     # How to reach the server, in the one line the expanded panel shows:
     # "Streamable HTTP · <url>" for the ones the dashboard can call,
     # "sandbox · <command>" for the ones it can start, "stdio · <command>"
-    # for the rest.
+    # for the rest. Every transport MCPToolDispatcher calls reads the same,
+    # because MCPClient reaches all of them over Streamable HTTP — a checkout
+    # runtime ("streamable_http") included.
     def transport_label(catalog)
       return nil if catalog.nil?
 
       transport = catalog[:transport].to_s
-      return [ "Streamable HTTP", catalog[:url] ].compact.join(" · ") if transport == "http"
+      if transport.in?(MCPToolDispatcher::HTTP_TRANSPORTS)
+        return [ "Streamable HTTP", catalog[:url].presence ].compact.join(" · ")
+      end
 
       prefix = catalog[:sandbox] ? "sandbox" : transport.presence
       [ prefix, catalog[:command] ].compact.join(" · ").presence