actionagent 1.9.1 → 1.9.3

data/app/models/action_agent/agent.rb

@@ -51,6 +51,7 @@ module ActionAgent
     # Callbacks
     before_validation :generate_slug, on: :create
     before_validation :apply_conventional_schema_tools, on: :create
+    before_validation :require_approval_for_gained_side_effects, unless: :observed?
     after_create :create_initial_version
     after_update :create_version_on_config_change, if: :configuration_changed?
     after_destroy :release_telemetry_traces, if: :observed?
@@ -83,6 +84,30 @@ module ActionAgent
       github ruby rails aws gcp python typescript docker kubernetes
     ].freeze
 
+    # What each instruction set adds to the instructions a run executes
+    # under (#composed_instructions_for): the conventions of that stack, as a
+    # developer message the model can act on.
+    INSTRUCTION_SET_GUIDANCE = {
+      "github" => "Work the GitHub way: small focused commits with messages that say why, branches named for the " \
+        "change, pull requests that describe what changed and how it was verified, and issues referenced by number.",
+      "ruby" => "Write idiomatic Ruby: follow the project's RuboCop configuration, prefer small methods and plain " \
+        "objects, use keyword arguments for options, and add or update tests (Minitest or RSpec, as the project uses).",
+      "rails" => "Follow Rails conventions: fat models and thin controllers, strong parameters, migrations for every " \
+        "schema change, scopes and validations on the model, and bin/rails commands for generators, tests and tasks.",
+      "aws" => "For AWS, prefer least-privilege IAM, keep infrastructure in code (CloudFormation, CDK or Terraform), " \
+        "name the region explicitly, and never print or commit credentials.",
+      "gcp" => "For Google Cloud, prefer least-privilege service accounts, keep infrastructure in code (Terraform), " \
+        "name the project and region explicitly, and use Secret Manager rather than plain environment values.",
+      "python" => "Write idiomatic Python: PEP 8, type hints on public functions, the project's own environment and " \
+        "dependency tool, and pytest tests for new behaviour.",
+      "typescript" => "Write strict TypeScript: no implicit any, explicit types on exported APIs, the project's lint and " \
+        "format settings, and tests in the framework the project already uses.",
+      "docker" => "For Docker, keep images small and reproducible: pinned base image versions, multi-stage builds, a " \
+        "non-root user, and no secrets baked into layers.",
+      "kubernetes" => "For Kubernetes, write declarative manifests with resource requests and limits, readiness and " \
+        "liveness probes, and Secrets for credentials; apply changes namespace by namespace."
+    }.freeze
+
     # Built-in tools/MCPs. Host-declared schema tools are offered alongside
     # these — see .available_tools, which is what the editor and the APIs
     # serialize. This constant stays the built-in set so existing references
@@ -156,6 +181,24 @@ module ActionAgent
       self.tools = defaults if defaults.any?
     end
 
+    # run_command, write_file, edit_file and slack_post_message wait for a
+    # person's approval unless the agent's approval list says otherwise
+    # (AgentToolbox::APPROVAL_BY_DEFAULT). They join the list when the agent
+    # gains their capability and this save brought no approval list of its
+    # own: an agent built from a template, a POST to the agents API with
+    # tools alone, a PATCH that enables a capability. The builder and the
+    # Tools tab send the list, so an Approval switch turned off holds.
+    def require_approval_for_gained_side_effects
+      return unless has_attribute?(:approval_required_tools)
+      return if attribute_came_from_user?("approval_required_tools")
+
+      gained = Array(tools).map(&:to_s) - Array(tools_in_database).map(&:to_s)
+      names = AgentToolbox.default_approvals(gained)
+      return if names.empty?
+
+      self[:approval_required_tools] = approval_required_tools | names
+    end
+
     # The ActiveAgent class name this agent's runs are recorded under — the
     # correlation key between platform Agent records and telemetry traces
     # (TelemetryTrace#agent_class) and solid_agent contexts. An observed
@@ -229,9 +272,19 @@ module ActionAgent
     # The system instructions an action executes under: named actions stack
     # their prompt below the agent's base instructions; the default action
     # uses the base instructions alone.
+    #
+    # The agent's instruction sets come last, as the conventions to work by.
     def composed_instructions_for(action_name)
       action = action_prompt_for(action_name)
-      [ instructions, action&.dig("prompt") ].map(&:presence).compact.join("\n\n").presence
+      [ instructions, action&.dig("prompt"), instruction_set_guidance ].map(&:presence).compact.join("\n\n").presence
+    end
+
+    # The guidance of the instruction sets this agent selected, or nil.
+    def instruction_set_guidance
+      lines = Array(instruction_sets).filter_map { |set| INSTRUCTION_SET_GUIDANCE[set.to_s] }
+      return nil if lines.empty?
+
+      "Conventions to follow:\n#{lines.map { |line| "- #{line}" }.join("\n")}"
     end
 
     # Returns the configuration as a hash for versioning

data/app/models/action_agent/code_session.rb

@@ -6,6 +6,12 @@ module ActionAgent
   # outcome Claude Code reported, and the diff the session left in the
   # working tree.
   #
+  # A session is one turn of a conversation (CodeConversation). The first
+  # turn is the conversation's root; each later one names it
+  # (conversation_root_id), runs after the one before it, and resumes the same
+  # CLI session (resume_session_id), so Claude Code or Codex remembers what
+  # came before. Every existing session is a conversation of one turn.
+  #
   # The transcript is scrubbed of the sandbox's secrets (its GitHub token and
   # Claude Code credential) before it is stored, and bounded: long strings
   # are truncated and events past MAX_EVENTS are counted rather than kept.
@@ -17,6 +23,9 @@ module ActionAgent
     belongs_to :evaluation_run, optional: true
     belongs_to :verification_run, class_name: "EvaluationRun", optional: true
     belongs_to :previous_code_session, class_name: "CodeSession", optional: true
+    belongs_to :conversation_root, class_name: "CodeSession", optional: true
+    has_many :follow_up_turns, -> { order(:turn_index, :id) }, class_name: "CodeSession",
+      foreign_key: :conversation_root_id, inverse_of: :conversation_root
 
     enum :status, { queued: 0, running: 1, succeeded: 2, failed: 3, cancelled: 4 }
 
@@ -26,11 +35,32 @@ module ActionAgent
     MAX_EVENT_STRING = 4_000
     MAX_DIFF_BYTES = 500_000
     RUNNERS = %w[claude_code codex].freeze
+    # Where a conversation was started. Older sessions recorded none; see
+    # #origin.
+    ORIGINS = %w[settings boot_fix evaluation_fix chat].freeze
+    # A Claude Code session id, as --session-id and --resume take it.
+    SESSION_UUID = /\A\h{8}-\h{4}-\h{4}-\h{4}-\h{12}\z/
+    # A note from the dashboard is fenced in this tag ahead of the person's
+    # message, and the tag is taken out of anything the person typed.
+    NOTE_TAG = "dashboard-note"
 
     validates :prompt, presence: true, length: { maximum: MAX_PROMPT_CHARACTERS }
     validates :runner, inclusion: { in: RUNNERS }
 
+    validates :origin, inclusion: { in: ORIGINS }, allow_nil: true
+    # A Codex conversation resumes the thread id its first turn reported.
+    validates :resume_session_id, format: { with: SESSION_UUID }, allow_nil: true, if: -> { runner == "claude_code" }
+
+    # A conversation's first Claude Code turn names the CLI session it
+    # starts (--session-id), so every later turn can resume it even when the
+    # first ended before reporting its own id.
+    before_validation(on: :create) do
+      self.resume_session_id ||= SecureRandom.uuid if root? && runner == "claude_code"
+    end
+
     scope :recent, -> { order(created_at: :desc) }
+    # The first turn of every conversation.
+    scope :conversation_roots, -> { where(conversation_root_id: nil) }
 
     # JSON columns carry no default on MySQL or SQLite (see the migration).
     def events
@@ -41,6 +71,51 @@ module ActionAgent
       succeeded? || failed? || cancelled?
     end
 
+    def root?
+      conversation_root_id.nil?
+    end
+
+    # The conversation's first turn: this one, or the one it names.
+    def root
+      root? ? self : conversation_root
+    end
+
+    # Every turn of this session's conversation, in order.
+    #
+    # @return [Array<CodeSession>]
+    def turns
+      # Read afresh: turns are added under the sandbox's lock while this
+      # session may hold an older list.
+      [ root, *CodeSession.where(conversation_root_id: root.id).order(:turn_index, :id).to_a ]
+    end
+
+    # Where the conversation was started. Sessions from before origins were
+    # recorded are told apart by what they ran for: an evaluation fix names
+    # its run, and a boot fix is one its project recorded
+    # (ProjectBootFix.project_for).
+    def origin
+      recorded = super.presence
+      return recorded if recorded
+      return "evaluation_fix" if evaluation_run_id
+      return "boot_fix" if persisted? && root? && ProjectBootFix.project_for(self)
+
+      "settings"
+    end
+
+    # What the CLI is given on stdin: the dashboard's note, fenced, ahead of
+    # the person's message. The prompt itself stays what they typed.
+    def stdin_text
+      return prompt if context_note.blank?
+
+      "<#{NOTE_TAG}>\n#{context_note}\n</#{NOTE_TAG}>\n\n#{prompt}"
+    end
+
+    # +text+ without the dashboard's note tags, so a person cannot make their
+    # own words read as the dashboard's.
+    def self.strip_note_tags(text)
+      text.to_s.gsub(%r{</?\s*#{NOTE_TAG}[^>]*>}i, "")
+    end
+
     # Whether an outcome and a diff may still be recorded for this session.
     # finished_at is set once nothing more will be: by CodeSessionJob when it
     # settles a session it ran (whatever the backend returned, raised or
@@ -111,6 +186,10 @@ module ActionAgent
         evaluation_run_id: evaluation_run_id,
         evaluation_id: evaluation_run&.evaluation_id,
         fix_item: fix_item,
+        conversation_id: root? ? id : conversation_root_id,
+        turn_index: turn_index,
+        origin: origin,
+        context_note: context_note,
         verification_run_id: verification_run_id,
         verification_error: verification_error,
         result: result,
@@ -121,6 +200,7 @@ module ActionAgent
         input_tokens: input_tokens,
         output_tokens: output_tokens,
         event_count: events.size + dropped_events_count.to_i,
+        diff_stat: finished? ? DiffStat.call(diff) : nil,
         # What a client polls until: false once nothing about the session
         # changes any more.
         diff_pending: diff_pending?,

data/app/models/action_agent/evaluation_run.rb

@@ -78,6 +78,15 @@ module ActionAgent
       verdict.to_h.stringify_keys.presence if verdict.is_a?(Hash)
     end
 
+    # The model comparison a comparison run recorded (Report#comparison):
+    # each model's pass rate with its interval, every pair's difference and
+    # whether it is decisive, and the conclusion. nil for a single-model
+    # run, or one recorded before runs kept it.
+    def recorded_comparison
+      comparison = scores&.dig("_comparison")
+      comparison if comparison.is_a?(Hash) && comparison.present?
+    end
+
     # How the report names the judge, the way the suite panel does: the
     # judge the recorded verdict names — unless that is only the pass-rate
     # ranking — else the evaluation's judge model. nil when neither is set,
@@ -191,6 +200,16 @@ module ActionAgent
       cost_breakdown.usage
     end
 
+    # The judge's run-level spend as recorded, without pricing anything:
+    # what the publishing application reported for the calls no result owns,
+    # else the engine's meter, else nil.
+    def recorded_judge_usage_run
+      reported = scores&.dig("_judge_usage_run")
+      return reported if reported.is_a?(Hash)
+
+      judge_usage_meter&.merge("source" => "meter")
+    end
+
     # Route templates for the report's fix item actions, relative to the
     # dashboard mount: `%{key}` is filled in per MCP server by the report.
     # The JSON API leaves `mount` empty — the React app resolves paths
@@ -220,7 +239,7 @@ module ActionAgent
     # writes with Report#to_html. The run's recorded verdict and judge go
     # with it: the report is not to re-rank the rebuilt results by pass
     # rate and show a different judge's pick, verdict or `judged by` than
-    # the suite panel does. Raises ActiveRecord::RecordNotFound via the
+    # the suite panel does, nor resample the comparison the run recorded. Raises ActiveRecord::RecordNotFound via the
     # caller for a run of a generation-sampling evaluation, which has no
     # scenario results to report on.
     #
@@ -229,12 +248,19 @@ module ActionAgent
     # judge's run-level spend, so the page shows every cost the dashboard
     # does. `estimate: false` rebuilds the report from what was recorded
     # alone — the import summarizes a published run that way, so the
-    # summaries it stores stay the application's own figures.
+    # summaries it stores stay the application's own figures, and the
+    # export (EvaluationReportExport) serves it that way, so the same run
+    # always exports the same report. The judge's run-level spend is then
+    # the one recorded: the application's for an imported run, the meter's
+    # for one the engine judged.
     #
     # The engine runs against every activeagent since 1.4, so the report
     # kwargs that arrived later are passed only when Report.new takes them.
     def to_report(links: report_links, estimate: true)
-      rows = scenario_results.includes(:scenario).sort_by do |row|
+      # A replay not yet scored (a fanned-out run in progress) is not a
+      # result the report can grade, so it is left out rather than read as
+      # a failure.
+      rows = scenario_results.where.not(status: :pending).includes(:scenario).sort_by do |row|
         [ row.evaluated_scenario["position"].to_i, row.evaluation_scenario_id, row.model ]
       end
       breakdown = cost_breakdown if estimate
@@ -274,8 +300,10 @@ module ActionAgent
         agent_name: evaluation.agent&.name,
         links: links
       }
-      kwargs[:judge_usage] = breakdown.judge_usage_run if breakdown && self.class.report_accepts?(:judge_usage)
+      judge_usage_run = breakdown ? breakdown.judge_usage_run : recorded_judge_usage_run
+      kwargs[:judge_usage] = judge_usage_run if judge_usage_run && self.class.report_accepts?(:judge_usage)
       kwargs[:release] = release_summary if release_summary && self.class.report_accepts?(:release)
+      kwargs[:comparison] = recorded_comparison if recorded_comparison && self.class.report_accepts?(:comparison)
       self.class.report_class.new(**kwargs)
     end
 
@@ -319,7 +347,11 @@ module ActionAgent
     # for it, and — when estimating — how its cost was priced.
     def replay_metadata_for(row, breakdown)
       metadata = row.replay_metadata.dup
-      reported_judge = row.diagnosis.is_a?(Hash) ? row.diagnosis["_judge_usage"] : nil
+      # A fanned-out run's results each keep what their scoring job spent on
+      # the judge, already folded into the run's meter. The meter is the
+      # run's figure (EvaluationRunCost#result_judge reads it the same way),
+      # so the parts are not counted a second time.
+      reported_judge = row.diagnosis.is_a?(Hash) && !judge_usage_meter ? row.diagnosis["_judge_usage"] : nil
       metadata["judge_usage"] = reported_judge if reported_judge.is_a?(Hash)
       return metadata unless breakdown
 

data/app/models/action_agent/provider_key.rb

@@ -39,7 +39,8 @@ module ActionAgent
     HOST_PROVIDERS = %w[ollama].freeze
     # Tools connected with a credential, configured beside the providers
     # (Settings -> Integrations) but never offered to the agent builder.
-    CONNECTION_PROVIDERS = %w[claude_code codex].freeze
+    # Slack's is the bot token the agents' slack tools post with (SlackTools).
+    CONNECTION_PROVIDERS = %w[claude_code codex slack].freeze
     PROVIDERS = (KEY_PROVIDERS + HOST_PROVIDERS + CONNECTION_PROVIDERS).freeze
 
     # Only an Anthropic API key (sk-ant-api03-…, from the Claude Console or
@@ -52,6 +53,7 @@ module ActionAgent
     # dashboard never touches the credential.
     CLAUDE_CODE_CREDENTIAL = /\Ask-ant-api\d{2}-[A-Za-z0-9_-]+\z/
     CODEX_CREDENTIAL = /\Ask-(?!ant-|or-)[A-Za-z0-9_-]+\z/
+    SLACK_CREDENTIAL = /\Axoxb-[A-Za-z0-9-]+\z/
     # A Claude subscription token, as earlier versions stored. Recognized so
     # a stored one is never handed out (see #needs_replacing?).
     SUBSCRIPTION_TOKEN_PREFIX = "sk-ant-oat"
@@ -95,6 +97,8 @@ module ActionAgent
     }, if: -> { provider == "claude_code" }
     validates :credential, format: { with: CODEX_CREDENTIAL, message: "must be an OpenAI API key (sk-…)" },
       if: -> { provider == "codex" }
+    validates :credential, format: { with: SLACK_CREDENTIAL, message: "must be a Slack bot token (xoxb-…)" },
+      if: -> { provider == "slack" }
     validates :api_key, length: { maximum: 500 }, allow_nil: true
 
     # Deletes every Claude Code connection that still holds a Claude

data/app/queries/action_agent/trace_window_report.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module ActionAgent
+  # Full-window counts and chart buckets, independent of the capped trace
+  # details. Read only scalar columns, never the potentially large spans.
+  class TraceWindowReport
+    MAX_BUCKETS = 180
+
+    def initialize(scope, from:, to:, bucket_seconds:)
+      @scope, @from, @to = scope, from, to
+      duration = (to - from).ceil
+      @bucket_seconds = bucket_seconds.to_i.clamp([ (duration.to_f / MAX_BUCKETS).ceil, 1 ].max, duration)
+    end
+
+    def as_json
+      width = @bucket_seconds
+      buckets = Array.new(((@to - @from) / width).ceil) do |index|
+        tally.merge(start_ms: milliseconds(@from + index * width), end_ms: milliseconds([ @from + (index + 1) * width, @to ].min), agents: {})
+      end
+      total = tally
+      @scope.in_batches(of: 1000) do |batch|
+        batch.pluck(:timestamp, :agent_class, :status, :total_duration_ms).each do |timestamp, agent, status, duration|
+          index = ((timestamp - @from) / width).floor
+          next unless timestamp < @to && index >= 0 && index < buckets.size
+
+          [ total, buckets[index] ].each do |counts|
+            counts[:requests] += 1
+            counts[:errors] += 1 if status == TelemetryTrace::STATUS_ERROR
+            if duration && duration.finite?
+              counts[:duration_sum] += duration
+              counts[:duration_count] += 1
+            end
+          end
+          agents = buckets[index][:agents]
+          agents[agent] = agents.fetch(agent, 0) + 1 if agent
+        end
+      end
+      {
+        total_count: total[:requests],
+        summary: summary(total).merge(throughput_per_minute: (total[:requests] * 60.0 / (@to - @from)).round(1)),
+        window_start_ms: milliseconds(@from), window_end_ms: milliseconds(@to), bucket_seconds: width,
+        buckets: buckets.map { |bucket| summary(bucket).merge(bucket.slice(:start_ms, :end_ms, :agents)) }
+      }
+    end
+
+    private
+
+    def tally
+      { requests: 0, errors: 0, duration_sum: 0.0, duration_count: 0 }
+    end
+
+    def summary(counts)
+      counts.slice(:requests, :errors).merge(avg_latency_ms: counts[:duration_count].positive? ? (counts[:duration_sum] / counts[:duration_count]).round : 0)
+    end
+
+    def milliseconds(time)
+      (time.to_f * 1000).to_i
+    end
+  end
+end

data/app/serializers/action_agent/code_conversation_serializer.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module ActionAgent
+  # A Claude Code or Codex conversation (CodeConversation) in the shape the
+  # Interactions view lists: one row per conversation, keyed "code-<root id>"
+  # beside contexts ("<id>") and reported traces ("trace-<id>"), and, in
+  # detail, its turns with their transcripts.
+  #
+  # Each turn is one run of the CLI, so it carries what a trace would: its
+  # tokens, cost and duration, from the CLI's result event.
+  class CodeConversationSerializer
+    LABELS = { "claude_code" => "Claude Code", "codex" => "Codex" }.freeze
+
+    def self.summary(root, turns = root.turns)
+      new(root, turns).summary
+    end
+
+    def self.detail(root, turns = root.turns, after: {})
+      new(root, turns).detail(after: after)
+    end
+
+    def initialize(root, turns)
+      @root = root
+      @turns = turns
+      @sandbox = root.sandbox_session
+    end
+
+    def summary
+      last = @turns.last
+      project = @sandbox.try(:project)
+      {
+        id: "code-#{@root.id}",
+        source: "code_session",
+        runner: @root.runner,
+        origin: @root.origin,
+        agent_name: LABELS.fetch(@root.runner, @root.runner),
+        action_name: nil,
+        display_name: [ LABELS.fetch(@root.runner, @root.runner), @sandbox.try(:repository) ].compact.join(" · "),
+        agent: nil,
+        model: @turns.filter_map(&:model).last,
+        status: active&.status || last.status,
+        active: !active.nil?,
+        tokens: {
+          input: @turns.sum { |turn| turn.input_tokens.to_i },
+          output: @turns.sum { |turn| turn.output_tokens.to_i },
+          total: @turns.sum { |turn| turn.input_tokens.to_i + turn.output_tokens.to_i }
+        },
+        total_cost_usd: @turns.sum { |turn| turn.total_cost_usd.to_f }.round(6),
+        duration_ms: @turns.sum { |turn| turn.duration_ms.to_i },
+        message_count: @turns.size,
+        turn_count: @turns.size,
+        preview: {
+          input: InteractionPreview.line(@root.prompt),
+          output: InteractionPreview.line(@turns.reverse.find { |turn| turn.result.present? }&.result)
+        },
+        sandbox_session_id: @sandbox.session_id,
+        sandbox_status: @sandbox.status,
+        project: project ? { id: project.id, name: project.name } : nil,
+        credential_mode: @root.credential_mode,
+        created_at: @root.created_at.iso8601,
+        last_activity_at: (@turns.filter_map { |turn| turn.finished_at || turn.started_at }.max || last.created_at).iso8601
+      }
+    end
+
+    # The summary plus every turn: its summary, and its transcript from
+    # +after+[turn id] onward, so a client polling the running turn asks only
+    # for what it has not seen. A finished turn's diff comes from the session
+    # endpoint, on demand: it is the whole checkout's.
+    def detail(after: {})
+      summary.merge(
+        turns: @turns.map do |turn|
+          from = after[turn.id.to_s].to_i.clamp(0, turn.events.size)
+          turn.summary.merge(events: turn.events.drop(from), events_offset: from,
+            dropped_events_count: turn.dropped_events_count.to_i)
+        end,
+        browser: @sandbox.respond_to?(:browser_summary) ? @sandbox.browser_summary : nil
+      )
+    end
+
+    private
+
+    def active
+      @turns.find { |turn| turn.running? } || @turns.find { |turn| turn.queued? }
+    end
+  end
+end

data/app/serializers/action_agent/evaluation_serializer.rb

@@ -125,8 +125,19 @@ module ActionAgent
     # 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
+    # With +markdown+ each item carries its `markdown`
+    # (ActiveAgent::Evals::ReportMarkdown#fix_item_markdown), which the
+    # dashboard's fix cards copy.
+    def fix_items(run, links: nil, markdown: false)
+      unless markdown
+        return links ? run.fix_items(links: links) : run.fix_items
+      end
+
+      report = links ? run.to_report(links: links) : run.to_report
+      items = report.fix_items
+      return items unless report.respond_to?(:fix_item_markdown)
+
+      items.map { |item| item.merge("markdown" => report.fix_item_markdown(item)) }
     rescue StandardError => e
       Rails.logger.warn(
         "[ActionAgent] evaluation run #{run.id} fix_items failed: #{e.class}: #{e.message}"

data/app/services/action_agent/agent_execution_service.rb

@@ -537,6 +537,12 @@ module ActionAgent
         }
       when "call_agent"
         call_agent(slug: kwargs[:slug], message: kwargs[:message])
+      when "translate_text"
+        translate_text(**kwargs.to_h.symbolize_keys.slice(:text, :target_language, :source_language))
+      when *CheckoutTools::FUNCTIONS
+        checkout_tools.call(name.to_s, kwargs)
+      when *SlackTools::FUNCTIONS
+        SlackTools.new(SlackTools.token_for(owner)).call(name.to_s, kwargs)
       when "request_handoff"
         request_handoff(**kwargs.slice(:reason, :url, :form_values, :instructions))
       else
@@ -727,6 +733,37 @@ module ActionAgent
       (text.length / 4.0).round
     end
 
+    # The checkout tools act on the sandbox the run was given, found among
+    # the agent's owner's sessions as the dispatcher finds its runtime.
+    def checkout_tools
+      @checkout_tools ||= begin
+        sandbox_id = @run.try(:sandbox_id)
+        CheckoutTools.new(sandbox_id && SandboxSession.for_owner(owner).find_by(session_id: sandbox_id))
+      end
+    end
+
+    # translate_text: one generation on this run's provider, model and the
+    # owner's credentials, with no tools and no conversation.
+    def translate_text(text:, target_language:, source_language: nil)
+      return { error: "No text to translate" } if text.to_s.strip.empty?
+      return { error: "target_language is required" } if target_language.to_s.strip.empty?
+
+      name = provider
+      options = { model: requested_model }.merge(owner_provider_options(name))
+      translator = Class.new(ActiveAgent::Base) do
+        define_singleton_method(:name) { "ActionAgent::Translator" }
+        generate_with name, **options
+      end
+      from = source_language.present? ? " from #{source_language}" : ""
+      instructions = "Translate the user's text#{from} into #{target_language}. Reply with the translation only — " \
+        "no notes, quotes or preamble. Keep formatting, code, URLs and placeholders exactly as they are."
+      response = translator.prompt(message: text.to_s, instructions: instructions).generate_now
+
+      { translation: response&.message&.content.to_s, target_language: target_language }
+    rescue StandardError => e
+      { error: "Translation failed: #{e.message}" }
+    end
+
     def call_agent(slug:, message:)
       depth = Thread.current[:agent_call_depth].to_i
       return { error: "call_agent depth limit (#{MAX_CALL_DEPTH}) reached" } if depth >= MAX_CALL_DEPTH

data/app/services/action_agent/agent_tool_roster.rb

@@ -50,18 +50,25 @@ 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, :runtimes
+    attr_reader :agent, :discovery, :runtimes, :workspace_agents
 
     # @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
     # @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: [])
+    # @param workspace_agents [ActiveRecord::Relation, nil] the workspace's
+    #   other agents, whose MCP servers each service row counts as
+    #   +workspace_agents+ — what a new agent's builder shows as already in
+    #   use, since an unsaved agent has no usage of its own to show
+    def initialize(agent:, traces:, hours: ToolDiscovery::DEFAULT_WINDOW_HOURS, runtimes: [], workspace_agents: nil)
       @agent = agent
       @runtimes = Array(runtimes).index_by { |runtime| runtime[:key] }
+      @workspace_agents = workspace_agents
+      # An agent not saved yet has no traces of its own, and no name to
+      # match unattributed ones by.
       @discovery = ToolDiscovery.new(
-        traces: agent.telemetry_traces(traces),
+        traces: agent.persisted? ? agent.telemetry_traces(traces) : traces.none,
         agents: Agent.where(id: agent.id),
         hours: hours
       )
@@ -118,6 +125,7 @@ module ActionAgent
       used = detected_by_server[key] || []
       calls = used.sum { |tool| tool[:calls] }
       enabled = configured_servers.key?(key)
+      unreachable = MCPToolDispatcher.unreachable_reason(MCPCatalog.connection(key) || runtimes[key])
 
       {
         key: key,
@@ -133,10 +141,25 @@ module ActionAgent
         calls: calls,
         errors: used.sum { |tool| tool[:errors] },
         last_seen: used.filter_map { |tool| tool[:last_seen] }.max,
+        # Whether a dashboard run reaches it (MCPToolDispatcher), and when
+        # not, why: a stdio server, or one needing a credential it can't send.
+        callable: unreachable.nil?,
+        unavailable_reason: unreachable,
+        workspace_agents: workspace_usage[key].to_i,
         tools: service_tools(key, catalog, used)
       }
     end
 
+    # server key => how many of the workspace's agents enable it. Empty
+    # unless the caller handed in +workspace_agents+.
+    def workspace_usage
+      @workspace_usage ||= Array(workspace_agents).each_with_object(Hash.new(0)) do |other, counts|
+        next if agent.persisted? && other.id == agent.id
+
+        self.class.configured_servers(other).each_key { |key| counts[key] += 1 }
+      end
+    end
+
     # 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>"
@@ -233,6 +256,10 @@ module ActionAgent
           description: Agent::TOOL_DESCRIPTIONS[capability],
           enabled: saved_tools.include?(capability),
           editable: true,
+          # Whether AgentToolbox gives the model anything for it. A capability
+          # without definitions is a name on the roster and nothing more, so
+          # the builder offers its MCP service (or nothing) in its place.
+          implemented: AgentToolbox::DEFINITIONS.key?(capability),
           approval_names: capability_functions(capability) - AgentToolbox::INPUT_FUNCTIONS
         )
       end
@@ -283,27 +310,35 @@ module ActionAgent
     # carries a top-level Hash keyed by server name — the same three shapes
     # EvaluationToolResolver tolerates.
     def configured_servers
-      @configured_servers ||= configured_entries.each_with_object({}) do |entry, map|
-        key = entry_key(entry)
-        map[key] = entry if key.present?
-      end
+      @configured_servers ||= self.class.configured_servers(agent)
     end
 
-    def configured_entries
-      servers = agent.mcp_servers
+    class << self
+      # server key => the entry +agent+ stores for it, in any of the three
+      # shapes above.
+      def configured_servers(agent)
+        configured_entries(agent.mcp_servers).each_with_object({}) do |entry, map|
+          key = entry_key(entry)
+          map[key] = entry if key.present?
+        end
+      end
+
+      private
 
-      if servers.is_a?(Hash)
-        servers.map { |key, value| value.respond_to?(:key?) ? value.to_h.stringify_keys.merge("key" => key.to_s) : key.to_s }
-      else
-        Array(servers)
+      def configured_entries(servers)
+        if servers.is_a?(Hash)
+          servers.map { |key, value| value.respond_to?(:key?) ? value.to_h.stringify_keys.merge("key" => key.to_s) : key.to_s }
+        else
+          Array(servers)
+        end
       end
-    end
 
-    def entry_key(entry)
-      return entry.to_s.strip.presence if entry.is_a?(String) || entry.is_a?(Symbol)
-      return nil unless entry.respond_to?(:key?)
+      def entry_key(entry)
+        return entry.to_s.strip.presence if entry.is_a?(String) || entry.is_a?(Symbol)
+        return nil unless entry.respond_to?(:key?)
 
-      (entry["key"] || entry[:key] || entry["name"] || entry[:name]).to_s.strip.presence
+        (entry["key"] || entry[:key] || entry["name"] || entry[:name]).to_s.strip.presence
+      end
     end
 
     # The per-server allow-list, or nil when the entry names none — which