lex-agentic-memory 0.1.0

data/spec/legion/extensions/agentic/memory/palimpsest/runners/cognitive_palimpsest_spec.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Palimpsest::Runners::CognitivePalimpsest do
+  let(:engine) { Legion::Extensions::Agentic::Memory::Palimpsest::Helpers::PalimpsestEngine.new }
+  let(:runner) do
+    obj = Object.new
+    obj.extend(described_class)
+    obj
+  end
+
+  describe '#create_palimpsest' do
+    it 'creates a palimpsest' do
+      result = runner.create_palimpsest(topic: 'memory', domain: :factual)
+      expect(result[:success]).to be true
+      expect(result[:topic]).to eq('memory')
+    end
+
+    it 'returns failure for duplicate topic' do
+      runner.create_palimpsest(topic: 'dupe')
+      result = runner.create_palimpsest(topic: 'dupe')
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:limit_or_duplicate)
+    end
+  end
+
+  describe '#overwrite_belief' do
+    it 'overwrites a belief' do
+      result = runner.overwrite_belief(topic: 'sky', content: 'blue', confidence: 0.8)
+      expect(result[:success]).to be true
+      expect(result[:version]).to eq(1)
+      expect(result[:confidence]).to eq(0.8)
+    end
+
+    it 'increments version on subsequent writes' do
+      runner.overwrite_belief(topic: 'sky', content: 'v1')
+      result = runner.overwrite_belief(topic: 'sky', content: 'v2')
+      expect(result[:version]).to eq(2)
+    end
+
+    it 'accepts custom engine' do
+      result = runner.overwrite_belief(topic: 'x', content: 'y', engine: engine)
+      expect(result[:success]).to be true
+      expect(engine.palimpsests).to have_key('x')
+    end
+  end
+
+  describe '#peek_through_belief' do
+    it 'returns previous layers' do
+      runner.overwrite_belief(topic: 'p', content: 'v1')
+      runner.overwrite_belief(topic: 'p', content: 'v2')
+      result = runner.peek_through_belief(topic: 'p', depth: 1)
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(1)
+      expect(result[:layers].first[:content]).to eq('v1')
+    end
+
+    it 'returns empty for topic with no history' do
+      runner.overwrite_belief(topic: 'fresh', content: 'v1')
+      result = runner.peek_through_belief(topic: 'fresh')
+      expect(result[:count]).to eq(0)
+    end
+  end
+
+  describe '#erode_belief' do
+    it 'erodes current layer confidence' do
+      runner.overwrite_belief(topic: 'e', content: 'x', confidence: 0.8)
+      result = runner.erode_belief(topic: 'e')
+      expect(result[:success]).to be true
+      expect(result[:confidence]).to be < 0.8
+    end
+
+    it 'returns failure for unknown topic' do
+      result = runner.erode_belief(topic: 'missing')
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:not_found)
+    end
+  end
+
+  describe '#ghost_layers' do
+    it 'returns ghost layers for topic' do
+      runner.overwrite_belief(topic: 'g', content: 'v1', confidence: 0.8)
+      runner.overwrite_belief(topic: 'g', content: 'v2')
+      result = runner.ghost_layers(topic: 'g')
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#all_ghost_layers' do
+    it 'aggregates ghosts from all palimpsests' do
+      runner.overwrite_belief(topic: 'a', content: 'v1', confidence: 0.8)
+      runner.overwrite_belief(topic: 'a', content: 'v2')
+      result = runner.all_ghost_layers
+      expect(result[:success]).to be true
+      expect(result[:count]).to be >= 1
+    end
+  end
+
+  describe '#domain_archaeology' do
+    it 'returns all layers for domain' do
+      runner.create_palimpsest(topic: 'arch', domain: :procedural)
+      runner.overwrite_belief(topic: 'arch', content: 'v1')
+      runner.overwrite_belief(topic: 'arch', content: 'v2')
+      result = runner.domain_archaeology(domain: :procedural)
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(2)
+    end
+  end
+
+  describe '#belief_drift' do
+    it 'returns drift info' do
+      runner.overwrite_belief(topic: 'd', content: 'v1', confidence: 0.2)
+      runner.overwrite_belief(topic: 'd', content: 'v2', confidence: 0.9)
+      result = runner.belief_drift(topic: 'd')
+      expect(result[:success]).to be true
+      expect(result[:drift]).to be > 0
+    end
+
+    it 'returns failure for unknown topic' do
+      result = runner.belief_drift(topic: 'ghost_topic')
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#overwrite_frequency' do
+    it 'returns overwrite count' do
+      3.times { |i| runner.overwrite_belief(topic: 'freq', content: "v#{i}") }
+      result = runner.overwrite_frequency(topic: 'freq')
+      expect(result[:success]).to be true
+      expect(result[:overwrite_count]).to eq(3)
+    end
+
+    it 'returns failure for unknown topic' do
+      result = runner.overwrite_frequency(topic: 'missing')
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#most_rewritten' do
+    it 'returns sorted list' do
+      3.times { runner.overwrite_belief(topic: 'hot', content: "v#{it}") }
+      runner.overwrite_belief(topic: 'cold', content: 'v1')
+      result = runner.most_rewritten(limit: 2)
+      expect(result[:success]).to be true
+      expect(result[:palimpsests].first[:topic]).to eq('hot')
+    end
+  end
+
+  describe '#decay_all_ghosts' do
+    it 'returns success' do
+      result = runner.decay_all_ghosts
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#palimpsest_report' do
+    it 'returns report with expected keys' do
+      runner.overwrite_belief(topic: 'rep', content: 'v1', confidence: 0.8)
+      runner.overwrite_belief(topic: 'rep', content: 'v2')
+      result = runner.palimpsest_report
+      expect(result[:success]).to be true
+      expect(result).to include(:palimpsest_count, :total_ghosts, :average_drift)
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Reserve::Client do
+  subject(:client) { described_class.new }
+
+  describe '#add_cognitive_pathway' do
+    it 'delegates to runner' do
+      result = client.add_cognitive_pathway(function: :reasoning)
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#damage_cognitive_pathway' do
+    it 'damages and reports state' do
+      pathway = client.add_cognitive_pathway(function: :test)
+      result = client.damage_cognitive_pathway(pathway_id: pathway[:pathway_id], amount: 0.3)
+      expect(result[:state]).to eq(:healthy)
+    end
+  end
+
+  describe '#cognitive_reserve_stats' do
+    it 'returns stats' do
+      result = client.cognitive_reserve_stats
+      expect(result[:success]).to be true
+      expect(result[:pathway_count]).to eq(0)
+    end
+  end
+
+  describe 'with injected engine' do
+    it 'uses the provided engine' do
+      engine = Legion::Extensions::Agentic::Memory::Reserve::Helpers::ReserveEngine.new
+      engine.add_pathway(function: :preloaded)
+      custom_client = described_class.new(engine: engine)
+      expect(custom_client.cognitive_reserve_stats[:pathway_count]).to eq(1)
+    end
+  end
+end

data/spec/legion/extensions/agentic/memory/reserve/helpers/pathway_spec.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Reserve::Helpers::Pathway do
+  subject(:pathway) do
+    described_class.new(id: :path_one, function: :reasoning, domain: :cognition)
+  end
+
+  let(:constants) { Legion::Extensions::Agentic::Memory::Reserve::Helpers::Constants }
+
+  describe '#initialize' do
+    it 'sets id' do
+      expect(pathway.id).to eq(:path_one)
+    end
+
+    it 'sets function' do
+      expect(pathway.function).to eq(:reasoning)
+    end
+
+    it 'sets domain' do
+      expect(pathway.domain).to eq(:cognition)
+    end
+
+    it 'starts at full capacity' do
+      expect(pathway.capacity).to eq(1.0)
+    end
+
+    it 'starts healthy' do
+      expect(pathway.state).to eq(:healthy)
+    end
+
+    it 'starts with empty backups' do
+      expect(pathway.backup_ids).to be_empty
+    end
+
+    it 'clamps capacity above ceiling' do
+      p = described_class.new(id: :x, function: :test, capacity: 1.5)
+      expect(p.capacity).to eq(constants::CAPACITY_CEILING)
+    end
+
+    it 'clamps capacity below floor' do
+      p = described_class.new(id: :x, function: :test, capacity: -0.5)
+      expect(p.capacity).to eq(constants::CAPACITY_FLOOR)
+    end
+  end
+
+  describe '#damage' do
+    it 'reduces capacity' do
+      pathway.damage(amount: 0.3)
+      expect(pathway.capacity).to eq(0.7)
+    end
+
+    it 'increments damage count' do
+      pathway.damage(amount: 0.1)
+      expect(pathway.damage_count).to eq(1)
+    end
+
+    it 'clamps at floor' do
+      pathway.damage(amount: 2.0)
+      expect(pathway.capacity).to eq(0.0)
+    end
+
+    it 'returns self for chaining' do
+      expect(pathway.damage(amount: 0.1)).to be(pathway)
+    end
+  end
+
+  describe '#recover' do
+    before { pathway.damage(amount: 0.5) }
+
+    it 'increases capacity' do
+      original = pathway.capacity
+      pathway.recover(amount: 0.1)
+      expect(pathway.capacity).to be > original
+    end
+
+    it 'clamps at ceiling' do
+      pathway.recover(amount: 2.0)
+      expect(pathway.capacity).to eq(1.0)
+    end
+  end
+
+  describe '#add_backup' do
+    it 'adds a backup pathway ID' do
+      pathway.add_backup(pathway_id: :backup_one)
+      expect(pathway.backup_ids).to include(:backup_one)
+    end
+
+    it 'ignores duplicates' do
+      pathway.add_backup(pathway_id: :backup_one)
+      pathway.add_backup(pathway_id: :backup_one)
+      expect(pathway.backup_ids.size).to eq(1)
+    end
+  end
+
+  describe '#remove_backup' do
+    it 'removes a backup' do
+      pathway.add_backup(pathway_id: :backup_one)
+      pathway.remove_backup(pathway_id: :backup_one)
+      expect(pathway.backup_ids).to be_empty
+    end
+  end
+
+  describe '#state' do
+    it 'is :healthy at full capacity' do
+      expect(pathway.state).to eq(:healthy)
+    end
+
+    it 'is :degraded below threshold without backups' do
+      pathway.damage(amount: 0.6)
+      expect(pathway.state).to eq(:degraded)
+    end
+
+    it 'is :compensating below threshold with backups' do
+      pathway.add_backup(pathway_id: :backup_one)
+      pathway.damage(amount: 0.6)
+      expect(pathway.state).to eq(:compensating)
+    end
+
+    it 'is :failed at very low capacity' do
+      pathway.damage(amount: 0.95)
+      expect(pathway.state).to eq(:failed)
+    end
+  end
+
+  describe '#effective_capacity' do
+    it 'returns raw capacity when healthy' do
+      expect(pathway.effective_capacity).to eq(1.0)
+    end
+
+    it 'compensates when degraded with backup capacities' do
+      pathway.damage(amount: 0.7)
+      effective = pathway.effective_capacity(backup_capacities: [0.8])
+      expect(effective).to be > pathway.capacity
+    end
+
+    it 'does not exceed threshold with compensation' do
+      pathway.damage(amount: 0.6)
+      effective = pathway.effective_capacity(backup_capacities: [1.0, 1.0])
+      expect(effective).to be <= constants::CAPACITY_CEILING
+    end
+  end
+
+  describe '#redundancy' do
+    it 'returns zero with no backups' do
+      expect(pathway.redundancy).to eq(0)
+    end
+
+    it 'returns backup count' do
+      pathway.add_backup(pathway_id: :a)
+      pathway.add_backup(pathway_id: :b)
+      expect(pathway.redundancy).to eq(2)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns expected keys' do
+      h = pathway.to_h
+      expect(h).to include(
+        :id, :function, :domain, :capacity, :state,
+        :backup_count, :backup_ids, :damage_count,
+        :compensation_count, :created_at, :updated_at
+      )
+    end
+  end
+end

data/spec/legion/extensions/agentic/memory/reserve/helpers/reserve_engine_spec.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Reserve::Helpers::ReserveEngine do
+  subject(:engine) { described_class.new }
+
+  let(:constants) { Legion::Extensions::Agentic::Memory::Reserve::Helpers::Constants }
+
+  describe '#initialize' do
+    it 'starts with empty pathways' do
+      expect(engine.pathways).to be_empty
+    end
+
+    it 'starts with empty history' do
+      expect(engine.history).to be_empty
+    end
+  end
+
+  describe '#add_pathway' do
+    it 'creates a pathway' do
+      pathway = engine.add_pathway(function: :reasoning)
+      expect(pathway).to be_a(Legion::Extensions::Agentic::Memory::Reserve::Helpers::Pathway)
+    end
+
+    it 'stores the pathway' do
+      pathway = engine.add_pathway(function: :memory)
+      expect(engine.pathways[pathway.id]).to be(pathway)
+    end
+
+    it 'respects limit' do
+      constants::MAX_PATHWAYS.times { |i| engine.add_pathway(function: :"fn_#{i}") }
+      expect(engine.add_pathway(function: :overflow)).to be_nil
+    end
+  end
+
+  describe '#link_backup' do
+    let!(:primary) { engine.add_pathway(function: :reasoning) }
+    let!(:backup) { engine.add_pathway(function: :reasoning_backup) }
+
+    it 'links backup to primary' do
+      engine.link_backup(primary_id: primary.id, backup_id: backup.id)
+      expect(primary.backup_ids).to include(backup.id)
+    end
+
+    it 'returns nil for unknown IDs' do
+      expect(engine.link_backup(primary_id: :nonexistent, backup_id: backup.id)).to be_nil
+    end
+  end
+
+  describe '#damage_pathway' do
+    let!(:pathway) { engine.add_pathway(function: :reasoning) }
+
+    it 'reduces capacity' do
+      engine.damage_pathway(pathway_id: pathway.id, amount: 0.3)
+      expect(pathway.capacity).to eq(0.7)
+    end
+
+    it 'returns nil for unknown ID' do
+      expect(engine.damage_pathway(pathway_id: :nonexistent, amount: 0.1)).to be_nil
+    end
+
+    it 'triggers compensation when degraded with backup' do
+      backup = engine.add_pathway(function: :backup)
+      engine.link_backup(primary_id: pathway.id, backup_id: backup.id)
+      engine.damage_pathway(pathway_id: pathway.id, amount: 0.7)
+      expect(pathway.compensation_count).to be >= 1
+    end
+  end
+
+  describe '#recover_pathway' do
+    let!(:pathway) { engine.add_pathway(function: :reasoning) }
+
+    it 'increases capacity' do
+      engine.damage_pathway(pathway_id: pathway.id, amount: 0.5)
+      original = pathway.capacity
+      engine.recover_pathway(pathway_id: pathway.id, amount: 0.1)
+      expect(pathway.capacity).to be > original
+    end
+  end
+
+  describe '#effective_capacity' do
+    it 'returns capacity with compensation' do
+      primary = engine.add_pathway(function: :reasoning)
+      backup = engine.add_pathway(function: :backup)
+      engine.link_backup(primary_id: primary.id, backup_id: backup.id)
+      engine.damage_pathway(pathway_id: primary.id, amount: 0.7)
+      expect(engine.effective_capacity(pathway_id: primary.id)).to be > primary.capacity
+    end
+
+    it 'returns nil for unknown ID' do
+      expect(engine.effective_capacity(pathway_id: :nonexistent)).to be_nil
+    end
+  end
+
+  describe '#overall_reserve' do
+    it 'returns 1.0 when empty' do
+      expect(engine.overall_reserve).to eq(1.0)
+    end
+
+    it 'decreases when pathways are damaged' do
+      p = engine.add_pathway(function: :test)
+      engine.damage_pathway(pathway_id: p.id, amount: 0.5)
+      expect(engine.overall_reserve).to be < 1.0
+    end
+  end
+
+  describe '#reserve_label' do
+    it 'returns :robust when healthy' do
+      engine.add_pathway(function: :test)
+      expect(engine.reserve_label).to eq(:robust)
+    end
+
+    it 'returns worse labels when damaged' do
+      p = engine.add_pathway(function: :test)
+      engine.damage_pathway(pathway_id: p.id, amount: 0.8)
+      expect(%i[vulnerable critical reduced]).to include(engine.reserve_label)
+    end
+  end
+
+  describe '#degraded_pathways' do
+    it 'returns empty when all healthy' do
+      engine.add_pathway(function: :test)
+      expect(engine.degraded_pathways).to be_empty
+    end
+
+    it 'returns degraded pathways' do
+      p = engine.add_pathway(function: :test)
+      engine.damage_pathway(pathway_id: p.id, amount: 0.6)
+      expect(engine.degraded_pathways.size).to eq(1)
+    end
+  end
+
+  describe '#domain_reserve' do
+    it 'computes reserve for specific domain' do
+      engine.add_pathway(function: :reasoning, domain: :cognition)
+      engine.add_pathway(function: :emotion, domain: :affect)
+      expect(engine.domain_reserve(domain: :cognition)).to eq(1.0)
+    end
+
+    it 'returns default for unknown domain' do
+      expect(engine.domain_reserve(domain: :nonexistent)).to eq(1.0)
+    end
+  end
+
+  describe '#most_vulnerable' do
+    it 'returns pathways sorted by capacity ascending' do
+      healthy = engine.add_pathway(function: :healthy)
+      weak = engine.add_pathway(function: :weak)
+      engine.damage_pathway(pathway_id: weak.id, amount: 0.7)
+      result = engine.most_vulnerable(limit: 2)
+      expect(result.first[:capacity]).to be <= result.last[:capacity]
+      expect(result.first[:function]).to eq(weak.function)
+      expect(result.last[:function]).to eq(healthy.function)
+    end
+  end
+
+  describe '#most_redundant' do
+    it 'returns pathways sorted by backup count descending' do
+      redundant = engine.add_pathway(function: :main)
+      simple = engine.add_pathway(function: :simple)
+      backup = engine.add_pathway(function: :backup)
+      engine.link_backup(primary_id: redundant.id, backup_id: backup.id)
+      result = engine.most_redundant(limit: 3)
+      expect(result.first[:backup_count]).to be >= result.last[:backup_count]
+      expect(result.first[:function]).to eq(redundant.function)
+      expect(result.last[:function]).to eq(simple.function).or eq(backup.function)
+    end
+  end
+
+  describe '#recover_all' do
+    it 'recovers non-failed pathways' do
+      p = engine.add_pathway(function: :test)
+      engine.damage_pathway(pathway_id: p.id, amount: 0.3)
+      original = p.capacity
+      engine.recover_all
+      expect(p.capacity).to be > original
+    end
+
+    it 'does not recover failed pathways' do
+      p = engine.add_pathway(function: :test)
+      engine.damage_pathway(pathway_id: p.id, amount: 0.95)
+      original = p.capacity
+      engine.recover_all
+      expect(p.capacity).to eq(original)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns stats hash' do
+      h = engine.to_h
+      expect(h).to include(
+        :pathway_count, :overall_reserve, :reserve_label,
+        :healthy_count, :degraded_count, :failed_count, :history_size
+      )
+    end
+  end
+end

data/spec/legion/extensions/agentic/memory/reserve/runners/cognitive_reserve_spec.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Reserve::Runners::CognitiveReserve do
+  let(:runner_host) do
+    Object.new.tap { |o| o.extend(described_class) }
+  end
+
+  describe '#add_cognitive_pathway' do
+    it 'creates a pathway' do
+      result = runner_host.add_cognitive_pathway(function: :reasoning)
+      expect(result[:success]).to be true
+      expect(result[:pathway_id]).to be_a(Symbol)
+    end
+  end
+
+  describe '#link_backup_pathway' do
+    it 'links a backup' do
+      primary = runner_host.add_cognitive_pathway(function: :main)
+      backup = runner_host.add_cognitive_pathway(function: :backup)
+      result = runner_host.link_backup_pathway(
+        primary_id: primary[:pathway_id],
+        backup_id:  backup[:pathway_id]
+      )
+      expect(result[:success]).to be true
+      expect(result[:backup_count]).to eq(1)
+    end
+
+    it 'returns failure for unknown IDs' do
+      result = runner_host.link_backup_pathway(primary_id: :fake, backup_id: :fake)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#damage_cognitive_pathway' do
+    it 'damages and returns state' do
+      pathway = runner_host.add_cognitive_pathway(function: :test)
+      result = runner_host.damage_cognitive_pathway(pathway_id: pathway[:pathway_id], amount: 0.3)
+      expect(result[:success]).to be true
+      expect(result[:capacity]).to eq(0.7)
+    end
+
+    it 'returns failure for unknown ID' do
+      result = runner_host.damage_cognitive_pathway(pathway_id: :fake, amount: 0.1)
+      expect(result[:success]).to be false
+    end
+  end
+
+  describe '#recover_cognitive_pathway' do
+    it 'recovers capacity' do
+      pathway = runner_host.add_cognitive_pathway(function: :test)
+      runner_host.damage_cognitive_pathway(pathway_id: pathway[:pathway_id], amount: 0.5)
+      result = runner_host.recover_cognitive_pathway(pathway_id: pathway[:pathway_id], amount: 0.1)
+      expect(result[:success]).to be true
+      expect(result[:capacity]).to eq(0.6)
+    end
+  end
+
+  describe '#cognitive_reserve_assessment' do
+    it 'returns assessment with expected keys' do
+      result = runner_host.cognitive_reserve_assessment
+      expect(result[:success]).to be true
+      expect(result).to include(:overall_reserve, :reserve_label, :most_vulnerable, :degraded, :failed)
+    end
+  end
+
+  describe '#domain_cognitive_reserve' do
+    it 'returns domain-specific reserve' do
+      runner_host.add_cognitive_pathway(function: :reasoning, domain: :cognition)
+      result = runner_host.domain_cognitive_reserve(domain: :cognition)
+      expect(result[:success]).to be true
+      expect(result[:domain]).to eq(:cognition)
+    end
+  end
+
+  describe '#most_redundant_pathways' do
+    it 'returns pathways sorted by redundancy' do
+      result = runner_host.most_redundant_pathways
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#update_cognitive_reserve' do
+    it 'runs recovery and returns stats' do
+      result = runner_host.update_cognitive_reserve
+      expect(result[:success]).to be true
+      expect(result).to include(:pathway_count, :overall_reserve)
+    end
+  end
+
+  describe '#cognitive_reserve_stats' do
+    it 'returns stats' do
+      result = runner_host.cognitive_reserve_stats
+      expect(result[:success]).to be true
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Memory::Semantic::Client do
+  subject(:client) { described_class.new }
+
+  it 'includes Runners::SemanticMemory' do
+    expect(described_class.ancestors).to include(Legion::Extensions::Agentic::Memory::Semantic::Runners::SemanticMemory)
+  end
+
+  it 'supports full knowledge lifecycle' do
+    # Build a taxonomy
+    client.store_concept(name: :animal, domain: :biology, properties: { kingdom: :animalia })
+    client.relate_concepts(source: :mammal, target: :animal, type: :is_a)
+    client.relate_concepts(source: :dog, target: :mammal, type: :is_a)
+    client.relate_concepts(source: :cat, target: :mammal, type: :is_a)
+    client.relate_concepts(source: :dog, target: :tail, type: :has_a)
+
+    # Query taxonomy
+    expect(client.check_category(concept: :dog, category: :mammal)[:is_member]).to be true
+    expect(client.find_instances(category: :mammal)[:count]).to eq(2)
+
+    # Spreading activation
+    activated = client.activate_spread(seed: :dog)
+    expect(activated[:activated]).to have_key(:dog)
+
+    # Retrieve
+    concept = client.retrieve_concept(name: :dog)
+    expect(concept[:found]).to be true
+
+    # Tick
+    client.update_semantic_memory
+    stats = client.semantic_memory_stats
+    expect(stats[:stats][:concepts]).to be >= 3
+  end
+end