lemans 1.4.0 → 1.5.0

data/lib/lemans/result.rb

@@ -136,6 +136,12 @@ module Lemans
       def as_json(**) = to_h
     end
 
+    Restart = Data.define(:trial, :step, :mode) do
+      def initialize(trial:, step:, mode: nil) = super
+
+      def as_json(**) = to_h.compact
+    end
+
     Step = Data.define(:outcome, :usage, :duration) do
       def as_json(**) = { outcome: outcome.as_json, usage: usage&.as_json, duration: }.compact
 
@@ -150,7 +156,7 @@ module Lemans
     attr_reader :id, :task, :agent, :model, :index,
                 :profile_digest, :task_digest, :revision
 
-    attr_accessor :tags, :metadata
+    attr_accessor :tags, :metadata, :restarted_from
 
     attr_reader :phases, :steps
 
@@ -171,6 +177,7 @@ module Lemans
       @metadata = {}
       @phases = []
       @steps = nil
+      @restarted_from = nil
 
       @id = id || "#{task}__#{SecureRandom.alphanumeric(7)}"
       @outcome = Outcome.new(:pending)
@@ -239,12 +246,55 @@ module Lemans
       self
     end
 
+    # A step is settled once the next one started: it passed its gate and left a savepoint.
+    def settled_steps
+      names = phases.map(&:name)
+      (1..steps.to_a.size).count { names.include?(:"agent.#{it + 1}") }
+    end
+
+    # The step whose verification ran last, nil when none did
+    def verified_step
+      name = phases.reverse.find { it.name.to_s.match?(/\Averifier(\.\d+)?\z/) }&.name or return nil
+      name.to_s[/\.(\d+)\z/, 1]&.to_i || steps&.size || 1
+    end
+
+    # Carries over the steps before `step`; a reverification carries `step` itself too.
+    def restart!(source, step:, mode: nil)
+      @restarted_from = Restart.new(trial: source.id, step:, mode: mode&.to_s)
+      carried = mode == :reverify ? step : step - 1
+
+      if source.steps
+        source.steps.first(carried).each { step_completed!(it.outcome, it.usage, duration: it.duration) }
+      elsif carried.positive?
+        # A single-step run graded before keeps its agent outcome; a failed grading lost it.
+        completed!(source.scored? ? source.outcome : Outcome.new(:completed), source.usage)
+      end
+      self
+    end
+
+    # Splices in the named phases of the source run, shifted so that its
+    # `through` phase ends now, and moves this run's environment setup back in
+    # front of them: the timeline reads as one run.
+    def adopt_phases!(source, names, through: names.last, now: Time.now.utc)
+      delta = now - source.phases.find { it.name == through }.finished_at
+
+      setup = phases.first
+      shift = source.phases.find { it.name == setup.name }.finished_at + delta - setup.finished_at
+      phases[0] = Phase.new(setup.name, started_at: setup.started_at + shift, finished_at: setup.finished_at + shift)
+
+      source.phases.select { names.include?(it.name) }.each do |phase|
+        phases << Phase.new(phase.name, started_at: phase.started_at + delta, finished_at: phase.finished_at + delta)
+      end
+      self
+    end
+
     private def aggregate_usage = steps.filter_map(&:usage).reduce(:+)
 
     def as_json(**)
       {
         trial: id, task:, agent:, model:, index:,
         profile_digest:, task_digest:, revision: revision&.as_json,
+        restarted_from: restarted_from&.as_json,
         lemans_version: VERSION,
         tags:, metadata:, phases: phases.map(&:as_json),
         steps: steps&.map(&:as_json),
@@ -264,6 +314,7 @@ module Lemans
         )
         result.tags = data[:tags] || []
         result.metadata = data[:metadata] || {}
+        result.restarted_from = Restart.new(**data[:restarted_from]) if data[:restarted_from]
         phases_from(data).each { result.phases << it }
 
         # Steps first: the stored outcome/usage below override the aggregates.

data/lib/lemans/runner/task.rb

@@ -20,18 +20,22 @@ module Lemans
       def_delegators :definition, :name, :config
       def_delegators :result, :id
 
-      private attr_reader :definition, :store, :reporter
+      private attr_reader :definition, :store, :reporter, :restart_from, :restart_mode
 
-      def initialize(model, task_definition, index: 0, store: nil, reporter: nil)
+      def initialize(model, task_definition, index: 0, store: nil, reporter: nil, restart_from: nil, restart_mode: nil)
         @model = model
         @definition = task_definition
         @index = index
         @store = store
         @reporter = reporter
+        @restart_from = restart_from
+        @restart_mode = restart_mode
         @status = :pending
 
-        # prepare the result object: it's used by the actual execution down the stack
-        @result = Result.from_task(definition, index:, model: model || config.models.first)
+        # prepare the result object: it's used by the actual execution down the stack;
+        # a restart keeps the agent of the run it restarts
+        @result = Result.from_task(definition, index:, model: model || config.models.first,
+                                               **({ agent: restart_from.agent } if restart_from))
       end
 
       def with_reporter(reporter)
@@ -55,7 +59,7 @@ module Lemans
       private
 
       def execute!
-        Trial.new(definition, model, store:, result:).run
+        Trial.new(definition, model, store:, result:, agent: restart_from&.agent, restart_from:, restart_mode:).run
       end
     end
   end

data/lib/lemans/runner.rb

@@ -20,20 +20,26 @@ module Lemans
 
     attr_reader :config, :tasks, :store, :reporter
 
-    private attr_reader :resuming, :executor
+    private attr_reader :resuming, :restarts, :restart_mode, :allow_scored, :executor
 
-    def initialize(config, tasks, store: nil, reporter: nil, executor: nil, resume: false)
+    def initialize(config, tasks, store: nil, reporter: nil, executor: nil, resume: false,
+                   restarts: [], restart_mode: nil, allow_scored: false)
       @config = config
       @tasks = tasks
       @store = store
       @reporter = reporter
       @executor = executor || Executor.new(config.concurrency)
       @resuming = resume
+      @restarts = restarts
+      @restart_mode = restart_mode
+      @allow_scored = allow_scored
     end
 
     def resuming? = @resuming
 
     def attempts
+      return @attempts ||= restart_attempts if restarts.any?
+
       @attempts ||= config.agent.models.flat_map do |model|
         @tasks.flat_map do |task|
           completed = resuming? ? completed_attempts(task, model) : 0
@@ -64,6 +70,43 @@ module Lemans
 
     private
 
+    # Every run is checked before any starts: one refused run stops the batch.
+    def restart_attempts
+      refusals = []
+      attempts = restarts.filter_map do |restart|
+        restart_attempt(restart)
+      rescue ConfigError => e
+        refusals << e.message
+        nil
+      end
+      raise ConfigError, refusals.join("\n") if refusals.any?
+
+      attempts
+    end
+
+    # A run named for a restart is restarted on purpose: a changed task or
+    # bench is the operator's call, and a reverification may grade a scored run.
+    def restart_attempt(restart)
+      refuse = ->(reason) { raise ConfigError, "cannot restart #{restart.id}: #{reason}" }
+      task = tasks.find { it.name == restart.task }
+      refuse.("task #{restart.task} is not in the bench") unless task
+      refuse.("it is already scored (--allow-scored to restart it anyway)") if restart.scored? && restart_mode != :reverify && !allow_scored
+
+      case restart_mode
+      when :reverify
+        refuse.("it never reached a verification") unless restart.verified_step
+      when :recover
+        refuse.("#{restart.agent} cannot recover a session") unless Agents.lookup(restart.agent).recoverable?
+
+        history = task.multistep? ? "agent.result.#{restart.settled_steps + 1}.json" : "agent.result.json"
+        refuse.("it has no #{history} to recover from") unless store&.read_artifact(restart, history)
+      else
+        refuse.("no step was settled before it failed") if restart.settled_steps.zero?
+      end
+
+      Task.new(restart.model, task, store:, index: restart.index || 1, restart_from: restart, restart_mode:)
+    end
+
     def completed_attempts(task, model)
       completed_runs.count do |run|
         run.task == task.name &&

data/lib/lemans/store.rb

@@ -46,5 +46,11 @@ module Lemans
     def read_artifact(result, path)
       raise NotImplementedError
     end
+
+    # Returns the sorted paths of the artifacts the result stored (the result
+    # record is not one of them)
+    def artifacts(result)
+      raise NotImplementedError
+    end
   end
 end

data/lib/lemans/stores/fs.rb

@@ -52,8 +52,8 @@ module Lemans
       end
 
       def delete(result)
-        dir = root.glob("**/#{result.id}").find(&:directory?)
-        return unless dir
+        dir = result_dir(result)
+        return unless dir.directory?
 
         FileUtils.remove_entry(dir.to_s)
         prune_empty_parents(dir.parent)
@@ -90,6 +90,13 @@ module Lemans
         file.read if file.file?
       end
 
+      def artifacts(result)
+        dir = result_dir(result)
+        return [] unless dir.directory?
+
+        (dir.glob("**/*").select(&:file?).map { it.relative_path_from(dir).to_s } - [ FILENAME ]).sort
+      end
+
       private
 
       def filtered(text) = filterer ? filterer.filter(text) : text
@@ -132,9 +139,14 @@ module Lemans
         tmp&.delete if tmp&.exist?
       end
 
-      # result.json is stored at <root>/<model-short>/<result-id>
+      # result.json is stored at <root>/<model-short>/<result-id>; a tree
+      # arranged by hand (runs grouped under batch directories) is searched
+      # for the id instead.
       def result_dir(result)
-        root.join((result.model || result.agent).to_s.split("/").last.tr("#", "-"), result.id)
+        canonical = root.join((result.model || result.agent).to_s.split("/").last.to_s.tr("#", "-"), result.id)
+        return canonical if canonical.directory?
+
+        root.glob("**/#{result.id}").find(&:directory?) || canonical
       end
     end
   end

data/lib/lemans/trial/patch.rb

@@ -61,6 +61,15 @@ module Lemans
         raise InfrastructureError, "could not savepoint the tree the step left behind" unless savepoint
       end
 
+      # Brings a fresh tree to where an earlier run left it: the settled steps'
+      # patches applied in order and marked as the savepoint, then the work of
+      # the step that run stopped in, on top of it, so collect! sees it as this step's.
+      def replay!(settled, unsettled = nil)
+        settled.each { apply!(it) }
+        savepoint!
+        apply!(unsettled) if unsettled
+      end
+
       # Puts the workdir back to the savepoint exactly: the verifier restored
       # the graded surfaces from the baseline and may have littered the tree,
       # and the next step's agent must find neither.
@@ -75,6 +84,18 @@ module Lemans
 
       private
 
+      def apply!(contents)
+        return if contents.empty?
+
+        Tempfile.create(%w[agent .patch]) do |file|
+          file.write(contents)
+          file.flush
+          environment.upload(file.path, REMOTE_PATCH)
+        end
+
+        environment.exec!("#{git} apply --binary --whitespace=nowarn #{REMOTE_PATCH} && rm -f #{REMOTE_PATCH}", timeout:)
+      end
+
       def save_diff(result, store, from, to, destination)
         diffed = environment.exec("#{git} diff --binary #{from} #{to} > #{REMOTE_PATCH}", timeout:)
         return unless diffed.success?

data/lib/lemans/trial.rb

@@ -12,13 +12,15 @@ module Lemans
   class Trial
     attr_reader :task, :config, :model, :agent_name, :environment, :result
 
-    private attr_reader :agent, :store, :snapshot, :patch, :current_step_index
+    private attr_reader :agent, :store, :restart_from, :restart_mode, :snapshot, :patch, :current_step_index
 
-    def initialize(task, model = nil, result: nil, store: nil, agent: nil, environment: nil)
+    def initialize(task, model = nil, result: nil, store: nil, agent: nil, environment: nil, restart_from: nil, restart_mode: nil)
       @task = task
       @config = task.config
       @model = model || config.models.first
       @store = store
+      @restart_from = restart_from
+      @restart_mode = restart_mode
 
       @agent = agent.is_a?(Agent) ? agent : Agents.build(agent || config.agent_name, profile: config.agent, model: @model)
       @agent_name = @agent.name
@@ -47,9 +49,12 @@ module Lemans
       @snapshot = nil
       @patch = nil
       @current_step_index = nil
+      @recovered_since = nil
     end
 
     def run
+      restart! if restart_from
+
       phase(:environment_setup) do
         environment.start
 
@@ -64,45 +69,55 @@ module Lemans
         # Seal the git state to collect the agent's patch later
         @patch = Patch.new(task, environment)
         patch.seal!
+        patch.replay!(settled_patches, (restart_artifact("agent.patch") if restart_mode)) if restart_from
 
-        agent.install(task, environment)
+        # A reverification of the last step runs no agent
+        agent.install(task, environment) unless restart_mode == :reverify && restart_step == task.steps
 
         environment.switch_network_policy!(config.agent.environment.network)
       end
 
-      each_step do |step_task|
-        response =
-          phase(:agent) do
-            agent.run(step_task, environment)
-          rescue InfrastructureError, ::Miniswen::InfrastructureError => e
-            # Mark the failure here, where the agent phase is still known
-            result.failed!(:agent_error, e.message)
-            collect_patch!
-            raise
-          rescue ::Miniswen::AccountingError
-            # Classified by the outer rescue; the work is still on disk
+      adopt_phases! if restart_from
+
+      pending = restart_mode
+      each_step(from: restart_from ? restart_step : 1) do |step_task|
+        mode, pending = pending, nil
+
+        unless mode == :reverify
+          history = restart_artifact("agent.result.json") if mode == :recover
+          response =
+            phase(:agent, started_at: (@recovered_since if mode == :recover)) do
+              agent.run(step_task, environment, history:)
+            rescue InfrastructureError, ::Miniswen::InfrastructureError => e
+              # Mark the failure here, where the agent phase is still known
+              result.failed!(:agent_error, e.message)
+              collect_patch!
+              raise
+            rescue ::Miniswen::AccountingError
+              # Classified by the outer rescue; the work is still on disk
+              collect_patch!
+              raise
+            end
+
+          # Whatever the agent brought back is evidence, a failed run's included
+          save_trajectory!(response.trajectory)
+          store&.save_artifact(result, response.raw_result, path: with_step_index("agent.result.json")) if response.raw_result
+
+          if response.error?
+            result.failed!(:agent_error, response.error)
             collect_patch!
-            raise
+            return result
           end
 
-        # Whatever the agent brought back is evidence, a failed run's included
-        save_trajectory!(response.trajectory)
-        store&.save_artifact(result, response.raw_result, path: with_step_index("agent.result.json")) if response.raw_result
-
-        if response.error?
-          result.failed!(:agent_error, response.error)
-          collect_patch!
-          return result
-        end
+          if task.multistep?
+            result.step_completed!(response.outcome, response.usage, duration: result.phases.last.duration)
+          else
+            result.completed!(response.outcome, response.usage)
+          end
 
-        if task.multistep?
-          result.step_completed!(response.outcome, response.usage, duration: result.phases.last.duration)
-        else
-          result.completed!(response.outcome, response.usage)
+          check_cost_limit!
         end
 
-        check_cost_limit!
-
         collect_patch!
         if step_task.final_step?
           patch.compile!(result, store) if task.multistep? && store
@@ -166,31 +181,84 @@ module Lemans
       store.save_artifact(result, JSON.pretty_generate(trajectory.to_atif), path:)
     end
 
-    def each_step
+    def each_step(from: 1)
       return yield task unless task.multistep?
 
       catch(:halt) do
-        1.upto(task.steps) do |index|
-          resume_agent! if index > 1
+        from.upto(task.steps) do |index|
+          # The first step of a restart finds a fresh tree, already replayed
+          resume_agent! if index > from
           @current_step_index = index
           yield task.for_step(index)
         end
       end
     end
 
+    # The step a restart begins at: the one a reverification grades again, or
+    # the first one not settled (run afresh, or recovered from its history).
+    def restart_step
+      @restart_step ||= restart_mode == :reverify ? restart_from.verified_step : restart_from.settled_steps + 1
+    end
+
+    # The new run carries the settled steps' evidence, and the agent's part of
+    # a step it grades again: the patch is collected anew.
+    def restart!
+      result.restart!(restart_from, step: restart_step, mode: restart_mode)
+      carried = restart_mode == :reverify ? %w[trajectory.json agent.result.json].map { restart_path(it) } : []
+
+      store.artifacts(restart_from).each do |path|
+        next unless path[%r{\.(\d+)(?:\.[^./]+)?\z}, 1].to_i.between?(1, restart_step - 1) || carried.include?(path)
+
+        store.save_artifact(result, store.read_artifact(restart_from, path), path:)
+      end
+    end
+
+    def settled_patches
+      (1...restart_step).map do |index|
+        store.read_artifact(restart_from, "agent.#{index}.patch") ||
+          raise(InfrastructureError, "#{restart_from.id} has no agent.#{index}.patch to replay")
+      end
+    end
+
+    def restart_artifact(name)
+      path = restart_path(name)
+      store.read_artifact(restart_from, path) || raise(InfrastructureError, "#{restart_from.id} has no #{path} to restart from")
+    end
+
+    def restart_path(name) = task.multistep? ? with_step_index(name, restart_step) : name
+
+    # A recovered step's agent phase reaches back over the part the source
+    # run already spent, so the step lasts as long as both parts together.
+    def adopt_phases!
+      names = restart_from.phases.map(&:name).select { it.to_s[/\.(\d+)\z/, 1].to_i.between?(1, restart_step - 1) }
+      agent_phase = restart_path("agent").to_sym
+      now = Time.now.utc
+
+      case restart_mode
+      when :reverify
+        result.adopt_phases!(restart_from, names + [ agent_phase ], now:)
+      when :recover
+        result.adopt_phases!(restart_from, names, through: agent_phase, now:)
+        partial = restart_from.phases.find { it.name == agent_phase }
+        @recovered_since = now - (partial.finished_at - partial.started_at)
+      else
+        result.adopt_phases!(restart_from, names, now:)
+      end
+    end
+
     def resume_agent!
       patch.restore!
       environment.exec!("rm -rf #{Verifier::TESTS_DIR} #{Shellwords.escape(task.verifier.logs_dir)}")
       environment.switch_network_policy!(config.agent.environment.network)
     end
 
-    def with_step_index(path)
-      return path unless current_step_index
+    def with_step_index(path, index = current_step_index)
+      return path unless index
 
       *pre, last = path.to_s.split(".")
-      return "#{last}.#{current_step_index}" if pre.empty?
+      return "#{last}.#{index}" if pre.empty?
 
-      [ *pre, current_step_index, last ].join(".")
+      [ *pre, index, last ].join(".")
     end
 
     def sandbox_ttl
@@ -209,8 +277,8 @@ module Lemans
       )
     end
 
-    def phase(name)
-      result.phase_started(with_step_index(name).to_sym)
+    def phase(name, started_at: nil)
+      result.phase_started(with_step_index(name).to_sym, started_at)
       yield
     ensure
       result.phase_finished(with_step_index(name).to_sym)

data/lib/lemans/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Lemans
-  VERSION = "1.4.0"
+  VERSION = "1.5.0"
 end

data/lib/lemans.rb

@@ -11,6 +11,8 @@ loader.ignore("#{__dir__}/miniswen.rb", "#{__dir__}/miniswen")
 loader.ignore("#{__dir__}/lemans/trial/verifier/assets")
 # templates/ holds the files `lemans init` scaffolds, not Ruby the harness loads.
 loader.ignore("#{__dir__}/lemans/cli/templates")
+# proxy/ holds the image the Docker backend runs for allowlists, not Ruby the harness loads.
+loader.ignore("#{__dir__}/lemans/environments/docker/proxy")
 loader.setup
 
 require "miniswen"

data/lib/miniswen/agent.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "json"
+require "time"
 require "miniswen/version"
 require "miniswen/ruby_llm"
 
@@ -261,25 +262,17 @@ module Miniswen
       @reporter = reporter
     end
 
-    def run(instruction)
-      uname = execute("uname -srvm").output.to_s.strip
-      @messages = [
-        { role: "system", content: SYSTEM_TEMPLATE },
-        { role: "user", content: format(INSTANCE_TEMPLATE,
-                                        instruction: instruction,
-                                        system_information: uname,
-                                        macos_sed_note: uname.start_with?("Darwin") ? "\n#{MACOS_SED_NOTE}" : "") }
-      ]
-
-      @steps = 0
-      @cost = 0.0
-
-      @totals = { input_tokens: 0, output_tokens: 0, cached_tokens: 0, thinking_tokens: 0 }
+    # With a `history` (the Result of an interrupted run), the session goes on
+    # where it stopped, under the budget the earlier part already spent.
+    def run(instruction = nil, history: nil)
+      if history
+        resume(history)
+      else
+        start(instruction)
+      end
 
-      @cost_known = true
       @consecutive_format_errors = 0
       @refused_turns = 0
-      @started_at = @clock.call
 
       loop do
         (status = limit_reached) and return finish(status)
@@ -329,6 +322,49 @@ module Miniswen
 
     private
 
+    def start(instruction)
+      uname = execute("uname -srvm").output.to_s.strip
+      @messages = [
+        { role: "system", content: SYSTEM_TEMPLATE },
+        { role: "user", content: format(INSTANCE_TEMPLATE,
+                                        instruction: instruction,
+                                        system_information: uname,
+                                        macos_sed_note: uname.start_with?("Darwin") ? "\n#{MACOS_SED_NOTE}" : "") }
+      ]
+
+      @steps = 0
+      @cost = 0.0
+      @cost_known = true
+      @totals = { input_tokens: 0, output_tokens: 0, cached_tokens: 0, thinking_tokens: 0 }
+      @started_at = @clock.call
+    end
+
+    def resume(history)
+      @messages = answered_messages(history.messages)
+
+      @steps = history.steps.to_i
+      @cost = history.cost_usd.to_f
+      @cost_known = !history.cost_usd.nil?
+      @totals = { input_tokens: history.input_tokens.to_i, output_tokens: history.output_tokens.to_i,
+                  cached_tokens: history.cached_tokens.to_i, thinking_tokens: history.thinking_tokens.to_i }
+      @started_at = @clock.call - elapsed(history.messages)
+    end
+
+    # A turn whose calls did not all get a result cannot go back to a provider:
+    # it is dropped, and the model decides again from the tree it left.
+    def answered_messages(messages)
+      turn = messages.rindex { it[:role] == "assistant" && it[:tool_calls] }
+      return messages.dup unless turn
+
+      answered = messages[(turn + 1)..].filter_map { it[:tool_call_id] if it[:role] == "tool" }
+      messages[turn][:tool_calls].all? { answered.include?(it[:id]) } ? messages.dup : messages[0...turn]
+    end
+
+    def elapsed(messages)
+      times = messages.filter_map { Time.parse(it[:timestamp]) if it[:role] == "assistant" && it[:timestamp] }
+      times.empty? ? 0.0 : times.max - times.min
+    end
+
     def execute(command)
       environment.exec(command, timeout: exec_timeout, env: EXEC_ENV)
     end

data/lib/miniswen/cli.rb

@@ -25,6 +25,7 @@ module Miniswen
       @jail = false
       @allowed_hosts = nil
       @workdir = nil
+      @history = nil
     end
 
     def run
@@ -56,7 +57,7 @@ module Miniswen
       agent = Agent.new(model:, reporter:, environment:, **options)
 
       begin
-        result = agent.run(instruction)
+        result = agent.run(instruction, history: @history && Agent::Result.from_h(JSON.parse(@history)))
       rescue StandardError => e
         write_results(agent.partial_result(error_message(e)))
         raise
@@ -105,7 +106,7 @@ module Miniswen
 
     def parse_args!
       parser = OptionParser.new do |opts|
-        opts.banner = "Usage: miniswen -m MODEL -p INSTRUCTION [...options]"
+        opts.banner = "Usage: miniswen -m MODEL (-p INSTRUCTION | --continue-from PATH) [...options]"
 
         opts.on("-m MODEL", "--model=MODEL", String,
                 "LLM to use (litellm format, e.g.: openrouter/openai/gpt-5.6-luna") do |v|
@@ -116,6 +117,10 @@ module Miniswen
           @instruction = File.file?(v) ? File.read(v) : v
         end
 
+        opts.on("--continue-from=PATH", String, "Continue the session saved by --results-path at PATH (no -p needed)") do |v|
+          @history = File.read(v)
+        end
+
         opts.on("--max-steps=STEPS", Integer, "Max steps count") do |v|
           options[:max_steps] = v
         end
@@ -197,7 +202,7 @@ module Miniswen
       return if @refresh_registry
 
       raise "Use -m to specify the model" unless @model
-      raise "Please, provide instructions via -p option" unless @instruction
+      raise "Please, provide instructions via -p option" unless @instruction || @history
     end
   end
 end

data/lib/miniswen/environment/docker.rb

@@ -20,7 +20,7 @@ module Miniswen
         env&.each { |key, value| argv += [ "--env", "#{key}=#{value}" ] }
         argv << id
         argv += [ "timeout", timeout.ceil.to_s ] if timeout&.positive?
-        argv += [ "sh", "-c", command ]
+        argv += [ "bash", "-c", command ]
 
         Open3.popen2e(*argv) do |stdin, pipe, wait|
           stdin.close