lex-somatic-marker 0.1.0

data/lib/legion/extensions/somatic_marker.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/somatic_marker/version'
+require 'legion/extensions/somatic_marker/helpers/constants'
+require 'legion/extensions/somatic_marker/helpers/somatic_marker'
+require 'legion/extensions/somatic_marker/helpers/body_state'
+require 'legion/extensions/somatic_marker/helpers/marker_store'
+require 'legion/extensions/somatic_marker/runners/somatic_marker'
+
+module Legion
+  module Extensions
+    module SomaticMarker
+      extend Legion::Extensions::Core if Legion::Extensions.const_defined? :Core
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/somatic_marker/client'
+
+RSpec.describe Legion::Extensions::SomaticMarker::Client do
+  let(:client) { described_class.new }
+
+  it 'responds to all runner methods' do
+    expect(client).to respond_to(:register_marker)
+    expect(client).to respond_to(:evaluate_option)
+    expect(client).to respond_to(:make_decision)
+    expect(client).to respond_to(:reinforce)
+    expect(client).to respond_to(:update_body)
+    expect(client).to respond_to(:body_state)
+    expect(client).to respond_to(:markers_for_action)
+    expect(client).to respond_to(:recent_decisions)
+    expect(client).to respond_to(:update_somatic_markers)
+    expect(client).to respond_to(:somatic_marker_stats)
+  end
+
+  it 'maintains isolated state per instance' do
+    client_a = described_class.new
+    client_b = described_class.new
+
+    client_a.register_marker(action: :deploy, domain: :ops, valence: 0.9)
+    result_b = client_b.evaluate_option(action: :deploy, domain: :ops)
+
+    expect(client_a.somatic_marker_stats[:marker_count]).to eq(1)
+    expect(client_b.somatic_marker_stats[:marker_count]).to eq(0)
+    expect(result_b[:signal]).to eq(:neutral)
+  end
+
+  it 'runs a full decision cycle' do
+    # Register markers from past experience
+    client.register_marker(action: :merge,   domain: :git, valence: 0.7,  source: :experience)
+    client.register_marker(action: :revert,  domain: :git, valence: -0.6, source: :experience)
+    client.register_marker(action: :hotfix,  domain: :git, valence: 0.3,  source: :inference)
+
+    # Make a decision
+    result = client.make_decision(options: %i[merge revert hotfix], domain: :git)
+    expect(result[:success]).to be true
+    expect(result[:decision][:ranked].first[:action]).to eq(:merge)
+
+    # Reinforce with negative outcome (merge caused issues)
+    marker_id = client.markers_for_action(action: :merge, domain: :git)[:markers].first[:id]
+    client.reinforce(marker_id: marker_id, outcome_valence: -0.8)
+
+    # After reinforcement, evaluate again
+    eval_result = client.evaluate_option(action: :merge, domain: :git)
+    # Valence should have moved toward negative
+    expect(eval_result[:valence]).to be < 0.7
+  end
+
+  it 'body state affects decision context' do
+    client.register_marker(action: :take_risk, domain: :strategy, valence: 0.1)
+
+    # Under stress, body state should be surfaced
+    client.update_body(tension: 0.9, comfort: 0.1)
+    result = client.make_decision(options: %i[take_risk play_safe], domain: :strategy)
+    expect(result[:decision][:body_contribution][:stressed]).to be true
+  end
+
+  it 'decay removes faded markers over time' do
+    client.register_marker(action: :old_action, domain: :history, valence: 0.0)
+
+    # Run enough decay cycles to fade the marker
+    60.times { client.update_somatic_markers }
+
+    stats = client.somatic_marker_stats
+    expect(stats[:marker_count]).to eq(0)
+  end
+
+  it 'tracks multiple domains independently' do
+    client.register_marker(action: :approve, domain: :finance, valence:  0.8)
+    client.register_marker(action: :approve, domain: :security, valence: -0.7)
+
+    finance_result  = client.evaluate_option(action: :approve, domain: :finance)
+    security_result = client.evaluate_option(action: :approve, domain: :security)
+
+    expect(finance_result[:signal]).to eq(:approach)
+    expect(security_result[:signal]).to eq(:avoid)
+  end
+end

data/spec/legion/extensions/somatic_marker/helpers/body_state_spec.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::SomaticMarker::Helpers::BodyState do
+  subject(:state) { described_class.new }
+
+  describe '#initialize' do
+    it 'sets neutral defaults' do
+      expect(state.arousal).to eq(0.5)
+      expect(state.tension).to eq(0.5)
+      expect(state.comfort).to eq(0.5)
+      expect(state.gut_signal).to eq(0.0)
+    end
+
+    it 'accepts custom values' do
+      s = described_class.new(arousal: 0.8, tension: 0.2, comfort: 0.9, gut_signal: 0.4)
+      expect(s.arousal).to eq(0.8)
+      expect(s.tension).to eq(0.2)
+      expect(s.comfort).to eq(0.9)
+      expect(s.gut_signal).to eq(0.4)
+    end
+
+    it 'clamps values to valid ranges' do
+      s = described_class.new(arousal: 2.0, tension: -1.0, comfort: 1.5, gut_signal: -2.0)
+      expect(s.arousal).to eq(1.0)
+      expect(s.tension).to eq(0.0)
+      expect(s.comfort).to eq(1.0)
+      expect(s.gut_signal).to eq(-1.0)
+    end
+  end
+
+  describe '#composite_valence' do
+    it 'returns a value in reasonable range for neutral state' do
+      # neutral: comfort=0.5, tension=0.5, gut=0.0
+      # => (0.5*0.4) + ((1-0.5)*0.3) + (0.0*0.3) = 0.2 + 0.15 + 0.0 = 0.35
+      val = state.composite_valence
+      expect(val).to be_within(0.001).of(0.35)
+    end
+
+    it 'returns higher value for comfortable low-tension state' do
+      high = described_class.new(comfort: 1.0, tension: 0.0, gut_signal: 1.0)
+      low  = described_class.new(comfort: 0.0, tension: 1.0, gut_signal: -1.0)
+      expect(high.composite_valence).to be > low.composite_valence
+    end
+
+    it 'weights comfort at 0.4' do
+      s = described_class.new(comfort: 1.0, tension: 0.5, gut_signal: 0.0)
+      neutral = described_class.new(comfort: 0.0, tension: 0.5, gut_signal: 0.0)
+      diff = s.composite_valence - neutral.composite_valence
+      expect(diff).to be_within(0.001).of(0.4)
+    end
+
+    it 'weights tension at 0.3 (inverted)' do
+      low_tension  = described_class.new(comfort: 0.5, tension: 0.0, gut_signal: 0.0)
+      high_tension = described_class.new(comfort: 0.5, tension: 1.0, gut_signal: 0.0)
+      diff = low_tension.composite_valence - high_tension.composite_valence
+      expect(diff).to be_within(0.001).of(0.3)
+    end
+
+    it 'weights gut_signal at 0.3' do
+      pos = described_class.new(comfort: 0.5, tension: 0.5, gut_signal: 1.0)
+      neg = described_class.new(comfort: 0.5, tension: 0.5, gut_signal: -1.0)
+      diff = pos.composite_valence - neg.composite_valence
+      expect(diff).to be_within(0.001).of(0.6)
+    end
+  end
+
+  describe '#update' do
+    it 'updates individual fields' do
+      state.update(arousal: 0.9)
+      expect(state.arousal).to eq(0.9)
+      expect(state.tension).to eq(0.5)
+    end
+
+    it 'clamps updated values' do
+      state.update(tension: 1.5)
+      expect(state.tension).to eq(1.0)
+    end
+
+    it 'ignores nil fields' do
+      state.update(comfort: nil)
+      expect(state.comfort).to eq(0.5)
+    end
+  end
+
+  describe '#decay' do
+    it 'drifts arousal toward 0.5' do
+      high = described_class.new(arousal: 0.9)
+      high.decay
+      expect(high.arousal).to be < 0.9
+      expect(high.arousal).to be >= 0.5
+    end
+
+    it 'drifts tension toward 0.5' do
+      low = described_class.new(tension: 0.1)
+      low.decay
+      expect(low.tension).to be > 0.1
+      expect(low.tension).to be <= 0.5
+    end
+
+    it 'drifts gut_signal toward 0.0' do
+      pos = described_class.new(gut_signal: 0.8)
+      pos.decay
+      expect(pos.gut_signal).to be < 0.8
+      expect(pos.gut_signal).to be >= 0.0
+    end
+
+    it 'decays negative gut_signal toward 0.0' do
+      neg = described_class.new(gut_signal: -0.8)
+      neg.decay
+      expect(neg.gut_signal).to be > -0.8
+      expect(neg.gut_signal).to be <= 0.0
+    end
+
+    it 'does not overshoot neutral targets' do
+      high_arousal = described_class.new(arousal: 0.53)
+      high_arousal.decay
+      expect(high_arousal.arousal).to be >= 0.5
+    end
+  end
+
+  describe '#stressed?' do
+    it 'returns true when tension > 0.7 and comfort < 0.3' do
+      stressed = described_class.new(tension: 0.8, comfort: 0.2)
+      expect(stressed.stressed?).to be true
+    end
+
+    it 'returns false when tension is moderate' do
+      relaxed = described_class.new(tension: 0.5, comfort: 0.2)
+      expect(relaxed.stressed?).to be false
+    end
+
+    it 'returns false when comfort is moderate' do
+      not_stressed = described_class.new(tension: 0.8, comfort: 0.5)
+      expect(not_stressed.stressed?).to be false
+    end
+
+    it 'returns false for default state' do
+      expect(state.stressed?).to be false
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all state keys' do
+      h = state.to_h
+      expect(h).to include(:arousal, :tension, :comfort, :gut_signal, :composite_valence, :stressed)
+    end
+
+    it 'reflects current values' do
+      s = described_class.new(arousal: 0.7, tension: 0.8, comfort: 0.2, gut_signal: -0.5)
+      h = s.to_h
+      expect(h[:arousal]).to eq(0.7)
+      expect(h[:stressed]).to be true
+    end
+  end
+end

data/spec/legion/extensions/somatic_marker/helpers/marker_store_spec.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::SomaticMarker::Helpers::MarkerStore do
+  subject(:store) { described_class.new }
+
+  describe '#register_marker' do
+    it 'creates a new marker' do
+      marker = store.register_marker(action: :deploy, domain: :ops, valence: 0.7)
+      expect(marker).to be_a(Legion::Extensions::SomaticMarker::Helpers::SomaticMarker)
+      expect(marker.action).to eq(:deploy)
+      expect(marker.domain).to eq(:ops)
+      expect(marker.valence).to be_within(0.001).of(0.7)
+    end
+
+    it 'stores the marker in the store' do
+      store.register_marker(action: :deploy, domain: :ops, valence: 0.5)
+      expect(store.markers.size).to eq(1)
+    end
+
+    it 'assigns sequential ids' do
+      m1 = store.register_marker(action: :first,  domain: :d, valence: 0.1)
+      m2 = store.register_marker(action: :second, domain: :d, valence: 0.2)
+      expect(m1.id).to eq('sm_1')
+      expect(m2.id).to eq('sm_2')
+    end
+
+    it 'accepts custom source' do
+      marker = store.register_marker(action: :deploy, domain: :ops, valence: 0.5, source: :instruction)
+      expect(marker.source).to eq(:instruction)
+    end
+
+    it 'evicts weakest marker when at MAX_MARKERS capacity' do
+      max = Legion::Extensions::SomaticMarker::Helpers::Constants::MAX_MARKERS
+
+      # Fill store with mid-strength markers
+      max.times do |i|
+        store.register_marker(action: :"action_#{i}", domain: :d, valence: 0.0)
+      end
+
+      # Manually weaken one
+      weakest = store.markers.values.first
+      50.times { weakest.decay }
+
+      initial_count = store.markers.size
+      store.register_marker(action: :overflow, domain: :d, valence: 0.5)
+      expect(store.markers.size).to eq(initial_count)
+    end
+  end
+
+  describe '#evaluate_option' do
+    it 'returns neutral signal with no markers' do
+      result = store.evaluate_option(action: :deploy, domain: :ops)
+      expect(result[:signal]).to eq(:neutral)
+      expect(result[:marker_count]).to eq(0)
+    end
+
+    it 'returns approach signal for positive markers' do
+      store.register_marker(action: :deploy, domain: :ops, valence: 0.9)
+      result = store.evaluate_option(action: :deploy, domain: :ops)
+      expect(result[:signal]).to eq(:approach)
+    end
+
+    it 'returns avoid signal for negative markers' do
+      store.register_marker(action: :deploy, domain: :ops, valence: -0.9)
+      result = store.evaluate_option(action: :deploy, domain: :ops)
+      expect(result[:signal]).to eq(:avoid)
+    end
+
+    it 'weighs markers by strength' do
+      store.register_marker(action: :deploy, domain: :ops, valence: 0.9)
+      # Weaken the positive marker heavily
+      marker = store.markers.values.first
+      40.times { marker.decay }
+
+      store.register_marker(action: :deploy, domain: :ops, valence: -0.9)
+
+      result = store.evaluate_option(action: :deploy, domain: :ops)
+      # Strong negative should outweigh weak positive
+      expect(result[:valence]).to be < 0
+    end
+
+    it 'only considers markers matching action and domain' do
+      store.register_marker(action: :deploy,   domain: :ops, valence: 0.9)
+      store.register_marker(action: :rollback, domain: :ops, valence: -0.9)
+      store.register_marker(action: :deploy,   domain: :dev, valence: -0.9)
+
+      result = store.evaluate_option(action: :deploy, domain: :ops)
+      expect(result[:signal]).to eq(:approach)
+      expect(result[:marker_count]).to eq(1)
+    end
+  end
+
+  describe '#decide' do
+    it 'returns ranked options' do
+      store.register_marker(action: :approve, domain: :risk, valence:  0.8)
+      store.register_marker(action: :reject,  domain: :risk, valence: -0.8)
+
+      result = store.decide(options: %i[approve reject], domain: :risk)
+      expect(result[:ranked].first[:action]).to eq(:approve)
+      expect(result[:ranked].last[:action]).to eq(:reject)
+    end
+
+    it 'records decision in history' do
+      store.decide(options: %i[go stop], domain: :ops)
+      expect(store.decision_history.size).to eq(1)
+    end
+
+    it 'caps options at MAX_OPTIONS_PER_DECISION' do
+      max = Legion::Extensions::SomaticMarker::Helpers::Constants::MAX_OPTIONS_PER_DECISION
+      options = (max + 5).times.map { |i| :"option_#{i}" }
+      result = store.decide(options: options, domain: :ops)
+      expect(result[:ranked].size).to eq(max)
+    end
+
+    it 'includes body_contribution in result' do
+      result = store.decide(options: %i[act wait], domain: :ops)
+      expect(result).to have_key(:body_contribution)
+    end
+
+    it 'caps decision history at MAX_DECISION_HISTORY' do
+      max = Legion::Extensions::SomaticMarker::Helpers::Constants::MAX_DECISION_HISTORY
+      (max + 5).times { store.decide(options: %i[go stop], domain: :ops) }
+      expect(store.decision_history(limit: max + 10).size).to eq(max)
+    end
+  end
+
+  describe '#reinforce_marker' do
+    it 'reinforces an existing marker' do
+      m = store.register_marker(action: :deploy, domain: :ops, valence: 0.0)
+      result = store.reinforce_marker(marker_id: m.id, outcome_valence: 1.0)
+      expect(result).to eq(m)
+      expect(m.valence).to be > 0.0
+    end
+
+    it 'returns nil for unknown marker id' do
+      result = store.reinforce_marker(marker_id: 'nonexistent', outcome_valence: 0.5)
+      expect(result).to be_nil
+    end
+  end
+
+  describe '#update_body_state' do
+    it 'updates the body state' do
+      store.update_body_state(tension: 0.9, comfort: 0.1)
+      expect(store.body_state.tension).to eq(0.9)
+      expect(store.body_state.comfort).to eq(0.1)
+    end
+
+    it 'returns the updated body state' do
+      result = store.update_body_state(gut_signal: 0.5)
+      expect(result).to be_a(Legion::Extensions::SomaticMarker::Helpers::BodyState)
+    end
+  end
+
+  describe '#markers_for' do
+    it 'returns markers matching action and domain' do
+      store.register_marker(action: :send,    domain: :email, valence: 0.3)
+      store.register_marker(action: :send,    domain: :email, valence: 0.7)
+      store.register_marker(action: :receive, domain: :email, valence: 0.5)
+
+      found = store.markers_for(action: :send, domain: :email)
+      expect(found.size).to eq(2)
+      found.each { |m| expect(m.action).to eq(:send) }
+    end
+
+    it 'returns empty array when no matching markers' do
+      expect(store.markers_for(action: :unknown, domain: :unknown)).to be_empty
+    end
+  end
+
+  describe '#body_influence' do
+    it 'returns composite valence and stressed flag' do
+      result = store.body_influence
+      expect(result).to have_key(:composite_valence)
+      expect(result).to have_key(:stressed)
+    end
+  end
+
+  describe '#decay_all' do
+    it 'decays all markers' do
+      store.register_marker(action: :deploy, domain: :ops, valence: 0.5)
+      before_strength = store.markers.values.first.strength
+      store.decay_all
+      expect(store.markers.values.first.strength).to be < before_strength
+    end
+
+    it 'removes faded markers' do
+      m = store.register_marker(action: :deploy, domain: :ops, valence: 0.0)
+      # Force marker to nearly faded state
+      50.times { m.decay }
+      store.decay_all
+      expect(store.markers).not_to have_key(m.id)
+    end
+
+    it 'returns decay stats' do
+      store.register_marker(action: :deploy, domain: :ops, valence: 0.5)
+      result = store.decay_all
+      expect(result).to have_key(:markers_decayed)
+      expect(result).to have_key(:markers_removed)
+    end
+
+    it 'decays body state' do
+      store.update_body_state(arousal: 0.9)
+      before = store.body_state.arousal
+      store.decay_all
+      expect(store.body_state.arousal).to be < before
+    end
+  end
+
+  describe '#decision_history' do
+    it 'returns up to limit recent decisions' do
+      5.times { store.decide(options: %i[act wait], domain: :ops) }
+      expect(store.decision_history(limit: 3).size).to eq(3)
+    end
+
+    it 'returns all decisions when under limit' do
+      2.times { store.decide(options: %i[act wait], domain: :ops) }
+      expect(store.decision_history(limit: 10).size).to eq(2)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns summary stats' do
+      store.register_marker(action: :deploy, domain: :ops, valence: 0.5)
+      store.decide(options: %i[go stop], domain: :ops)
+
+      h = store.to_h
+      expect(h[:marker_count]).to eq(1)
+      expect(h[:decision_count]).to eq(1)
+      expect(h).to have_key(:body_state)
+      expect(h).to have_key(:stressed)
+    end
+  end
+end

data/spec/legion/extensions/somatic_marker/helpers/somatic_marker_spec.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::SomaticMarker::Helpers::SomaticMarker do
+  subject(:marker) do
+    described_class.new(id: 'sm_1', action: :deploy, domain: :ops, valence: 0.5)
+  end
+
+  describe '#initialize' do
+    it 'stores all attributes' do
+      expect(marker.id).to eq('sm_1')
+      expect(marker.action).to eq(:deploy)
+      expect(marker.domain).to eq(:ops)
+      expect(marker.strength).to eq(0.5)
+      expect(marker.source).to eq(:experience)
+    end
+
+    it 'clamps valence to [-1, 1]' do
+      high = described_class.new(id: 'sm_2', action: :act, domain: :d, valence: 2.0)
+      low  = described_class.new(id: 'sm_3', action: :act, domain: :d, valence: -2.0)
+      expect(high.valence).to eq(1.0)
+      expect(low.valence).to eq(-1.0)
+    end
+
+    it 'clamps strength to [0, 1]' do
+      over  = described_class.new(id: 'sm_4', action: :act, domain: :d, valence: 0.0, strength: 1.5)
+      under = described_class.new(id: 'sm_5', action: :act, domain: :d, valence: 0.0, strength: -0.5)
+      expect(over.strength).to eq(1.0)
+      expect(under.strength).to eq(0.0)
+    end
+
+    it 'sets created_at' do
+      expect(marker.created_at).to be_a(Time)
+    end
+  end
+
+  describe '#signal' do
+    it 'returns :approach when valence > POSITIVE_BIAS' do
+      m = described_class.new(id: 'sm_6', action: :act, domain: :d, valence: 0.8)
+      expect(m.signal).to eq(:approach)
+    end
+
+    it 'returns :avoid when valence < NEGATIVE_BIAS' do
+      m = described_class.new(id: 'sm_7', action: :act, domain: :d, valence: -0.8)
+      expect(m.signal).to eq(:avoid)
+    end
+
+    it 'returns :neutral for mid-range valence' do
+      m = described_class.new(id: 'sm_8', action: :act, domain: :d, valence: 0.0)
+      expect(m.signal).to eq(:neutral)
+    end
+
+    it 'returns :neutral at exactly POSITIVE_BIAS boundary' do
+      m = described_class.new(id: 'sm_9', action: :act, domain: :d, valence: 0.6)
+      expect(m.signal).to eq(:neutral)
+    end
+
+    it 'returns :neutral at exactly NEGATIVE_BIAS boundary' do
+      m = described_class.new(id: 'sm_10', action: :act, domain: :d, valence: -0.6)
+      expect(m.signal).to eq(:neutral)
+    end
+  end
+
+  describe '#reinforce' do
+    it 'moves valence toward positive outcome' do
+      m = described_class.new(id: 'sm_11', action: :act, domain: :d, valence: 0.0)
+      25.times { m.reinforce(outcome_valence: 1.0) }
+      expect(m.valence).to be > 0.5
+    end
+
+    it 'moves valence toward negative outcome' do
+      m = described_class.new(id: 'sm_12', action: :act, domain: :d, valence: 0.0)
+      25.times { m.reinforce(outcome_valence: -1.0) }
+      expect(m.valence).to be < -0.5
+    end
+
+    it 'boosts strength on reinforce' do
+      m = described_class.new(id: 'sm_13', action: :act, domain: :d, valence: 0.0, strength: 0.3)
+      m.reinforce(outcome_valence: 0.5)
+      expect(m.strength).to be > 0.3
+    end
+
+    it 'clamps valence at 1.0' do
+      m = described_class.new(id: 'sm_14', action: :act, domain: :d, valence: 0.99)
+      50.times { m.reinforce(outcome_valence: 1.0) }
+      expect(m.valence).to be <= 1.0
+    end
+
+    it 'clamps valence at -1.0' do
+      m = described_class.new(id: 'sm_15', action: :act, domain: :d, valence: -0.99)
+      50.times { m.reinforce(outcome_valence: -1.0) }
+      expect(m.valence).to be >= -1.0
+    end
+
+    it 'clamps strength at 1.0' do
+      m = described_class.new(id: 'sm_16', action: :act, domain: :d, valence: 0.0, strength: 0.95)
+      m.reinforce(outcome_valence: 0.5)
+      expect(m.strength).to be <= 1.0
+    end
+  end
+
+  describe '#decay' do
+    it 'reduces strength by MARKER_DECAY' do
+      m = described_class.new(id: 'sm_17', action: :act, domain: :d, valence: 0.0, strength: 0.5)
+      before = m.strength
+      m.decay
+      expect(m.strength).to be_within(0.001).of(before - Legion::Extensions::SomaticMarker::Helpers::Constants::MARKER_DECAY)
+    end
+
+    it 'floors strength at 0.0' do
+      m = described_class.new(id: 'sm_18', action: :act, domain: :d, valence: 0.0, strength: 0.005)
+      m.decay
+      expect(m.strength).to eq(0.0)
+    end
+  end
+
+  describe '#faded?' do
+    it 'returns false when strength is above floor' do
+      m = described_class.new(id: 'sm_19', action: :act, domain: :d, valence: 0.0, strength: 0.5)
+      expect(m.faded?).to be false
+    end
+
+    it 'returns true when strength is at or below floor' do
+      m = described_class.new(id: 'sm_20', action: :act, domain: :d, valence: 0.0, strength: 0.05)
+      expect(m.faded?).to be true
+    end
+
+    it 'returns true after enough decay cycles' do
+      m = described_class.new(id: 'sm_21', action: :act, domain: :d, valence: 0.0, strength: 0.2)
+      20.times { m.decay }
+      expect(m.faded?).to be true
+    end
+  end
+
+  describe '#valence_label' do
+    it 'returns :strongly_negative for very negative valence' do
+      m = described_class.new(id: 'sm_22', action: :act, domain: :d, valence: -0.9)
+      expect(m.valence_label).to eq(:strongly_negative)
+    end
+
+    it 'returns :negative for moderately negative valence' do
+      m = described_class.new(id: 'sm_23', action: :act, domain: :d, valence: -0.4)
+      expect(m.valence_label).to eq(:negative)
+    end
+
+    it 'returns :neutral for near-zero valence' do
+      m = described_class.new(id: 'sm_24', action: :act, domain: :d, valence: 0.0)
+      expect(m.valence_label).to eq(:neutral)
+    end
+
+    it 'returns :positive for moderately positive valence' do
+      m = described_class.new(id: 'sm_25', action: :act, domain: :d, valence: 0.4)
+      expect(m.valence_label).to eq(:positive)
+    end
+
+    it 'returns :strongly_positive for very positive valence' do
+      m = described_class.new(id: 'sm_26', action: :act, domain: :d, valence: 0.9)
+      expect(m.valence_label).to eq(:strongly_positive)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with all expected keys' do
+      h = marker.to_h
+      expect(h).to include(:id, :action, :domain, :valence, :strength, :source, :signal, :label, :created_at)
+    end
+
+    it 'includes the computed signal' do
+      m = described_class.new(id: 'sm_27', action: :act, domain: :d, valence: 0.8)
+      expect(m.to_h[:signal]).to eq(:approach)
+    end
+  end
+end