ace-test-runner-e2e 0.29.8 → 0.38.11

data/lib/ace/test/end_to_end_runner/atoms/skill_result_parser.rb

@@ -13,6 +13,7 @@ module Ace
         #   - **Failed**: 0
         #   - **Total**: 8
         #   - **Report Paths**: 8p5jo2-lint-ts001-reports/*
+        #   - **Observations**: None
         #   - **Issues**: None
         #
         # Falls back to ResultParser.parse() for JSON responses.
@@ -45,6 +46,7 @@ module Ace
             fields[:failed] = extract_field(text, "Failed")
             fields[:total] = extract_field(text, "Total")
             fields[:report_paths] = extract_field(text, "Report Paths")
+            fields[:observations] = extract_field(text, "Observations")
             fields[:issues] = extract_field(text, "Issues")
 
             # Need at least test_id and status for a valid parse
@@ -69,8 +71,7 @@ module Ace
             passed.times { |i| test_cases << {id: "TC-#{format("%03d", i + 1)}", description: "", status: "pass", actual: "", notes: ""} }
             failed.times { |i| test_cases << {id: "TC-#{format("%03d", passed + i + 1)}", description: "", status: "fail", actual: "", notes: ""} }
 
-            issues = parsed[:issues]
-            observations = (issues && issues.downcase != "none") ? issues : ""
+            observations = normalize_observations(parsed[:observations], parsed[:issues])
 
             {
               test_id: parsed[:test_id],
@@ -131,8 +132,8 @@ module Ace
             fields[:failed_tcs] = extract_field(text, "Failed TCs")
             fields[:issues] = extract_field(text, "Issues")
 
-            return parse(text) unless fields[:test_id] && fields[:status] &&
-              fields[:tcs_passed] && fields[:tcs_failed] && fields[:tcs_total]
+            return parse_minimal_verifier(text) unless fields[:test_id] && fields[:status]
+            return parse(text) unless fields[:tcs_passed] && fields[:tcs_failed] && fields[:tcs_total]
 
             passed = fields[:tcs_passed].to_i
             failed = fields[:tcs_failed].to_i
@@ -180,6 +181,58 @@ module Ace
             }
           end
 
+          def self.parse_minimal_verifier(text)
+            compact = text.to_s.strip
+            results_match = compact.match(/Results:\s*(\d+)\s*\/\s*(\d+)\s*passed/i)
+            if results_match
+              passed = results_match[1].to_i
+              total = results_match[2].to_i
+              status = if total.zero?
+                "fail"
+              elsif passed == total
+                "pass"
+              elsif passed.zero?
+                "fail"
+              else
+                "partial"
+              end
+              failed = [total - passed, 0].max
+              test_cases = []
+              passed.times { |i| test_cases << {id: "TC-#{format("%03d", i + 1)}", description: "", status: "pass", actual: "", notes: ""} }
+              failed.times { |i| test_cases << {id: "TC-#{format("%03d", passed + i + 1)}", description: "", status: "fail", actual: "", notes: "", category: "unknown"} }
+
+              return {
+                test_id: "",
+                status: status,
+                test_cases: test_cases,
+                summary: "#{passed}/#{total} passed",
+                observations: compact
+              }
+            end
+
+            status_match = compact.match(/\b(PASS|FAIL|PARTIAL|ERROR)\b/i)
+            return parse(text) unless status_match
+
+            status = normalize_status(status_match[1])
+            evidence = compact.sub(/^.*?\b#{Regexp.escape(status_match[1])}\b[:\-\s]*/i, "").strip
+            tc_status = (status == "pass") ? "pass" : "fail"
+
+            {
+              test_id: "",
+              status: status,
+              test_cases: [{
+                id: "TC-001",
+                description: "",
+                status: tc_status,
+                actual: "",
+                notes: evidence,
+                category: ((tc_status == "fail") ? "unknown" : nil)
+              }],
+              summary: evidence.empty? ? status : evidence,
+              observations: evidence
+            }
+          end
+
           # Parse TC-level markdown return contract
           def self.parse_tc_markdown(text)
             fields = {}
@@ -188,6 +241,7 @@ module Ace
             fields[:tc_id] = extract_field(text, "TC ID")
             fields[:status] = extract_field(text, "Status")
             fields[:report_paths] = extract_field(text, "Report Paths")
+            fields[:observations] = extract_field(text, "Observations")
             fields[:issues] = extract_field(text, "Issues")
 
             # Need test_id, tc_id, and status for a valid TC parse
@@ -200,8 +254,7 @@ module Ace
           def self.to_tc_normalized(parsed)
             parsed[:status] = normalize_status(parsed[:status])
 
-            issues = parsed[:issues]
-            observations = (issues && issues.downcase != "none") ? issues : ""
+            observations = normalize_observations(parsed[:observations], parsed[:issues])
 
             {
               test_id: parsed[:test_id],
@@ -234,9 +287,22 @@ module Ace
             end
           end
 
+          def self.normalize_observations(primary, fallback = nil)
+            [primary, fallback].each do |value|
+              next if value.nil?
+
+              normalized = value.to_s.strip
+              next if normalized.empty? || normalized.casecmp("none").zero?
+
+              return normalized
+            end
+
+            ""
+          end
+
           private_class_method :parse_markdown, :to_normalized, :extract_field,
             :parse_tc_markdown, :to_tc_normalized, :normalize_status,
-            :parse_failed_tcs
+            :parse_failed_tcs, :parse_minimal_verifier, :normalize_observations
         end
       end
     end

data/lib/ace/test/end_to_end_runner/cli/commands/run_test.rb

@@ -20,9 +20,9 @@ module Ace
             desc <<~DESC.strip
               Run E2E tests via LLM execution
 
-              Discovers and executes TS-* test scenarios in a package's test/e2e/ directory.
-              Tests are sent to an LLM provider which executes the test steps and returns
-              structured results.
+              Discovers and executes deterministic preflight tests from test/feat
+              before TS-* agent scenarios from test/e2e. Tests are sent to an LLM
+              provider which executes the scenario steps and returns structured results.
 
               Output:
                 Exit codes: 0 (all pass), 1 (any fail/error)
@@ -35,7 +35,7 @@ module Ace
               "ace-lint --provider gemini:flash  # Use specific provider",
               "ace-lint --provider glite     # Use API provider (predict mode)",
               "ace-lint --tags smoke         # Run only smoke-tagged scenarios",
-              "ace-lint TS-LINT-003 --dry-run  # Preview scenarios that would run"
+              "ace-lint TS-LINT-003 --dry-run  # Preview preflight and scenario phases"
             ]
 
             argument :package, required: true, desc: "Package name (e.g., ace-lint)"
@@ -55,7 +55,7 @@ module Ace
             option :report_dir, type: :string,
               desc: "Explicit report directory path (overrides computed path)"
             option :dry_run, type: :boolean,
-              desc: "Preview which scenarios would run without executing"
+              desc: "Preview which preflight tests and scenarios would run without executing"
             option :tags, type: :string,
               desc: "Comma-separated scenario tags to include"
             option :verify, type: :boolean,
@@ -110,7 +110,7 @@ module Ace
 
             private
 
-            # Handle dry-run mode: preview which scenarios would run
+            # Handle dry-run mode: preview which preflight tests and scenarios would run
             #
             # @param package [String] Package name
             # @param test_id [String, nil] Test ID
@@ -125,15 +125,28 @@ module Ace
                 tags: tags,
                 base_dir: Dir.pwd
               )
-              if files.empty?
+              preflight_files = discoverer.find_integration_tests(package: package, base_dir: Dir.pwd)
+              if files.empty? && preflight_files.empty?
                 raise Ace::Support::Cli::Error.new(
                   "No tests found for package '#{package}'" +
                   (test_id ? " with ID '#{test_id}'" : "")
                 )
               end
 
-              output.puts "Dry run: preview of scenarios to execute"
+              output.puts "Dry run: preview of execution phases"
               output.puts ""
+              output.puts "Phase 1: deterministic preflight"
+              if preflight_files.empty?
+                output.puts "  (none)"
+              else
+                preflight_files.each do |file|
+                  output.puts "  [preflight] #{file}"
+                end
+              end
+              output.puts ""
+              output.puts "Phase 2: scenarios"
+              output.puts "  (none)" if files.empty?
+              output.puts "" unless files.empty?
 
               files.each do |file|
                 scenario = loader.load(File.dirname(file))

data/lib/ace/test/end_to_end_runner/models/test_case.rb

@@ -9,7 +9,8 @@ module Ace
         # Contains parsed frontmatter metadata and the full markdown body
         # from an independent test case file within a scenario directory.
         class TestCase
-          attr_reader :tc_id, :title, :content, :file_path, :pending, :goal_format
+          attr_reader :tc_id, :title, :content, :file_path, :pending, :goal_format,
+            :declared_artifacts, :optional_artifacts
 
           # @param tc_id [String] Test case identifier (e.g., "TC-001")
           # @param title [String] Test case title from frontmatter
@@ -17,13 +18,18 @@ module Ace
           # @param file_path [String] Absolute path to the source test file
           # @param pending [String, nil] Pending reason (presence = pending, value = reason)
           # @param goal_format [String, nil] Test case source format ("standalone")
-          def initialize(tc_id:, title:, content:, file_path:, pending: nil, goal_format: nil)
+          # @param declared_artifacts [Array<String>] Required artifact paths under results/tc/*
+          # @param optional_artifacts [Array<String>] Optional artifact paths under results/tc/*
+          def initialize(tc_id:, title:, content:, file_path:, pending: nil, goal_format: nil,
+            declared_artifacts: [], optional_artifacts: [])
             @tc_id = tc_id
             @title = title
             @content = content
             @file_path = file_path
             @pending = pending
             @goal_format = goal_format
+            @declared_artifacts = declared_artifacts
+            @optional_artifacts = optional_artifacts
           end
 
           # Whether this test case is pending (should be skipped)

data/lib/ace/test/end_to_end_runner/models/test_result.rb

@@ -10,7 +10,7 @@ module Ace
         # from executing a test scenario via LLM.
         class TestResult
           attr_reader :test_id, :status, :test_cases, :summary,
-            :started_at, :completed_at, :report_dir, :error
+            :started_at, :completed_at, :report_dir, :error, :metadata, :observations
 
           # @param test_id [String] Test identifier
           # @param status [String] Overall status: "pass", "fail", "partial", "error"
@@ -20,8 +20,10 @@ module Ace
           # @param completed_at [Time] When execution completed
           # @param report_dir [String, nil] Path to the reports directory
           # @param error [String, nil] Error message if execution failed
+          # @param observations [String] Runner/verifier observations for report context
+          # @param metadata [Hash] Additional structured phase/report metadata
           def initialize(test_id:, status:, test_cases: [], summary: "",
-            started_at: nil, completed_at: nil, report_dir: nil, error: nil)
+            started_at: nil, completed_at: nil, report_dir: nil, error: nil, observations: "", metadata: {})
             @test_id = test_id
             @status = status
             @test_cases = test_cases
@@ -30,6 +32,8 @@ module Ace
             @completed_at = completed_at || Time.now
             @report_dir = report_dir
             @error = error
+            @observations = observations.to_s
+            @metadata = metadata
           end
 
           # Check if the test passed
@@ -94,7 +98,9 @@ module Ace
               started_at: started_at,
               completed_at: completed_at,
               report_dir: dir,
-              error: error
+              error: error,
+              observations: observations,
+              metadata: metadata
             )
           end
 

data/lib/ace/test/end_to_end_runner/models/test_scenario.rb

@@ -12,7 +12,7 @@ module Ace
           attr_reader :test_id, :title, :area, :package, :priority, :duration,
             :requires, :file_path, :content, :timeout,
             :setup_steps, :dir_path, :fixture_path, :test_cases,
-            :tags, :tool_under_test, :sandbox_layout
+            :tags, :tool_under_test, :sandbox_layout, :sandbox_profile
 
           # @param test_id [String] Test identifier (e.g., "TS-LINT-001")
           # @param title [String] Test title
@@ -31,11 +31,12 @@ module Ace
           # @param tags [Array<String>] Scenario-level tags for discovery-time filtering
           # @param tool_under_test [String, nil] Primary tool under test
           # @param sandbox_layout [Hash] Declared sandbox artifact layout
+          # @param sandbox_profile [String] Sandbox bootstrap profile
           def initialize(test_id:, title:, area:, package:, file_path:, content:,
             priority: "medium", duration: "~5min", requires: {},
             setup_steps: [], dir_path: nil, fixture_path: nil, test_cases: [],
             timeout: nil, tags: [], tool_under_test: nil,
-            sandbox_layout: {})
+            sandbox_layout: {}, sandbox_profile: "ace-default")
             @test_id = test_id
             @title = title
             @area = area
@@ -53,6 +54,7 @@ module Ace
             @tags = tags
             @tool_under_test = tool_under_test
             @sandbox_layout = sandbox_layout
+            @sandbox_profile = sandbox_profile
           end
 
           # Generate short package name (without ace- prefix)

data/lib/ace/test/end_to_end_runner/molecules/affected_detector.rb

@@ -39,10 +39,15 @@ module Ace
           # @return [Array<String>] Changed file paths
           def get_changed_files(base_dir, ref)
             # Run git diff to get changed files using array-based command for security
-            output, status = Open3.capture2("git", "diff", "--name-only", ref, "--",
+            output, stderr, status = Open3.capture3("git", "diff", "--name-only", ref, "--",
               chdir: base_dir)
 
-            return [] unless status.success?
+            unless status.success?
+              message = stderr.to_s.strip
+              message = "git diff exited with status #{status.exitstatus}" if message.empty?
+              warn "Warning: git detection failed: #{message}"
+              return []
+            end
 
             output.lines.map(&:strip).reject(&:empty?)
           rescue => e

data/lib/ace/test/end_to_end_runner/molecules/bwrap_sandbox_backend.rb

@@ -0,0 +1,271 @@
+# frozen_string_literal: true
+
+require "etc"
+require "fileutils"
+require "open3"
+
+module Ace
+  module Test
+    module EndToEndRunner
+      module Molecules
+        # Wraps subprocesses in a lightweight bubblewrap sandbox on Linux.
+        class BwrapSandboxBackend
+          BUNDLER_ENV_PREFIXES = %w[BUNDLE BUNDLER].freeze
+          STRIPPED_ENV_KEYS = %w[RUBYOPT RUBYLIB].freeze
+          PROVIDER_HOME_MOUNTS = [
+            [".claude", ".claude"],
+            [".codex", ".codex"],
+            [".gemini", ".gemini"],
+            [".pi", ".pi"],
+            [".local/share/opencode", ".local/share/opencode"]
+          ].freeze
+          DEFAULT_SYSTEM_MOUNTS = %w[/usr /bin /sbin /lib /lib64 /etc /opt /var/lib/flatpak/exports].freeze
+
+          attr_reader :sandbox_root
+
+          def self.supported?
+            Gem.win_platform? == false && RUBY_PLATFORM.include?("linux")
+          end
+
+          def self.available?(bwrap_path: "bwrap")
+            return false unless supported?
+
+            system("which", bwrap_path, out: File::NULL, err: File::NULL)
+          end
+
+          def initialize(sandbox_root:, source_root: nil, bwrap_path: "bwrap", outer_env: nil)
+            @sandbox_root = File.expand_path(sandbox_root)
+            @source_root = source_root ? File.expand_path(source_root) : infer_source_root
+            @bwrap_path = bwrap_path
+            @outer_env = sanitized_outer_env(outer_env)
+          end
+
+          def ensure_available!
+            return if self.class.available?(bwrap_path: @bwrap_path)
+
+            raise "bubblewrap is required for Linux E2E sandboxing but '#{@bwrap_path}' is not available"
+          end
+
+          def prepared_env(base_env = {})
+            env = stringify_keys(base_env)
+            STRIPPED_ENV_KEYS.each { |key| env.delete(key) }
+            env["PROJECT_ROOT_PATH"] = @sandbox_root
+            env["ACE_E2E_SOURCE_ROOT"] ||= @source_root if @source_root
+            env["HOME"] = sandbox_home
+            env["TMPDIR"] = sandbox_tmp
+            env["XDG_RUNTIME_DIR"] = sandbox_runtime_dir
+            env["TMUX_TMPDIR"] ||= sandbox_runtime_dir
+            env["BUNDLE_GEMFILE"] ||= File.join(@sandbox_root, ".ace-local", "e2e-runtime", "Gemfile")
+            env["ACE_CONFIG_PATH"] ||= File.join(@sandbox_root, ".ace")
+            env["BUNDLE_APP_CONFIG"] ||= bundler_app_config
+            env["BUNDLE_USER_HOME"] ||= bundler_home
+            env["BUNDLE_USER_CACHE"] ||= bundler_cache
+            env["BUNDLE_USER_CONFIG"] ||= bundler_user_config
+            env["PATH"] ||= ENV["PATH"].to_s
+            env
+          end
+
+          def wrap_command(cmd, chdir:, env: {})
+            command_prefix(chdir: chdir, env: env) + Array(cmd)
+          end
+
+          def command_prefix(chdir:, env: {})
+            ensure_available!
+            merged_env = prepared_env(env)
+            ensure_runtime_dirs(merged_env)
+
+            args = [
+              @bwrap_path,
+              "--clearenv",
+              "--die-with-parent",
+              "--new-session",
+              "--proc", "/proc",
+              "--dev-bind", "/dev", "/dev",
+              "--tmpfs", "/tmp",
+              "--tmpfs", home_root,
+              "--dir", merged_env.fetch("HOME"),
+              "--bind", merged_env.fetch("HOME"), merged_env.fetch("HOME")
+            ]
+
+            host_mounts(merged_env.fetch("PATH")).each do |mount|
+              append_bind(args, mount, mount, read_only: true)
+            end
+            append_bind(args, @source_root, @source_root, read_only: true) if @source_root
+            append_bind(args, @sandbox_root, @sandbox_root, read_only: false)
+            append_bind(args, support_root, support_root, read_only: false)
+            ruby_root = merged_env["ACE_E2E_SANDBOX_RUBY_ROOT"].to_s
+            append_bind(args, ruby_root, ruby_root, read_only: true) if !ruby_root.empty? && File.exist?(ruby_root)
+            bind_provider_homes(args, merged_env.fetch("HOME"))
+
+            setenvs = {
+              "HOME" => merged_env.fetch("HOME"),
+              "TMPDIR" => merged_env.fetch("TMPDIR"),
+              "XDG_RUNTIME_DIR" => merged_env.fetch("XDG_RUNTIME_DIR"),
+              "TMUX_TMPDIR" => merged_env.fetch("TMUX_TMPDIR"),
+              "PATH" => merged_env.fetch("PATH"),
+              "PROJECT_ROOT_PATH" => merged_env.fetch("PROJECT_ROOT_PATH")
+            }
+            setenvs["ACE_E2E_SOURCE_ROOT"] = merged_env["ACE_E2E_SOURCE_ROOT"] if merged_env["ACE_E2E_SOURCE_ROOT"]
+            setenvs["ACE_E2E_SANDBOX_RUBY_ROOT"] = ruby_root unless ruby_root.empty?
+            setenvs["ACE_TMUX_SESSION"] = merged_env["ACE_TMUX_SESSION"] if merged_env["ACE_TMUX_SESSION"]
+
+            merged_env.each do |key, value|
+              next if setenvs.key?(key)
+              next if value.nil?
+
+              setenvs[key] = value.to_s
+            end
+
+            setenvs.each do |key, value|
+              args.concat(["--setenv", key, value])
+            end
+
+            args.concat(["--chdir", File.expand_path(chdir), "--"])
+            args
+          end
+
+          def capture3(cmd, chdir:, env: {}, stdin_data: nil)
+            Open3.capture3(
+              @outer_env,
+              *wrap_command(cmd, chdir: chdir, env: env),
+              chdir: "/",
+              stdin_data: stdin_data
+            )
+          end
+
+          def exec(cmd, chdir:, env: {})
+            Kernel.exec(@outer_env, *wrap_command(cmd, chdir: chdir, env: env))
+          end
+
+          private
+
+          def sandbox_home
+            File.join(support_root, "home")
+          end
+
+          def sandbox_tmp
+            File.join(support_root, "tmp")
+          end
+
+          def sandbox_runtime_dir
+            File.join(support_root, "runtime")
+          end
+
+          def bundler_root
+            File.join(support_root, "bundler")
+          end
+
+          def bundler_home
+            File.join(bundler_root, "home")
+          end
+
+          def bundler_cache
+            File.join(bundler_root, "cache")
+          end
+
+          def bundler_user_config
+            File.join(bundler_root, "config")
+          end
+
+          def bundler_app_config
+            File.join(bundler_root, "app-config")
+          end
+
+          def home_root
+            File.dirname(actual_home)
+          end
+
+          def actual_home
+            File.expand_path(ENV.fetch("HOME"))
+          end
+
+          def infer_source_root
+            env_root = ENV["ACE_E2E_SOURCE_ROOT"].to_s.strip
+            return File.expand_path(env_root) unless env_root.empty?
+
+            File.expand_path(Dir.pwd)
+          end
+
+          def support_root
+            "#{@sandbox_root}.support"
+          end
+
+          def host_mounts(path_value)
+            mounts = DEFAULT_SYSTEM_MOUNTS.select { |path| File.exist?(path) }
+            path_value.to_s.split(File::PATH_SEPARATOR).each do |entry|
+              next if entry.to_s.strip.empty?
+
+              expanded = File.expand_path(entry)
+              next unless File.exist?(expanded)
+
+              mounts << expanded
+              mounts << mise_install_root(expanded) if expanded.include?("/.local/share/mise/installs/")
+            end
+
+            mounts.compact.uniq.sort
+          end
+
+          def mise_install_root(path)
+            match = path.match(%r{\A(.*/\.local/share/mise/installs/[^/]+/[^/]+)})
+            match && match[1]
+          end
+
+          def ensure_runtime_dirs(env)
+            [
+              @sandbox_root,
+              support_root,
+              env.fetch("HOME"),
+              env.fetch("TMPDIR"),
+              env.fetch("XDG_RUNTIME_DIR"),
+              env.fetch("BUNDLE_APP_CONFIG"),
+              env.fetch("BUNDLE_USER_HOME"),
+              env.fetch("BUNDLE_USER_CACHE")
+            ].each { |path| FileUtils.mkdir_p(path) }
+            FileUtils.chmod(0o700, env.fetch("XDG_RUNTIME_DIR")) if File.exist?(env.fetch("XDG_RUNTIME_DIR"))
+          end
+
+          def bind_provider_homes(args, sandbox_home_dir)
+            PROVIDER_HOME_MOUNTS.each do |source_suffix, target_suffix|
+              source = File.join(actual_home, source_suffix)
+              next unless File.exist?(source)
+
+              target = File.join(sandbox_home_dir, target_suffix)
+              FileUtils.mkdir_p(File.dirname(target))
+              FileUtils.mkdir_p(target) if File.directory?(source)
+              append_bind(args, source, target, read_only: false)
+            end
+          end
+
+          def append_bind(args, source, target, read_only:)
+            source = File.expand_path(source)
+            target = File.expand_path(target)
+            FileUtils.mkdir_p(File.dirname(target))
+            FileUtils.mkdir_p(target) if File.directory?(source)
+            args.concat([read_only ? "--ro-bind" : "--bind", source, target])
+          end
+
+          def stringify_keys(hash)
+            hash.each_with_object({}) { |(key, value), acc| acc[key.to_s] = value }
+          end
+
+          def sanitized_process_env(base_env)
+            stringify_keys(base_env).each_with_object({}) do |(key, value), env|
+              next if strip_env_key?(key)
+
+              env[key] = value
+            end
+          end
+
+          def sanitized_outer_env(outer_env)
+            path = stringify_keys(outer_env || {"PATH" => ENV["PATH"].to_s})["PATH"]
+            {"PATH" => path.to_s.empty? ? ENV["PATH"].to_s : path.to_s}
+          end
+
+          def strip_env_key?(key)
+            STRIPPED_ENV_KEYS.include?(key) || BUNDLER_ENV_PREFIXES.any? { |prefix| key.start_with?(prefix) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/test/end_to_end_runner/molecules/config_loader.rb

@@ -23,7 +23,22 @@ module Ace
           # @return [String] Default provider from config
           def self.default_provider
             config = load
-            config.dig("execution", "provider") || "claude:sonnet"
+            config.dig("execution", "runner_provider") ||
+              config.dig("execution", "provider") || "claude:sonnet"
+          end
+
+          # @return [String] Default runner provider from config
+          def self.default_runner_provider
+            config = load
+            config.dig("execution", "runner_provider") ||
+              config.dig("execution", "provider") || "claude:sonnet"
+          end
+
+          # @return [String] Default verifier provider from config
+          def self.default_verifier_provider
+            config = load
+            config.dig("execution", "verifier_provider") ||
+              config.dig("execution", "provider") || "claude:sonnet"
           end
 
           # @return [Integer] Default timeout from config
@@ -38,6 +53,18 @@ module Ace
             config.dig("execution", "parallel") || 3
           end
 
+          # @return [String] Default sandbox bootstrap profile
+          def self.default_sandbox_profile
+            config = load
+            config.dig("sandbox", "profile") || "ace-default"
+          end
+
+          # @return [String] Dedicated Ruby version for sandbox runtime
+          def self.default_sandbox_ruby_version
+            config = load
+            config.dig("sandbox", "ruby_version") || "3.4.9"
+          end
+
           # @return [Array<String>] CLI provider names
           def self.cli_providers
             config = load