lex-reflection 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f00b5c12fad1944aecab293210605cb153c7b687c9e83f6edf6dd7e0ff7c1ef4
+  data.tar.gz: 00b17affa2c5c7f41e2d77db913194752f060284ade1310bc3ec82e96842aad5
+SHA512:
+  metadata.gz: 8e8427810654fd6319cfcad7ed17a96b3dbf91fbc0be92615a594f0fecfef2a6c9c4c3afbeac6d4340a1401bf378d3acdc985972c55fb8d1be09df9160f8fb94
+  data.tar.gz: 1f3c636b1d80e6c20065ca081d66d46f9b8280f7dba424b1fbf7d9629bf85ce830fb7ab79d7a011911a0de86cdebb290fde8d423947d10cdb01a9a3fb1b04c20

data/Gemfile

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+gemspec
+
+group :test do
+  gem 'rake'
+  gem 'rspec'
+  gem 'rspec_junit_formatter'
+  gem 'rubocop', require: false
+  gem 'rubocop-rspec', require: false
+  gem 'simplecov'
+end
+
+gem 'legion-gaia', path: '../../legion-gaia'

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Esity
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,86 @@
+# lex-reflection
+
+Meta-cognitive monitoring and adaptation engine for the LegionIO cognitive architecture. Generates structured self-assessments from tick data.
+
+## What It Does
+
+Each tick, analyzes cognitive performance across seven categories: prediction calibration, curiosity effectiveness, emotional stability, trust drift, memory health, cognitive load, and mode patterns. Detects notable patterns and generates reflection entries with severity labels and actionable recommendations. Maintains per-category health scores that combine into a weighted `cognitive_health` composite. Reflections can be marked as acted on to track which adaptations were followed.
+
+## Usage
+
+```ruby
+client = Legion::Extensions::Reflection::Client.new
+
+# Reflect on each tick's results
+result = client.reflect(
+  tick_results: {
+    prediction_engine:          { confidence: 0.35 },
+    working_memory_integration: { curiosity_intensity: 0.9 },
+    emotional_evaluation:       { stability: 0.4, valence: -0.2 },
+    memory_consolidation:       { pruned: 8, total: 10 },
+    elapsed:                    4.8,
+    budget:                     5.0
+  }
+)
+# => { reflections_generated: 2, cognitive_health: 0.62,
+#      new_reflections: [
+#        { category: :prediction_calibration, severity: :significant,
+#          observation: 'Prediction accuracy is below threshold',
+#          recommendation: :investigate, acted_on: false }
+#      ], total_reflections: 2 }
+
+# Check cognitive health
+client.cognitive_health
+# => { health: 0.62, category_scores: { prediction_calibration: 0.35, ... },
+#      unacted_count: 2, critical_count: 0, significant_count: 1 }
+
+# Mark a reflection as acted on
+client.adapt(reflection_id: reflection_id)
+
+# Query reflections
+client.recent_reflections(limit: 5)
+client.reflections_by_category(category: :emotional_stability)
+client.reflection_stats
+```
+
+## Monitored Categories
+
+| Category | Signal |
+|----------|--------|
+| `prediction_calibration` | `tick_results[:prediction_engine][:confidence]` |
+| `curiosity_effectiveness` | `tick_results[:working_memory_integration][:curiosity_intensity]` |
+| `emotional_stability` | `tick_results[:emotional_evaluation][:stability]` |
+| `memory_health` | pruned/total ratio from `memory_consolidation` |
+| `cognitive_load` | elapsed/budget ratio |
+| `trust_drift` | trust composite delta |
+| `mode_patterns` | mode oscillation frequency |
+
+## Severity Levels
+
+`:trivial` < `:notable` < `:significant` < `:critical`
+
+## LLM Enhancement
+
+When `legion-llm` is loaded and started, `Helpers::LlmEnhancer` enriches reflection output with analytically generated prose.
+
+**Methods**:
+
+`LlmEnhancer.enhance_reflection(monitors_data:, health_scores:)` — takes the raw monitors data array and per-category health score hash produced by `Helpers::Monitors`, and returns `{ observations: { category_sym => "text", ... } }`. The runner replaces the `observation` string on each reflection entry with the LLM-generated text. All category, severity, and recommendation symbols are left untouched — only the human-readable observation string changes.
+
+`LlmEnhancer.reflect_on_dream(dream_results:)` — takes the phase result hash from a completed dream cycle and returns `{ reflection: "..." }` containing a 2-4 sentence first-person, present-tense reflection on what emerged. Used by the `reflect_on_dream` runner method, which is called from `lex-dream`'s `dream_reflection` phase (phase 7). Returns `source: :llm` or `source: :mechanical` in the runner result.
+
+**Availability gate**: `LlmEnhancer.available?` checks `Legion::LLM.started?`. Returns `false` if `legion-llm` is not loaded, not configured, or raises any error.
+
+**Fallback**: When LLM is unavailable or either method returns `nil`, `reflect` uses the template observation strings from `Helpers::Monitors`, and `reflect_on_dream` uses `build_mechanical_dream_reflection` (assembles a sentence from memory audit, contradiction, and agenda counts).
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec
+bundle exec rubocop
+```
+
+## License
+
+MIT

data/lex-reflection.gemspec

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/reflection/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lex-reflection'
+  spec.version       = Legion::Extensions::Reflection::VERSION
+  spec.authors       = ['Esity']
+  spec.email         = ['matthewdiverson@gmail.com']
+
+  spec.summary       = 'LEX Reflection'
+  spec.description   = 'Metacognitive self-monitoring for brain-modeled agentic AI'
+  spec.homepage      = 'https://github.com/LegionIO/lex-reflection'
+  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-reflection'
+  spec.metadata['documentation_uri'] = 'https://github.com/LegionIO/lex-reflection'
+  spec.metadata['changelog_uri'] = 'https://github.com/LegionIO/lex-reflection'
+  spec.metadata['bug_tracker_uri'] = 'https://github.com/LegionIO/lex-reflection/issues'
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    Dir.glob('{lib,spec}/**/*') + %w[lex-reflection.gemspec Gemfile LICENSE README.md]
+  end
+  spec.require_paths = ['lib']
+  spec.add_development_dependency 'legion-gaia'
+end

data/lib/legion/extensions/reflection/client.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/reflection/helpers/constants'
+require 'legion/extensions/reflection/helpers/reflection'
+require 'legion/extensions/reflection/helpers/reflection_store'
+require 'legion/extensions/reflection/helpers/monitors'
+require 'legion/extensions/reflection/runners/reflection'
+
+module Legion
+  module Extensions
+    module Reflection
+      class Client
+        include Runners::Reflection
+
+        attr_reader :reflection_store
+
+        def initialize(store: nil, **)
+          @reflection_store = store || Helpers::ReflectionStore.new
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/reflection/helpers/constants.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Reflection
+      module Helpers
+        module Constants
+          CATEGORIES = %i[
+            prediction_calibration
+            curiosity_effectiveness
+            emotional_stability
+            trust_drift
+            memory_health
+            cognitive_load
+            mode_patterns
+          ].freeze
+
+          SEVERITIES = %i[trivial notable significant critical].freeze
+
+          RECOMMENDATIONS = %i[
+            increase_curiosity
+            decrease_curiosity
+            stabilize_emotion
+            rebuild_trust
+            consolidate_memory
+            reduce_load
+            celebrate_success
+            investigate
+            no_action
+          ].freeze
+
+          # Thresholds for monitor triggers
+          PREDICTION_ACCURACY_LOW       = 0.4
+          PREDICTION_ACCURACY_DROP      = 0.2
+          CURIOSITY_RESOLUTION_LOW      = 0.2
+          CURIOSITY_RESOLUTION_HIGH     = 0.8
+          EMOTION_INSTABILITY_THRESHOLD = 0.3
+          EMOTION_FLATNESS_THRESHOLD    = 0.05
+          TRUST_DROP_THRESHOLD          = 0.15
+          MEMORY_DECAY_RATIO_HIGH       = 0.8
+          BUDGET_OVER_THRESHOLD         = 0.9
+          MODE_OSCILLATION_THRESHOLD    = 5
+
+          # Rolling window for metrics
+          METRIC_WINDOW_SIZE = 20
+
+          # Health score weights
+          HEALTH_WEIGHTS = {
+            prediction_calibration:  0.25,
+            curiosity_effectiveness: 0.15,
+            emotional_stability:     0.15,
+            trust_drift:             0.15,
+            memory_health:           0.15,
+            cognitive_load:          0.15
+          }.freeze
+
+          MAX_REFLECTIONS = 100
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/reflection/helpers/llm_enhancer.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Reflection
+      module Helpers
+        module LlmEnhancer
+          SYSTEM_PROMPT = <<~PROMPT
+            You are the metacognitive reflection engine for an autonomous AI agent built on LegionIO.
+            You analyze post-tick cognitive metrics and produce insightful observations.
+            Be analytical and specific. Reference the actual numbers. Identify correlations between metrics.
+            Write as internal reflection, not a report. Present tense, first person.
+          PROMPT
+
+          # Maps prompt label -> actual category symbol from Constants::CATEGORIES
+          CATEGORY_LABEL_MAP = {
+            'EMOTION'    => :emotional_stability,
+            'PREDICTION' => :prediction_calibration,
+            'MEMORY'     => :memory_health,
+            'TRUST'      => :trust_drift,
+            'CURIOSITY'  => :curiosity_effectiveness,
+            'IDENTITY'   => :mode_patterns
+          }.freeze
+
+          REFLECTION_CATEGORIES = CATEGORY_LABEL_MAP.keys.freeze
+
+          module_function
+
+          def available?
+            defined?(Legion::LLM) && Legion::LLM.respond_to?(:started?) && Legion::LLM.started?
+          rescue StandardError
+            false
+          end
+
+          def enhance_reflection(monitors_data:, health_scores:)
+            prompt = build_enhance_reflection_prompt(monitors_data: monitors_data, health_scores: health_scores)
+            response = llm_ask(prompt)
+            parse_enhance_reflection_response(response)
+          rescue StandardError => e
+            Legion::Logging.warn "[reflection:llm] enhance_reflection failed: #{e.message}"
+            nil
+          end
+
+          def reflect_on_dream(dream_results:)
+            prompt = build_reflect_on_dream_prompt(dream_results: dream_results)
+            response = llm_ask(prompt)
+            parse_reflect_on_dream_response(response)
+          rescue StandardError => e
+            Legion::Logging.warn "[reflection:llm] reflect_on_dream failed: #{e.message}"
+            nil
+          end
+
+          # --- Private helpers ---
+
+          def llm_ask(prompt)
+            chat = Legion::LLM.chat
+            chat.with_instructions(SYSTEM_PROMPT)
+            chat.ask(prompt)
+          end
+          private_class_method :llm_ask
+
+          def build_enhance_reflection_prompt(monitors_data:, health_scores:)
+            metrics_lines = format_monitors_data(monitors_data)
+            health_lines  = health_scores.map { |cat, score| "#{cat}: #{score.round(3)}" }.join("\n")
+
+            <<~PROMPT
+              Analyze these post-tick cognitive metrics and generate insightful observations.
+
+              METRICS:
+              #{metrics_lines}
+
+              HEALTH SCORES:
+              #{health_lines}
+
+              For each category, write 1-2 sentences of genuine analytical observation.
+              Look for correlations between categories. Note concerning or interesting patterns.
+
+              Format EXACTLY as (one line per category):
+              EMOTION: <observation>
+              PREDICTION: <observation>
+              MEMORY: <observation>
+              TRUST: <observation>
+              CURIOSITY: <observation>
+              IDENTITY: <observation>
+            PROMPT
+          end
+          private_class_method :build_enhance_reflection_prompt
+
+          def format_monitors_data(monitors_data)
+            return '' unless monitors_data.is_a?(Array)
+
+            monitors_data.filter_map do |entry|
+              next unless entry.is_a?(Hash) && entry[:category]
+
+              metrics = entry[:metrics]
+              if metrics.is_a?(Hash) && metrics.any?
+                metric_str = metrics.map { |k, v| "#{k}=#{v.is_a?(Float) ? v.round(3) : v}" }.join(', ')
+                "#{entry[:category].to_s.upcase}: #{metric_str}"
+              else
+                entry[:category].to_s.upcase
+              end
+            end.join("\n")
+          end
+          private_class_method :format_monitors_data
+
+          def parse_enhance_reflection_response(response)
+            return nil unless response&.content
+
+            observations = {}
+            CATEGORY_LABEL_MAP.each do |label, category_sym|
+              match = response.content.match(/^#{label}:\s*(.+)$/i)
+              observations[category_sym] = match.captures.first.strip if match
+            end
+
+            observations.empty? ? nil : { observations: observations }
+          end
+          private_class_method :parse_enhance_reflection_response
+
+          def build_reflect_on_dream_prompt(dream_results:)
+            summary = format_dream_results(dream_results)
+
+            <<~PROMPT
+              Reflect on the completed dream cycle and its cognitive significance.
+
+              DREAM CYCLE RESULTS:
+              #{summary}
+
+              Generate a first-person, present-tense reflection on what emerged from this dream cycle.
+              Be specific about patterns, consolidations, and what needs attention.
+
+              Format EXACTLY as:
+              REFLECTION: <2-4 sentences of internal reflection>
+            PROMPT
+          end
+          private_class_method :build_reflect_on_dream_prompt
+
+          def format_dream_results(dream_results)
+            return 'no results' unless dream_results.is_a?(Hash) && dream_results.any?
+
+            dream_results.map do |phase, result|
+              next unless result.is_a?(Hash)
+
+              summary = result.except(:error).map { |k, v| "#{k}=#{v}" }.first(4).join(', ')
+              "#{phase}: #{summary}"
+            end.compact.join("\n")
+          end
+          private_class_method :format_dream_results
+
+          def parse_reflect_on_dream_response(response)
+            return nil unless response&.content
+
+            match = response.content.match(/REFLECTION:\s*(.+)/im)
+            return nil unless match
+
+            { reflection: match.captures.first.strip }
+          end
+          private_class_method :parse_reflect_on_dream_response
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/reflection/helpers/monitors.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Reflection
+      module Helpers
+        module Monitors
+          module_function
+
+          def run_all(tick_results, metric_history)
+            reflections = []
+            reflections.concat(monitor_predictions(tick_results, metric_history))
+            reflections.concat(monitor_curiosity(tick_results))
+            reflections.concat(monitor_emotions(tick_results))
+            reflections.concat(monitor_trust(tick_results, metric_history))
+            reflections.concat(monitor_memory(tick_results))
+            reflections.concat(monitor_cognitive_load(tick_results))
+            reflections
+          end
+
+          def monitor_predictions(tick_results, history)
+            prediction = tick_results[:prediction_engine]
+            return [] unless prediction.is_a?(Hash)
+
+            reflections = []
+            confidence = prediction[:confidence]
+
+            if confidence.is_a?(Numeric) && confidence < Constants::PREDICTION_ACCURACY_LOW
+              reflections << ReflectionFactory.new_reflection(
+                category:       :prediction_calibration,
+                observation:    "Prediction confidence is low at #{(confidence * 100).round}%",
+                severity:       ReflectionFactory.severity_for_drop(1.0 - confidence),
+                metrics:        { confidence: confidence },
+                recommendation: :increase_curiosity
+              )
+            end
+
+            reflections.concat(detect_accuracy_trend(history))
+            reflections
+          end
+
+          def monitor_curiosity(tick_results)
+            curiosity = tick_results[:working_memory_integration]
+            return [] unless curiosity.is_a?(Hash)
+
+            reflections = []
+
+            resolution_rate = curiosity[:resolution_rate] if curiosity.key?(:resolution_rate)
+            if resolution_rate.is_a?(Numeric)
+              if resolution_rate < Constants::CURIOSITY_RESOLUTION_LOW
+                reflections << ReflectionFactory.new_reflection(
+                  category:       :curiosity_effectiveness,
+                  observation:    "Curiosity resolution rate is low at #{(resolution_rate * 100).round}%",
+                  severity:       :notable,
+                  metrics:        { resolution_rate: resolution_rate },
+                  recommendation: :decrease_curiosity
+                )
+              elsif resolution_rate > Constants::CURIOSITY_RESOLUTION_HIGH
+                reflections << ReflectionFactory.new_reflection(
+                  category:       :curiosity_effectiveness,
+                  observation:    "Curiosity resolution rate is excellent at #{(resolution_rate * 100).round}%",
+                  severity:       :trivial,
+                  metrics:        { resolution_rate: resolution_rate },
+                  recommendation: :celebrate_success
+                )
+              end
+            end
+
+            reflections
+          end
+
+          def monitor_emotions(tick_results)
+            emotion = tick_results[:emotional_evaluation]
+            return [] unless emotion.is_a?(Hash)
+
+            reflections = []
+            stability = emotion[:stability] || emotion.dig(:momentum, :stability)
+
+            if stability.is_a?(Numeric)
+              if stability < Constants::EMOTION_INSTABILITY_THRESHOLD
+                reflections << ReflectionFactory.new_reflection(
+                  category:       :emotional_stability,
+                  observation:    "Emotional state is unstable (stability: #{stability.round(2)})",
+                  severity:       :significant,
+                  metrics:        { stability: stability },
+                  recommendation: :stabilize_emotion
+                )
+              elsif stability > (1.0 - Constants::EMOTION_FLATNESS_THRESHOLD)
+                reflections << ReflectionFactory.new_reflection(
+                  category:       :emotional_stability,
+                  observation:    'Emotional state is unusually flat — possible disengagement',
+                  severity:       :notable,
+                  metrics:        { stability: stability },
+                  recommendation: :investigate
+                )
+              end
+            end
+
+            reflections
+          end
+
+          def monitor_trust(tick_results, history)
+            trust = tick_results[:action_selection]
+            return [] unless trust.is_a?(Hash) && trust[:trust_score].is_a?(Numeric)
+
+            trust_scores = history.filter_map { |h| h.dig(:action_selection, :trust_score) }
+            return [] if trust_scores.size < 3
+
+            recent_avg = trust_scores.last(5).sum / trust_scores.last(5).size.to_f
+            older_avg = trust_scores.first(5).sum / trust_scores.first(5).size.to_f
+            drop = older_avg - recent_avg
+
+            return [] unless drop > Constants::TRUST_DROP_THRESHOLD
+
+            [ReflectionFactory.new_reflection(
+              category:       :trust_drift,
+              observation:    "Trust scores have dropped by #{(drop * 100).round}% recently",
+              severity:       ReflectionFactory.severity_for_drop(drop),
+              metrics:        { drop: drop, recent_avg: recent_avg, older_avg: older_avg },
+              recommendation: :rebuild_trust
+            )]
+          end
+
+          def monitor_memory(tick_results)
+            memory = tick_results[:memory_consolidation]
+            return [] unless memory.is_a?(Hash)
+
+            pruned = memory[:pruned] || 0
+            total = memory[:total] || 1
+            ratio = pruned.to_f / [total, 1].max
+
+            return [] unless ratio > Constants::MEMORY_DECAY_RATIO_HIGH
+
+            [ReflectionFactory.new_reflection(
+              category:       :memory_health,
+              observation:    "High memory decay ratio: #{(ratio * 100).round}% of traces pruned",
+              severity:       :significant,
+              metrics:        { pruned: pruned, total: total, ratio: ratio },
+              recommendation: :consolidate_memory
+            )]
+          end
+
+          def monitor_cognitive_load(tick_results)
+            elapsed = tick_results[:elapsed]
+            budget = tick_results[:budget]
+            return [] unless elapsed.is_a?(Numeric) && budget.is_a?(Numeric) && budget.positive?
+
+            utilization = elapsed / budget
+            return [] unless utilization > Constants::BUDGET_OVER_THRESHOLD
+
+            [ReflectionFactory.new_reflection(
+              category:       :cognitive_load,
+              observation:    "Tick budget utilization at #{(utilization * 100).round}%",
+              severity:       utilization > 1.0 ? :significant : :notable,
+              metrics:        { utilization: utilization, elapsed: elapsed, budget: budget },
+              recommendation: :reduce_load
+            )]
+          end
+
+          def detect_accuracy_trend(history)
+            accuracies = history.filter_map { |h| h.dig(:prediction_engine, :confidence) }
+            return [] if accuracies.size < 5
+
+            recent = accuracies.last(5).sum / 5.0
+            older = accuracies.first(5).sum / 5.0
+            drop = older - recent
+
+            return [] unless drop > Constants::PREDICTION_ACCURACY_DROP
+
+            [ReflectionFactory.new_reflection(
+              category:       :prediction_calibration,
+              observation:    "Prediction accuracy trending down: #{(older * 100).round}% -> #{(recent * 100).round}%",
+              severity:       ReflectionFactory.severity_for_drop(drop),
+              metrics:        { trend_drop: drop, recent_avg: recent, older_avg: older },
+              recommendation: :increase_curiosity
+            )]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/reflection/helpers/reflection.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module Reflection
+      module Helpers
+        module ReflectionFactory
+          module_function
+
+          def new_reflection(category:, observation:, severity: :notable,
+                             metrics: {}, recommendation: :no_action)
+            raise ArgumentError, "invalid category: #{category}" unless Constants::CATEGORIES.include?(category)
+            raise ArgumentError, "invalid severity: #{severity}" unless Constants::SEVERITIES.include?(severity)
+
+            {
+              reflection_id:  SecureRandom.uuid,
+              category:       category,
+              observation:    observation,
+              severity:       severity,
+              metrics:        metrics,
+              recommendation: recommendation,
+              created_at:     Time.now.utc,
+              acted_on:       false
+            }
+          end
+
+          def severity_weight(severity)
+            case severity
+            when :critical    then 1.0
+            when :significant then 0.7
+            when :notable     then 0.4
+            when :trivial     then 0.1
+            else 0.0
+            end
+          end
+
+          def severity_for_drop(drop)
+            if drop >= 0.4 then :critical
+            elsif drop >= 0.25 then :significant
+            elsif drop >= 0.1  then :notable
+            else :trivial
+            end
+          end
+        end
+      end
+    end
+  end
+end