lex-agentic-memory 0.1.0

data/spec/legion/extensions/agentic/memory/paleontology/runners/cognitive_paleontology_spec.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Paleontology::Runners::CognitivePaleontology do
+  let(:engine) { Legion::Extensions::Agentic::Memory::Paleontology::Helpers::PaleontologyEngine.new }
+  let(:runner) { described_class }
+
+  describe '.record_extinction' do
+    it 'succeeds' do
+      result = runner.record_extinction(
+        fossil_type: :strategy, domain: :cognitive, content: 'old way',
+        extinction_cause: :obsolescence, engine: engine
+      )
+      expect(result[:success]).to be true
+      expect(result[:fossil][:fossil_type]).to eq :strategy
+    end
+
+    it 'returns failure for invalid type' do
+      result = runner.record_extinction(
+        fossil_type: :bogus, domain: :cognitive, content: 'x',
+        extinction_cause: :obsolescence, engine: engine
+      )
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '.begin_excavation' do
+    it 'succeeds' do
+      result = runner.begin_excavation(target_stratum: 1, engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:excavation][:target_stratum]).to eq 1
+    end
+  end
+
+  describe '.excavate' do
+    it 'returns fossil when found' do
+      engine.record_extinction(
+        fossil_type: :pattern, domain: :semantic, content: 'x',
+        extinction_cause: :displacement, stratum_depth: 1
+      )
+      exc = engine.begin_excavation(target_stratum: 1)
+      result = runner.excavate(excavation_id: exc.id, engine: engine)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns nil message when empty stratum' do
+      exc = engine.begin_excavation(target_stratum: 4)
+      result = runner.excavate(excavation_id: exc.id, engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:fossil]).to be_nil
+    end
+  end
+
+  describe '.list_fossils' do
+    before do
+      engine.record_extinction(
+        fossil_type: :strategy, domain: :cognitive, content: 'a',
+        extinction_cause: :obsolescence
+      )
+      engine.record_extinction(
+        fossil_type: :pattern, domain: :semantic, content: 'b',
+        extinction_cause: :displacement
+      )
+    end
+
+    it 'lists all' do
+      result = runner.list_fossils(engine: engine)
+      expect(result[:count]).to eq 2
+    end
+
+    it 'filters by type' do
+      result = runner.list_fossils(engine: engine, fossil_type: :strategy)
+      expect(result[:count]).to eq 1
+    end
+
+    it 'filters by cause' do
+      result = runner.list_fossils(engine:           engine,
+                                   extinction_cause: :displacement)
+      expect(result[:count]).to eq 1
+    end
+  end
+
+  describe '.paleontology_status' do
+    it 'returns report' do
+      result = runner.paleontology_status(engine: engine)
+      expect(result[:success]).to be true
+      expect(result[:report]).to be_a Hash
+    end
+  end
+end

data/spec/legion/extensions/agentic/memory/palimpsest/client_spec.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Palimpsest::Client do
+  subject(:client) { described_class.new }
+
+  it 'full lifecycle: overwrite, peek, ghost, drift, report' do
+    r1 = client.overwrite_belief(topic: 'democracy', content: 'mob rule', confidence: 0.4)
+    expect(r1[:success]).to be true
+
+    r2 = client.overwrite_belief(topic: 'democracy', content: 'representative government', confidence: 0.9)
+    expect(r2[:version]).to eq(2)
+
+    peek = client.peek_through_belief(topic: 'democracy', depth: 1)
+    expect(peek[:count]).to eq(1)
+    expect(peek[:layers].first[:content]).to eq('mob rule')
+
+    ghosts = client.ghost_layers(topic: 'democracy')
+    expect(ghosts[:count]).to eq(1)
+
+    drift = client.belief_drift(topic: 'democracy')
+    expect(drift[:drift]).to be_within(0.01).of(0.5)
+
+    report = client.palimpsest_report
+    expect(report[:palimpsest_count]).to eq(1)
+    expect(report[:total_ghosts]).to eq(1)
+  end
+
+  it 'accepts injected engine' do
+    engine = Legion::Extensions::Agentic::Memory::Palimpsest::Helpers::PalimpsestEngine.new
+    c = described_class.new(engine: engine)
+    c.overwrite_belief(topic: 'test', content: 'hello')
+    expect(engine.palimpsests).to have_key('test')
+  end
+
+  it 'erodes and decays' do
+    client.overwrite_belief(topic: 'erosion', content: 'v1', confidence: 0.8)
+    result = client.erode_belief(topic: 'erosion')
+    expect(result[:confidence]).to be < 0.8
+
+    client.overwrite_belief(topic: 'erosion', content: 'v2', confidence: 0.8)
+    decay_result = client.decay_all_ghosts
+    expect(decay_result[:success]).to be true
+  end
+
+  it 'domain_archaeology retrieves all layers for domain' do
+    client.create_palimpsest(topic: 'arch_topic', domain: :normative)
+    client.overwrite_belief(topic: 'arch_topic', content: 'old norm')
+    client.overwrite_belief(topic: 'arch_topic', content: 'new norm')
+    result = client.domain_archaeology(domain: :normative)
+    expect(result[:count]).to eq(2)
+  end
+
+  it 'most_rewritten respects limit' do
+    5.times { |i| client.overwrite_belief(topic: "topic_#{i}", content: 'x') }
+    result = client.most_rewritten(limit: 3)
+    expect(result[:palimpsests].size).to eq(3)
+  end
+end

data/spec/legion/extensions/agentic/memory/palimpsest/helpers/belief_layer_spec.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Palimpsest::Helpers::BeliefLayer do
+  subject(:layer) do
+    described_class.new(content: 'the sky is blue', confidence: 0.8, domain: :factual)
+  end
+
+  describe '#initialize' do
+    it 'sets content' do
+      expect(layer.content).to eq('the sky is blue')
+    end
+
+    it 'sets confidence' do
+      expect(layer.confidence).to eq(0.8)
+    end
+
+    it 'sets domain' do
+      expect(layer.domain).to eq(:factual)
+    end
+
+    it 'generates a uuid id' do
+      expect(layer.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'sets timestamp' do
+      expect(layer.timestamp).to be_a(Time)
+    end
+
+    it 'is not superseded by default' do
+      expect(layer.superseded_by).to be_nil
+      expect(layer.superseded?).to be false
+    end
+
+    it 'clamps confidence above 1.0' do
+      l = described_class.new(content: 'x', confidence: 1.5)
+      expect(l.confidence).to eq(1.0)
+    end
+
+    it 'clamps confidence below 0.0' do
+      l = described_class.new(content: 'x', confidence: -0.5)
+      expect(l.confidence).to eq(0.0)
+    end
+
+    it 'defaults version to 1' do
+      l = described_class.new(content: 'x')
+      expect(l.version).to eq(1)
+    end
+
+    it 'defaults author to :system' do
+      l = described_class.new(content: 'x')
+      expect(l.author).to eq(:system)
+    end
+  end
+
+  describe '#supersede!' do
+    it 'sets superseded_by' do
+      layer.supersede!('next-id')
+      expect(layer.superseded_by).to eq('next-id')
+      expect(layer.superseded?).to be true
+    end
+  end
+
+  describe '#ghost?' do
+    context 'when superseded with confidence above threshold' do
+      it 'is a ghost' do
+        layer.supersede!('x')
+        expect(layer.ghost?).to be true
+      end
+    end
+
+    context 'when not superseded' do
+      it 'is not a ghost' do
+        expect(layer.ghost?).to be false
+      end
+    end
+
+    context 'when superseded with confidence at or below threshold' do
+      it 'is not a ghost' do
+        low = described_class.new(content: 'x', confidence: 0.05)
+        low.supersede!('x')
+        expect(low.ghost?).to be false
+      end
+    end
+  end
+
+  describe '#dissipated?' do
+    it 'is dissipated when superseded and confidence at or below threshold' do
+      low = described_class.new(content: 'x', confidence: 0.05)
+      low.supersede!('x')
+      expect(low.dissipated?).to be true
+    end
+
+    it 'is not dissipated when not superseded' do
+      expect(layer.dissipated?).to be false
+    end
+  end
+
+  describe '#erode!' do
+    it 'reduces confidence by EROSION_RATE' do
+      original = layer.confidence
+      layer.erode!
+      expect(layer.confidence).to be < original
+    end
+
+    it 'does not go below 0.0' do
+      low = described_class.new(content: 'x', confidence: 0.02)
+      low.erode!(rate: 0.1)
+      expect(low.confidence).to eq(0.0)
+    end
+
+    it 'accepts a custom rate' do
+      layer.erode!(rate: 0.1)
+      expect(layer.confidence).to be_within(0.001).of(0.7)
+    end
+  end
+
+  describe '#confidence_label' do
+    it 'returns :high for 0.8' do
+      expect(layer.confidence_label).to eq(:high)
+    end
+
+    it 'returns :ghost for very low confidence' do
+      l = described_class.new(content: 'x', confidence: 0.05)
+      expect(l.confidence_label).to eq(:ghost)
+    end
+  end
+
+  describe '#ghost_label' do
+    it 'returns :not_ghost when not superseded' do
+      expect(layer.ghost_label).to eq(:not_ghost)
+    end
+
+    it 'returns :strong_ghost when superseded with high confidence' do
+      layer.supersede!('x')
+      expect(layer.ghost_label).to eq(:strong_ghost)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns expected keys' do
+      h = layer.to_h
+      expect(h).to include(:id, :content, :confidence, :domain, :version, :author,
+                           :timestamp, :superseded_by, :superseded, :ghost, :label)
+    end
+
+    it 'rounds confidence to 4 decimal places' do
+      expect(layer.to_h[:confidence]).to eq(0.8)
+    end
+  end
+end

data/spec/legion/extensions/agentic/memory/palimpsest/helpers/constants_spec.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Palimpsest::Helpers::Constants do
+  describe 'constants' do
+    it 'defines MAX_PALIMPSESTS' do
+      expect(described_class::MAX_PALIMPSESTS).to eq(200)
+    end
+
+    it 'defines MAX_LAYERS_PER_TOPIC' do
+      expect(described_class::MAX_LAYERS_PER_TOPIC).to eq(20)
+    end
+
+    it 'defines DEFAULT_CONFIDENCE' do
+      expect(described_class::DEFAULT_CONFIDENCE).to eq(0.7)
+    end
+
+    it 'defines GHOST_THRESHOLD' do
+      expect(described_class::GHOST_THRESHOLD).to eq(0.1)
+    end
+
+    it 'defines EROSION_RATE' do
+      expect(described_class::EROSION_RATE).to eq(0.05)
+    end
+
+    it 'defines GHOST_DECAY' do
+      expect(described_class::GHOST_DECAY).to eq(0.02)
+    end
+
+    it 'defines 8 LAYER_DOMAINS' do
+      expect(described_class::LAYER_DOMAINS.size).to eq(8)
+    end
+
+    it 'includes expected domains' do
+      expect(described_class::LAYER_DOMAINS).to include(:factual, :procedural, :normative, :identity)
+    end
+  end
+
+  describe '.label_for' do
+    it 'returns correct CONFIDENCE_LABELS label' do
+      expect(described_class.label_for(described_class::CONFIDENCE_LABELS, 0.95)).to eq(:certain)
+      expect(described_class.label_for(described_class::CONFIDENCE_LABELS, 0.75)).to eq(:high)
+      expect(described_class.label_for(described_class::CONFIDENCE_LABELS, 0.55)).to eq(:moderate)
+      expect(described_class.label_for(described_class::CONFIDENCE_LABELS, 0.35)).to eq(:low)
+      expect(described_class.label_for(described_class::CONFIDENCE_LABELS, 0.15)).to eq(:faint)
+      expect(described_class.label_for(described_class::CONFIDENCE_LABELS, 0.05)).to eq(:ghost)
+    end
+
+    it 'returns correct GHOST_LABELS label' do
+      expect(described_class.label_for(described_class::GHOST_LABELS, 0.6)).to eq(:strong_ghost)
+      expect(described_class.label_for(described_class::GHOST_LABELS, 0.4)).to eq(:moderate_ghost)
+      expect(described_class.label_for(described_class::GHOST_LABELS, 0.2)).to eq(:faint_ghost)
+      expect(described_class.label_for(described_class::GHOST_LABELS, 0.05)).to eq(:dissipated)
+    end
+
+    it 'returns correct DRIFT_LABELS label' do
+      expect(described_class.label_for(described_class::DRIFT_LABELS, 0.8)).to eq(:radical)
+      expect(described_class.label_for(described_class::DRIFT_LABELS, 0.5)).to eq(:major)
+      expect(described_class.label_for(described_class::DRIFT_LABELS, 0.3)).to eq(:moderate)
+      expect(described_class.label_for(described_class::DRIFT_LABELS, 0.1)).to eq(:minor)
+      expect(described_class.label_for(described_class::DRIFT_LABELS, 0.01)).to eq(:stable)
+    end
+  end
+end

data/spec/legion/extensions/agentic/memory/palimpsest/helpers/palimpsest_engine_spec.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Palimpsest::Helpers::PalimpsestEngine do
+  subject(:engine) { described_class.new }
+
+  describe '#create' do
+    it 'creates a new palimpsest' do
+      p = engine.create(topic: 'gravity', domain: :factual)
+      expect(p).not_to be_nil
+      expect(p.topic).to eq('gravity')
+    end
+
+    it 'returns nil for duplicate topic' do
+      engine.create(topic: 'gravity')
+      expect(engine.create(topic: 'gravity')).to be_nil
+    end
+
+    it 'stores in palimpsests hash' do
+      engine.create(topic: 'light')
+      expect(engine.palimpsests).to have_key('light')
+    end
+  end
+
+  describe '#overwrite' do
+    it 'creates and overwrites in one call' do
+      layer = engine.overwrite(topic: 'sky', content: 'blue', confidence: 0.8)
+      expect(layer).not_to be_nil
+      expect(layer.content).to eq('blue')
+    end
+
+    it 'overwrites an existing palimpsest' do
+      engine.overwrite(topic: 'sky', content: 'v1', confidence: 0.7)
+      engine.overwrite(topic: 'sky', content: 'v2', confidence: 0.9)
+      expect(engine.palimpsests['sky'].current_layer.content).to eq('v2')
+    end
+  end
+
+  describe '#peek_through' do
+    it 'returns previous layers as hashes' do
+      engine.overwrite(topic: 'x', content: 'old')
+      engine.overwrite(topic: 'x', content: 'new')
+      layers = engine.peek_through(topic: 'x', depth: 1)
+      expect(layers.first[:content]).to eq('old')
+    end
+
+    it 'returns empty for unknown topic' do
+      expect(engine.peek_through(topic: 'unknown')).to eq([])
+    end
+  end
+
+  describe '#erode' do
+    it 'reduces confidence' do
+      engine.overwrite(topic: 'y', content: 'content', confidence: 0.8)
+      result = engine.erode(topic: 'y')
+      expect(result).to be < 0.8
+    end
+
+    it 'returns nil for unknown topic' do
+      expect(engine.erode(topic: 'missing')).to be_nil
+    end
+  end
+
+  describe '#ghost_layers_for' do
+    it 'returns ghost layers as hashes' do
+      engine.overwrite(topic: 'z', content: 'v1', confidence: 0.8)
+      engine.overwrite(topic: 'z', content: 'v2')
+      layers = engine.ghost_layers_for(topic: 'z')
+      expect(layers.size).to eq(1)
+      expect(layers.first).to be_a(Hash)
+    end
+
+    it 'returns empty for unknown topic' do
+      expect(engine.ghost_layers_for(topic: 'missing')).to eq([])
+    end
+  end
+
+  describe '#all_ghost_layers' do
+    it 'aggregates ghosts across all palimpsests' do
+      engine.overwrite(topic: 'a', content: 'v1', confidence: 0.8)
+      engine.overwrite(topic: 'a', content: 'v2')
+      engine.overwrite(topic: 'b', content: 'v1', confidence: 0.7)
+      engine.overwrite(topic: 'b', content: 'v2')
+      expect(engine.all_ghost_layers.size).to eq(2)
+    end
+  end
+
+  describe '#domain_archaeology' do
+    it 'returns all layers for a given domain' do
+      engine.create(topic: 'a', domain: :factual)
+      engine.overwrite(topic: 'a', content: 'v1')
+      engine.overwrite(topic: 'a', content: 'v2')
+      engine.create(topic: 'b', domain: :emotional)
+      engine.overwrite(topic: 'b', content: 'feeling')
+      layers = engine.domain_archaeology(domain: :factual)
+      expect(layers.size).to eq(2)
+      expect(layers.all? { |l| l[:topic] == 'a' }).to be true
+    end
+  end
+
+  describe '#belief_drift' do
+    it 'returns drift hash' do
+      engine.overwrite(topic: 'drift', content: 'v1', confidence: 0.3)
+      engine.overwrite(topic: 'drift', content: 'v2', confidence: 0.9)
+      result = engine.belief_drift(topic: 'drift')
+      expect(result[:drift]).to be > 0
+      expect(result[:label]).to be_a(Symbol)
+    end
+
+    it 'returns nil for unknown topic' do
+      expect(engine.belief_drift(topic: 'unknown')).to be_nil
+    end
+  end
+
+  describe '#overwrite_frequency' do
+    it 'returns count of overwrites' do
+      engine.overwrite(topic: 'freq', content: 'v1')
+      engine.overwrite(topic: 'freq', content: 'v2')
+      engine.overwrite(topic: 'freq', content: 'v3')
+      expect(engine.overwrite_frequency(topic: 'freq')).to eq(3)
+    end
+
+    it 'returns nil for unknown topic' do
+      expect(engine.overwrite_frequency(topic: 'missing')).to be_nil
+    end
+  end
+
+  describe '#most_rewritten' do
+    it 'returns palimpsests sorted by overwrite count descending' do
+      3.times { engine.overwrite(topic: 'many', content: "v#{it}") }
+      engine.overwrite(topic: 'few', content: 'v1')
+      result = engine.most_rewritten(limit: 2)
+      expect(result.first[:topic]).to eq('many')
+    end
+
+    it 'respects limit' do
+      5.times { |i| engine.overwrite(topic: "t#{i}", content: 'x') }
+      expect(engine.most_rewritten(limit: 3).size).to eq(3)
+    end
+  end
+
+  describe '#decay_all!' do
+    it 'decays ghost layers without raising' do
+      engine.overwrite(topic: 'g', content: 'v1', confidence: 0.8)
+      engine.overwrite(topic: 'g', content: 'v2')
+      old_conf = engine.palimpsests['g'].historical_layers.first.confidence
+      engine.decay_all!
+      expect(engine.palimpsests['g'].historical_layers.first.confidence).to be < old_conf
+    end
+  end
+
+  describe '#palimpsest_report' do
+    it 'returns report hash' do
+      engine.overwrite(topic: 'r1', content: 'v1', confidence: 0.8)
+      engine.overwrite(topic: 'r1', content: 'v2')
+      report = engine.palimpsest_report
+      expect(report).to include(:palimpsest_count, :total_ghosts, :average_drift, :most_rewritten)
+      expect(report[:palimpsest_count]).to eq(1)
+    end
+
+    it 'returns zero average_drift for empty engine' do
+      expect(engine.palimpsest_report[:average_drift]).to eq(0.0)
+    end
+  end
+end

data/spec/legion/extensions/agentic/memory/palimpsest/helpers/palimpsest_spec.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Palimpsest::Helpers::Palimpsest do
+  subject(:pal) { described_class.new(topic: 'weather', domain: :factual) }
+
+  describe '#initialize' do
+    it 'sets topic and domain' do
+      expect(pal.topic).to eq('weather')
+      expect(pal.domain).to eq(:factual)
+    end
+
+    it 'starts with no layers' do
+      expect(pal.current_layer).to be_nil
+      expect(pal.historical_layers).to be_empty
+    end
+
+    it 'starts with overwrite_count of 0' do
+      expect(pal.overwrite_count).to eq(0)
+    end
+
+    it 'generates an id' do
+      expect(pal.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+  end
+
+  describe '#overwrite!' do
+    it 'sets the current layer on first call' do
+      layer = pal.overwrite!('it will rain', confidence: 0.7)
+      expect(pal.current_layer).to eq(layer)
+      expect(pal.current_layer.content).to eq('it will rain')
+    end
+
+    it 'increments overwrite_count' do
+      pal.overwrite!('v1')
+      pal.overwrite!('v2')
+      expect(pal.overwrite_count).to eq(2)
+    end
+
+    it 'moves current to historical on second write' do
+      pal.overwrite!('v1')
+      pal.overwrite!('v2')
+      expect(pal.historical_layers.size).to eq(1)
+      expect(pal.historical_layers.first.content).to eq('v1')
+    end
+
+    it 'marks the old layer as superseded' do
+      pal.overwrite!('v1')
+      v1 = pal.current_layer
+      pal.overwrite!('v2')
+      expect(v1.superseded?).to be true
+    end
+
+    it 'increments layer version' do
+      pal.overwrite!('v1')
+      pal.overwrite!('v2')
+      expect(pal.current_layer.version).to eq(2)
+    end
+  end
+
+  describe '#peek_through' do
+    before do
+      pal.overwrite!('v1')
+      pal.overwrite!('v2')
+      pal.overwrite!('v3')
+    end
+
+    it 'returns the most recent historical layer by default' do
+      layers = pal.peek_through(depth: 1)
+      expect(layers.size).to eq(1)
+      expect(layers.first.content).to eq('v2')
+    end
+
+    it 'returns multiple historical layers' do
+      layers = pal.peek_through(depth: 2)
+      expect(layers.size).to eq(2)
+    end
+
+    it 'returns empty when no history' do
+      fresh = described_class.new(topic: 'new')
+      expect(fresh.peek_through).to be_empty
+    end
+
+    it 'does not exceed available history' do
+      layers = pal.peek_through(depth: 100)
+      expect(layers.size).to eq(2)
+    end
+  end
+
+  describe '#erode_current!' do
+    it 'reduces confidence of current layer' do
+      pal.overwrite!('content', confidence: 0.8)
+      original = pal.current_layer.confidence
+      pal.erode_current!
+      expect(pal.current_layer.confidence).to be < original
+    end
+
+    it 'returns nil when no current layer' do
+      expect(pal.erode_current!).to be_nil
+    end
+  end
+
+  describe '#ghost_layers' do
+    it 'returns superseded layers with confidence above threshold' do
+      pal.overwrite!('v1', confidence: 0.8)
+      pal.overwrite!('v2')
+      expect(pal.ghost_layers.size).to eq(1)
+    end
+
+    it 'excludes dissipated layers' do
+      pal.overwrite!('v1', confidence: 0.05)
+      pal.overwrite!('v2')
+      expect(pal.ghost_layers).to be_empty
+    end
+  end
+
+  describe '#restoration_strength' do
+    it 'returns 0.0 with no ghosts' do
+      pal.overwrite!('v1')
+      expect(pal.restoration_strength).to eq(0.0)
+    end
+
+    it 'returns average ghost confidence' do
+      pal.overwrite!('v1', confidence: 0.8)
+      pal.overwrite!('v2', confidence: 0.6)
+      pal.overwrite!('v3')
+      strength = pal.restoration_strength
+      expect(strength).to be > 0.0
+    end
+  end
+
+  describe '#belief_drift' do
+    it 'returns 0.0 with no history' do
+      pal.overwrite!('v1', confidence: 0.7)
+      expect(pal.belief_drift).to eq(0.0)
+    end
+
+    it 'measures distance from origin to current' do
+      pal.overwrite!('v1', confidence: 0.3)
+      pal.overwrite!('v2', confidence: 0.8)
+      expect(pal.belief_drift).to be_within(0.01).of(0.5)
+    end
+  end
+
+  describe '#drift_label' do
+    it 'returns a symbol' do
+      pal.overwrite!('v1', confidence: 0.3)
+      pal.overwrite!('v2', confidence: 0.9)
+      expect(pal.drift_label).to be_a(Symbol)
+    end
+  end
+
+  describe '#decay_ghosts!' do
+    it 'erodes all historical layers' do
+      pal.overwrite!('v1', confidence: 0.8)
+      pal.overwrite!('v2')
+      old_conf = pal.historical_layers.first.confidence
+      pal.decay_ghosts!
+      expect(pal.historical_layers.first.confidence).to be < old_conf
+    end
+  end
+
+  describe '#to_h' do
+    before { pal.overwrite!('v1') }
+
+    it 'returns expected keys' do
+      h = pal.to_h
+      expect(h).to include(:id, :topic, :domain, :layer_count, :overwrite_count,
+                           :ghost_count, :restoration_strength, :belief_drift,
+                           :drift_label, :current_layer, :created_at)
+    end
+  end
+end