agent-harness 0.5.7 → 0.5.9

data/lib/agent_harness/providers/aider.rb

@@ -6,6 +6,17 @@ module AgentHarness
     #
     # Provides integration with the Aider CLI tool.
     class Aider < Base
+      UV_VERSION = "0.8.17"
+      SUPPORTED_CLI_VERSION = "0.86.2"
+      SUPPORTED_CLI_REQUIREMENT = Gem::Requirement.new(">= #{SUPPORTED_CLI_VERSION}", "< 0.87.0").freeze
+      PYTHON_VERSION = "python3.12"
+      BINARY_PATH = "/usr/local/bin/aider"
+      UV_TOOL_ENV = {
+        "UV_TOOL_BIN_DIR" => "/usr/local/bin",
+        "UV_TOOL_DIR" => "/opt/uv/tools",
+        "UV_PYTHON_INSTALL_DIR" => "/opt/uv/python"
+      }.freeze
+
       class << self
         def provider_name
           :aider
@@ -50,6 +61,66 @@ module AgentHarness
           ]
         end
 
+        def installation_contract(version: SUPPORTED_CLI_VERSION)
+          version = version.strip if version.respond_to?(:strip)
+
+          unless version.is_a?(String) && !version.empty?
+            raise ArgumentError,
+              "Unsupported Aider CLI version #{version.inspect}; " \
+              "supported versions must satisfy #{SUPPORTED_CLI_REQUIREMENT}"
+          end
+
+          parsed_version = begin
+            Gem::Version.new(version)
+          rescue ArgumentError
+            raise ArgumentError,
+              "Unsupported Aider CLI version #{version.inspect}; " \
+              "supported versions must satisfy #{SUPPORTED_CLI_REQUIREMENT}"
+          end
+
+          unless SUPPORTED_CLI_REQUIREMENT.satisfied_by?(parsed_version)
+            raise ArgumentError,
+              "Unsupported Aider CLI version #{version.inspect}; " \
+              "supported versions must satisfy #{SUPPORTED_CLI_REQUIREMENT}"
+          end
+
+          default_package = "aider-chat==#{version}".freeze
+          bootstrap_command = [
+            "python3", "-m", "pip", "install", "--no-cache-dir", "--break-system-packages", "uv==#{UV_VERSION}"
+          ].freeze
+          install_command_prefix = [
+            "uv", "tool", "install", "--force", "--python", PYTHON_VERSION, "--with", "pip"
+          ].freeze
+          install_command = (install_command_prefix + [default_package]).freeze
+          supported_versions = [version].freeze
+          version_requirement = SUPPORTED_CLI_REQUIREMENT.requirements
+            .map { |op, ver| "#{op} #{ver}".freeze }
+            .freeze
+
+          contract = {
+            source: :uv_tool,
+            bootstrap_source: :pip,
+            bootstrap_package: "uv==#{UV_VERSION}",
+            bootstrap_commands: [bootstrap_command].freeze,
+            install_environment: UV_TOOL_ENV,
+            package: default_package,
+            package_name: "aider-chat",
+            version: version,
+            version_format: "%{package_name}==%{version}",
+            version_requirement: version_requirement,
+            binary_name: binary_name,
+            binary_path: BINARY_PATH,
+            install_command_prefix: install_command_prefix,
+            install_command: install_command,
+            supported_versions: supported_versions
+          }
+
+          contract.each_value do |value|
+            value.freeze if value.is_a?(String)
+          end
+          contract.freeze
+        end
+
         def smoke_test_contract
           Base::DEFAULT_SMOKE_TEST_CONTRACT
         end

data/lib/agent_harness/providers/anthropic.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "json"
+require "shellwords"
 
 module AgentHarness
   module Providers
@@ -15,6 +16,12 @@ module AgentHarness
     class Anthropic < Base
       # Model name pattern for Anthropic Claude models
       MODEL_PATTERN = /^claude-[\d.-]+-(?:opus|sonnet|haiku)(?:-\d{8})?$/i
+      SUPPORTED_CLI_VERSION = "2.1.92"
+      SUPPORTED_CLI_REQUIREMENT = Gem::Requirement.new(">= #{SUPPORTED_CLI_VERSION}", "< 2.2.0").freeze
+
+      # Matches semver (e.g. "2.1.92"), optional pre-release (e.g. "2.1.92-beta.1"),
+      # or channel tokens (e.g. "latest", "stable").
+      VALID_VERSION_PATTERN = /\A(?:\d+\.\d+\.\d+(?:-[a-zA-Z0-9.]+)?|latest|stable)\z/
 
       class << self
         def provider_name
@@ -25,11 +32,80 @@ module AgentHarness
           "claude"
         end
 
+        def install_contract(version: nil)
+          target_version = version.nil? ? SUPPORTED_CLI_VERSION : version
+          target_version = target_version.strip if target_version.respond_to?(:strip)
+          validate_version!(target_version)
+          version_requirement = SUPPORTED_CLI_REQUIREMENT.requirements
+            .map { |op, ver| "#{op} #{ver}" }
+            .join(", ")
+          channel_token = %w[latest stable].include?(target_version.to_s)
+
+          warning = "Review the downloaded installer before execution and verify any published checksum or signature metadata when available."
+          if channel_token
+            warning += " Channel '#{target_version}' is not pinned; the resolved version may fall " \
+              "outside the supported range (#{version_requirement}). Verify the installed version " \
+              "after installation."
+          end
+
+          {
+            provider: provider_name,
+            binary_name: binary_name,
+            binary_paths: [
+              "$HOME/.local/bin/claude",
+              binary_name
+            ],
+            install: {
+              strategy: :shell,
+              source: "official",
+              command: "tmp_script=$(mktemp) && trap 'rm -f \"$tmp_script\"' EXIT && curl -fsSL https://claude.ai/install.sh -o \"$tmp_script\" && bash \"$tmp_script\" #{Shellwords.shellescape(target_version)}",
+              warning: warning,
+              post_install_binary_path: "$HOME/.local/bin/claude",
+              # When a channel token is used, include the requirement so
+              # consumers can validate the installed version post-install.
+              version_not_pinned: channel_token
+            },
+            supported_versions: {
+              default: SUPPORTED_CLI_VERSION,
+              requirement: version_requirement,
+              channel: "stable"
+            },
+            runtime_contract: {
+              available_via: binary_name,
+              build_command: [
+                binary_name,
+                "--print",
+                "--output-format=json"
+              ],
+              required_features: [
+                "print_mode",
+                "json_output",
+                "mcp_config",
+                "mcp_list",
+                "dangerously_skip_permissions",
+                "models_list"
+              ]
+            }
+          }
+        end
+
         def available?
           executor = AgentHarness.configuration.command_executor
           !!executor.which(binary_name)
         end
 
+        def provider_metadata_overrides
+          {
+            auth: {
+              service: :anthropic,
+              api_family: :anthropic
+            },
+            identity: {
+              bot_usernames: %w[claude anthropic]
+            }
+          }
+        end
+
         def firewall_requirements
           {
             domains: [
@@ -87,6 +163,33 @@ module AgentHarness
 
         private
 
+        def validate_version!(version)
+          unless version.is_a?(String) && !version.strip.empty?
+            raise ArgumentError, "Invalid version: #{version.inspect}. " \
+              "Must be a semver string (e.g. '2.1.92'), optional pre-release suffix, or a channel token ('latest', 'stable')."
+          end
+
+          version_str = version.strip
+
+          unless VALID_VERSION_PATTERN.match?(version_str)
+            raise ArgumentError, "Invalid version: #{version.inspect}. " \
+              "Must be a semver string (e.g. '2.1.92'), optional pre-release suffix, or a channel token ('latest', 'stable')."
+          end
+
+          return if %w[latest stable].include?(version_str)
+
+          gem_version = begin
+            Gem::Version.new(version_str)
+          rescue ArgumentError
+            raise ArgumentError, "Invalid version: #{version.inspect}. " \
+              "Must be a semver string (e.g. '2.1.92'), optional pre-release suffix, or a channel token ('latest', 'stable')."
+          end
+          return if SUPPORTED_CLI_REQUIREMENT.satisfied_by?(gem_version)
+
+          raise ArgumentError, "Version #{version.inspect} is outside the supported range " \
+            "(#{SUPPORTED_CLI_REQUIREMENT}). Update SUPPORTED_CLI_REQUIREMENT before targeting this version."
+        end
+
         def parse_models_list(output)
           return [] if output.nil? || output.empty?
 
@@ -240,7 +343,7 @@ module AgentHarness
           rate_limited: [
             /rate.?limit/i,
             /too.?many.?requests/i,
-            /429/,
+            /\b429\b/,
             /overloaded/i,
             /session.?limit/i
           ],
@@ -249,7 +352,7 @@ module AgentHarness
             /authentication.*error/i,
             /invalid.*api.*key/i,
             /unauthorized/i,
-            /401/,
+            /\b401\b/,
             /session.*expired/i,
             /not.*logged.*in/i,
             /login.*required/i,
@@ -265,17 +368,17 @@ module AgentHarness
             /connection.*reset/i,
             /temporary.*error/i,
             /service.*unavailable/i,
-            /503/,
-            /502/,
-            /504/
+            /\b503\b/,
+            /\b502\b/,
+            /\b504\b/
           ],
           permanent: [
             /invalid.*model/i,
             /unsupported.*operation/i,
             /not.*found/i,
-            /404/,
+            /\b404\b/,
             /bad.*request/i,
-            /400/,
+            /\b400\b/,
             /model.*deprecated/i,
             /end-of-life/i
           ]

data/lib/agent_harness/providers/base.rb

@@ -41,7 +41,7 @@ module AgentHarness
         rate_limited: [
           /rate.?limit/i,
           /too.?many.?requests/i,
-          /429/
+          /\b429\b/
         ],
         auth_expired: [
           /invalid.*api.*key/i,
@@ -57,8 +57,8 @@ module AgentHarness
           /timeout/i,
           /connection.*error/i,
           /service.*unavailable/i,
-          /503/,
-          /502/
+          /\b503\b/,
+          /\b502\b/
         ]
       }.tap { |patterns| patterns.each_value(&:freeze) }.freeze
 
@@ -98,6 +98,8 @@ module AgentHarness
       # @option options [ProviderRuntime, Hash, nil] :provider_runtime per-request
       #   runtime overrides (model, base_url, api_provider, env, flags, metadata).
       #   A plain Hash is automatically coerced into a ProviderRuntime.
+      #   Providers can derive request-scoped execution preparation from this
+      #   runtime to materialize config files or other bootstrap state.
       # @return [Response] the response
       def send_message(prompt:, **options)
         log_debug("send_message_start", prompt_length: prompt.length, options: options.keys)
@@ -111,6 +113,7 @@ module AgentHarness
 
         # Build command
         command = build_command(prompt, options)
+        preparation = build_execution_preparation(options)
 
         # Calculate timeout
         timeout = options[:timeout] || @config.timeout || default_timeout
@@ -121,6 +124,7 @@ module AgentHarness
           command,
           timeout: timeout,
           env: build_env(options),
+          preparation: preparation,
           **command_execution_options(options)
         )
         duration = Time.now - start_time
@@ -210,6 +214,17 @@ module AgentHarness
         env
       end
 
+      # Build structured runtime preparation for the executor.
+      #
+      # Provider subclasses can override to request request-scoped file writes
+      # or other bootstrap work without shell-wrapping the main command.
+      #
+      # @param options [Hash] options
+      # @return [ExecutionPreparation, nil] preparation contract or nil
+      def build_execution_preparation(options)
+        nil
+      end
+
       # Parse CLI output into Response - override in subclasses
       #
       # Combines stdout and stderr for error classification so that
@@ -309,8 +324,22 @@ module AgentHarness
         execution_options
       end
 
-      def execute_with_timeout(command, timeout:, env:, stdin_data: nil, **execution_options)
-        @executor.execute(command, timeout: timeout, env: env, stdin_data: stdin_data, **execution_options)
+      def execute_with_timeout(command, timeout:, env:, preparation: nil, stdin_data: nil, **execution_options)
+        kwargs = {timeout: timeout, env: env}
+        kwargs[:stdin_data] = stdin_data unless stdin_data.nil?
+        kwargs[:preparation] = preparation unless preparation.nil?
+        kwargs.merge!(execution_options)
+
+        @executor.execute(command, **kwargs)
+      rescue ArgumentError => e
+        unknown_keyword_message = e.message
+        raise unless unknown_keyword_message.start_with?("unknown keyword", "unknown keywords")
+        raise unless unknown_keyword_message.include?(":preparation")
+
+        raise ProviderError.new(
+          "Injected executor #{@executor.class}#execute must accept the preparation: keyword argument",
+          original_error: e
+        )
       end
 
       def track_tokens(response)

data/lib/agent_harness/providers/codex.rb

@@ -25,6 +25,15 @@ module AgentHarness
           !!executor.which(binary_name)
         end
 
+        def provider_metadata_overrides
+          {
+            auth: {
+              service: :openai,
+              api_family: :openai
+            }
+          }
+        end
+
         def firewall_requirements
           {
             domains: [
@@ -53,11 +62,33 @@ module AgentHarness
           ]
         end
 
-        def installation_contract
-          default_package = "@openai/codex@#{SUPPORTED_CLI_VERSION}".freeze
+        def installation_contract(version: SUPPORTED_CLI_VERSION)
+          version = version.strip if version.respond_to?(:strip)
+
+          unless version.is_a?(String) && !version.empty?
+            raise ArgumentError,
+              "Unsupported Codex CLI version #{version.inspect}; " \
+              "supported versions must satisfy #{SUPPORTED_CLI_REQUIREMENT}"
+          end
+
+          parsed_version = begin
+            Gem::Version.new(version)
+          rescue ArgumentError
+            raise ArgumentError,
+              "Unsupported Codex CLI version #{version.inspect}; " \
+              "supported versions must satisfy #{SUPPORTED_CLI_REQUIREMENT}"
+          end
+
+          unless SUPPORTED_CLI_REQUIREMENT.satisfied_by?(parsed_version)
+            raise ArgumentError,
+              "Unsupported Codex CLI version #{version.inspect}; " \
+              "supported versions must satisfy #{SUPPORTED_CLI_REQUIREMENT}"
+          end
+
+          default_package = "@openai/codex@#{version}".freeze
           install_command_prefix = ["npm", "install", "-g", "--ignore-scripts"].freeze
           install_command = (install_command_prefix + [default_package]).freeze
-          supported_versions = [SUPPORTED_CLI_VERSION].freeze
+          supported_versions = [version].freeze
           version_requirement = SUPPORTED_CLI_REQUIREMENT.requirements
             .map { |op, ver| "#{op} #{ver}".freeze }
             .freeze
@@ -66,7 +97,7 @@ module AgentHarness
             source: :npm,
             package: default_package,
             package_name: "@openai/codex",
-            version: SUPPORTED_CLI_VERSION,
+            version: version,
             version_requirement: version_requirement,
             binary_name: binary_name,
             install_command_prefix: install_command_prefix,
@@ -141,7 +172,7 @@ module AgentHarness
 
       def error_patterns
         COMMON_ERROR_PATTERNS.merge(
-          auth_expired: COMMON_ERROR_PATTERNS[:auth_expired] + [/401/, /incorrect.*api.*key/i],
+          auth_expired: COMMON_ERROR_PATTERNS[:auth_expired] + [/\b401\b/, /incorrect.*api.*key/i],
           transient: COMMON_ERROR_PATTERNS[:transient] + [/connection.*reset/i],
           sandbox_failure: [
             /bwrap.*no permissions/i,
@@ -157,7 +188,7 @@ module AgentHarness
           if api_key.strip.start_with?("sk-")
             return {valid: true, expires_at: nil, error: nil, auth_method: :api_key}
           else
-            return {valid: false, expires_at: nil, error: "OPENAI_API_KEY is set but does not appear to be a valid OpenAI API key"}
+            return {valid: false, expires_at: nil, error: "OPENAI_API_KEY is set but does not appear to be a valid OpenAI API key", auth_method: nil}
           end
         end
 
@@ -168,14 +199,14 @@ module AgentHarness
             if key.strip.start_with?("sk-")
               return {valid: true, expires_at: nil, error: nil, auth_method: :config_file}
             else
-              return {valid: false, expires_at: nil, error: "Config file API key is set but does not appear to be a valid OpenAI API key"}
+              return {valid: false, expires_at: nil, error: "Config file API key is set but does not appear to be a valid OpenAI API key", auth_method: nil}
             end
           end
         end
 
-        {valid: false, expires_at: nil, error: "No OpenAI API key found. Set OPENAI_API_KEY or configure in #{codex_config_path}"}
+        {valid: false, expires_at: nil, error: "No OpenAI API key found. Set OPENAI_API_KEY or configure in #{codex_config_path}", auth_method: nil}
       rescue IOError, JSON::ParserError => e
-        {valid: false, expires_at: nil, error: e.message}
+        {valid: false, expires_at: nil, error: e.message, auth_method: nil}
       end
 
       def health_status

data/lib/agent_harness/providers/cursor.rb

@@ -12,6 +12,12 @@ module AgentHarness
     #   provider = AgentHarness::Providers::Cursor.new
     #   response = provider.send_message(prompt: "Hello!")
     class Cursor < Base
+      INSTALL_SCRIPT_URL = "https://cursor.com/install"
+      INSTALL_TARGET_LATEST = "latest"
+      INSTALL_BUILD = "2026.03.30-a5d3e17"
+      INSTALL_SCRIPT_SHA256 = "8371988b483abec13c07c10e95cccc839da81ebf9596e430d3c90835a227cbad"
+      INSTALL_LINUX_X64_PACKAGE_SHA256 = "e0d4b611db111d2dbe76474386271bff3e1dbb2cc6ddf527f9d5d5801b2ce2a0"
+
       class << self
         def provider_name
           :cursor
@@ -26,6 +32,15 @@ module AgentHarness
           !!executor.which(binary_name)
         end
 
+        def provider_metadata_overrides
+          {
+            auth: {
+              service: :cursor,
+              api_family: :cursor
+            }
+          }
+        end
+
         def firewall_requirements
           {
             domains: [
@@ -84,9 +99,66 @@ module AgentHarness
           family_name.match?(/^(claude|gpt|cursor)-/)
         end
 
+        def install_metadata(version: nil)
+          install_target = normalize_install_target(version)
+          linux_x64_package_url = package_url_for(os: "linux", arch: "x64")
+
+          {
+            source: {
+              type: :shell_script,
+              url: INSTALL_SCRIPT_URL,
+              resolved_version: INSTALL_BUILD,
+              default_artifact_url: linux_x64_package_url
+            },
+            checksum: {
+              strategy: :sha256,
+              targets: {
+                script: {
+                  url: INSTALL_SCRIPT_URL,
+                  value: INSTALL_SCRIPT_SHA256
+                },
+                artifacts: {
+                  "linux/x64" => {
+                    url: linux_x64_package_url,
+                    value: INSTALL_LINUX_X64_PACKAGE_SHA256
+                  }
+                }
+              }
+            },
+            binary: {
+              name: binary_name,
+              path: "$HOME/.local/bin/#{binary_name}",
+              suggested_global_path: "/usr/local/bin/#{binary_name}"
+            },
+            version: {
+              default: INSTALL_TARGET_LATEST,
+              supported: install_target,
+              command: [binary_name, "--version"]
+            }
+          }
+        end
+
         def smoke_test_contract
           Base::DEFAULT_SMOKE_TEST_CONTRACT
         end
+
+        private
+
+        def package_url_for(os:, arch:)
+          format(
+            "https://downloads.cursor.com/lab/%<build>s/%<os>s/%<arch>s/agent-cli-package.tar.gz",
+            build: INSTALL_BUILD,
+            os: os,
+            arch: arch
+          )
+        end
+
+        def normalize_install_target(version)
+          target = version.nil? ? INSTALL_TARGET_LATEST : version.to_s
+          return target if target == INSTALL_TARGET_LATEST
+
+          raise ArgumentError, "Unsupported Cursor install target: #{version.inspect}"
+        end
       end
 
       def name
@@ -156,7 +228,7 @@ module AgentHarness
           rate_limited: [
             /rate.?limit/i,
             /too.?many.?requests/i,
-            /429/
+            /\b429\b/
           ],
           auth_expired: [
             /authentication.*error/i,
@@ -192,12 +264,14 @@ module AgentHarness
 
         # Execute command with prompt on stdin
         env = build_env(options)
+        preparation = build_execution_preparation(options)
         start_time = Time.now
         result = execute_with_timeout(
           command,
           timeout: timeout,
           env: env,
           stdin_data: prompt,
+          preparation: preparation,
           **command_execution_options(options)
         )
         duration = Time.now - start_time
@@ -253,7 +327,7 @@ module AgentHarness
         return nil unless self.class.available?
 
         begin
-          result = @executor.execute(["cursor-agent", "mcp", "list"], timeout: 5)
+          result = @executor.execute([self.class.binary_name, "mcp", "list"], timeout: 5)
           return nil unless result.success?
 
           parse_mcp_servers_output(result.stdout)

data/lib/agent_harness/providers/gemini.rb

@@ -30,7 +30,22 @@ module AgentHarness
           !!executor.which(binary_name)
         end
 
+        def provider_metadata_overrides
+          {
+            auth: {
+              service: :google,
+              api_family: :gemini
+            }
+          }
+        end
+
         def install_contract(version: SUPPORTED_CLI_VERSION)
+          version = version.strip if version.respond_to?(:strip)
+
+          unless version.is_a?(String) && !version.empty?
+            raise ArgumentError, "Unsupported Gemini CLI version #{version.inspect}. Supported requirement: #{SUPPORTED_CLI_REQUIREMENT}"
+          end
+
           parsed_version = begin
             Gem::Version.new(version)
           rescue ArgumentError
@@ -170,7 +185,7 @@ module AgentHarness
           rate_limited: [
             /rate.?limit/i,
             /quota.?exceeded/i,
-            /429/
+            /\b429\b/
           ],
           auth_expired: [
             /authentication/i,
@@ -184,7 +199,7 @@ module AgentHarness
           transient: [
             /timeout/i,
             /temporary/i,
-            /503/
+            /\b503\b/
           ]
         }
       end
@@ -196,21 +211,21 @@ module AgentHarness
         end
 
         credentials = read_gemini_credentials
-        return {valid: false, expires_at: nil, error: "No Gemini credentials found. Run 'gemini auth login' or set GEMINI_API_KEY or GOOGLE_API_KEY"} unless credentials
+        return {valid: false, expires_at: nil, error: "No Gemini credentials found. Run 'gemini auth login' or set GEMINI_API_KEY or GOOGLE_API_KEY", auth_method: nil} unless credentials
 
         token = credentials["access_token"] || credentials["oauth_token"]
         unless token.is_a?(String) && !token.strip.empty?
-          return {valid: false, expires_at: nil, error: "No authentication token in Gemini credentials"}
+          return {valid: false, expires_at: nil, error: "No authentication token in Gemini credentials", auth_method: nil}
         end
 
         expires_at = parse_gemini_expiry(credentials)
         if expires_at && expires_at < Time.now
-          {valid: false, expires_at: expires_at, error: "Gemini session expired. Run 'gemini auth login' to re-authenticate"}
+          {valid: false, expires_at: expires_at, error: "Gemini session expired. Run 'gemini auth login' to re-authenticate", auth_method: :oauth}
         else
           {valid: true, expires_at: expires_at, error: nil, auth_method: :oauth}
         end
       rescue IOError, JSON::ParserError => e
-        {valid: false, expires_at: nil, error: e.message}
+        {valid: false, expires_at: nil, error: e.message, auth_method: nil}
       end
 
       def health_status

data/lib/agent_harness/providers/github_copilot.rb

@@ -37,6 +37,18 @@ module AgentHarness
           !!executor.which(binary_name)
         end
 
+        def provider_metadata_overrides
+          {
+            auth: {
+              service: :github,
+              api_family: :github_copilot
+            },
+            identity: {
+              bot_usernames: ["github-copilot[bot]"]
+            }
+          }
+        end
+
         def firewall_requirements
           {
             domains: [

data/lib/agent_harness/providers/kilocode.rb

@@ -41,6 +41,7 @@ module AgentHarness
         end
 
         def installation_contract(version: DEFAULT_VERSION)
+          version = version.strip if version.respond_to?(:strip)
           validate_install_version!(version)
           package_spec = "#{PACKAGE_NAME}@#{version}"
 
@@ -67,8 +68,22 @@ module AgentHarness
         private
 
         def validate_install_version!(version)
+          unless version.is_a?(String) && !version.strip.empty?
+            raise ArgumentError,
+              "Unsupported Kilocode CLI version #{version.inspect}; " \
+              "supported versions must satisfy #{SUPPORTED_VERSION_REQUIREMENT}"
+          end
+
+          parsed_version = begin
+            Gem::Version.new(version)
+          rescue ArgumentError
+            raise ArgumentError,
+              "Unsupported Kilocode CLI version #{version.inspect}; " \
+              "supported versions must satisfy #{SUPPORTED_VERSION_REQUIREMENT}"
+          end
+
           requirement = Gem::Requirement.new(SUPPORTED_VERSION_REQUIREMENT)
-          return if requirement.satisfied_by?(Gem::Version.new(version))
+          return if requirement.satisfied_by?(parsed_version)
 
           raise ArgumentError,
             "Unsupported Kilocode CLI version #{version.inspect}; " \