lemans 1.3.1 → 1.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 94b9194a7931b789ba1cb675cfc8d81e0367f8b73754ce1fa11cbff33fff7174
-  data.tar.gz: 4b61d46c323ddd60cb016402d757cb53db56c0adb372709d73ebeec369789e41
+  metadata.gz: '08d62b21b79425a5c1e99867270b4cf2dd41ccb07f8ab7f5e5381a416170907f'
+  data.tar.gz: 802e7e3f665913b95a5409882f10b067f4118efe1e2de650a07dd93382f035af
 SHA512:
-  metadata.gz: db72821e26aa89d9bb9922134042e38c3041a2a8df32669c7e3d69d9ad5f06ebd2fddbfcee89b0f38bc4a4a0f263190858fc24ee86aac5e51984ee1b62a7a6b1
-  data.tar.gz: 1b144ff16c02f963031bf078f03f465508edad3f0ed061e0879905ca189143ad14e6a008a0f9fbaf2d0bea28e2124f82f84eea3f5596bb771251c868e675cd50
+  metadata.gz: fabad5219961a7514c44f888bd79713db444a1dc5b8b20c6153ae1e55c4252cc4065939bb6671a4e6511a1809f4b89da00ff2a642825348c184969fdf49a7c15
+  data.tar.gz: '08a08843cb79dcb1da14e27b1b11d2126fe0d8049dc7cdbcccb573c0c93d81f44613ed6f4e905ec23ab3e9f41e2f6eac44a49e9d520c50ebfca3f82a6d9f4f5f'

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 ## [Unreleased]
 
+## [1.3.3] - 2026-09-11
+
+- Daytona: retry sandbox creation when the SDK gives up on a stalled start (the half-made sandbox is adopted or deleted first).
+- Miniswen: run local commands through `sh -c` (a missing command is exit 127, not a harness crash).
+- Miniswen: retry model calls for ~5 min instead of ~1, truncated responses included.
+- `lemans-remote run --launch-interval N` (default 3s) spaces sandbox launches; `--concurrency` is now a no-op.
+
+## [1.3.2] - 2026-09-08
+
+- Miniswen: increase provider error max retry window to ~1 min.
+- Collect patches on agent errors.
+
 ## [1.3.1] - 2026-09-04
 
 - `agent.max_output_tokens` and `lemans run --max-output-tokens`

data/exe/lemans-remote

@@ -16,7 +16,8 @@
 #   per task × model (--run-in-band for a single sandbox, --attempts N to
 #   repeat each task in N sandboxes); results are archived to the
 #   lemans-remote-runs volume. Add --sync to wait for a single sandbox
-#   and download into ./runs directly instead:
+#   and download into ./runs directly instead. Launches go out one at a
+#   time, --launch-interval seconds apart (default 3):
 #
 #     exe/lemans-remote run --bench ../ai-evals --task hello-world
 #     exe/lemans-remote run --bench ../ai-evals --model openrouter/z-ai/glm-5.2 --model openrouter/qwen/qwen3.5-coder --args="-k 2 -c 8"
@@ -31,7 +32,8 @@
 #   Then watch, fetch, and clean up:
 #
 #     exe/lemans-remote status [--history] [--running | --complete] [-W [INTERVAL]]
-#     exe/lemans-remote pull-runs [RUN_ID ...] [--all] [--dry-run]
+#     exe/lemans-remote logs RUN_ID [--tail N]
+#     exe/lemans-remote pull-runs [RUN_ID ...] [--match SUBSTR] [--all] [--dry-run]
 #     exe/lemans-remote drop-orphans [--min-age 10m]
 #     exe/lemans-remote clobber RUN_ID ... | --all
 #     exe/lemans-remote snapshots
@@ -213,11 +215,7 @@ module LemansRemote # :nodoc: all
 
     def pack(to:)
       Dir.mktmpdir("lemans-remote-stage") do |stage|
-        @bench.root.children.each do |child|
-          next if EXCLUDES.include?(child.basename.to_s)
-
-          FileUtils.cp_r(child, File.join(stage, child.basename.to_s))
-        end
+        stage_files(stage)
         prune_tasks(stage) if @selected_tasks
         _, err, status = Open3.capture3("tar", "-czf", to, "-C", stage, ".")
         raise "could not pack the bench: #{err}" unless status.success?
@@ -227,6 +225,44 @@ module LemansRemote # :nodoc: all
 
     private
 
+    # Every sandbox gets a copy, so a git bench ships what git would: tracked
+    # files plus untracked ones .gitignore lets through.
+    def stage_files(stage)
+      files = git_files
+      return copy_children(stage) unless files
+
+      files.each do |relative|
+        next if EXCLUDES.include?(relative.split("/", 2).first)
+
+        source = @bench.root.join(relative)
+        # The index still lists a file deleted from disk
+        next unless File.exist?(source) || File.symlink?(source)
+
+        destination = File.join(stage, relative)
+        FileUtils.mkdir_p(File.dirname(destination))
+        FileUtils.copy_entry(source, destination)
+      end
+    end
+
+    def copy_children(stage)
+      @bench.root.children.each do |child|
+        next if EXCLUDES.include?(child.basename.to_s)
+
+        FileUtils.cp_r(child, File.join(stage, child.basename.to_s))
+      end
+    end
+
+    # nil when the bench is not a git checkout; a nested repository lists as a
+    # bare directory, and is left out
+    def git_files
+      out, _err, status = Open3.capture3(
+        "git", "-C", @bench.root.to_s, "ls-files", "-z", "--cached", "--others", "--exclude-standard"
+      )
+      return nil unless status.success?
+
+      out.split("\0").reject { it.end_with?("/") }
+    end
+
     def prune_tasks(stage)
       tasks_rel = @bench.tasks_dir.relative_path_from(@bench.root).to_s
       staged_tasks = File.join(stage, tasks_rel)
@@ -405,16 +441,57 @@ module LemansRemote # :nodoc: all
       end
     end
 
-    def manifests(sandbox)
-      code = 'require "json"; puts Dir.glob("/vault/*/manifest.json", File::FNM_DOTMATCH)' \
-             ".filter_map { |f| JSON.parse(File.read(f)) rescue nil }.to_json"
-      response = sandbox.process.exec(command: "ruby -e #{Shellwords.escape(code)}", timeout: 120)
+    # The vault is an S3-backed FUSE mount: listing /vault is one request,
+    # but every /vault/<run>/manifest.json is another round-trip, so a plain
+    # glob over hundreds of runs outlives the exec timeout. List once, then
+    # read the manifests concurrently (and only the requested ones, if any).
+    MANIFEST_READERS = 32
+    MANIFESTS_TIMEOUT_SEC = 120
+
+    MANIFESTS_CODE = <<~'RUBY'
+      require "json"
+      only = JSON.parse(ARGV[0])
+      match = ARGV[1]
+      ids = Dir.children("/vault")
+      ids &= only if only
+      ids.select! { it.include?(match) } if match && !match.empty?
+      queue = Queue.new
+      ids.each { queue << it }
+      queue.close
+      found = Queue.new
+      readers = Array.new([ids.size, ENV.fetch("LEMANS_MANIFEST_READERS", "32").to_i].min) do
+        Thread.new do
+          while (id = queue.pop)
+            found << JSON.parse(File.read("/vault/#{id}/manifest.json")) rescue nil
+          end
+        end
+      end
+      readers.each(&:join)
+      list = []
+      list << found.pop until found.empty?
+      puts list.to_json
+    RUBY
+
+    def manifests(sandbox, only: nil, match: nil)
+      args = [ only&.to_a.to_json, match.to_s ].map { Shellwords.escape(it) }.join(" ")
+      response = sandbox.process.exec(
+        command: "LEMANS_MANIFEST_READERS=#{MANIFEST_READERS} ruby -e #{Shellwords.escape(MANIFESTS_CODE)} #{args}",
+        timeout: MANIFESTS_TIMEOUT_SEC
+      )
       raise "could not read the vault manifests: #{response.result}" unless response.exit_code.zero?
 
       body = response.result.to_s.strip
       body.empty? ? [] : JSON.parse(body)
     end
 
+    def run_log(sandbox, run_id)
+      remote = "/vault/#{run_id}/run.log"
+      response = sandbox.process.exec(command: "cat #{Shellwords.escape(remote)}", timeout: 120)
+      raise "no log in the vault for #{run_id} (never launched, or still running on a sandbox that is gone)" unless response.exit_code.zero?
+
+      response.result.to_s
+    end
+
     def archive_size(sandbox, run_id)
       remote = "/vault/#{run_id}/runs.tar.gz"
       response = sandbox.process.exec(command: "du -h #{Shellwords.escape(remote)}", timeout: 60)
@@ -467,9 +544,10 @@ module LemansRemote # :nodoc: all
     SETUP_TIMEOUT_SEC = 300
     TRANSFER_TIMEOUT_SEC = 900
     TIMED_OUT = 124
+    CREATE_ATTEMPTS = 3
 
     def initialize(bench:, snapshot:, run_id:, tasks:, models:, extra_args:, extra_env:,
-                   timeout_sec:, runs_dir:, keep:, sync:, shell:)
+                   timeout_sec:, runs_dir:, keep:, sync:, shell:, launch_interval: 0)
       @bench = bench
       @snapshot = snapshot
       @run_id = run_id
@@ -482,6 +560,7 @@ module LemansRemote # :nodoc: all
       @keep = keep
       @sync = sync
       @shell = shell
+      @launch_interval = launch_interval
       @started_at = Time.now.utc.iso8601
     end
 
@@ -518,8 +597,39 @@ module LemansRemote # :nodoc: all
       0
     end
 
+    # Daytona sometimes never starts a sandbox it accepted; the SDK gives up
+    # after a minute and the half-made sandbox stays behind under this run's
+    # labels. A retry waits the launch interval first.
     def create_sandbox(volume = nil)
-      params = ::Daytona::CreateSandboxFromSnapshotParams.new(
+      attempt = 0
+      begin
+        attempt += 1
+        LemansRemote.client.create(sandbox_params(volume))
+      rescue *Backend::Retries::SDK_ERRORS => e
+        drop_half_created
+        raise if attempt >= CREATE_ATTEMPTS
+
+        say :retry, "sandbox did not start (#{e.message}), attempt #{attempt + 1}/#{CREATE_ATTEMPTS}", :yellow
+        sleep @launch_interval if @launch_interval.positive?
+        retry
+      end
+    end
+
+    # Runs from the rescue of a failed creation, so it must not raise: an
+    # exception here would replace the creation error and end the retries.
+    def drop_half_created
+      query = ::Daytona::ListSandboxesQuery.new(labels: { RUN_ID_LABEL => @run_id })
+      LemansRemote.client.list(query).each do |sandbox|
+        sandbox.delete
+      rescue StandardError => e
+        warn "lemans-remote: could not delete half-created sandbox #{sandbox.id}: #{e.message}"
+      end
+    rescue StandardError => e
+      warn "lemans-remote: could not list the sandboxes of #{@run_id}: #{e.message}"
+    end
+
+    def sandbox_params(volume)
+      ::Daytona::CreateSandboxFromSnapshotParams.new(
         snapshot: @snapshot,
         env_vars: env_vars,
         labels: {
@@ -533,7 +643,6 @@ module LemansRemote # :nodoc: all
         ttl_minutes: (@timeout_sec / 60.0).ceil + 60,
         volumes: volume ? [ Vault.mount_param(volume) ] : nil
       )
-      LemansRemote.client.create(params)
     end
 
     def env_vars
@@ -799,7 +908,9 @@ module LemansRemote # :nodoc: all
     option :runs_dir, default: "runs", desc: "Sync mode: local directory to sync the results into"
     option :env, repeatable: true, desc: "Forward an extra host ENV variable by name"
     option :concurrency, type: :numeric, default: 4, aliases: "-C",
-                         desc: "Async mode: how many sandboxes to launch in parallel (1 to serialize)"
+                         desc: "Ignored: launches go out one at a time, --launch-interval apart (kept so older invocations still parse)"
+    option :launch_interval, type: :numeric, default: 3,
+                             desc: "Async mode: seconds between consecutive launches (0 to disable)"
     def run_bench
       bench = Lemans::Config.load_file(options[:bench])
 
@@ -826,7 +937,7 @@ module LemansRemote # :nodoc: all
       attempts = options[:attempts].to_i
       raise Thor::Error, "lemans-remote: --attempts must be at least 1" if attempts < 1
       raise Thor::Error, "lemans-remote: --attempts needs async mode — drop --sync" if options[:sync] && attempts > 1
-      raise Thor::Error, "lemans-remote: --concurrency must be at least 1" if options[:concurrency].to_i < 1
+      raise Thor::Error, "lemans-remote: --launch-interval must not be negative" if options[:launch_interval].to_f.negative?
 
       models = options[:model] || []
       jobs =
@@ -855,7 +966,7 @@ module LemansRemote # :nodoc: all
         elsif attempts > 1 then "#{jobs.size / attempts} task × model batch(es) × #{attempts} attempts"
         else "one per task × model"
         end
-      say_status :fanout, "#{jobs.size} sandboxes, #{fanout}, #{options[:concurrency].to_i} at a time"
+      say_status :fanout, "#{jobs.size} sandboxes, #{fanout}, one every #{options[:launch_interval]}s"
       failures, retried = launch_batches(bench, jobs, provisioner)
       finish_retry(planner, retried) if retry_groups
       say_status :detached, "`lemans-remote status` to watch, `lemans-remote pull-runs` to fetch results"
@@ -897,15 +1008,36 @@ module LemansRemote # :nodoc: all
       raise Thor::Error, "lemans-remote: #{e.message}"
     end
 
+    desc "logs RUN_ID", "Print a run's lemans output (live from its sandbox, or from the vault once it finished)"
+    option :tail, type: :numeric, desc: "Only the last N lines"
+    def logs(run_id)
+      row = Fleet.rows.find { it.run_id == run_id }
+      text =
+        if row&.state == DaytonaApiClient::SandboxState::STARTED
+          row.sandbox.process.exec(command: "cat #{REMOTE_LOG} 2>/dev/null", timeout: 60).result.to_s
+        elsif row && Fleet::LIVE_STATES.include?(row.state)
+          # The vault gets the log when the run exits, and a sandbox still
+          # coming up has nothing to read yet
+          raise "#{run_id} is #{row.state} — it has not started logging yet"
+        else
+          with_vault { |vault, sandbox| vault.run_log(sandbox, run_id) }
+        end
+      text = text.lines.last(options[:tail].to_i).join if options[:tail]
+      say text
+    rescue RuntimeError => e
+      raise Thor::Error, "lemans-remote: #{e.message}"
+    end
+
     map "pull-runs" => :pull_runs
     desc "pull-runs [RUN_IDS...]", "Download archived runs from the vault into the local runs directory"
     option :all, type: :boolean, default: false, desc: "Pull every completed run, even ones already pulled"
     option :dry_run, type: :boolean, default: false, desc: "Preview what would be downloaded without pulling anything"
     option :runs_dir, default: "runs", desc: "Local directory to sync the results into"
+    option :match, desc: "Only consider runs whose id contains this substring (e.g. a task name)"
     def pull_runs(*run_ids)
       pulled = []
       with_vault do |vault, sandbox|
-        manifests = vault.manifests(sandbox)
+        manifests = vault.manifests(sandbox, only: (run_ids if run_ids.any?), match: options[:match])
         known = manifests.map { it["run_id"] }
         targets =
           if run_ids.any?
@@ -1123,39 +1255,31 @@ module LemansRemote # :nodoc: all
         runs_dir: options[:runs_dir],
         keep: options[:keep],
         sync: options[:sync],
-        shell: shell
+        shell: shell,
+        launch_interval: options[:launch_interval].to_f
       ).call
     end
 
+    # One at a time, `interval` apart: a burst of creations stalls Daytona's
+    # scheduler.
     def launch_batches(bench, jobs, provisioner)
-      queue = Queue.new
-      jobs.each { queue << it }
-      failures = Queue.new
-      launched = Queue.new
+      interval = options[:launch_interval].to_f
+      failures = []
+      launched = []
 
-      threads = [ options[:concurrency].to_i, jobs.size ].min.times.map do
-        Thread.new do
-          loop do
-            batch, models, attempt, group =
-              begin
-                queue.pop(true)
-              rescue ThreadError
-                break
-              end
-            begin
-              launch_batch(bench, batch, models, provisioner, attempt:)
-              launched << group if group
-            rescue StandardError => e
-              label = batch.empty? ? "all" : batch.join(",")
-              label += "/a#{attempt}" if attempt
-              failures << "#{label} (#{e.message})"
-            end
-          end
+      jobs.each_with_index do |(batch, models, attempt, group), index|
+        sleep interval if index.positive? && interval.positive?
+        begin
+          launch_batch(bench, batch, models, provisioner, attempt:)
+          launched << group if group
+        rescue StandardError => e
+          label = batch.empty? ? "all" : batch.join(",")
+          label += "/a#{attempt}" if attempt
+          failures << "#{label} (#{e.message})"
         end
       end
-      threads.each(&:join)
 
-      [ Array.new(failures.size) { failures.pop }, Array.new(launched.size) { launched.pop } ]
+      [ failures, launched ]
     end
 
     def build_run_id(bench, tasks, models, attempt = nil)

data/lib/lemans/agents/miniswen_installed.rb

@@ -14,8 +14,9 @@ module Lemans
       NAME = "miniswen-installed"
       RESULTS_PATH = "/tmp/lemans-miniswen.result.json"
       INSTALL_TIMEOUT_SEC = 300
-      # The CLI enforces max-time itself; the slack only covers process
-      # startup, so the results file exists before the outer exec expires.
+      # The CLI enforces max-time itself, but between steps only: a command
+      # started just before the deadline runs to its own exec timeout first,
+      # and the outer exec must outlast that too. The slack covers startup.
       EXEC_SLACK_SEC = 60
 
       def install(_task, environment)
@@ -31,8 +32,7 @@ module Lemans
       # An in-sandbox run self-reports: everything but the verifier's reward
       # comes from a file the sandbox wrote.
       def obtain_result(task, environment)
-        run = environment.exec(command_for(task), timeout: profile.timeout + EXEC_SLACK_SEC,
-                                                  env: provider_env(environment))
+        run = environment.exec(command_for(task), timeout: outer_timeout, env: provider_env(environment))
 
         begin
           Tempfile.create(%w[miniswen .result.json]) do |file|
@@ -49,6 +49,8 @@ module Lemans
 
       attr_reader :raw_result
 
+      def outer_timeout = profile.timeout + profile.exec_timeout + EXEC_SLACK_SEC
+
       # A missing credential fails the run before the sandbox executes
       # anything: it is the operator's configuration to fix, not a trial result.
       def provider_env(environment)

data/lib/lemans/environments/daytona/retries.rb

@@ -7,6 +7,8 @@ module Lemans
     class Daytona
       # Another try for calls whose repeat is free. Only reads qualify: a
       # mutation may have landed server-side before its failure surfaced.
+      # Sandbox creation is the exception (Daytona#create_sandbox): what it
+      # half-made is found by label and dealt with before the repeat.
       module Retries
         # The snapshot service leaks the generated client's own error classes
         # instead of wrapping them, so both dialects have to be caught.

data/lib/lemans/environments/daytona.rb

@@ -9,12 +9,18 @@ module Lemans
     # Daytona sandboxes. Daytona builds images server-side into reusable content-named
     # snapshots and enforces the network policy itself.
     class Daytona < Environment
+      include Retries
+
       DEFAULT_BUILD_TIMEOUT = 600
 
       # Workspace tarballs ride uploads/downloads, so transfers get their own
       # budget through the SDK's streaming API instead of the global HTTP cap.
       TRANSFER_TIMEOUT = 900
 
+      CREATE_ATTEMPTS = 3
+      CREATE_RETRY_DELAY = 5
+      ADOPT_TIMEOUT = 180
+
       SDKTweaks.apply!
       # The SDK's typhoeus/libcurl transfers segfault the VM under concurrent
       # easy_perform calls; Faraday/Net::HTTP is pure Ruby, so transfers need
@@ -47,7 +53,7 @@ module Lemans
       end
 
       def start
-        @sandbox = client.create(create_params, on_snapshot_create_logs: @logger)
+        @sandbox = create_sandbox
         @started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
         @shell = Shell.new(sandbox)
         self
@@ -116,6 +122,64 @@ module Lemans
 
       def client = self.class.client
 
+      # Under load Daytona accepts a sandbox, then stalls past the SDK's fixed
+      # minute. The one it half-made carries this trial's labels: adopt it if
+      # it comes up, delete it otherwise, and only then try again. Without
+      # labels there is nothing to find it by, so the failure stands.
+      def create_sandbox
+        attempt = 0
+        begin
+          attempt += 1
+          client.create(create_params, on_snapshot_create_logs: @logger)
+        rescue *Retries::SDK_ERRORS => e
+          raise if labels.empty? || !retryable?(e)
+
+          if (leftover = half_created(e))
+            return leftover if await_start(leftover)
+
+            reap!(leftover, e)
+          end
+          raise if attempt >= CREATE_ATTEMPTS
+
+          log "sandbox did not start (#{e.message}), attempt #{attempt + 1}/#{CREATE_ATTEMPTS}"
+          sleep CREATE_RETRY_DELAY
+          retry
+        end
+      end
+
+      # One create makes one sandbox; two under the same labels is not ours to sort out.
+      def half_created(error)
+        found = client.list(::Daytona::ListSandboxesQuery.new(labels: labels)).to_a
+        if found.size > 1
+          raise InfrastructureError, "#{could_not_start(error)}; #{found.map(&:id).join(", ")} all carry #{labels.inspect}"
+        end
+
+        found.first
+      rescue *Retries::SDK_ERRORS => e
+        raise InfrastructureError, "#{could_not_start(error)}; a sandbox may still be running under #{labels.inspect}, " \
+                                   "and listing them failed: #{e.message}"
+      end
+
+      # The SDK's wait fails at once on a dead sandbox.
+      def await_start(sandbox)
+        sandbox.wait_for_sandbox_start(ADOPT_TIMEOUT)
+        log "adopted sandbox #{sandbox.id}, which came up after the SDK gave up on it"
+        true
+      rescue *Retries::SDK_ERRORS => e
+        log "sandbox #{sandbox.id} did not come up on its own: #{e.message}"
+        false
+      end
+
+      def reap!(sandbox, error)
+        sandbox.delete
+      rescue *Retries::SDK_ERRORS => e
+        raise InfrastructureError, "#{could_not_start(error)}; #{sandbox.id} may still be running and could not be deleted: #{e.message}"
+      end
+
+      def could_not_start(error) = "daytona: could not start sandbox: #{error.message}"
+
+      def log(message) = @logger&.call("lemans: #{message}\n")
+
       # A sandbox inherits the snapshot's resources, so the profile's are
       # stamped into the snapshot at build time.
       def create_params

data/lib/lemans/trial.rb

@@ -77,6 +77,11 @@ module Lemans
           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
 
@@ -86,6 +91,7 @@ module Lemans
 
         if response.error?
           result.failed!(:agent_error, response.error)
+          collect_patch!
           return result
         end
 
@@ -97,7 +103,7 @@ module Lemans
 
         check_cost_limit!
 
-        patch.collect!(result, store, path: with_step_index("agent.patch")) if store
+        collect_patch!
         if step_task.final_step?
           patch.compile!(result, store) if task.multistep? && store
           # Don't index the final verification
@@ -146,6 +152,10 @@ module Lemans
 
     private
 
+    def collect_patch!
+      patch.collect!(result, store, path: with_step_index("agent.patch")) if store
+    end
+
     def save_trajectory!(trajectory)
       return unless trajectory && store
 

data/lib/lemans/version.rb

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

data/lib/miniswen/agent.rb

@@ -513,7 +513,7 @@ module Miniswen
       body = e.response&.body.to_s
       detail = body.empty? ? e.message : "#{e.message}: #{body[0, 1000]}"
       raise InfrastructureError, "miniswen: the model call failed: #{detail}"
-    rescue Faraday::SSLError, Faraday::ConnectionFailed, Faraday::TimeoutError => e
+    rescue Faraday::SSLError, Faraday::ConnectionFailed, Faraday::TimeoutError, Faraday::ParsingError => e
       raise InfrastructureError, "miniswen: the model call failed: #{e.class}: #{e.message}"
     end
 

data/lib/miniswen/local.rb

@@ -9,8 +9,10 @@ module Miniswen
   class Local < Environment
     TIMEOUT_EXIT_CODE = 124
 
+    # Always through a shell: Ruby execs a metacharacter-free string directly,
+    # and a missing binary would then raise ENOENT here instead of exiting 127.
     def exec(command, timeout: nil, env: nil)
-      Open3.popen2e(env || {}, command, pgroup: true) do |stdin, io, wait_thr|
+      Open3.popen2e(env || {}, "sh", "-c", command, pgroup: true) do |stdin, io, wait_thr|
         stdin.close
         reader = Thread.new { io.read }
 

data/lib/miniswen/ruby_llm.rb

@@ -8,9 +8,10 @@ RubyLLM.configure do |config|
   config.logger = Logger.new(IO::NULL) unless ENV["MINISWEN_DEBUG"] == "1"
 end
 
-# Increase retry window to handle egress network issues
+# About five minutes of retries (1, 2, 4, ... 128s plus jitter): provider
+# outages and rate-limit windows outlast the minute this used to allow.
 RubyLLM.configure do |config|
-  config.max_retries = 3
+  config.max_retries = 8
   config.retry_interval = 1
 end
 
@@ -36,13 +37,13 @@ module Miniswen
     end
   end
 
-  # A handshake reset never sent the request, so retrying is as safe as the
-  # ConnectionFailed retries ruby_llm already does; it only lists SSL errors
-  # as fatal.
-  module RetryTransientSSL
-    def retry_exceptions = super + [ Faraday::SSLError ]
+  # ruby_llm lists SSL errors as fatal, but a handshake reset never sent the
+  # request; a 200 with a truncated JSON body is the same dropped connection
+  # one step later.
+  module RetryTransientFailures
+    def retry_exceptions = super + [ Faraday::SSLError, Faraday::ParsingError ]
   end
 end
 
 RubyLLM::Providers::OpenRouter.prepend(Miniswen::VerbatimReasoningDetails)
-RubyLLM::Connection.prepend(Miniswen::RetryTransientSSL)
+RubyLLM::Connection.prepend(Miniswen::RetryTransientFailures)

data/lib/miniswen/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Miniswen
-  VERSION = "1.3.1"
+  VERSION = "1.3.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lemans
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 1.3.3
 platform: ruby
 authors:
 - Svyatoslav Kryukov
@@ -53,6 +53,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.203'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement