lex-assessor 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ee974378d5cc8bd9b93e356c359aeb0437d5c31614561706590c9d11c57e1ab4
+  data.tar.gz: 657ee8494e2ecb23cb8d6f7863eed2813f9634872b31edb186c36344768bd24a
+SHA512:
+  metadata.gz: c3486bb38f5412de35cf35403e0b61af44c5593d8d5e945a8fa1ae23672d7eb41634ad96d5b361bfc114b6ce79937aca2a78d059a55ed7378829be70c13ed522
+  data.tar.gz: 035cc91d9340c17de9d0c1abb11fcd4961c6e1882c10d7bed8541d4c9b92f22cc5036b87fb3fa6f920d14807bcb549183e6b5974d9ae36a49307edf5a6542e41

data/Gemfile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'rspec', '~> 3.13'
+gem 'rspec_junit_formatter'
+gem 'rubocop', '~> 1.75', require: false
+gem 'rubocop-legion', '~> 0.1', require: false
+gem 'rubocop-rspec', require: false
+gem 'simplecov', require: false

data/lex-assessor.gemspec

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/assessor/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lex-assessor'
+  spec.version       = Legion::Extensions::Assessor::VERSION
+  spec.authors       = ['Esity']
+  spec.email         = ['matthewdiverson@gmail.com']
+
+  spec.summary       = 'Fleet pipeline intake for LegionIO'
+  spec.description   = 'Fleet pipeline intake: classify, deduplicate, and route work items'
+  spec.homepage      = 'https://github.com/LegionIO/lex-assessor'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = '>= 3.4'
+
+  spec.metadata['homepage_uri']          = spec.homepage
+  spec.metadata['source_code_uri']       = 'https://github.com/LegionIO/lex-assessor'
+  spec.metadata['changelog_uri']         = 'https://github.com/LegionIO/lex-assessor'
+  spec.metadata['documentation_uri']     = 'https://github.com/LegionIO/lex-assessor'
+  spec.metadata['bug_tracker_uri']       = 'https://github.com/LegionIO/lex-assessor/issues'
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    Dir.glob('{lib}/**/*') + %w[lex-assessor.gemspec Gemfile]
+  end
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'legion-cache',     '>= 1.3.11'
+  spec.add_dependency 'legion-crypt',     '>= 1.4.9'
+  spec.add_dependency 'legion-data',      '>= 1.4.17'
+  spec.add_dependency 'legion-json',      '>= 1.2.1'
+  spec.add_dependency 'legion-logging',   '>= 1.3.2'
+  spec.add_dependency 'legion-settings',  '>= 1.3.14'
+  spec.add_dependency 'legion-transport', '>= 1.3.9'
+end

data/lib/legion/extensions/assessor/actors/assessor.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+return unless defined?(Legion::Extensions::Actors::Subscription)
+
+module Legion
+  module Extensions
+    module Assessor
+      module Actor
+        class Assessor < Legion::Extensions::Actors::Subscription
+          def runner_function
+            'assess'
+          end
+
+          def check_subtask?
+            true
+          end
+
+          def generate_task?
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/assessor/helpers/classifier.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Assessor
+      module Helpers
+        module Classifier
+          extend self
+
+          CLASSIFICATION_SCHEMA = {
+            type:       :object,
+            properties: {
+              priority:             { type: :string, enum: %w[low medium high critical] },
+              complexity:           {
+                type: :string,
+                enum: %w[trivial_fix simple_bug moderate_feature complex_feature critical_production background]
+              },
+              work_type:            { type: :string, enum: %w[bug_fix feature refactor test docs dependency security] },
+              language:             { type: :string },
+              estimated_difficulty: { type: :number, minimum: 0.0, maximum: 1.0 }
+            },
+            required:   %w[priority complexity work_type estimated_difficulty]
+          }.freeze
+
+          def classify(work_item:)
+            prompt = build_prompt(work_item: work_item)
+            result = Legion::LLM::Prompt.extract(
+              prompt,
+              schema:  classification_schema,
+              tools:   [],
+              intent:  { capability: :moderate },
+              caller:  { extension: 'lex-assessor', operation: 'classify' },
+              agent:   {
+                id:   'fleet:assessor',
+                name: 'Fleet Assessor',
+                type: :autonomous,
+                goal: work_item[:title]
+              },
+              tracing: {
+                trace_id:       work_item[:work_item_id],
+                correlation_id: work_item[:source_ref]
+              }
+            )
+
+            normalize_result(json_parse(result.message[:content]))
+          end
+
+          def classification_schema
+            CLASSIFICATION_SCHEMA
+          end
+
+          def build_prompt(work_item:)
+            <<~PROMPT
+              Classify this work item for an autonomous coding pipeline.
+
+              Source: #{work_item[:source]}
+              Reference: #{work_item[:source_ref]}
+              Title: #{work_item[:title]}
+              Description: #{work_item[:description]}
+
+              Classify the complexity, priority, work type, primary language, and estimated difficulty (0.0 to 1.0).
+
+              Complexity levels:
+              - trivial_fix: one-line change, obvious fix
+              - simple_bug: clear bug, single file, straightforward
+              - moderate_feature: multi-file change, needs planning
+              - complex_feature: architectural change, multiple subsystems
+              - critical_production: production outage, needs immediate fix with max capability
+              - background: low-priority chore, minimal review needed
+            PROMPT
+          end
+
+          def difficulty_to_capability(difficulty)
+            case difficulty
+            when 0.0...0.3 then :basic
+            when 0.3...0.6 then :moderate
+            else :reasoning
+            end
+          end
+
+          private
+
+          def json_parse(content)
+            Legion::JSON.load(content) # rubocop:disable Legion/HelperMigration/DirectJson
+          end
+
+          def normalize_result(result)
+            {
+              priority:             (result[:priority] || :medium).to_sym,
+              complexity:           (result[:complexity] || :moderate_feature).to_sym,
+              work_type:            (result[:work_type] || :bug_fix).to_sym,
+              language:             (result[:language] || :ruby).to_sym,
+              estimated_difficulty: (result[:estimated_difficulty] || 0.5).to_f.clamp(0.0, 1.0)
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/assessor/helpers/config_templates.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Assessor
+      module Helpers
+        module ConfigTemplates
+          extend self
+
+          TEMPLATES = {
+            trivial_fix:         {
+              planning:       { enabled: false, solvers: 1, validators: 0, max_iterations: 1 }.freeze,
+              implementation: { solvers: 1, validators: 0, max_iterations: 1, models: nil }.freeze,
+              validation:     { enabled: false, run_tests: true, run_lint: true, security_scan: false, adversarial_review: false, reviewer_models: nil }.freeze,
+              feedback:       { drain_enabled: false, max_drain_rounds: 1, summarize_after: 1 }.freeze
+            }.freeze,
+            simple_bug:          {
+              planning:       { enabled: false, solvers: 1, validators: 0, max_iterations: 1 }.freeze,
+              implementation: { solvers: 1, validators: 1, max_iterations: 3, models: nil }.freeze,
+              validation:     { enabled: true, run_tests: true, run_lint: true, security_scan: true, adversarial_review: true, reviewer_models: nil }.freeze,
+              feedback:       { drain_enabled: true, max_drain_rounds: 2, summarize_after: 2 }.freeze
+            }.freeze,
+            moderate_feature:    {
+              planning:       { enabled: true, solvers: 1, validators: 1, max_iterations: 2 }.freeze,
+              implementation: { solvers: 1, validators: 3, max_iterations: 5, models: nil }.freeze,
+              validation:     { enabled: true, run_tests: true, run_lint: true, security_scan: true, adversarial_review: true, reviewer_models: nil }.freeze,
+              feedback:       { drain_enabled: true, max_drain_rounds: 3, summarize_after: 2 }.freeze
+            }.freeze,
+            complex_feature:     {
+              planning:       { enabled: true, solvers: 2, validators: 2, max_iterations: 3 }.freeze,
+              implementation: { solvers: 2, validators: 3, max_iterations: 8, models: nil }.freeze,
+              validation:     { enabled: true, run_tests: true, run_lint: true, security_scan: true, adversarial_review: true, reviewer_models: nil }.freeze,
+              feedback:       { drain_enabled: true, max_drain_rounds: 3, summarize_after: 2 }.freeze
+            }.freeze,
+            critical_production: {
+              # planning skipped intentionally: critical items need immediate action, not planning overhead
+              planning:       { enabled: false, solvers: 1, validators: 0, max_iterations: 1 }.freeze,
+              implementation: { solvers: 3, validators: 3, max_iterations: 10, models: nil }.freeze,
+              validation:     { enabled: true, run_tests: true, run_lint: true, security_scan: true, adversarial_review: true, reviewer_models: nil }.freeze,
+              feedback:       { drain_enabled: true, max_drain_rounds: 3, summarize_after: 2 }.freeze
+            }.freeze,
+            background:          {
+              # validation.enabled=false is the gate; run_tests/run_lint pre-configured if re-enabled via override
+              planning:       { enabled: false, solvers: 1, validators: 0, max_iterations: 1 }.freeze,
+              implementation: { solvers: 1, validators: 0, max_iterations: 2, models: nil }.freeze,
+              validation:     { enabled: false, run_tests: true, run_lint: true, security_scan: false, adversarial_review: false, reviewer_models: nil }.freeze,
+              feedback:       { drain_enabled: false, max_drain_rounds: 1, summarize_after: 1 }.freeze
+            }.freeze
+          }.freeze
+
+          DEFAULT_TEMPLATE = :moderate_feature
+
+          def for_classification(complexity:)
+            key = complexity.to_sym
+            template = TEMPLATES.fetch(key) { TEMPLATES[DEFAULT_TEMPLATE] }
+            deep_dup(template)
+          end
+
+          def merge_with_overrides(template:, overrides:)
+            return deep_dup(template) if overrides.nil? || overrides.empty?
+
+            deep_merge(template, overrides)
+          end
+
+          private
+
+          def deep_dup(hash)
+            hash.each_with_object({}) do |(k, v), result|
+              result[k] = v.is_a?(Hash) ? deep_dup(v) : v
+            end
+          end
+
+          def deep_merge(base, overlay)
+            base.merge(overlay) do |_key, old_val, new_val|
+              if old_val.is_a?(Hash) && new_val.is_a?(Hash)
+                deep_merge(old_val, new_val)
+              else
+                new_val
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/assessor/helpers/dedup.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module Legion
+  module Extensions
+    module Assessor
+      module Helpers
+        module Dedup
+          extend self
+
+          CACHE_PREFIX = 'fleet:active:'
+
+          def fingerprint(source:, source_ref:, title:)
+            Digest::SHA256.hexdigest("#{source}:#{source_ref}:#{title}")
+          end
+
+          def duplicate?(fingerprint:)
+            !cache_get(cache_key(fingerprint)).nil?
+          end
+
+          def default_ttl
+            Legion::Settings.dig(:fleet, :cache, :dedup_ttl_seconds)&.to_i || 86_400
+          end
+
+          def claim!(fingerprint:, ttl: default_ttl)
+            cache_set_nx(cache_key(fingerprint), '1', ttl: ttl)
+          end
+
+          def release!(fingerprint:)
+            cache_delete(cache_key(fingerprint))
+          end
+
+          def cache_key(fingerprint)
+            "#{CACHE_PREFIX}#{fingerprint}"
+          end
+
+          private
+
+          def cache_get(key)
+            Legion::Cache.get(key) # rubocop:disable Legion/HelperMigration/DirectCache
+          end
+
+          def cache_set_nx(key, value, ttl:)
+            Legion::Cache.set_nx(key, value, ttl: ttl)
+          end
+
+          def cache_delete(key)
+            Legion::Cache.delete(key) # rubocop:disable Legion/HelperMigration/DirectCache
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/assessor/runners/assessor.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Assessor
+      module Runners
+        module Assessor
+          extend self
+
+          def assess(results: nil, work_item: nil, args: nil, **)
+            results = json_load_string(results) if results.is_a?(String)
+            work_item ||= results&.dig(:work_item) || args&.dig(:work_item)
+            raise ArgumentError, "work_item is nil in #{__method__}" if work_item.nil?
+
+            fingerprint = Helpers::Dedup.fingerprint(
+              source:     work_item[:source],
+              source_ref: work_item[:source_ref],
+              title:      work_item[:title]
+            )
+
+            return { success: false, reason: :duplicate, work_item_id: work_item[:work_item_id] } unless Helpers::Dedup.claim!(fingerprint: fingerprint)
+
+            classification   = Helpers::Classifier.classify(work_item: work_item)
+            template         = Helpers::ConfigTemplates.for_classification(complexity: classification[:complexity])
+            source_overrides = extract_source_overrides(work_item[:config])
+            merged_config    = Helpers::ConfigTemplates.merge_with_overrides(template: template, overrides: source_overrides)
+
+            work_item = work_item.merge(
+              config:                  work_item[:config].merge(merged_config).merge(
+                priority:             classification[:priority],
+                complexity:           classification[:complexity],
+                estimated_difficulty: classification[:estimated_difficulty]
+              ),
+              resolved_max_iterations: merged_config.dig(:implementation, :max_iterations) || 5,
+              pipeline:                work_item[:pipeline].merge(
+                stage: 'assessed',
+                trace: work_item[:pipeline][:trace] + [build_trace_entry]
+              )
+            )
+
+            { success: true, work_item: work_item }
+          end
+
+          def escalate(results: nil, work_item: nil, args: nil, **)
+            results = json_load_string(results) if results.is_a?(String)
+            work_item ||= results&.dig(:work_item) || args&.dig(:work_item)
+            raise ArgumentError, "work_item is nil in #{__method__}" if work_item.nil?
+
+            notify_external_systems(work_item)
+
+            # Step 4: Clear dedup cache key
+            fingerprint = Helpers::Dedup.fingerprint(
+              source:     work_item[:source],
+              source_ref: work_item[:source_ref],
+              title:      work_item[:title]
+            )
+            Helpers::Dedup.release!(fingerprint: fingerprint)
+
+            # Step 5: Clear Redis refs (payload, context, worktree)
+            cleanup_redis_refs(work_item[:work_item_id])
+
+            # Step 6: Return escalated work item
+            work_item = work_item.merge(
+              pipeline: work_item[:pipeline].merge(
+                stage: 'escalated',
+                trace: work_item[:pipeline][:trace] + [build_trace_entry(stage: 'escalation')]
+              )
+            )
+
+            { success: true, work_item: work_item }
+          end
+
+          private
+
+          def json_load_string(str)
+            Legion::JSON.load(str) # rubocop:disable Legion/HelperMigration/DirectJson
+          end
+
+          def extract_source_overrides(config)
+            return nil if config.nil?
+
+            overrides = {}
+            %i[planning implementation validation feedback workspace context tracing safety selection escalation].each do |key|
+              overrides[key] = config[key] if config[key].is_a?(Hash) && !config[key].values.all?(&:nil?)
+            end
+            overrides.empty? ? nil : overrides
+          end
+
+          def build_trace_entry(stage: 'assessor')
+            {
+              stage:        stage,
+              node:         node_name,
+              started_at:   ::Time.now.utc.iso8601,
+              completed_at: ::Time.now.utc.iso8601,
+              token_usage:  nil
+            }
+          end
+
+          def notify_external_systems(work_item)
+            owner        = work_item.dig(:repo, :owner)
+            repo         = work_item.dig(:repo, :name)
+            issue_number = work_item[:source_ref].to_s.scan(/\d+/).last&.to_i
+
+            if defined?(Legion::Extensions::Github::Runners::Labels)
+              Legion::Extensions::Github::Runners::Labels.add_labels_to_issue(
+                owner: owner, repo: repo, issue_number: issue_number, labels: ['fleet:escalated']
+              )
+            else
+              Legion::Logging.warn('fleet:assessor: lex-github not loaded; skipping issue label') # rubocop:disable Legion/HelperMigration/DirectLogging
+            end
+
+            if defined?(Legion::Extensions::Github::Runners::Comments)
+              Legion::Extensions::Github::Runners::Comments.create_issue_comment(
+                owner: owner, repo: repo, issue_number: issue_number,
+                body:  build_escalation_summary(work_item)
+              )
+            else
+              Legion::Logging.warn('fleet:assessor: lex-github not loaded; skipping escalation comment') # rubocop:disable Legion/HelperMigration/DirectLogging
+            end
+
+            submit_to_approval_queue(work_item)
+          end
+
+          def submit_to_approval_queue(work_item)
+            if defined?(Legion::Extensions::Audit::Runners::ApprovalQueue)
+              Legion::Extensions::Audit::Runners::ApprovalQueue.submit(
+                approval_type:      'fleet.escalation',
+                payload:            { work_item: work_item.merge(pipeline: work_item[:pipeline].merge(attempt: 0, resumed: true)) },
+                requester_id:       'fleet:assessor',
+                resume_routing_key: 'lex.developer.runners.developer.incorporate_feedback',
+                resume_exchange:    'lex.developer'
+              )
+            else
+              Legion::Logging.warn('fleet:assessor: lex-audit not loaded; skipping ApprovalQueue submission') # rubocop:disable Legion/HelperMigration/DirectLogging
+            end
+          end
+
+          def build_escalation_summary(work_item)
+            attempt  = work_item.dig(:pipeline, :attempt) || 0
+            review   = work_item.dig(:pipeline, :review_result) || {}
+            feedback = Array(work_item.dig(:pipeline, :feedback_history))
+
+            <<~SUMMARY
+              ## Fleet Pipeline -- Escalation
+
+              **Work Item**: #{work_item[:work_item_id]}
+              **Title**: #{work_item[:title]}
+              **Attempts**: #{attempt}
+              **Last Verdict**: #{review[:verdict] || 'N/A'}
+
+              ### Feedback History
+              #{feedback.map { |f| "- Round #{f[:round]}: #{Array(f[:issues]).join(', ')}" }.join("\n")}
+
+              This work item has been escalated for human review after exceeding the maximum iteration count.
+            SUMMARY
+          end
+
+          def cleanup_redis_refs(work_item_id)
+            cache_delete("fleet:payload:#{work_item_id}")
+            cache_delete("fleet:context:#{work_item_id}")
+            cache_delete("fleet:worktree:#{work_item_id}")
+          end
+
+          def cache_delete(key)
+            Legion::Cache.delete(key) # rubocop:disable Legion/HelperMigration/DirectCache
+          end
+
+          def node_name
+            Legion::Settings.dig(:node, :name) || 'unknown'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/assessor/transport/exchanges/assessor.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Assessor
+      module Transport
+        module Exchanges
+          class Assessor < Legion::Transport::Exchange
+            def exchange_name
+              'lex.assessor'
+            end
+
+            def exchange_options
+              { type: 'topic', durable: true }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/assessor/transport/queues/assessor.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Assessor
+      module Transport
+        module Queues
+          class Assessor < Legion::Transport::Queue
+            def queue_name
+              'lex.assessor.runners.assessor'
+            end
+
+            def queue_options
+              { durable: true }
+            end
+
+            def routing_key
+              'lex.assessor.runners.assessor.#'
+            end
+
+            def exchange
+              Exchanges::Assessor
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/assessor/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Assessor
+      VERSION = '0.1.0'
+    end
+  end
+end

data/lib/legion/extensions/assessor.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'assessor/version'
+require_relative 'assessor/helpers/config_templates'
+require_relative 'assessor/helpers/dedup'
+require_relative 'assessor/helpers/classifier'
+require_relative 'assessor/runners/assessor'
+
+if defined?(Legion::Transport::Exchange)
+  require_relative 'assessor/transport/exchanges/assessor'
+  require_relative 'assessor/transport/queues/assessor'
+end
+
+require_relative 'assessor/actors/assessor'
+
+module Legion
+  module Extensions
+    module Assessor
+      extend Legion::Extensions::Core if defined?(Legion::Extensions::Core)
+
+      def self.llm_required?
+        true
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification
+name: lex-assessor
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Esity
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: legion-cache
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.11
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.11
+- !ruby/object:Gem::Dependency
+  name: legion-crypt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.9
+- !ruby/object:Gem::Dependency
+  name: legion-data
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.17
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.17
+- !ruby/object:Gem::Dependency
+  name: legion-json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+- !ruby/object:Gem::Dependency
+  name: legion-logging
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.2
+- !ruby/object:Gem::Dependency
+  name: legion-settings
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.14
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.14
+- !ruby/object:Gem::Dependency
+  name: legion-transport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.9
+description: 'Fleet pipeline intake: classify, deduplicate, and route work items'
+email:
+- matthewdiverson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- lex-assessor.gemspec
+- lib/legion/extensions/assessor.rb
+- lib/legion/extensions/assessor/actors/assessor.rb
+- lib/legion/extensions/assessor/helpers/classifier.rb
+- lib/legion/extensions/assessor/helpers/config_templates.rb
+- lib/legion/extensions/assessor/helpers/dedup.rb
+- lib/legion/extensions/assessor/runners/assessor.rb
+- lib/legion/extensions/assessor/transport/exchanges/assessor.rb
+- lib/legion/extensions/assessor/transport/queues/assessor.rb
+- lib/legion/extensions/assessor/version.rb
+homepage: https://github.com/LegionIO/lex-assessor
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-assessor
+  source_code_uri: https://github.com/LegionIO/lex-assessor
+  changelog_uri: https://github.com/LegionIO/lex-assessor
+  documentation_uri: https://github.com/LegionIO/lex-assessor
+  bug_tracker_uri: https://github.com/LegionIO/lex-assessor/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Fleet pipeline intake for LegionIO
+test_files: []