actionagent 1.7.2 → 1.8.0

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,100 @@ 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
+      return {} unless app_runtime?
+
+      owners_record(ProviderKey.where(provider: "claude_code"))&.runtime_environment || {}
+    end
+
     # Check if session is still valid
     def active?
       !expired? && !failed? && !completed? && expires_at > Time.current
@@ -95,28 +208,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 +259,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 +294,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,118 @@
+# 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.
+    def evaluation(evaluation)
+      summary = summary(evaluation)
+      latest, previous = recent_runs(evaluation, 2)
+
+      summary.merge(
+        latest_run: latest ? run(latest, number: summary[:run_count]) : nil,
+        previous_run: previous ? run_summary(previous, number: summary[:run_count] - 1) : nil
+      )
+    end
+
+    # Returns the evaluation's configuration and run count, without its runs.
+    def summary(evaluation)
+      {
+        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
+      }
+    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: run.scores,
+        selection: run.selection,
+        models: run.models,
+        usage: run.usage,
+        error_message: run.error_message
+      )
+    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.
+    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
+      }
+    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.recent.limit(limit).to_a
+      end
+    end
+
+    # Returns the run's position in its evaluation's history, oldest = 1.
+    def run_number(evaluation, run)
+      evaluation.evaluation_runs.where("created_at < ? OR (created_at = ? AND id <= ?)", run.created_at, run.created_at, run.id).count
+    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_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

data/app/services/action_agent/claude_code_auth.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module ActionAgent
+  # How Claude Code sessions authenticate (ActionAgent.claude_code_auth), and
+  # the one rule for whether an owner's Claude Code is "connected", shared by
+  # the sandbox listing, the assistant's configuration and the session API so
+  # they never disagree.
+  #
+  # :api_key     the owner's Anthropic API key, stored as a ProviderKey. A
+  #              Claude subscription token stored by an earlier version does
+  #              not count (ProviderKey#needs_replacing?).
+  # :local_login the login of the machine the dashboard runs on, as
+  #              `claude auth status` reports it (see
+  #              LocalSandboxBackend.claude_login_status). The dashboard never
+  #              sees that credential.
+  #
+  # Anthropic does not let third-party products store or route requests
+  # through Claude.ai subscription credentials, so there is no third mode:
+  # https://code.claude.com/docs/en/legal-and-compliance.md
+  module ClaudeCodeAuth
+    module_function
+
+    # @return [String] "api_key" or "local_login"
+    def mode
+      ActionAgent.claude_code_auth.to_s
+    end
+
+    def local_login?
+      mode == "local_login"
+    end
+
+    # Why +orchestrator+'s backend cannot run Claude Code sessions with the
+    # configured authentication, or nil. A machine's own login is the
+    # dashboard user's, so only a backend running sessions as that user, on
+    # that machine, may use it: a container or a remote host would either
+    # find no login or need it copied there, which is what this mode exists
+    # to never do.
+    def backend_refusal(orchestrator)
+      return unless local_login?
+      return if orchestrator.local?
+
+      "ActionAgent.claude_code_auth = :local_login uses this machine's own Claude Code login, so it works only " \
+        "with the :local sandbox backend, not #{orchestrator.backend_name}"
+    end
+
+    # Whether the owner of +provider_keys+ (a ProviderKey scope already
+    # narrowed to them) has an API key Claude Code can run on.
+    def api_key_connected?(provider_keys)
+      provider_keys.where(provider: "claude_code").any? { |key| key.runtime_environment.present? }
+    end
+
+    # What the dashboard reports about Claude Code for the owner of
+    # +provider_keys+: booleans and the login's method, never a credential.
+    #
+    # @return [Hash] { mode:, connected:, login: } (login for :local_login only)
+    def status(provider_keys)
+      if local_login?
+        # Only the :local backend uses the login, and no other one needs
+        # this machine's CLI asked about it.
+        login = local_backend? ? LocalSandboxBackend.claude_login_status : LocalSandboxBackend::LOGGED_OUT
+        { mode: mode, connected: login[:logged_in], login: login.slice(:logged_in, :auth_method) }
+      else
+        { mode: mode, connected: api_key_connected?(provider_keys) }
+      end
+    end
+
+    # A backend that cannot even be loaded is not the :local one.
+    def local_backend?
+      SandboxOrchestrator.new.local?
+    rescue StandardError, LoadError
+      false
+    end
+
+    # Why a Claude Code session cannot start in +sandbox+ for want of
+    # credentials, or nil.
+    def credential_refusal(sandbox)
+      if local_login?
+        return if LocalSandboxBackend.claude_login_status[:logged_in]
+
+        "Claude Code is not logged in on this machine: run `claude /login` as the user the dashboard runs as"
+      elsif sandbox.runtime_environment.blank?
+        "Claude Code is not connected: connect an Anthropic API key in Settings -> Integrations first"
+      end
+    end
+  end
+end