lex-mood 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 52558938da1dfd56dce95ce2b1a368f843cc9d843b7c82276d9c75ed1ea832fa
+  data.tar.gz: cc469d9968204fb7c8087e8b52d41508ce8bbef4955f46d16bc57db88eed75d7
+SHA512:
+  metadata.gz: 973d7eefaf080e8267db5f01d9e5b866bf3c623777f4ed72456549f9e9d65373f0142ec6493338102b92a9fb04ecb783e3887bcfab5264b86039e382511bb591
+  data.tar.gz: 5b88fdebece4cbf60e544e4372d5b6c213c1f131081c7f83f598e5d719f821b9f945cb9cc06adc8f3d02cb1c965fe09b2de5ee8f225fe2ea63a08489a1131e10

data/Gemfile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec
+
+group :dev, :test do
+  gem 'rspec', '~> 3.12'
+  gem 'rubocop', '~> 1.75'
+  gem 'rubocop-rspec', '~> 3.0'
+end
+
+gem 'legion-gaia', path: '../../legion-gaia'

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Matthew Iverson
+
+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,93 @@
+# lex-mood
+
+Persistent mood state for LegionIO agents. Part of the LegionIO cognitive architecture extension ecosystem (LEX).
+
+## What It Does
+
+`lex-mood` models the agent's sustained background affect — distinct from acute emotion. Where emotion is a reactive signal spike, mood is a slow-moving four-dimensional state (valence, arousal, energy, stability) updated via EMA. The current mood classification (one of nine states) emits modulation values that bias attention, risk tolerance, and curiosity across the cognitive architecture.
+
+Key capabilities:
+
+- **Nine mood states**: serene, content, curious, energized, anxious, frustrated, melancholic, flat, neutral
+- **Four dimensions**: valence, arousal, energy, stability — all EMA-smoothed
+- **Inertia**: each mood has a resistance coefficient preventing rapid oscillation
+- **Modulations**: per-mood attention_threshold, risk_tolerance, and curiosity_boost values
+- **Mood trend**: improving / stable / declining based on recent history
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem 'lex-mood'
+```
+
+Or install directly:
+
+```
+gem install lex-mood
+```
+
+## Usage
+
+```ruby
+require 'legion/extensions/mood'
+
+client = Legion::Extensions::Mood::Client.new
+
+# Update mood from tick results
+result = client.update_mood(tick_results: tick_phase_results)
+# => { mood: :curious, valence: 0.62, arousal: 0.55, energy: 0.7,
+#      modulations: { curiosity_boost: 0.2, attention_threshold: 0.2 } }
+
+# Query current mood
+client.current_mood
+# => { mood: :curious, valence: 0.62, arousal: 0.55, energy: 0.7, stability: 0.8 }
+
+# Query a specific modulation parameter
+client.mood_modulation(parameter: :risk_tolerance)
+# => { parameter: :risk_tolerance, modulation: 0.5, current_mood: :curious }
+
+# View mood history
+client.mood_history(limit: 10)
+
+# Summary stats
+client.mood_stats
+# => { current_mood: :curious, dominant_mood: :content, trend: :stable, ... }
+```
+
+## Mood States and Modulations
+
+| Mood | Attention Threshold | Risk Tolerance | Curiosity Boost |
+|---|---|---|---|
+| serene | 0.3 | 0.5 | 0.1 |
+| content | 0.4 | 0.5 | 0.15 |
+| curious | 0.2 | 0.5 | 0.2 |
+| energized | 0.3 | 0.65 | 0.1 |
+| anxious | 0.1 | 0.2 | 0.05 |
+| frustrated | 0.5 | 0.4 | 0.05 |
+| melancholic | 0.5 | 0.35 | 0.05 |
+| flat | 0.6 | 0.45 | 0.02 |
+| neutral | 0.4 | 0.5 | 0.1 |
+
+## Runner Methods
+
+| Method | Description |
+|---|---|
+| `update_mood` | Extract valence/arousal/energy from tick results and update state |
+| `current_mood` | Current mood symbol and all dimension values |
+| `mood_modulation` | Specific modulation value for the current mood |
+| `mood_history` | Recent mood state history |
+| `mood_stats` | Current mood, dominant mood, trend, modulation table |
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec
+bundle exec rubocop
+```
+
+## License
+
+MIT

data/lex-mood.gemspec

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/mood/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lex-mood'
+  spec.version       = Legion::Extensions::Mood::VERSION
+  spec.authors       = ['Esity']
+  spec.email         = ['matthewdiverson@gmail.com']
+
+  spec.summary       = 'LEX Mood'
+  spec.description   = 'Persistent mood state that emerges from emotional patterns and biases cognitive processing'
+  spec.homepage      = 'https://github.com/LegionIO/lex-mood'
+  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-mood'
+  spec.metadata['documentation_uri'] = 'https://github.com/LegionIO/lex-mood'
+  spec.metadata['changelog_uri'] = 'https://github.com/LegionIO/lex-mood'
+  spec.metadata['bug_tracker_uri'] = 'https://github.com/LegionIO/lex-mood/issues'
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    Dir.glob('{lib,spec}/**/*') + %w[lex-mood.gemspec Gemfile LICENSE README.md]
+  end
+  spec.require_paths = ['lib']
+  spec.add_development_dependency 'legion-gaia'
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Mood
+      class Client
+        include Runners::Mood
+
+        attr_reader :mood_state
+
+        def initialize(mood_state: nil, **)
+          @mood_state = mood_state || Helpers::MoodState.new
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Mood
+      module Helpers
+        module Constants
+          # Mood states (valence x arousal quadrants + neutral)
+          MOOD_STATES = %i[
+            serene
+            content
+            curious
+            energized
+            anxious
+            frustrated
+            melancholic
+            flat
+            neutral
+          ].freeze
+
+          # Mood dimensions
+          DIMENSIONS = %i[valence arousal energy stability].freeze
+
+          # EMA alpha for mood updates (slow — mood is resistant to change)
+          MOOD_ALPHA = 0.1
+
+          # How many ticks before mood recalculates
+          UPDATE_INTERVAL = 5
+
+          # Mood history capacity
+          MAX_MOOD_HISTORY = 200
+
+          # Dimension ranges for mood classification
+          MOOD_CLASSIFICATION = {
+            serene:      { valence: (0.3..), arousal: (..0.3), energy: (0.3..) },
+            content:     { valence: (0.3..), arousal: (0.3..0.6) },
+            curious:     { valence: (0.1..), arousal: (0.4..0.7), energy: (0.4..) },
+            energized:   { valence: (0.2..), arousal: (0.7..) },
+            anxious:     { valence: (..0.3), arousal: (0.6..) },
+            frustrated:  { valence: (..-0.1), arousal: (0.4..0.8) },
+            melancholic: { valence: (..-0.1), arousal: (..0.4) },
+            flat:        { valence: (-0.2..0.2), arousal: (..0.3), energy: (..0.3) }
+          }.freeze
+
+          # Modulation effects: how each mood biases cognitive processing
+          MOOD_MODULATIONS = {
+            serene:      { attention_threshold: -0.1, risk_tolerance: 0.1, curiosity_boost: 0.0 },
+            content:     { attention_threshold: 0.0, risk_tolerance: 0.05, curiosity_boost: 0.05 },
+            curious:     { attention_threshold: -0.15, risk_tolerance: 0.1, curiosity_boost: 0.2 },
+            energized:   { attention_threshold: -0.05, risk_tolerance: 0.15, curiosity_boost: 0.1 },
+            anxious:     { attention_threshold: -0.2, risk_tolerance: -0.2, curiosity_boost: -0.1 },
+            frustrated:  { attention_threshold: 0.1, risk_tolerance: -0.1, curiosity_boost: -0.15 },
+            melancholic: { attention_threshold: 0.15, risk_tolerance: -0.15, curiosity_boost: -0.2 },
+            flat:        { attention_threshold: 0.2, risk_tolerance: 0.0, curiosity_boost: -0.1 },
+            neutral:     { attention_threshold: 0.0, risk_tolerance: 0.0, curiosity_boost: 0.0 }
+          }.freeze
+
+          # Mood inertia — how resistant each mood is to change
+          MOOD_INERTIA = {
+            serene:      0.7,
+            content:     0.6,
+            curious:     0.4,
+            energized:   0.3,
+            anxious:     0.5,
+            frustrated:  0.5,
+            melancholic: 0.8,
+            flat:        0.9,
+            neutral:     0.2
+          }.freeze
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/mood/helpers/mood_state.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Mood
+      module Helpers
+        class MoodState
+          attr_reader :current_mood, :valence, :arousal, :energy, :stability, :history, :tick_counter
+
+          def initialize
+            @valence = 0.5
+            @arousal = 0.3
+            @energy = 0.5
+            @stability = 0.8
+            @current_mood = :neutral
+            @history = []
+            @tick_counter = 0
+          end
+
+          def update(inputs)
+            @tick_counter += 1
+            return @current_mood unless (@tick_counter % Constants::UPDATE_INTERVAL).zero?
+
+            alpha = effective_alpha
+            @valence = ema(@valence, inputs[:valence] || @valence, alpha)
+            @arousal = ema(@arousal, inputs[:arousal] || @arousal, alpha)
+            @energy = ema(@energy, inputs[:energy] || @energy, alpha)
+
+            compute_stability
+            classify_mood
+            record_history
+
+            @current_mood
+          end
+
+          def modulations
+            Constants::MOOD_MODULATIONS.fetch(@current_mood, Constants::MOOD_MODULATIONS[:neutral])
+          end
+
+          def inertia
+            Constants::MOOD_INERTIA.fetch(@current_mood, 0.5)
+          end
+
+          def duration_in_current_mood
+            return 0 if @history.empty?
+
+            consecutive = 0
+            @history.reverse_each do |entry|
+              break unless entry[:mood] == @current_mood
+
+              consecutive += 1
+            end
+            consecutive * Constants::UPDATE_INTERVAL
+          end
+
+          def mood_trend(window: 20)
+            recent = @history.last(window)
+            return :insufficient_data if recent.size < 3
+
+            valences = recent.map { |h| h[:valence] }
+            avg_first = valences[0...(valences.size / 2)].sum / (valences.size / 2).to_f
+            avg_second = valences[(valences.size / 2)..].sum / (valences.size - (valences.size / 2)).to_f
+
+            delta = avg_second - avg_first
+            if delta > 0.05
+              :improving
+            elsif delta < -0.05
+              :declining
+            else
+              :stable
+            end
+          end
+
+          def to_h
+            {
+              current_mood: @current_mood,
+              valence:      @valence.round(3),
+              arousal:      @arousal.round(3),
+              energy:       @energy.round(3),
+              stability:    @stability.round(3),
+              modulations:  modulations,
+              inertia:      inertia,
+              duration:     duration_in_current_mood,
+              trend:        mood_trend,
+              history_size: @history.size
+            }
+          end
+
+          private
+
+          def effective_alpha
+            base_alpha = Constants::MOOD_ALPHA
+            current_inertia = inertia
+            base_alpha * (1.0 - (current_inertia * 0.5))
+          end
+
+          def ema(current, observed, alpha)
+            ((current * (1.0 - alpha)) + (observed * alpha)).clamp(0.0, 1.0)
+          end
+
+          def compute_stability
+            return if @history.size < 3
+
+            recent_moods = @history.last(10).map { |h| h[:mood] }
+            unique_moods = recent_moods.uniq.size
+            @stability = (1.0 - (unique_moods.to_f / [recent_moods.size, 1].max)).clamp(0.0, 1.0)
+          end
+
+          def classify_mood
+            best_match = :neutral
+            best_score = 0
+
+            Constants::MOOD_CLASSIFICATION.each do |mood, criteria|
+              score = match_score(criteria)
+              if score > best_score
+                best_score = score
+                best_match = mood
+              end
+            end
+
+            @current_mood = best_match
+          end
+
+          def match_score(criteria)
+            matched = 0
+            total = criteria.size
+
+            matched += 1 if criteria[:valence]&.cover?(@valence)
+            matched += 1 if criteria[:arousal]&.cover?(@arousal)
+            matched += 1 if criteria[:energy]&.cover?(@energy)
+
+            matched.to_f / [total, 1].max
+          end
+
+          def record_history
+            @history << {
+              mood:      @current_mood,
+              valence:   @valence,
+              arousal:   @arousal,
+              energy:    @energy,
+              stability: @stability,
+              at:        Time.now.utc
+            }
+            @history = @history.last(Constants::MAX_MOOD_HISTORY)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Mood
+      module Runners
+        module Mood
+          include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers) &&
+                                                      Legion::Extensions::Helpers.const_defined?(:Lex)
+
+          def update_mood(tick_results: {}, **)
+            inputs = extract_mood_inputs(tick_results)
+            mood_state.update(inputs)
+
+            Legion::Logging.debug "[mood] #{mood_state.current_mood} (v=#{mood_state.valence.round(2)} " \
+                                  "a=#{mood_state.arousal.round(2)} e=#{mood_state.energy.round(2)})"
+
+            {
+              mood:        mood_state.current_mood,
+              valence:     mood_state.valence,
+              arousal:     mood_state.arousal,
+              energy:      mood_state.energy,
+              stability:   mood_state.stability,
+              modulations: mood_state.modulations
+            }
+          end
+
+          def current_mood(**)
+            Legion::Logging.debug "[mood] query: #{mood_state.current_mood}"
+            mood_state.to_h
+          end
+
+          def mood_modulation(parameter:, **)
+            mods = mood_state.modulations
+            value = mods[parameter.to_sym]
+
+            Legion::Logging.debug "[mood] modulation: #{parameter}=#{value} (mood=#{mood_state.current_mood})"
+
+            {
+              parameter:    parameter.to_sym,
+              modulation:   value || 0.0,
+              current_mood: mood_state.current_mood
+            }
+          end
+
+          def mood_history(limit: 20, **)
+            history = mood_state.history.last(limit)
+            {
+              entries: history.map { |h| { mood: h[:mood], valence: h[:valence], arousal: h[:arousal], at: h[:at] } },
+              trend:   mood_state.mood_trend(window: limit),
+              count:   history.size
+            }
+          end
+
+          def mood_stats(**)
+            history = mood_state.history
+            mood_counts = Hash.new(0)
+            history.each { |h| mood_counts[h[:mood]] += 1 }
+
+            dominant = mood_counts.max_by { |_, v| v }&.first
+
+            {
+              current_mood:      mood_state.current_mood,
+              stability:         mood_state.stability,
+              duration:          mood_state.duration_in_current_mood,
+              trend:             mood_state.mood_trend,
+              dominant_mood:     dominant,
+              mood_distribution: mood_counts,
+              ticks_processed:   mood_state.tick_counter
+            }
+          end
+
+          private
+
+          def mood_state
+            @mood_state ||= Helpers::MoodState.new
+          end
+
+          def extract_mood_inputs(tick_results)
+            inputs = {}
+
+            emotion = tick_results[:emotional_evaluation]
+            if emotion.is_a?(Hash)
+              inputs[:valence] = normalize_emotional_valence(emotion)
+              inputs[:arousal] = emotion[:arousal] || emotion[:magnitude] || 0.3
+            end
+
+            inputs[:energy] = extract_energy(tick_results)
+
+            inputs
+          end
+
+          def normalize_emotional_valence(emotion)
+            if emotion[:valence].is_a?(Hash)
+              dims = emotion[:valence]
+              positive = (dims[:importance] || 0) + (dims[:familiarity] || 0)
+              negative = (dims[:urgency] || 0) + (dims[:novelty] || 0)
+              ((positive - negative + 1.0) / 2.0).clamp(0.0, 1.0)
+            elsif emotion[:magnitude].is_a?(Numeric)
+              (emotion[:magnitude] + 0.5).clamp(0.0, 1.0)
+            else
+              0.5
+            end
+          end
+
+          def extract_energy(tick_results)
+            load = tick_results[:elapsed]
+            budget = tick_results[:budget]
+            return 0.5 unless load.is_a?(Numeric) && budget.is_a?(Numeric) && budget.positive?
+
+            utilization = load / budget
+            (1.0 - utilization).clamp(0.0, 1.0)
+          end
+        end
+      end
+    end
+  end
+end

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

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

data/lib/legion/extensions/mood.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/mood/version'
+require 'legion/extensions/mood/helpers/constants'
+require 'legion/extensions/mood/helpers/mood_state'
+require 'legion/extensions/mood/runners/mood'
+require 'legion/extensions/mood/client'
+
+module Legion
+  module Extensions
+    module Mood
+      extend Legion::Extensions::Core if Legion::Extensions.const_defined?(:Core)
+    end
+  end
+end

data/spec/legion/extensions/mood/client_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Mood::Client do
+  it 'creates default mood state' do
+    client = described_class.new
+    expect(client.mood_state).to be_a(Legion::Extensions::Mood::Helpers::MoodState)
+  end
+
+  it 'accepts injected mood state' do
+    state = Legion::Extensions::Mood::Helpers::MoodState.new
+    client = described_class.new(mood_state: state)
+    expect(client.mood_state).to equal(state)
+  end
+
+  it 'includes Mood runner methods' do
+    client = described_class.new
+    expect(client).to respond_to(:update_mood, :current_mood, :mood_modulation,
+                                 :mood_history, :mood_stats)
+  end
+end

data/spec/legion/extensions/mood/helpers/constants_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Mood::Helpers::Constants do
+  it 'defines 9 mood states' do
+    expect(described_class::MOOD_STATES.size).to eq(9)
+  end
+
+  it 'defines 4 dimensions' do
+    expect(described_class::DIMENSIONS).to contain_exactly(:valence, :arousal, :energy, :stability)
+  end
+
+  it 'defines modulations for every mood state' do
+    described_class::MOOD_STATES.each do |mood|
+      expect(described_class::MOOD_MODULATIONS).to have_key(mood)
+    end
+  end
+
+  it 'defines inertia for every mood state' do
+    described_class::MOOD_STATES.each do |mood|
+      expect(described_class::MOOD_INERTIA).to have_key(mood)
+    end
+  end
+
+  it 'has inertia values between 0 and 1' do
+    described_class::MOOD_INERTIA.each_value do |v|
+      expect(v).to be_between(0.0, 1.0)
+    end
+  end
+end

data/spec/legion/extensions/mood/helpers/mood_state_spec.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Mood::Helpers::MoodState do
+  subject(:state) { described_class.new }
+
+  describe '#initialize' do
+    it 'starts neutral' do
+      expect(state.current_mood).to eq(:neutral)
+    end
+
+    it 'starts with moderate values' do
+      expect(state.valence).to eq(0.5)
+      expect(state.arousal).to eq(0.3)
+      expect(state.energy).to eq(0.5)
+    end
+  end
+
+  describe '#update' do
+    it 'does not change mood before update interval' do
+      state.update(valence: 0.9, arousal: 0.1)
+      expect(state.tick_counter).to eq(1)
+      expect(state.history).to be_empty
+    end
+
+    it 'updates mood at update interval' do
+      Legion::Extensions::Mood::Helpers::Constants::UPDATE_INTERVAL.times do
+        state.update(valence: 0.8, arousal: 0.2, energy: 0.7)
+      end
+      expect(state.history.size).to eq(1)
+    end
+
+    it 'gradually shifts dimensions via EMA' do
+      original_valence = state.valence
+      Legion::Extensions::Mood::Helpers::Constants::UPDATE_INTERVAL.times do
+        state.update(valence: 0.9, arousal: 0.5, energy: 0.6)
+      end
+      expect(state.valence).to be > original_valence
+    end
+
+    it 'can reach serene mood with high valence and low arousal' do
+      20.times do
+        Legion::Extensions::Mood::Helpers::Constants::UPDATE_INTERVAL.times do
+          state.update(valence: 0.9, arousal: 0.1, energy: 0.8)
+        end
+      end
+      expect(state.current_mood).to eq(:serene)
+    end
+
+    it 'can reach anxious mood with low valence and high arousal' do
+      20.times do
+        Legion::Extensions::Mood::Helpers::Constants::UPDATE_INTERVAL.times do
+          state.update(valence: 0.1, arousal: 0.9, energy: 0.5)
+        end
+      end
+      expect(state.current_mood).to eq(:anxious)
+    end
+  end
+
+  describe '#modulations' do
+    it 'returns modulation hash for current mood' do
+      mods = state.modulations
+      expect(mods).to have_key(:attention_threshold)
+      expect(mods).to have_key(:risk_tolerance)
+      expect(mods).to have_key(:curiosity_boost)
+    end
+  end
+
+  describe '#inertia' do
+    it 'returns inertia value for current mood' do
+      expect(state.inertia).to be_a(Numeric)
+      expect(state.inertia).to be_between(0.0, 1.0)
+    end
+  end
+
+  describe '#duration_in_current_mood' do
+    it 'returns 0 with no history' do
+      expect(state.duration_in_current_mood).to eq(0)
+    end
+  end
+
+  describe '#mood_trend' do
+    it 'returns :insufficient_data with few entries' do
+      expect(state.mood_trend).to eq(:insufficient_data)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns complete state hash' do
+      h = state.to_h
+      expect(h).to include(:current_mood, :valence, :arousal, :energy,
+                           :stability, :modulations, :inertia, :trend)
+    end
+  end
+end

data/spec/legion/extensions/mood/runners/mood_spec.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Mood::Runners::Mood do
+  let(:client) { Legion::Extensions::Mood::Client.new }
+
+  let(:tick_results) do
+    {
+      emotional_evaluation: { magnitude: 0.6, arousal: 0.4 },
+      elapsed:              2.0,
+      budget:               5.0
+    }
+  end
+
+  describe '#update_mood' do
+    it 'returns mood state' do
+      result = client.update_mood(tick_results: tick_results)
+      expect(result).to have_key(:mood)
+      expect(result).to have_key(:modulations)
+    end
+
+    it 'handles empty tick results' do
+      result = client.update_mood(tick_results: {})
+      expect(result[:mood]).to be_a(Symbol)
+    end
+
+    it 'handles valence hash from emotion' do
+      results = tick_results.merge(
+        emotional_evaluation: {
+          valence: { urgency: 0.2, importance: 0.6, novelty: 0.3, familiarity: 0.7 },
+          arousal: 0.5
+        }
+      )
+      result = client.update_mood(tick_results: results)
+      expect(result[:mood]).to be_a(Symbol)
+    end
+  end
+
+  describe '#current_mood' do
+    it 'returns full mood state' do
+      result = client.current_mood
+      expect(result).to include(:current_mood, :valence, :arousal, :energy, :stability)
+    end
+  end
+
+  describe '#mood_modulation' do
+    it 'returns modulation for a parameter' do
+      result = client.mood_modulation(parameter: :curiosity_boost)
+      expect(result[:parameter]).to eq(:curiosity_boost)
+      expect(result[:modulation]).to be_a(Numeric)
+    end
+
+    it 'returns 0.0 for unknown parameter' do
+      result = client.mood_modulation(parameter: :nonexistent)
+      expect(result[:modulation]).to eq(0.0)
+    end
+  end
+
+  describe '#mood_history' do
+    it 'returns empty history initially' do
+      result = client.mood_history
+      expect(result[:entries]).to be_empty
+    end
+  end
+
+  describe '#mood_stats' do
+    it 'returns stats summary' do
+      result = client.mood_stats
+      expect(result).to include(:current_mood, :stability, :trend, :ticks_processed)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Legion
+  module Logging
+    module_function
+
+    def debug(*); end
+
+    def info(*); end
+
+    def warn(*); end
+
+    def error(*); end
+  end
+
+  module Extensions
+    module Helpers; end
+  end
+end
+
+require 'legion/extensions/mood'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+  config.order = :random
+  Kernel.srand config.seed
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: lex-mood
+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-gaia
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Persistent mood state that emerges from emotional patterns and biases
+  cognitive processing
+email:
+- matthewdiverson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- README.md
+- lex-mood.gemspec
+- lib/legion/extensions/mood.rb
+- lib/legion/extensions/mood/client.rb
+- lib/legion/extensions/mood/helpers/constants.rb
+- lib/legion/extensions/mood/helpers/mood_state.rb
+- lib/legion/extensions/mood/runners/mood.rb
+- lib/legion/extensions/mood/version.rb
+- spec/legion/extensions/mood/client_spec.rb
+- spec/legion/extensions/mood/helpers/constants_spec.rb
+- spec/legion/extensions/mood/helpers/mood_state_spec.rb
+- spec/legion/extensions/mood/runners/mood_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/LegionIO/lex-mood
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-mood
+  source_code_uri: https://github.com/LegionIO/lex-mood
+  documentation_uri: https://github.com/LegionIO/lex-mood
+  changelog_uri: https://github.com/LegionIO/lex-mood
+  bug_tracker_uri: https://github.com/LegionIO/lex-mood/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: LEX Mood
+test_files: []