ace-test-runner-e2e 0.41.0 → 0.43.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '023288b5afdd9d9303ed0a4b439503062611cb9cd364e29f68aef91dab4a85c6'
-  data.tar.gz: 30026fd012aa74ebe994d0f41b0bcd809d6bf0599f4a842ad087756e88592d8b
+  metadata.gz: a10bfe582cd05ba82acd9de7b3cde9164748ae79f10197839d30ce1be1d5aa08
+  data.tar.gz: 92cb523accd05c05fbe2e7c76c1778204fb048b9e1794b8956d225bc257f2779
 SHA512:
-  metadata.gz: '062688fc71b5c282c9789c0c60cd1242a4b454436f6f98cfb39475fccc33025da06962c5e18c85728766dd59c3fe49aaff35bc987c4585c75b5218d5027c0dd1'
-  data.tar.gz: c06d63cd12734b3ac962e0699ecab8934e7f8797ae92b8ee0cf4fef2c3992c980e1e2f664b93e7d844b2bf7564b1003513d8b1c0ec51808e7fee6742d9a49645
+  metadata.gz: 2bf18a436f8f4148db5acc308df5f2071803c173539a1f6b60c5b6dd631ed176fb3c9dce8ce265af0cc493b07160b59b9373e81af877331cddd21571721694ed
+  data.tar.gz: 7c0024804c817351a3dc980b71496ac2d010f28c626206c2def6dd32cce48f35e01d73a9fbf8fd805c4691a3fcf3f2054c56dec51dd877026b0f65594c5a1986

data/CHANGELOG.md

@@ -7,6 +7,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.43.0] - 2026-10-05
+
+### Added
+- Frozen release manifests accept validated `runtime_dependencies` declarations for exact source-bound consumer edge verification. Missing required consumer declarations remain a proof failure.
+
+## [0.42.0] - 2026-10-04
+
+### Added
+- The `tmux-session` setup step is replaced by `runtime-session`: `runtime: tmux` (default) keeps the detached-session behavior and exports `ACE_TMUX_SESSION` + `ACE_RUNTIME=tmux`; `runtime: herdr` inherits the caller's live herdr environment and exports `ACE_RUNTIME=herdr`, failing explicitly when no herdr context is live (no fabricated stand-in).
+
 ## [0.41.0] - 2026-09-29
 
 ### Changed

data/handbook/guides/scenario-yml-reference.g.md

@@ -112,17 +112,18 @@ Available directives:
 - `copy-fixtures` — Copy fixtures/ directory into sandbox
 - `write-file:` — Write inline content to a file (`path:` + `content:`)
 - `agent-env:` — Environment variables passed to the runner/verifier agent subprocess (not setup commands)
-- `tmux-session` — Create a detached tmux session
-  - String form: `tmux-session` (uses scenario-based naming)
-  - Hash form: `tmux-session: { name-source: run-id }` (uses unique E2E run ID as session name)
-  - Runner teardown removes the created session after test execution
+- `runtime-session` — Establish a live terminal runtime context for the scenario
+  - String form: `runtime-session` (tmux session with scenario-based naming)
+  - Hash form: `runtime-session: { name-source: run-id }` (tmux session named by the E2E run ID)
+  - Hash form: `runtime-session: { runtime: herdr }` (inherits the caller's live HERDR_SESSION/HERDR_PANE; fails explicitly when absent)
+  - tmux sessions export ACE_TMUX_SESSION; both runtimes export ACE_RUNTIME. tmux sessions are removed by runner teardown after test execution
 
 Example:
 
 ```yaml
 setup:
   - git-init
-  - tmux-session:
+  - runtime-session:
       name-source: run-id
   - run: "cp ${ACE_E2E_SOURCE_ROOT:-$PROJECT_ROOT_PATH}/mise.toml mise.toml && mise trust mise.toml"
   - copy-fixtures

data/handbook/templates/scenario.yml.template.yml

@@ -51,14 +51,14 @@ requires:
   ruby: ">= 3.0"
 
 # Setup directives (executed before test cases)
-# Available: git-init, run:, copy-fixtures, write-file:, agent-env:, tmux-session
+# Available: git-init, run:, copy-fixtures, write-file:, agent-env:, runtime-session
 # Rules:
 # - setup is fail-fast (do not use `|| true`)
 # - fixtures/setup own sandbox preparation; runner TCs do not re-implement setup
 setup:
   - git-init
   # Optional detached tmux session for test isolation (uses unique run ID)
-  # - tmux-session:
+  # - runtime-session:
   #     name-source: run-id
   - run: "cp ${ACE_E2E_SOURCE_ROOT:-$PROJECT_ROOT_PATH}/mise.toml mise.toml && mise trust mise.toml"
   # Uncomment as needed:

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

@@ -163,9 +163,32 @@ module Ace
             match ? match[1].upcase : nil
           end
 
+          # Bundler machinery (installed gem trees, compact-index caches,
+          # config, shared-gem dirs) is install plumbing, not verifier
+          # evidence: `--full-index` alone pulls a ~97MB compact index, which
+          # previously got inlined into the verifier prompt whole.
+          BUNDLER_MACHINE_SEGMENTS = %w[
+            .bundle .gem bundler-cache bundler-home bundler-config
+            compact_index specifications cache bin
+          ].freeze
+          MAX_ARTIFACT_FILE_BYTES = 256 * 1024
+          MAX_ARTIFACT_CONTENT_BYTES = 2 * 1024 * 1024
+
+          def artifact_evidence?(relative_path)
+            return false if relative_path.start_with?(".bundle/", ".gem/")
+
+            BUNDLER_MACHINE_SEGMENTS.none? do |segment|
+              relative_path.include?("/#{segment}/") || relative_path.start_with?("#{segment}/")
+            end
+          end
+
           def build_artifact_section(sandbox_path)
             sandbox_path = File.expand_path(sandbox_path)
-            files = Dir.glob(File.join(sandbox_path, "results", "**", "*")).select { |f| File.file?(f) }.sort
+            files = Dir.glob(File.join(sandbox_path, "results", "**", "*"))
+              .select { |f| File.file?(f) }
+              .map { |f| File.expand_path(f) }
+              .select { |f| artifact_evidence?(relative_path(f, sandbox_path)) }
+              .sort
             tree_entries = files.map { |f| relative_path(f, sandbox_path) }
 
             parts = []
@@ -186,12 +209,21 @@ module Ace
             parts << "## File contents"
             parts << ""
 
+            content_budget = MAX_ARTIFACT_CONTENT_BYTES
             files.each do |file|
+              size = File.size(file)
+              body = if size <= MAX_ARTIFACT_FILE_BYTES
+                safe_read(file)
+              else
+                "#{safe_read(file, MAX_ARTIFACT_FILE_BYTES)}\n... [truncated, #{size} bytes total]"
+              end
+              content_budget -= body.bytesize
               parts << "### `#{relative_path(file, sandbox_path)}`"
               parts << "```"
-              parts << safe_read(file)
+              parts << body
               parts << "```"
               parts << ""
+              break if content_budget <= 0
             end
 
             parts.join("\n").rstrip
@@ -324,8 +356,9 @@ module Ace
             File.expand_path(path).sub("#{File.expand_path(root)}/", "")
           end
 
-          def safe_read(path)
-            File.binread(path).encode("UTF-8", invalid: :replace, undef: :replace, replace: "?")
+          def safe_read(path, limit = nil)
+            raw = limit ? File.binread(path, limit) : File.binread(path)
+            raw.encode("UTF-8", invalid: :replace, undef: :replace, replace: "?")
           end
         end
       end

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

@@ -4,6 +4,7 @@ require "digest"
 require "fileutils"
 require "json"
 require "rubygems/version"
+require "rubygems/requirement"
 
 module Ace
   module Test
@@ -124,7 +125,7 @@ module Ace
               label = "packages[#{index}]"
               raise Invalid, "#{label} must be an object" unless entry.is_a?(Hash)
 
-              reject_unknown_keys!(entry, %w[name artifact_version source_sha supersedes], label)
+              reject_unknown_keys!(entry, %w[name artifact_version source_sha supersedes runtime_dependencies], label)
 
               name = entry["name"]
               unless name.is_a?(String) && name.match?(GEM_NAME_PATTERN)
@@ -134,9 +135,34 @@ module Ace
               validate_exact_version!(entry["artifact_version"], "#{label}(#{name}) artifact_version")
               validate_source_sha!(entry["source_sha"], "#{label}(#{name}) source_sha")
               validate_supersedes!(entry["supersedes"], entry["artifact_version"], "#{label}(#{name})")
+              validate_runtime_dependencies!(entry["runtime_dependencies"], label) if entry.key?("runtime_dependencies")
               name
             end
 
+            # These are frozen source declarations, not requirements inferred
+            # from whatever a registry happened to return during the proof.
+            def validate_runtime_dependencies!(raw, label)
+              unless raw.is_a?(Hash)
+                raise Invalid, "#{label} runtime_dependencies must be an object"
+              end
+              raw.each do |name, requirements|
+                unless name.is_a?(String) && name.match?(GEM_NAME_PATTERN) &&
+                    requirements.is_a?(Array) && !requirements.empty? &&
+                    requirements.uniq.length == requirements.length
+                  raise Invalid, "#{label} has invalid runtime dependency declaration"
+                end
+                requirements.each do |requirement|
+                  parsed = requirement.is_a?(String) ? Gem::Requirement.new(requirement) : nil
+                  canonical = parsed&.requirements&.map { |operator, version| "#{operator} #{version}" }
+                  unless canonical == [requirement]
+                    raise Invalid, "#{label} runtime dependency requirements must be canonical strings"
+                  end
+                rescue ArgumentError
+                  raise Invalid, "#{label} has invalid runtime dependency requirement"
+                end
+              end
+            end
+
             def validate_exact_version!(raw, label)
               unless raw.is_a?(String) && !raw.strip.empty?
                 raise Invalid, "#{label} must be an exact version string, got #{raw.inspect}"

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

@@ -17,7 +17,7 @@ module Ace
         #
         # Processes the setup array from scenario.yml, running each action
         # via Ruby system calls (no LLM involved). Supports: git-init,
-        # copy-fixtures, run, write-file, agent-env, tmux-session, and
+        # copy-fixtures, run, write-file, agent-env, runtime-session, and
         # release-manifest actions.
         #
         # Note: This is a Molecule because it performs filesystem I/O and
@@ -28,6 +28,7 @@ module Ace
           STRIPPED_ENV_KEYS = %w[RUBYOPT RUBYLIB].freeze
           RESERVED_ENV_KEYS = Molecules::SandboxRuntimeBuilder::RESERVED_ENV_KEYS + %w[
             PATH HOME TMPDIR XDG_RUNTIME_DIR TMUX_TMPDIR ACE_TMUX_SESSION
+            ACE_RUNTIME HERDR_SESSION HERDR_PANE HERDR_WORKSPACE_ID
           ]
           RELEASE_MANIFEST_DEFAULT_PATH = File.join(".ace-local", "release", "installation-manifest.json")
           # Retry trust state lives in the report directory — host-side,
@@ -56,14 +57,14 @@ module Ace
           # @param setup_steps [Array] Setup steps from scenario.yml
           # @param sandbox_dir [String] Path to the sandbox directory
           # @param fixture_source [String, nil] Path to the fixtures/ directory
-          # @param scenario_name [String, nil] Test ID for tmux session naming (e.g., "TS-OVERSEER-001")
-          # @param run_id [String, nil] Unique run ID for deterministic tmux session naming
+          # @param scenario_name [String, nil] Test ID for runtime session naming (e.g., "TS-OVERSEER-001")
+          # @param run_id [String, nil] Unique run ID for deterministic runtime session naming
           # @param release_manifest_path [String, nil] Explicit absolute manifest path carried
           #   from the invoking process (ACE_RELEASE_MANIFEST). When nil, the release-manifest
           #   step falls back to the default path under ACE_E2E_SOURCE_ROOT.
           # @param state_file [String, nil] Host-side path (report directory) for retry
           #   state. When nil, no retry state is recorded and the sandbox is never reused.
-          # @return [Hash] Result with :success, :steps_completed, :error, :env, :tmux_session keys
+          # @return [Hash] Result with :success, :steps_completed, :error, :env, :runtime_session keys
           def execute(setup_steps:, sandbox_dir:, fixture_source: nil, scenario_name: nil, run_id: nil, initial_env: {},
             git_excludes: [], release_manifest_path: nil, state_file: nil)
             # Initialized before any filesystem operation: an early failure
@@ -71,7 +72,7 @@ module Ace
             # secondary error from nil state.
             env = {}
             steps_completed = 0
-            @tmux_session = nil
+            @runtime_session = nil
             @teardown_env = nil
             FileUtils.mkdir_p(sandbox_dir)
             # A rerun invalidates any earlier success up front: state is
@@ -94,7 +95,7 @@ module Ace
             @release_manifest_input = release_manifest_path
             @release_manifest_state = nil
             steps_completed = 0
-            @tmux_session = nil
+            @runtime_session = nil
             @scenario_name = scenario_name
             @run_id = run_id
             @teardown_env = nil
@@ -137,7 +138,7 @@ module Ace
               steps_completed: steps_completed,
               error: nil,
               env: merged,
-              tmux_session: @tmux_session
+              runtime_session: @runtime_session
             }
           rescue => e
             {
@@ -145,24 +146,24 @@ module Ace
               steps_completed: steps_completed,
               error: e.message,
               env: merged_environment(env),
-              tmux_session: @tmux_session
+              runtime_session: @runtime_session
             }
           end
 
-          # Clean up resources created during setup (e.g. tmux session)
+          # Clean up resources created during setup (e.g. tmux runtime session)
           def teardown
-            return unless @tmux_session
+            return unless @runtime_session
 
             if @sandbox_backend
               @sandbox_backend.capture3(
-                ["tmux", "kill-session", "-t", @tmux_session],
+                ["tmux", "kill-session", "-t", @runtime_session],
                 chdir: @teardown_env&.fetch("PROJECT_ROOT_PATH", Dir.pwd) || Dir.pwd,
                 env: @teardown_env || {}
               )
             else
-              @system_runner.call("tmux", "kill-session", "-t", @tmux_session, out: File::NULL, err: File::NULL)
+              @system_runner.call("tmux", "kill-session", "-t", @runtime_session, out: File::NULL, err: File::NULL)
             end
-            @tmux_session = nil
+            @runtime_session = nil
           end
 
           private
@@ -179,8 +180,8 @@ module Ace
               handle_git_init(sandbox_dir, env)
             when "copy-fixtures"
               handle_copy_fixtures(sandbox_dir, fixture_source)
-            when "tmux-session"
-              handle_tmux_session(env)
+            when "runtime-session"
+              handle_runtime_session(env)
             when Hash
               execute_hash_step(step, sandbox_dir, env)
             else
@@ -200,8 +201,8 @@ module Ace
               handle_write_file(value["path"], value["content"], sandbox_dir)
             when "agent-env"
               handle_env(value, env)
-            when "tmux-session"
-              handle_tmux_session(env, value)
+            when "runtime-session"
+              handle_runtime_session(env, value)
             when "release-manifest"
               handle_release_manifest(value, sandbox_dir, env)
             else
@@ -209,8 +210,22 @@ module Ace
             end
           end
 
-          # Create an isolated detached tmux session and store its name in env
-          def handle_tmux_session(env, config = nil)
+          # Establish a live terminal runtime context for the scenario.
+          # runtime "tmux" (default) creates an isolated detached tmux
+          # session and exports ACE_TMUX_SESSION + ACE_RUNTIME=tmux.
+          # runtime "herdr" requires the caller's live HERDR_SESSION and
+          # HERDR_PANE (herdr workspaces are operator-owned; the runner
+          # never fabricates one) and exports ACE_RUNTIME=herdr. An absent
+          # herdr context fails the step explicitly — no scripted stand-in.
+          def handle_runtime_session(env, config = nil)
+            runtime = config.is_a?(Hash) ? config["runtime"].to_s.strip : ""
+            runtime = "tmux" if runtime.empty?
+            unless %w[tmux herdr].include?(runtime)
+              raise ArgumentError, "runtime-session supports runtimes: tmux, herdr (got '#{runtime}')"
+            end
+
+            return handle_herdr_session(env) if runtime == "herdr"
+
             name_source = config.is_a?(Hash) ? config["name-source"] : nil
             session_name = if name_source == "run-id" && @run_id && !@run_id.to_s.empty?
               @run_id
@@ -229,8 +244,23 @@ module Ace
             end
             raise "Failed to create tmux session '#{session_name}': #{stderr.strip}" unless status.success?
 
-            @tmux_session = session_name
+            @runtime_session = session_name
             env["ACE_TMUX_SESSION"] = session_name
+            env["ACE_RUNTIME"] = "tmux"
+            @teardown_env = merged_environment(env)
+          end
+
+          def handle_herdr_session(env)
+            merged = merged_environment(env)
+            herdr_session = merged["HERDR_SESSION"].to_s.strip
+            herdr_pane = merged["HERDR_PANE"].to_s.strip
+            if herdr_session.empty? || herdr_pane.empty?
+              raise "runtime-session herdr requires a live herdr context (HERDR_SESSION and HERDR_PANE); run this scenario inside herdr"
+            end
+
+            env["HERDR_SESSION"] = herdr_session
+            env["HERDR_PANE"] = herdr_pane
+            env["ACE_RUNTIME"] = "herdr"
             @teardown_env = merged_environment(env)
           end
 

data/lib/ace/test/end_to_end_runner/organisms/test_orchestrator.rb

@@ -396,7 +396,7 @@ module Ace
                 # Transient resources (tmux sessions) die with the first
                 # run's teardown; such scenarios always re-set-up on retry.
                 declares_transient = effective_steps.any? do |step|
-                  step == "tmux-session" || (step.is_a?(Hash) && step.key?("tmux-session"))
+                  step == "runtime-session" || (step.is_a?(Hash) && step.key?("runtime-session"))
                 end
                 state = declares_transient ? nil : Molecules::SetupExecutor.setup_state_for(
                   state_file, sandbox_path, setup_steps: effective_steps

data/lib/ace/test/end_to_end_runner/version.rb

@@ -3,7 +3,7 @@
 module Ace
   module Test
     module EndToEndRunner
-      VERSION = "0.41.0"
+      VERSION = "0.43.0"
     end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ace-test-runner-e2e
 version: !ruby/object:Gem::Version
-  version: 0.41.0
+  version: 0.43.0
 platform: ruby
 authors:
 - Michal Czyz
 bindir: exe
 cert_chain: []
-date: 2026-09-30 00:00:00.000000000 Z
+date: 2026-10-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ace-support-cli