ace-demo 0.25.1 → 0.25.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ae9f0aced46022fd683e573a13e899c0e0e5d119e1d50cd65903f0e1188983ec
-  data.tar.gz: 769e24a54a5c0162e30fa691ad378161c917f3774f87e1ed066f3a39a68a58ca
+  metadata.gz: 3dc9853e3f70693cc0dc687ab61f645ed432d0afae57a7dd2d7e87c746da9236
+  data.tar.gz: 4f85e3e89c5efefdbab60d3776e4a2c6b92feb2067a1bdbdc7954723caada2c4
 SHA512:
-  metadata.gz: a1d750f6d1c26789d9ed615352536aece06fd42dbf2b9b4619aa8db5bb6d889cbb629034f2217ba81c4630c59b77360bc1a76cf6adb638a5e6a8e828fb0bc606
-  data.tar.gz: '0368a6c97f32dcccd9a49e429e65b8b90ba45f0590d6dbc9bc3acd6ff9560ed04f4d7c630d2ea3dedb83de0356bf718f3aef0b9090baa157326a446ee9ce509f'
+  metadata.gz: fff3491b92a232bbbfe39aaf01ddf6f0e3924ff0d9644609572248d4338b0ecceadbcbd5a19f0854398e43c482864d2336eea6a9aaceb97e4ba9a9dda6a654f2
+  data.tar.gz: dada165a45b5b184b95f5a49cf30775a8e4290530f13e4ea75337aacfcf2cb4cb4267da621a3311ac2620b82c6d8c71c22a680acc3cb89e0fdc78cb8f9ff342c

data/CHANGELOG.md

@@ -6,6 +6,22 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
+### Fixed
+- Failed YAML tape verification by default when the final asciinema shell exit is non-zero, unless `verify.allow_nonzero_exit: true` opts out explicitly.
+- Surfaced non-zero cast exit codes in `record` / `verify` output and verification reports so broken recordings are diagnosable without opening the raw cast.
+
+## [0.25.6] - 2026-04-16
+
+### Added
+- Added additive YAML `tmux:` recorder-control directives for asciinema-backed demo tapes, covering shared-surface `attach`, `detach`, `wait`, `send`, and optional `capture` actions alongside existing visible `type:` commands.
+
+### Changed
+- Updated `ace-demo` recording/docs to treat tmux orchestration as structured recorder control instead of canonical raw tmux shell glue.
+
+### Fixed
+- Updated the `ace-tmux` runtime dependency constraint to `~> 0.17` so recorder-side tmux directives stay aligned with the new runtime inspection release line.
+- Rejected unsupported YAML `tmux.action: capture` directives during parsing, forwarded recording env values into recorder-side tmux control resolution, and clarified that tmux directives are supported only for the asciinema backend.
+- Rejected YAML `tmux:` directives when the resolved recording backend is `vhs` so unsupported backend/control-surface combinations fail fast instead of being silently ignored during VHS compilation.
 
 ## [0.25.1] - 2026-04-16
 

data/README.md

@@ -18,7 +18,7 @@
 
 ![ace-demo demo](docs/demo/ace-demo-getting-started.gif)
 
-`ace-demo` records terminal sessions as proof-of-work evidence for agent-driven workflows. Tapes define what to capture — either as simple [VHS](https://github.com/charmbracelet/vhs) scripts (`.tape`) or as YAML specs (`.tape.yml`) with sandbox setup, scenes, and teardown.
+`ace-demo` records terminal sessions as proof-of-work evidence for agent-driven workflows. Tapes define what to capture — either as simple [VHS](https://github.com/charmbracelet/vhs) scripts (`.tape`) or as YAML specs (`.tape.yml`) with sandbox setup, scenes, teardown, and optional tmux recorder-control directives.
 
 Recordings attach directly to GitHub pull requests as reviewable evidence. Requires `vhs`, `chromium`, and `ttyd` for deterministic rendering (see [setup requirements](docs/setup.md)).
 
@@ -43,6 +43,11 @@ scenes:
   commands:
   - type: ace-demo list
     sleep: 4s
+  - tmux:
+      action: wait
+      for: window-active
+      session: fork-demo
+      window: work
   - type: ace-demo record hello
     sleep: 6s
 
@@ -51,10 +56,12 @@ teardown:
 ```
 
 - **setup** — sandbox isolation, git init, fixture copying, or arbitrary shell via `run: <cmd>`
-- **scenes** — named command sequences compiled to VHS directives (`Type`, `Enter`, `Sleep`)
+- **scenes** — named command sequences with visible `type:` shell commands and optional `tmux:` recorder-control directives for asciinema-backed recordings
 - **teardown** — cleanup directives that always run (even on failure)
 - **settings** — optional `font_size`, `width`, `height`, `format` overrides
 
+Use `type:` for on-camera shell commands that should appear in the recording. Use `tmux:` only with the asciinema backend for recorder-control actions such as `attach`, `detach`, `wait`, and `send` when the demo needs deterministic tmux choreography without raw shell glue. YAML tapes recorded with the `vhs` backend must not include `tmux:` directives.
+
 Legacy `.tape` files use raw VHS syntax directly. See the [Usage Guide](docs/usage.md) for the full tape specification.
 
 ## Use Cases

data/lib/ace/demo/atoms/asciinema_tape_compiler.rb

@@ -27,6 +27,8 @@ module Ace
             lines << "# Scene: #{scene_name}" unless scene_name.to_s.strip.empty?
 
             scene.fetch("commands", []).each do |command|
+              next unless command["type"]
+
               lines << command.fetch("type")
               sleep_value = validate_sleep!(command["sleep"] || default_timeout)
               lines << "sleep #{sleep_value}"

data/lib/ace/demo/atoms/demo_yaml_parser.rb

@@ -170,6 +170,13 @@ module Ace
           raise DemoYamlParseError, "verify must be a map in #{source_path}" unless verify.is_a?(Hash)
 
           normalized = {}
+          if verify.key?("allow_nonzero_exit")
+            normalized["allow_nonzero_exit"] = normalize_boolean(
+              verify["allow_nonzero_exit"],
+              "verify.allow_nonzero_exit",
+              source_path
+            )
+          end
           normalized["require_vars"] = normalize_string_list(verify["require_vars"], "verify.require_vars", source_path) if verify.key?("require_vars")
           normalized["require_output"] = normalize_string_list(verify["require_output"], "verify.require_output", source_path) if verify.key?("require_output")
           if verify.key?("require_output_sequence")
@@ -185,6 +192,13 @@ module Ace
         end
         private_class_method :normalize_verify
 
+        def normalize_boolean(value, field, source_path)
+          return value if value == true || value == false
+
+          raise DemoYamlParseError, "#{field} must be a boolean in #{source_path}"
+        end
+        private_class_method :normalize_boolean
+
         def normalize_string_list(value, field, source_path)
           raise DemoYamlParseError, "#{field} must be an array in #{source_path}" unless value.is_a?(Array)
 
@@ -205,18 +219,88 @@ module Ace
               "scenes[#{scene_index}].commands[#{command_index}] must be a map in #{source_path}"
           end
 
-          type = command["type"]&.to_s
-          if type.nil? || type.strip.empty?
+          normalized = {"sleep" => command["sleep"]&.to_s}.compact
+          has_type = !command["type"].to_s.strip.empty?
+          has_tmux = command["tmux"].is_a?(Hash)
+
+          if has_type && has_tmux
             raise DemoYamlParseError,
-              "scenes[#{scene_index}].commands[#{command_index}].type is required in #{source_path}"
+              "scenes[#{scene_index}].commands[#{command_index}] cannot define both type and tmux in #{source_path}"
           end
 
-          {
-            "type" => type,
-            "sleep" => command["sleep"]&.to_s
-          }
+          if has_type
+            normalized["type"] = command["type"].to_s
+            return normalized
+          end
+
+          if has_tmux
+            normalized["tmux"] = normalize_tmux_command(
+              command["tmux"],
+              scene_index,
+              command_index,
+              source_path: source_path
+            )
+            return normalized
+          end
+
+          raise DemoYamlParseError,
+            "scenes[#{scene_index}].commands[#{command_index}] must define either type or tmux in #{source_path}"
         end
         private_class_method :normalize_command
+
+        def normalize_tmux_command(tmux, scene_index, command_index, source_path:)
+          directive = tmux.transform_keys(&:to_s)
+          action = directive["action"]&.to_s&.strip
+          if action.nil? || action.empty?
+            raise DemoYamlParseError,
+              "scenes[#{scene_index}].commands[#{command_index}].tmux.action is required in #{source_path}"
+          end
+
+          allowed = %w[attach detach wait send]
+          unless allowed.include?(action)
+            raise DemoYamlParseError,
+              "Unknown tmux action '#{action}' in #{source_path}. Allowed: #{allowed.join(', ')}"
+          end
+
+          normalized = {"action" => action}
+          %w[session window pane pattern].each do |field|
+            normalized[field] = directive[field].to_s if directive.key?(field)
+          end
+
+          case action
+          when "attach", "detach"
+            normalized["session"] = required_string!(directive, "session", scene_index, command_index, source_path)
+          when "wait"
+            normalized["for"] = required_string!(directive, "for", scene_index, command_index, source_path)
+            normalized["pattern"] = normalized["pattern"] if normalized["pattern"]
+            normalized["timeout"] = Float(directive["timeout"]) if directive.key?("timeout")
+          when "send"
+            command_text = directive["command"]&.to_s&.strip
+            key_text = directive["key"]&.to_s&.strip
+            if command_text.to_s.empty? == key_text.to_s.empty?
+              raise DemoYamlParseError,
+                "tmux send must define exactly one of command or key in #{source_path}"
+            end
+            normalized["command"] = command_text unless command_text.to_s.empty?
+            normalized["key"] = key_text unless key_text.to_s.empty?
+          end
+
+          normalized
+        rescue ArgumentError, TypeError => e
+          raise DemoYamlParseError, "#{e.message} (#{source_path})"
+        end
+        private_class_method :normalize_tmux_command
+
+        def required_string!(directive, field, scene_index, command_index, source_path)
+          value = directive[field]&.to_s&.strip
+          if value.nil? || value.empty?
+            raise DemoYamlParseError,
+              "scenes[#{scene_index}].commands[#{command_index}].tmux.#{field} is required in #{source_path}"
+          end
+
+          value
+        end
+        private_class_method :required_string!
       end
     end
   end

data/lib/ace/demo/atoms/record_option_validator.rb

@@ -34,11 +34,25 @@ module Ace
           raise ArgumentError, "Format 'webm' requires --backend vhs when recording YAML tapes"
         end
 
+        def validate_yaml_backend_capabilities!(backend:, spec:)
+          return unless backend == "vhs"
+          return unless yaml_uses_tmux_directives?(spec)
+
+          raise ArgumentError, "Backend 'vhs' does not support tmux directives in YAML tapes; use backend 'asciinema' or remove tmux commands"
+        end
+
         def validate_raw_tape_backend!(backend:)
           return if backend.nil? || backend == "vhs"
 
           raise ArgumentError, "Raw .tape recordings support backend 'vhs' only"
         end
+
+        def yaml_uses_tmux_directives?(spec)
+          Array(spec["scenes"]).any? do |scene|
+            Array(scene["commands"]).any? { |command| command.is_a?(Hash) && command["tmux"].is_a?(Hash) }
+          end
+        end
+        private_class_method :yaml_uses_tmux_directives?
       end
     end
   end

data/lib/ace/demo/atoms/vhs_tape_compiler.rb

@@ -26,6 +26,8 @@ module Ace
             lines << "# Scene: #{scene_name}" unless scene_name.to_s.strip.empty?
 
             scene.fetch("commands", []).each do |command|
+              next unless command["type"]
+
               type_text = command.fetch("type")
               if type_text.include?('"') || type_text.include?("$") || type_text.include?("\\")
                 lines << "Type `#{type_text}`"

data/lib/ace/demo/atoms/yaml_record_planner.rb

@@ -28,6 +28,7 @@ module Ace
             allow_nil: false
           )
           RecordOptionValidator.validate_yaml_backend_format!(backend: selected_backend, format: selected_format)
+          RecordOptionValidator.validate_yaml_backend_capabilities!(backend: selected_backend, spec: spec)
 
           selected_speed = playback_speed.nil? ? settings["playback_speed"] : playback_speed
           selected_speed = Atoms::PlaybackSpeedParser.parse(selected_speed)

data/lib/ace/demo/cli/commands/record.rb

@@ -322,6 +322,8 @@ module Ace
             puts "Missing output: #{missing_output.join(', ')}" unless missing_output.empty?
             missing_sequence = verification.details&.fetch(:missing_output_sequence, []) || []
             puts "Missing output sequence: #{missing_sequence.join(' -> ')}" unless missing_sequence.empty?
+            exit_code = verification.details&.fetch(:exit_code, nil)
+            puts "Exit code: #{exit_code}" unless exit_code.nil? || exit_code.zero?
             puts "Assertions replay: skipped" if verification.details&.fetch(:assertions_skipped, false)
           end
 

data/lib/ace/demo/cli/commands/verify.rb

@@ -61,6 +61,8 @@ module Ace
             puts "Missing output: #{missing_output.join(', ')}" unless missing_output.empty?
             missing_sequence = verification.details&.fetch(:missing_output_sequence, [])
             puts "Missing output sequence: #{missing_sequence.join(' -> ')}" unless missing_sequence.empty?
+            exit_code = verification.details&.fetch(:exit_code, nil)
+            puts "Exit code: #{exit_code}" unless exit_code.nil? || exit_code.zero?
             puts "Assertions replay: skipped" if verification.details&.fetch(:assertions_skipped, false)
           end
         end

data/lib/ace/demo/molecules/asciinema_executor.rb

@@ -42,7 +42,7 @@ module Ace
           raise AsciinemaNotFoundError, "Asciinema not found (#{effective_bin}). Install: #{INSTALL_URL}"
         end
 
-        def run_interactive(cmd, commands:, env: {}, asciinema_bin: "asciinema", chdir: nil)
+        def run_interactive(cmd, commands:, env: {}, handler: nil, asciinema_bin: "asciinema", chdir: nil)
           effective_bin = cmd.first || asciinema_bin
           options = {}
           options[:chdir] = chdir if chdir
@@ -80,8 +80,16 @@ module Ace
             wait_for_prompt(buffer, buffer_mutex, buffer_cv)
 
             commands.each do |command|
-              write_io.write("#{command.fetch(:command)}\n")
-              write_io.flush
+              if handler && command[:kind] != :shell
+                outcome = handler.call(command, write_io: write_io)
+                if outcome.is_a?(Hash) && outcome[:shell_command]
+                  write_io.write("#{outcome[:shell_command]}\n")
+                  write_io.flush
+                end
+              else
+                write_io.write("#{command.fetch(:command)}\n")
+                write_io.flush
+              end
               @sleeper.sleep(command.fetch(:sleep))
             end
 

data/lib/ace/demo/molecules/cast_verifier.rb

@@ -26,6 +26,8 @@ module Ace
           recorded_commands = (recorded_inputs + echoed_commands + script_commands).uniq
           verification_spec = tape_spec.fetch("verify", {})
           captured_vars = extract_output_vars(echoed_commands)
+          exit_code = final_exit_code(recording.events)
+          nonzero_exit_disallowed = exit_code && exit_code != 0 && !verification_spec.fetch("allow_nonzero_exit", false)
 
           commands_found = expected.select { |command| include_command?(recorded_commands, command) }
           commands_missing = expected - commands_found
@@ -43,14 +45,16 @@ module Ace
           )
 
           success = commands_missing.empty? && missing_vars.empty? && missing_output.empty? &&
-            missing_output_sequence.empty? && forbidden_hits.empty? && assertion_failures.empty?
+            missing_output_sequence.empty? && forbidden_hits.empty? && assertion_failures.empty? &&
+            !nonzero_exit_disallowed
           classification, status, summary, retryable = classify(
             commands_missing: commands_missing,
             missing_vars: missing_vars,
             missing_output: missing_output,
             missing_output_sequence: missing_output_sequence,
             forbidden_hits: forbidden_hits,
-            assertion_failures: assertion_failures
+            assertion_failures: assertion_failures,
+            nonzero_exit_disallowed: nonzero_exit_disallowed
           )
 
           Models::VerificationResult.new(
@@ -68,6 +72,7 @@ module Ace
               script_commands_recorded: script_commands.length,
               commands_expected: expected.length,
               captured_vars: captured_vars,
+              exit_code: exit_code,
               missing_vars: missing_vars,
               missing_output: missing_output,
               missing_output_sequence: missing_output_sequence,
@@ -117,10 +122,12 @@ module Ace
           end
         end
 
-        def classify(commands_missing:, missing_vars:, missing_output:, missing_output_sequence:, forbidden_hits:, assertion_failures:)
+        def classify(commands_missing:, missing_vars:, missing_output:, missing_output_sequence:, forbidden_hits:, assertion_failures:, nonzero_exit_disallowed:)
           return ["pass", "pass", "Verification passed", false] if commands_missing.empty? && missing_vars.empty? &&
-            missing_output.empty? && missing_output_sequence.empty? && forbidden_hits.empty? && assertion_failures.empty?
-          unless commands_missing.empty? && missing_vars.empty? && missing_output.empty? && missing_output_sequence.empty?
+            missing_output.empty? && missing_output_sequence.empty? && forbidden_hits.empty? && assertion_failures.empty? &&
+            !nonzero_exit_disallowed
+          unless commands_missing.empty? && missing_vars.empty? && missing_output.empty? && missing_output_sequence.empty? &&
+              !nonzero_exit_disallowed
             return ["scenario_defect", "scenario-defect", "Recording scenario failed verification", true]
           end
 
@@ -226,6 +233,15 @@ module Ace
           []
         end
 
+        def final_exit_code(events)
+          exit_event = events.reverse.find { |event| event.type == "x" }
+          return nil unless exit_event
+
+          Integer(exit_event.data)
+        rescue ArgumentError, TypeError
+          nil
+        end
+
         ANSI_ESCAPE_PATTERN = /\e\[[0-9;?]*[A-Za-z]/.freeze
         private_constant :ANSI_ESCAPE_PATTERN
 

data/lib/ace/demo/molecules/tmux_directive_executor.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "shellwords"
+
+module Ace
+  module Demo
+    module Molecules
+      class TmuxDirectiveExecutor
+        def initialize(control_surface: nil, executor: nil, tmux: "tmux")
+          @control_surface = control_surface
+          @executor = executor || Ace::Tmux::Molecules::TmuxExecutor.new
+          @tmux = tmux
+        end
+
+        def execute(command, env = nil)
+          directive = command.fetch("tmux")
+          action = directive.fetch("action")
+          surface = control_surface_for(env: env)
+
+          case action
+          when "attach"
+            session = directive.fetch("session")
+            {shell_command: [tmux, "attach-session", "-t", session].map { |part| Shellwords.escape(part) }.join(" ")}
+          when "detach"
+            surface.detach_session(session: directive["session"])
+            nil
+          when "wait"
+            surface.wait_for_condition(
+              condition: directive.fetch("for"),
+              session: directive["session"],
+              window: directive["window"],
+              pane: directive["pane"],
+              pattern: directive["pattern"],
+              timeout: directive.fetch("timeout", Ace::Tmux::Organisms::ControlSurface::DEFAULT_TIMEOUT)
+            )
+            nil
+          when "send"
+            if directive["command"]
+              surface.send_command(
+                session: directive["session"],
+                window: directive["window"],
+                pane: directive["pane"],
+                command: directive["command"]
+              )
+            else
+              surface.send_key(
+                session: directive["session"],
+                window: directive["window"],
+                pane: directive["pane"],
+                key: directive.fetch("key")
+              )
+            end
+            nil
+          else
+            raise ArgumentError, "Unsupported tmux action '#{action}'"
+          end
+        rescue KeyError => e
+          raise ArgumentError, "Invalid tmux directive: missing #{e.key}"
+        rescue Ace::Tmux::Error => e
+          raise Ace::Demo::Error, e.message
+        end
+
+        private
+
+        attr_reader :control_surface, :executor, :tmux
+
+        def control_surface_for(env:)
+          return control_surface if control_surface
+
+          resolver = Ace::Tmux::Molecules::RuntimeTargetResolver.new(
+            executor: executor,
+            tmux: tmux,
+            env: env || ENV
+          )
+          Ace::Tmux::Organisms::ControlSurface.new(executor: executor, resolver: resolver, tmux: tmux)
+        end
+      end
+    end
+  end
+end

data/lib/ace/demo/molecules/verification_report_writer.rb

@@ -41,6 +41,7 @@ module Ace
           append_list(lines, "Missing Vars", details[:missing_vars])
           append_list(lines, "Missing Output", details[:missing_output])
           append_list(lines, "Missing Output Sequence", details[:missing_output_sequence])
+          append_exit_code(lines, details[:exit_code])
           append_hits(lines, "Forbidden Output Hits", details[:forbidden_hits])
           append_assertion_skip(lines, details[:assertions_skipped])
           append_assertions(lines, details[:assertion_failures])
@@ -90,6 +91,15 @@ module Ace
           lines << ""
         end
 
+        def append_exit_code(lines, exit_code)
+          return if exit_code.nil? || exit_code.to_i.zero?
+
+          lines << "## Exit Code"
+          lines << ""
+          lines << "- `#{exit_code}`"
+          lines << ""
+        end
+
         def append_assertions(lines, assertions)
           return if assertions.nil? || assertions.empty?
 

data/lib/ace/demo/organisms/demo_recorder.rb

@@ -19,6 +19,7 @@ module Ace
           yaml_compiler: Atoms::VhsTapeCompiler,
           asciinema_tape_compiler: Atoms::AsciinemaTapeCompiler,
           media_retimer: Molecules::MediaRetimer.new,
+          tmux_directive_executor: Molecules::TmuxDirectiveExecutor.new,
           sandbox_builder: Molecules::DemoSandboxBuilder.new,
           teardown_executor: Molecules::DemoTeardownExecutor.new,
           output_dir: Demo.config["output_dir"],
@@ -37,6 +38,7 @@ module Ace
           @yaml_compiler = yaml_compiler
           @asciinema_tape_compiler = asciinema_tape_compiler
           @media_retimer = media_retimer
+          @tmux_directive_executor = tmux_directive_executor
           @sandbox_builder = sandbox_builder
           @teardown_executor = teardown_executor
           @output_dir = output_dir || ".ace-local/demo"
@@ -176,7 +178,15 @@ module Ace
               tty_size: settings.fetch("tty_size", "80x24"),
               asciinema_bin: @asciinema_bin
             )
-            @asciinema_executor.run_interactive(record_cmd, commands: commands, env: env, chdir: sandbox[:path])
+            @asciinema_executor.run_interactive(
+              record_cmd,
+              commands: commands,
+              env: env,
+              chdir: sandbox[:path],
+              handler: lambda { |command, write_io:|
+                handle_interactive_command(command, write_io: write_io, env: env)
+              }
+            )
             normalize_cast_terminal_size(cast_output_path, tty_size: settings.fetch("tty_size", "80x24"))
 
             convert_cmd = Atoms::AggCommandBuilder.build(
@@ -230,14 +240,38 @@ module Ace
         def interactive_commands_for(spec:)
           spec.fetch("scenes", []).flat_map do |scene|
             scene.fetch("commands", []).map do |command|
-              {
-                command: command.fetch("type"),
-                sleep: sleep_seconds(command["sleep"] || "2s")
-              }
+              normalize_interactive_command(command)
             end
           end
         end
 
+        def normalize_interactive_command(command)
+          if command["type"]
+            return {
+              kind: :shell,
+              command: command.fetch("type"),
+              sleep: sleep_seconds(command["sleep"] || "2s")
+            }
+          end
+
+          {
+            kind: :tmux,
+            directive: command.fetch("tmux"),
+            sleep: sleep_seconds(command["sleep"] || "2s")
+          }
+        end
+
+        def handle_interactive_command(command, write_io:, env:)
+          case command[:kind]
+          when :shell
+            write_io.write("#{command.fetch(:command)}\n")
+            write_io.flush
+            nil
+          when :tmux
+            @tmux_directive_executor.execute({"tmux" => command.fetch(:directive)}, env)
+          end
+        end
+
         def sleep_seconds(value)
           text = value.to_s.strip
           match = text.match(/\A(?<number>\d+(?:\.\d+)?)(?<unit>ms|s|m|h)?\z/)

data/lib/ace/demo/version.rb

@@ -2,6 +2,6 @@
 
 module Ace
   module Demo
-    VERSION = '0.25.1'
+    VERSION = '0.25.6'
   end
 end

data/lib/ace/demo.rb

@@ -2,6 +2,7 @@
 
 require "fileutils"
 require "ace/support/config"
+require "ace/tmux"
 
 require_relative "demo/version"
 require_relative "demo/atoms/vhs_command_builder"
@@ -40,6 +41,7 @@ require_relative "demo/molecules/media_retimer"
 require_relative "demo/molecules/demo_comment_poster"
 require_relative "demo/molecules/verification_report_writer"
 require_relative "demo/molecules/recording_manifest_writer"
+require_relative "demo/molecules/tmux_directive_executor"
 require_relative "demo/organisms/demo_recorder"
 require_relative "demo/organisms/demo_attacher"
 require_relative "demo/organisms/tape_creator"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ace-demo
 version: !ruby/object:Gem::Version
-  version: 0.25.1
+  version: 0.25.6
 platform: ruby
 authors:
 - Michal Czyz
 bindir: exe
 cert_chain: []
-date: 2026-04-20 00:00:00.000000000 Z
+date: 2026-04-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ace-support-cli
@@ -65,6 +65,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.13'
+- !ruby/object:Gem::Dependency
+  name: ace-tmux
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.17'
 - !ruby/object:Gem::Dependency
   name: ace-support-test-helpers
   requirement: !ruby/object:Gem::Requirement
@@ -189,6 +203,7 @@ files:
 - lib/ace/demo/molecules/tape_resolver.rb
 - lib/ace/demo/molecules/tape_scanner.rb
 - lib/ace/demo/molecules/tape_writer.rb
+- lib/ace/demo/molecules/tmux_directive_executor.rb
 - lib/ace/demo/molecules/verification_report_writer.rb
 - lib/ace/demo/molecules/vhs_executor.rb
 - lib/ace/demo/organisms/demo_attacher.rb