lex-agentic-affect 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d3edfb8ca48c97428f04fd913693fcffb129c1ee5bb8779be2dbd61ffeeeeed6
-  data.tar.gz: 6443631b15f56be9897948a5149912af86d203e81cc893ad86fe6e8d258e2122
+  metadata.gz: 74630b3aaa2366764ebb2af5fe332a6ce6b51778f2c6bcc22669348e051bf9f7
+  data.tar.gz: a241ea19f718a589b0bb0a3ef609d7dbf16bfad7ada03cb2a29288910779a26c
 SHA512:
-  metadata.gz: d28e2998e7ae2f15c19754565e8bb2fa92b67d4a9727f9e9d232cbff5c39e235570da1aa2e306363a1cc6a15f7476794bdc12bcebe7690efb0e1cc5819bc3926
-  data.tar.gz: 8d6c801d3769cb4b10db6db28eb62e81726c8213981e1fb5d2c92b61e9b625c714c7ce48f39928315e22cd406601992a165ce9db053d1f9b356c3b081bc13b74
+  metadata.gz: 560024c502ab7b4b43995b330dd7b17f8f7b086c8afbcbd9c48798d895a25ada189bb3e9deb34ce606be7206cb4a6264df98940c05b811bda0c560dc11317f12
+  data.tar.gz: fd7148b82824f8d2079bbdf8508bd9ff1031d11eb68ee00d78ca2eb52f6848dc401c0d444d976b8761224f2f7f90bb9ed8e9f6e46a85dbdd5c2056e0882b14b4

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [0.1.7] - 2026-03-31
+
+### Added
+- Empathy: `MentalModel` tracks `bond_role` and `channel`; partners start with 0.8 confidence
+- Empathy: `ModelStore#update_from_human_observation` processes GAIA partner observation hashes
+- Empathy: `ModelStore` Apollo Local persistence — `dirty?`, `mark_clean!`, `to_apollo_entries`, `from_apollo`
+- Empathy runner: `observe_human_observations(human_observations:)` processes GAIA-passed obs arrays
+- CognitiveEmpathy runner: `process_human_observations(human_observations:)` — perspective tracking + contagion (partner virulence 0.3, unknown 0.05)
+- Valence: `:direct_address` source urgency 0.8 added to `SOURCE_URGENCY`
+- MoodState: Apollo Local persistence — `dirty?`, `mark_clean!`, `to_apollo_entries`, `from_apollo`
+- `PersonalityState`: new class modeling Big Five OCEAN traits with Apollo Local persistence
+
 ## [0.1.6] - 2026-03-30
 
 ### Changed

data/lib/legion/extensions/agentic/affect/cognitive_empathy/runners/cognitive_empathy.rb

@@ -10,6 +10,28 @@ module Legion
               include Helpers::Constants
               include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
 
+              def process_human_observations(human_observations: [], **)
+                return { processed: 0 } if human_observations.empty?
+
+                human_observations.each do |obs|
+                  identity  = obs[:identity].to_s
+                  bond_role = obs[:bond_role] || :unknown
+
+                  take_empathic_perspective(
+                    agent_id:         identity,
+                    perspective_type: :affective,
+                    predicted_state:  { bond_role: bond_role, channel: obs[:channel] },
+                    confidence:       bond_role == :partner ? 0.7 : 0.4
+                  )
+
+                  virulence = bond_role == :partner ? 0.3 : 0.05
+                  engine.emotional_contagion(emotion_valence: 0.5, intensity: virulence)
+                end
+
+                log.debug("[cognitive_empathy] process_human_observations: count=#{human_observations.size}")
+                { processed: human_observations.size }
+              end
+
               def take_empathic_perspective(agent_id:, perspective_type:, predicted_state:, confidence: 0.5, **)
                 perspective = engine.take_perspective(
                   agent_id:         agent_id,

data/lib/legion/extensions/agentic/affect/emotion/helpers/valence.rb

@@ -23,6 +23,7 @@ module Legion
               SOURCE_URGENCY = {
                 firmware_violation: 1.0,
                 human_direct:       0.9,
+                direct_address:     0.8,
                 mesh_priority:      0.7,
                 scheduled:          0.4,
                 ambient:            0.1

data/lib/legion/extensions/agentic/affect/empathy/helpers/mental_model.rb

@@ -9,14 +9,16 @@ module Legion
             class MentalModel
               attr_reader :agent_id, :believed_goal, :emotional_state, :attention_focus,
                           :confidence_level, :cooperation_stance, :interaction_history,
-                          :predictions, :created_at, :updated_at
+                          :predictions, :created_at, :updated_at, :bond_role, :channel
 
-              def initialize(agent_id:)
+              def initialize(agent_id:, bond_role: :unknown, channel: nil, confidence: nil)
                 @agent_id = agent_id
+                @bond_role = bond_role
+                @channel = channel
                 @believed_goal = nil
                 @emotional_state = :unknown
                 @attention_focus = nil
-                @confidence_level = 0.5
+                @confidence_level = confidence || partner_default_confidence(bond_role)
                 @cooperation_stance = :unknown
                 @interaction_history = []
                 @predictions = []
@@ -83,6 +85,8 @@ module Legion
               def to_h
                 {
                   agent_id:            @agent_id,
+                  bond_role:           @bond_role,
+                  channel:             @channel,
                   believed_goal:       @believed_goal,
                   emotional_state:     @emotional_state,
                   attention_focus:     @attention_focus,
@@ -99,6 +103,10 @@ module Legion
 
               private
 
+              def partner_default_confidence(bond_role)
+                bond_role == :partner ? 0.8 : 0.5
+              end
+
               def update_believed_goal(goal)
                 @believed_goal = goal
               end

data/lib/legion/extensions/agentic/affect/empathy/helpers/model_store.rb

@@ -11,6 +11,7 @@ module Legion
 
               def initialize
                 @models = {}
+                @dirty = false
               end
 
               def get(agent_id)
@@ -29,6 +30,66 @@ module Legion
                 model
               end
 
+              def update_from_human_observation(observation)
+                identity   = observation[:identity].to_s
+                bond_role  = observation[:bond_role] || :unknown
+                channel    = observation[:channel]
+
+                key = identity
+                model = @models[key] ||= MentalModel.new(agent_id: key, bond_role: bond_role, channel: channel)
+                evidence = bond_role == :partner ? 0.8 : 0.5
+                model.update_from_observation(
+                  interaction_type:  :human_observation,
+                  evidence_strength: evidence,
+                  summary:           "channel=#{channel} content_type=#{observation[:content_type]} " \
+                                     "length=#{observation[:content_length]}"
+                )
+                evict_if_needed
+                @dirty = true
+                model
+              end
+
+              def dirty?
+                @dirty
+              end
+
+              def mark_clean!
+                @dirty = false
+              end
+
+              def to_apollo_entries
+                @models.values.map do |model|
+                  data = model.to_h.merge(
+                    created_at: model.created_at.iso8601,
+                    updated_at: model.updated_at.iso8601
+                  )
+                  {
+                    content: ::JSON.generate(data.transform_keys(&:to_s)),
+                    tags:    ['empathy', 'mental_model', model.agent_id]
+                  }
+                end
+              end
+
+              def from_apollo(store:)
+                entries = store.query(tags: %w[empathy mental_model])
+                entries.each do |entry|
+                  data = ::JSON.parse(entry[:content])
+                  agent_id = data['agent_id']
+                  next unless agent_id
+
+                  bond_role  = data['bond_role']&.to_sym || :unknown
+                  channel    = data['channel']&.to_sym
+                  confidence = data['confidence_level']
+
+                  model = MentalModel.new(agent_id: agent_id, bond_role: bond_role,
+                                          channel: channel, confidence: confidence)
+                  @models[agent_id] = model
+                rescue ::JSON::ParserError => e
+                  warn "[empathy] from_apollo: skipping invalid entry: #{e.message}"
+                  next
+                end
+              end
+
               def predict(agent_id, scenario)
                 model = get(agent_id)
                 return nil unless model

data/lib/legion/extensions/agentic/affect/empathy/runners/empathy.rb

@@ -10,6 +10,20 @@ module Legion
               include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
                                                           Legion::Extensions::Helpers.const_defined?(:Lex, false)
 
+              def observe_human_observations(human_observations: [], **)
+                return { observed: 0, identities: [] } if human_observations.empty?
+
+                identities = human_observations.map do |obs|
+                  model_store.update_from_human_observation(obs)
+                  obs[:identity].to_s
+                end
+
+                log.debug("[empathy] human_observations: count=#{identities.size} " \
+                          "identities=#{identities.join(',')}")
+
+                { observed: identities.size, identities: identities }
+              end
+
               def observe_agent(agent_id:, observation: {}, **)
                 model = model_store.update(agent_id, observation)
                 log.debug("[empathy] observed: agent=#{agent_id} emotion=#{model.emotional_state} " \

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

@@ -9,6 +9,8 @@ module Legion
             class MoodState
               attr_reader :current_mood, :valence, :arousal, :energy, :stability, :history, :tick_counter
 
+              DIRTY_THRESHOLD = 0.02
+
               def initialize
                 @valence = 0.5
                 @arousal = 0.3
@@ -17,6 +19,8 @@ module Legion
                 @current_mood = :neutral
                 @history = []
                 @tick_counter = 0
+                @dirty = false
+                @last_persisted_valence = @valence
               end
 
               def update(inputs)
@@ -31,10 +35,42 @@ module Legion
                 compute_stability
                 classify_mood
                 record_history
+                check_dirty
 
                 @current_mood
               end
 
+              def dirty?
+                @dirty
+              end
+
+              def mark_clean!
+                @dirty = false
+                @last_persisted_valence = @valence
+              end
+
+              def to_apollo_entries
+                [{
+                  content: ::JSON.generate(to_h.transform_keys(&:to_s).except('modulations')),
+                  tags:    %w[affect state global]
+                }]
+              end
+
+              def from_apollo(store:)
+                entries = store.query(tags: %w[affect state global])
+                return if entries.empty?
+
+                data = ::JSON.parse(entries.first[:content])
+                @valence = data['valence'].to_f if data['valence']
+                @arousal = data['arousal'].to_f if data['arousal']
+                @energy  = data['energy'].to_f  if data['energy']
+                @current_mood = data['current_mood']&.to_sym || @current_mood
+                @last_persisted_valence = @valence
+                @dirty = false
+              rescue ::JSON::ParserError => e
+                warn "[mood_state] from_apollo: invalid entry: #{e.message}"
+              end
+
               def modulations
                 Constants::MOOD_MODULATIONS.fetch(@current_mood, Constants::MOOD_MODULATIONS[:neutral])
               end
@@ -90,6 +126,10 @@ module Legion
 
               private
 
+              def check_dirty
+                @dirty = true if (@valence - @last_persisted_valence).abs >= DIRTY_THRESHOLD
+              end
+
               def effective_alpha
                 base_alpha = Constants::MOOD_ALPHA
                 current_inertia = inertia

data/lib/legion/extensions/agentic/affect/personality_state.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Agentic
+      module Affect
+        # PersonalityState models the Big Five (OCEAN) personality dimensions as global
+        # affect modifiers. Traits persist to Apollo Local tagged ['personality', 'ocean', 'global'].
+        class PersonalityState
+          TRAITS = %i[openness conscientiousness extraversion agreeableness neuroticism].freeze
+          DIRTY_THRESHOLD = 0.02
+
+          attr_reader(*TRAITS)
+
+          def initialize
+            TRAITS.each { |t| instance_variable_set(:"@#{t}", 0.5) }
+            @dirty = false
+            @last_persisted = snapshot
+          end
+
+          def update_trait(trait, value)
+            return unless TRAITS.include?(trait)
+
+            clamped = value.to_f.clamp(0.0, 1.0)
+            instance_variable_set(:"@#{trait}", clamped)
+            @dirty = true if (clamped - @last_persisted[trait]).abs >= DIRTY_THRESHOLD
+          end
+
+          def dirty?
+            @dirty
+          end
+
+          def mark_clean!
+            @dirty = false
+            @last_persisted = snapshot
+          end
+
+          def to_apollo_entries
+            [{
+              content: ::JSON.generate(to_h.transform_keys(&:to_s)),
+              tags:    %w[personality ocean global]
+            }]
+          end
+
+          def from_apollo(store:)
+            entries = store.query(tags: %w[personality ocean global])
+            return if entries.empty?
+
+            data = ::JSON.parse(entries.first[:content])
+            TRAITS.each do |trait|
+              val = data[trait.to_s]
+              instance_variable_set(:"@#{trait}", val.to_f.clamp(0.0, 1.0)) if val
+            end
+            @last_persisted = snapshot
+            @dirty = false
+          rescue ::JSON::ParserError => e
+            warn "[personality_state] from_apollo: invalid entry: #{e.message}"
+          end
+
+          def to_h
+            TRAITS.to_h { |t| [t, instance_variable_get(:"@#{t}")] }
+          end
+
+          private
+
+          def snapshot
+            TRAITS.to_h { |t| [t, instance_variable_get(:"@#{t}")] }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/agentic/affect/version.rb

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Agentic
       module Affect
-        VERSION = '0.1.6'
+        VERSION = '0.1.7'
       end
     end
   end

data/lib/legion/extensions/agentic/affect.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'affect/version'
+require_relative 'affect/personality_state'
 require_relative 'affect/cognitive_empathy'
 require_relative 'affect/reappraisal'
 require_relative 'affect/defusion'

data/spec/legion/extensions/agentic/affect/cognitive_empathy/runners/cognitive_empathy_human_obs_spec.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::CognitiveEmpathy::Runners::CognitiveEmpathy do
+  let(:runner) do
+    obj = Object.new
+    obj.extend(described_class)
+    obj
+  end
+
+  let(:partner_obs) do
+    {
+      identity:       'esity',
+      bond_role:      :partner,
+      channel:        :cli,
+      content_type:   :text,
+      content_length: 80,
+      direct_address: true,
+      timestamp:      Time.now.utc
+    }
+  end
+
+  let(:unknown_obs) do
+    {
+      identity:       'stranger',
+      bond_role:      :unknown,
+      channel:        :teams,
+      content_type:   :text,
+      content_length: 10,
+      direct_address: false,
+      timestamp:      Time.now.utc
+    }
+  end
+
+  describe '#process_human_observations' do
+    it 'returns empty result for empty array' do
+      result = runner.process_human_observations(human_observations: [])
+      expect(result[:processed]).to eq(0)
+    end
+
+    it 'processes a partner observation and creates a perspective' do
+      result = runner.process_human_observations(human_observations: [partner_obs])
+      expect(result[:processed]).to eq(1)
+    end
+
+    it 'processes multiple observations' do
+      result = runner.process_human_observations(human_observations: [partner_obs, unknown_obs])
+      expect(result[:processed]).to eq(2)
+    end
+
+    it 'applies contagion with higher virulence for partner bond_role' do
+      before_level = runner.current_empathic_state[:contagion_level]
+      runner.process_human_observations(human_observations: [partner_obs])
+      after_level = runner.current_empathic_state[:contagion_level]
+      expect(after_level).to be >= before_level
+    end
+
+    it 'applies contagion with lower virulence for unknown bond_role' do
+      runner.process_human_observations(human_observations: [unknown_obs])
+      result = runner.current_empathic_state
+      expect(result[:contagion_level]).to be >= 0.0
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/emotion/helpers/valence_direct_address_spec.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Emotion::Helpers::Valence do
+  describe 'SOURCE_URGENCY' do
+    it 'includes :direct_address with urgency 0.8' do
+      expect(described_class::SOURCE_URGENCY[:direct_address]).to eq(0.8)
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/empathy/helpers/model_store_apollo_spec.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Empathy::Helpers::ModelStore do
+  subject(:store) { described_class.new }
+
+  let(:obs_partner) do
+    {
+      identity:       'esity',
+      bond_role:      :partner,
+      channel:        :cli,
+      content_type:   :text,
+      content_length: 80,
+      direct_address: true,
+      timestamp:      Time.now.utc
+    }
+  end
+
+  let(:obs_unknown) do
+    {
+      identity:       'stranger',
+      bond_role:      :unknown,
+      channel:        :teams,
+      content_type:   :text,
+      content_length: 20,
+      direct_address: false,
+      timestamp:      Time.now.utc
+    }
+  end
+
+  describe '#update_from_human_observation' do
+    it 'creates a model for the observed identity' do
+      model = store.update_from_human_observation(obs_partner)
+      expect(model.agent_id).to eq('esity')
+    end
+
+    it 'sets confidence to 0.8 for partner bond_role' do
+      model = store.update_from_human_observation(obs_partner)
+      expect(model.confidence_level).to be_within(0.05).of(0.8)
+    end
+
+    it 'sets confidence near 0.5 for unknown bond_role' do
+      model = store.update_from_human_observation(obs_unknown)
+      expect(model.confidence_level).to be_within(0.1).of(0.5)
+    end
+
+    it 'stores bond_role on the model' do
+      model = store.update_from_human_observation(obs_partner)
+      expect(model.bond_role).to eq(:partner)
+    end
+
+    it 'stores channel on the model' do
+      model = store.update_from_human_observation(obs_partner)
+      expect(model.channel).to eq(:cli)
+    end
+
+    it 'increments store size' do
+      store.update_from_human_observation(obs_partner)
+      store.update_from_human_observation(obs_unknown)
+      expect(store.size).to eq(2)
+    end
+  end
+
+  describe '#dirty?' do
+    it 'is false on new store' do
+      expect(store.dirty?).to be false
+    end
+
+    it 'is true after an update_from_human_observation' do
+      store.update_from_human_observation(obs_partner)
+      expect(store.dirty?).to be true
+    end
+
+    it 'is false after mark_clean!' do
+      store.update_from_human_observation(obs_partner)
+      store.mark_clean!
+      expect(store.dirty?).to be false
+    end
+  end
+
+  describe '#mark_clean!' do
+    it 'resets dirty flag' do
+      store.update_from_human_observation(obs_partner)
+      store.mark_clean!
+      expect(store.dirty?).to be false
+    end
+  end
+
+  describe '#to_apollo_entries' do
+    it 'returns empty array when store is empty' do
+      expect(store.to_apollo_entries).to eq([])
+    end
+
+    it 'returns one entry per model' do
+      store.update_from_human_observation(obs_partner)
+      store.update_from_human_observation(obs_unknown)
+      expect(store.to_apollo_entries.size).to eq(2)
+    end
+
+    it 'includes empathy, mental_model, and agent_id in tags' do
+      store.update_from_human_observation(obs_partner)
+      entry = store.to_apollo_entries.first
+      expect(entry[:tags]).to include('empathy', 'mental_model', 'esity')
+    end
+
+    it 'serializes content as a JSON string' do
+      store.update_from_human_observation(obs_partner)
+      entry = store.to_apollo_entries.first
+      parsed = JSON.parse(entry[:content])
+      expect(parsed['agent_id']).to eq('esity')
+      expect(parsed).to have_key('confidence_level')
+    end
+  end
+
+  describe '#from_apollo' do
+    it 'restores models from apollo entries' do
+      store.update_from_human_observation(obs_partner)
+      entries = store.to_apollo_entries
+
+      new_store = described_class.new
+      apollo_stub = double('apollo_local')
+      allow(apollo_stub).to receive(:query).and_return(entries.map { |e| { content: e[:content] } })
+
+      new_store.from_apollo(store: apollo_stub)
+      expect(new_store.size).to eq(1)
+      expect(new_store.get('esity')).not_to be_nil
+    end
+
+    it 'restores bond_role on loaded model' do
+      store.update_from_human_observation(obs_partner)
+      entries = store.to_apollo_entries
+
+      new_store = described_class.new
+      apollo_stub = double('apollo_local')
+      allow(apollo_stub).to receive(:query).and_return(entries.map { |e| { content: e[:content] } })
+
+      new_store.from_apollo(store: apollo_stub)
+      expect(new_store.get('esity').bond_role).to eq(:partner)
+    end
+
+    it 'handles empty apollo result gracefully' do
+      apollo_stub = double('apollo_local')
+      allow(apollo_stub).to receive(:query).and_return([])
+      expect { store.from_apollo(store: apollo_stub) }.not_to raise_error
+      expect(store.size).to eq(0)
+    end
+
+    it 'skips entries with invalid JSON content' do
+      apollo_stub = double('apollo_local')
+      allow(apollo_stub).to receive(:query).and_return([{ content: 'not_json' }])
+      expect { store.from_apollo(store: apollo_stub) }.not_to raise_error
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/empathy/runners/empathy_human_obs_spec.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Empathy::Runners::Empathy do
+  let(:client) { Legion::Extensions::Agentic::Affect::Empathy::Client.new }
+
+  let(:partner_obs) do
+    {
+      identity:       'esity',
+      bond_role:      :partner,
+      channel:        :cli,
+      content_type:   :text,
+      content_length: 50,
+      direct_address: true,
+      timestamp:      Time.now.utc
+    }
+  end
+
+  let(:known_obs) do
+    {
+      identity:       'alice',
+      bond_role:      :known,
+      channel:        :teams,
+      content_type:   :text,
+      content_length: 20,
+      direct_address: false,
+      timestamp:      Time.now.utc
+    }
+  end
+
+  describe '#observe_human_observations' do
+    it 'returns empty result for empty array' do
+      result = client.observe_human_observations(human_observations: [])
+      expect(result[:observed]).to eq(0)
+    end
+
+    it 'processes a single partner observation' do
+      result = client.observe_human_observations(human_observations: [partner_obs])
+      expect(result[:observed]).to eq(1)
+      expect(result[:identities]).to include('esity')
+    end
+
+    it 'processes multiple observations' do
+      result = client.observe_human_observations(human_observations: [partner_obs, known_obs])
+      expect(result[:observed]).to eq(2)
+      expect(result[:identities]).to include('esity', 'alice')
+    end
+
+    it 'creates mental models for each identity' do
+      client.observe_human_observations(human_observations: [partner_obs])
+      model = client.model_store.get('esity')
+      expect(model).not_to be_nil
+    end
+
+    it 'sets higher confidence for partner bond_role' do
+      client.observe_human_observations(human_observations: [partner_obs])
+      model = client.model_store.get('esity')
+      expect(model.confidence_level).to be > 0.7
+    end
+
+    it 'marks store as dirty after observations' do
+      client.observe_human_observations(human_observations: [partner_obs])
+      expect(client.model_store.dirty?).to be true
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/mood/helpers/mood_state_apollo_spec.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::Mood::Helpers::MoodState do
+  subject(:state) { described_class.new }
+
+  describe '#dirty?' do
+    it 'is false on a fresh state' do
+      expect(state.dirty?).to be false
+    end
+
+    it 'is true after an update that crosses the update interval' do
+      Legion::Extensions::Agentic::Affect::Mood::Helpers::Constants::UPDATE_INTERVAL.times do
+        state.update(valence: 0.8, arousal: 0.2, energy: 0.7)
+      end
+      expect(state.dirty?).to be true
+    end
+  end
+
+  describe '#mark_clean!' do
+    it 'resets dirty flag' do
+      Legion::Extensions::Agentic::Affect::Mood::Helpers::Constants::UPDATE_INTERVAL.times do
+        state.update(valence: 0.8, arousal: 0.2, energy: 0.7)
+      end
+      state.mark_clean!
+      expect(state.dirty?).to be false
+    end
+  end
+
+  describe '#to_apollo_entries' do
+    it 'returns an array with a single entry' do
+      entries = state.to_apollo_entries
+      expect(entries).to be_an(Array)
+      expect(entries.size).to eq(1)
+    end
+
+    it 'tags the entry with affect, state, and global' do
+      entry = state.to_apollo_entries.first
+      expect(entry[:tags]).to include('affect', 'state', 'global')
+    end
+
+    it 'serializes mood, valence, and arousal in content' do
+      entry = state.to_apollo_entries.first
+      parsed = JSON.parse(entry[:content])
+      expect(parsed).to have_key('current_mood')
+      expect(parsed).to have_key('valence')
+      expect(parsed).to have_key('arousal')
+      expect(parsed).to have_key('energy')
+    end
+  end
+
+  describe '#from_apollo' do
+    it 'restores valence, arousal, and energy from stored entry' do
+      # Drive state to a non-default value
+      20.times do
+        Legion::Extensions::Agentic::Affect::Mood::Helpers::Constants::UPDATE_INTERVAL.times do
+          state.update(valence: 0.9, arousal: 0.8, energy: 0.7)
+        end
+      end
+      entries = state.to_apollo_entries
+
+      new_state = described_class.new
+      apollo_stub = double('apollo_local')
+      allow(apollo_stub).to receive(:query).and_return(entries.map { |e| { content: e[:content] } })
+
+      new_state.from_apollo(store: apollo_stub)
+      expect(new_state.valence).to be_within(0.1).of(state.valence)
+    end
+
+    it 'handles empty apollo result gracefully' do
+      apollo_stub = double('apollo_local')
+      allow(apollo_stub).to receive(:query).and_return([])
+      expect { state.from_apollo(store: apollo_stub) }.not_to raise_error
+    end
+
+    it 'handles invalid JSON gracefully' do
+      apollo_stub = double('apollo_local')
+      allow(apollo_stub).to receive(:query).and_return([{ content: 'bad_json{' }])
+      expect { state.from_apollo(store: apollo_stub) }.not_to raise_error
+    end
+  end
+end

data/spec/legion/extensions/agentic/affect/personality_state_spec.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Affect::PersonalityState do
+  subject(:ps) { described_class.new }
+
+  describe '#initialize' do
+    it 'starts with neutral OCEAN traits at 0.5' do
+      expect(ps.openness).to eq(0.5)
+      expect(ps.conscientiousness).to eq(0.5)
+      expect(ps.extraversion).to eq(0.5)
+      expect(ps.agreeableness).to eq(0.5)
+      expect(ps.neuroticism).to eq(0.5)
+    end
+
+    it 'is not dirty initially' do
+      expect(ps.dirty?).to be false
+    end
+  end
+
+  describe '#update_trait' do
+    it 'updates a single trait' do
+      ps.update_trait(:openness, 0.8)
+      expect(ps.openness).to be_within(0.01).of(0.8)
+    end
+
+    it 'marks dirty after a significant change' do
+      ps.update_trait(:openness, 0.9)
+      expect(ps.dirty?).to be true
+    end
+
+    it 'does not mark dirty for a tiny change below threshold' do
+      ps.update_trait(:openness, 0.501)
+      expect(ps.dirty?).to be false
+    end
+
+    it 'clamps values to [0.0, 1.0]' do
+      ps.update_trait(:openness, 1.5)
+      expect(ps.openness).to eq(1.0)
+      ps.update_trait(:openness, -0.5)
+      expect(ps.openness).to eq(0.0)
+    end
+  end
+
+  describe '#mark_clean!' do
+    it 'resets dirty flag' do
+      ps.update_trait(:openness, 0.9)
+      ps.mark_clean!
+      expect(ps.dirty?).to be false
+    end
+  end
+
+  describe '#to_apollo_entries' do
+    it 'returns one entry' do
+      entries = ps.to_apollo_entries
+      expect(entries.size).to eq(1)
+    end
+
+    it 'tags the entry with personality, ocean, and global' do
+      entry = ps.to_apollo_entries.first
+      expect(entry[:tags]).to include('personality', 'ocean', 'global')
+    end
+
+    it 'serializes all 5 OCEAN traits in content' do
+      entry = ps.to_apollo_entries.first
+      parsed = JSON.parse(entry[:content])
+      expect(parsed).to have_key('openness')
+      expect(parsed).to have_key('conscientiousness')
+      expect(parsed).to have_key('extraversion')
+      expect(parsed).to have_key('agreeableness')
+      expect(parsed).to have_key('neuroticism')
+    end
+  end
+
+  describe '#from_apollo' do
+    it 'restores OCEAN traits from stored entry' do
+      ps.update_trait(:openness, 0.9)
+      ps.update_trait(:neuroticism, 0.2)
+      entries = ps.to_apollo_entries
+
+      new_ps = described_class.new
+      apollo_stub = double('apollo_local')
+      allow(apollo_stub).to receive(:query).and_return(entries.map { |e| { content: e[:content] } })
+
+      new_ps.from_apollo(store: apollo_stub)
+      expect(new_ps.openness).to eq(0.9)
+      expect(new_ps.neuroticism).to eq(0.2)
+    end
+
+    it 'handles empty apollo result gracefully' do
+      apollo_stub = double('apollo_local')
+      allow(apollo_stub).to receive(:query).and_return([])
+      expect { ps.from_apollo(store: apollo_stub) }.not_to raise_error
+    end
+
+    it 'handles invalid JSON gracefully' do
+      apollo_stub = double('apollo_local')
+      allow(apollo_stub).to receive(:query).and_return([{ content: 'bad{json' }])
+      expect { ps.from_apollo(store: apollo_stub) }.not_to raise_error
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns hash of all 5 traits' do
+      h = ps.to_h
+      expect(h.keys).to include(:openness, :conscientiousness, :extraversion, :agreeableness, :neuroticism)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-agentic-affect
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - Esity
@@ -240,6 +240,7 @@ files:
 - lib/legion/extensions/agentic/affect/motivation/helpers/motivation_store.rb
 - lib/legion/extensions/agentic/affect/motivation/runners/motivation.rb
 - lib/legion/extensions/agentic/affect/motivation/version.rb
+- lib/legion/extensions/agentic/affect/personality_state.rb
 - lib/legion/extensions/agentic/affect/reappraisal.rb
 - lib/legion/extensions/agentic/affect/reappraisal/actors/auto_regulate.rb
 - lib/legion/extensions/agentic/affect/reappraisal/client.rb
@@ -294,6 +295,7 @@ files:
 - spec/legion/extensions/agentic/affect/cognitive_empathy/client_spec.rb
 - spec/legion/extensions/agentic/affect/cognitive_empathy/helpers/empathy_engine_spec.rb
 - spec/legion/extensions/agentic/affect/cognitive_empathy/helpers/perspective_spec.rb
+- spec/legion/extensions/agentic/affect/cognitive_empathy/runners/cognitive_empathy_human_obs_spec.rb
 - spec/legion/extensions/agentic/affect/cognitive_empathy/runners/cognitive_empathy_spec.rb
 - spec/legion/extensions/agentic/affect/contagion/client_spec.rb
 - spec/legion/extensions/agentic/affect/contagion/helpers/constants_spec.rb
@@ -309,13 +311,16 @@ files:
 - spec/legion/extensions/agentic/affect/emotion/client_spec.rb
 - spec/legion/extensions/agentic/affect/emotion/helpers/baseline_spec.rb
 - spec/legion/extensions/agentic/affect/emotion/helpers/momentum_spec.rb
+- spec/legion/extensions/agentic/affect/emotion/helpers/valence_direct_address_spec.rb
 - spec/legion/extensions/agentic/affect/emotion/helpers/valence_spec.rb
 - spec/legion/extensions/agentic/affect/emotion/runners/gut_spec.rb
 - spec/legion/extensions/agentic/affect/emotion/runners/valence_spec.rb
 - spec/legion/extensions/agentic/affect/empathy/client_spec.rb
 - spec/legion/extensions/agentic/affect/empathy/helpers/constants_spec.rb
 - spec/legion/extensions/agentic/affect/empathy/helpers/mental_model_spec.rb
+- spec/legion/extensions/agentic/affect/empathy/helpers/model_store_apollo_spec.rb
 - spec/legion/extensions/agentic/affect/empathy/helpers/model_store_spec.rb
+- spec/legion/extensions/agentic/affect/empathy/runners/empathy_human_obs_spec.rb
 - spec/legion/extensions/agentic/affect/empathy/runners/empathy_spec.rb
 - spec/legion/extensions/agentic/affect/fatigue/client_spec.rb
 - spec/legion/extensions/agentic/affect/fatigue/helpers/constants_spec.rb
@@ -332,6 +337,7 @@ files:
 - spec/legion/extensions/agentic/affect/interoception/runners/interoception_spec.rb
 - spec/legion/extensions/agentic/affect/mood/client_spec.rb
 - spec/legion/extensions/agentic/affect/mood/helpers/constants_spec.rb
+- spec/legion/extensions/agentic/affect/mood/helpers/mood_state_apollo_spec.rb
 - spec/legion/extensions/agentic/affect/mood/helpers/mood_state_spec.rb
 - spec/legion/extensions/agentic/affect/mood/runners/mood_spec.rb
 - spec/legion/extensions/agentic/affect/motivation/client_spec.rb
@@ -339,6 +345,7 @@ files:
 - spec/legion/extensions/agentic/affect/motivation/helpers/drive_state_spec.rb
 - spec/legion/extensions/agentic/affect/motivation/helpers/motivation_store_spec.rb
 - spec/legion/extensions/agentic/affect/motivation/runners/motivation_spec.rb
+- spec/legion/extensions/agentic/affect/personality_state_spec.rb
 - spec/legion/extensions/agentic/affect/reappraisal/actors/auto_regulate_spec.rb
 - spec/legion/extensions/agentic/affect/reappraisal/client_spec.rb
 - spec/legion/extensions/agentic/affect/reappraisal/helpers/constants_spec.rb