lex-agentic-learning 0.1.0

data/spec/legion/extensions/agentic/learning/anchoring/helpers/anchor_spec.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Learning::Anchoring::Helpers::Anchor do
+  subject(:anchor) { described_class.new(value: 100.0, domain: :financial) }
+
+  describe '#initialize' do
+    it 'sets value as float' do
+      expect(anchor.value).to eq(100.0)
+    end
+
+    it 'sets domain as symbol' do
+      expect(anchor.domain).to eq(:financial)
+    end
+
+    it 'sets initial strength to 1.0' do
+      expect(anchor.strength).to eq(1.0)
+    end
+
+    it 'generates a uuid id' do
+      expect(anchor.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'sets created_at' do
+      expect(anchor.created_at).to be_a(Time)
+    end
+
+    it 'sets last_accessed' do
+      expect(anchor.last_accessed).to be_a(Time)
+    end
+
+    it 'accepts integer value and converts to float' do
+      a = described_class.new(value: 50, domain: :general)
+      expect(a.value).to eq(50.0)
+    end
+
+    it 'defaults domain to :general when not specified' do
+      a = described_class.new(value: 10.0)
+      expect(a.domain).to eq(:general)
+    end
+  end
+
+  describe '#decay' do
+    it 'reduces strength by ANCHOR_DECAY' do
+      before = anchor.strength
+      anchor.decay
+      expect(anchor.strength).to be_within(0.001).of(before - Legion::Extensions::Agentic::Learning::Anchoring::Helpers::Constants::ANCHOR_DECAY)
+    end
+
+    it 'does not go below 0.0' do
+      50.times { anchor.decay }
+      expect(anchor.strength).to eq(0.0)
+    end
+  end
+
+  describe '#reinforce' do
+    it 'updates the value toward observed_value via EMA' do
+      anchor.reinforce(observed_value: 200.0)
+      expect(anchor.value).to be > 100.0
+      expect(anchor.value).to be < 200.0
+    end
+
+    it 'bumps strength up (capped at 1.0)' do
+      anchor.decay
+      before = anchor.strength
+      anchor.reinforce(observed_value: 100.0)
+      expect(anchor.strength).to be > before
+    end
+
+    it 'updates last_accessed' do
+      before = anchor.last_accessed
+      sleep 0.001
+      anchor.reinforce(observed_value: 100.0)
+      expect(anchor.last_accessed).to be >= before
+    end
+  end
+
+  describe '#pull' do
+    it 'returns a value between anchor value and estimate' do
+      result = anchor.pull(estimate: 200.0)
+      expect(result).to be > 100.0
+      expect(result).to be < 200.0
+    end
+
+    it 'pulls estimate closer to anchor value' do
+      biased = anchor.pull(estimate: 200.0)
+      expect((biased - 100.0).abs).to be < (200.0 - 100.0).abs
+    end
+
+    it 'returns anchor value when estimate equals anchor value' do
+      result = anchor.pull(estimate: 100.0)
+      expect(result).to be_within(0.001).of(100.0)
+    end
+  end
+
+  describe '#label' do
+    it 'returns :strong at full strength' do
+      expect(anchor.label).to eq(:strong)
+    end
+
+    it 'returns :moderate at moderate strength' do
+      anchor.instance_variable_set(:@strength, 0.6)
+      expect(anchor.label).to eq(:moderate)
+    end
+
+    it 'returns :weak at weak strength' do
+      anchor.instance_variable_set(:@strength, 0.35)
+      expect(anchor.label).to eq(:weak)
+    end
+
+    it 'returns :fading at very low strength' do
+      anchor.instance_variable_set(:@strength, 0.1)
+      expect(anchor.label).to eq(:fading)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with all expected keys' do
+      h = anchor.to_h
+      expect(h).to include(:id, :value, :domain, :strength, :label, :created_at, :last_accessed)
+    end
+
+    it 'includes correct value' do
+      expect(anchor.to_h[:value]).to eq(100.0)
+    end
+
+    it 'includes label' do
+      expect(anchor.to_h[:label]).to eq(:strong)
+    end
+  end
+end

data/spec/legion/extensions/agentic/learning/anchoring/helpers/anchor_store_spec.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Learning::Anchoring::Helpers::AnchorStore do
+  subject(:store) { described_class.new }
+
+  describe '#add' do
+    it 'creates and returns an Anchor' do
+      anchor = store.add(value: 50.0, domain: :financial)
+      expect(anchor).to be_a(Legion::Extensions::Agentic::Learning::Anchoring::Helpers::Anchor)
+    end
+
+    it 'stores anchors per domain' do
+      store.add(value: 50.0, domain: :financial)
+      store.add(value: 80.0, domain: :financial)
+      store.add(value: 10.0, domain: :temporal)
+      expect(store.domains).to include(:financial, :temporal)
+    end
+
+    it 'enforces MAX_ANCHORS_PER_DOMAIN limit' do
+      max = Legion::Extensions::Agentic::Learning::Anchoring::Helpers::Constants::MAX_ANCHORS_PER_DOMAIN
+      (max + 5).times { |i| store.add(value: i.to_f, domain: :financial) }
+      all = store.instance_variable_get(:@anchors)[:financial]
+      expect(all.size).to be <= max
+    end
+
+    it 'accepts integer value' do
+      anchor = store.add(value: 100, domain: :general)
+      expect(anchor.value).to eq(100.0)
+    end
+  end
+
+  describe '#strongest' do
+    it 'returns nil for unknown domain' do
+      expect(store.strongest(domain: :unknown)).to be_nil
+    end
+
+    it 'returns the anchor with highest strength' do
+      a1 = store.add(value: 10.0, domain: :financial)
+      a2 = store.add(value: 20.0, domain: :financial)
+      a1.instance_variable_set(:@strength, 0.3)
+      a2.instance_variable_set(:@strength, 0.9)
+      expect(store.strongest(domain: :financial).value).to eq(20.0)
+    end
+  end
+
+  describe '#find' do
+    it 'finds anchor by id' do
+      anchor = store.add(value: 42.0, domain: :general)
+      found  = store.find(id: anchor.id)
+      expect(found).to eq(anchor)
+    end
+
+    it 'returns nil for unknown id' do
+      expect(store.find(id: 'nonexistent')).to be_nil
+    end
+  end
+
+  describe '#evaluate' do
+    it 'returns no-pull result when domain has no anchors' do
+      result = store.evaluate(estimate: 100.0, domain: :empty)
+      expect(result[:pull_strength]).to eq(0.0)
+      expect(result[:anchored_estimate]).to eq(100.0)
+      expect(result[:anchor_value]).to be_nil
+    end
+
+    it 'returns biased estimate when anchor exists' do
+      store.add(value: 50.0, domain: :financial)
+      result = store.evaluate(estimate: 100.0, domain: :financial)
+      expect(result[:anchored_estimate]).to be > 50.0
+      expect(result[:anchored_estimate]).to be < 100.0
+    end
+
+    it 'includes pull_strength, anchor_value, correction keys' do
+      store.add(value: 50.0, domain: :financial)
+      result = store.evaluate(estimate: 100.0, domain: :financial)
+      expect(result).to include(:pull_strength, :anchor_value, :correction)
+    end
+
+    it 'correction is estimate minus anchored_estimate' do
+      store.add(value: 50.0, domain: :financial)
+      result = store.evaluate(estimate: 100.0, domain: :financial)
+      expect(result[:correction]).to be_within(0.001).of(100.0 - result[:anchored_estimate])
+    end
+  end
+
+  describe '#reference_frame' do
+    it 'returns neutral when no reference or anchor' do
+      result = store.reference_frame(value: 100.0, domain: :empty)
+      expect(result[:gain_or_loss]).to eq(:neutral)
+      expect(result[:magnitude]).to eq(0.0)
+    end
+
+    it 'detects gain when value above reference' do
+      store.shift_reference(domain: :financial, new_reference: 50.0)
+      result = store.reference_frame(value: 100.0, domain: :financial)
+      expect(result[:gain_or_loss]).to eq(:gain)
+      expect(result[:magnitude]).to be > 0
+    end
+
+    it 'detects loss when value below reference' do
+      store.shift_reference(domain: :financial, new_reference: 100.0)
+      result = store.reference_frame(value: 50.0, domain: :financial)
+      expect(result[:gain_or_loss]).to eq(:loss)
+    end
+
+    it 'applies loss aversion factor to losses' do
+      store.shift_reference(domain: :financial, new_reference: 100.0)
+      result = store.reference_frame(value: 50.0, domain: :financial)
+      raw_diff = 50.0
+      expected_magnitude = raw_diff * Legion::Extensions::Agentic::Learning::Anchoring::Helpers::Constants::LOSS_AVERSION_FACTOR
+      expect(result[:magnitude]).to be_within(0.001).of(expected_magnitude)
+    end
+
+    it 'does not apply loss aversion to gains' do
+      store.shift_reference(domain: :financial, new_reference: 50.0)
+      result = store.reference_frame(value: 100.0, domain: :financial)
+      expect(result[:magnitude]).to be_within(0.001).of(50.0)
+    end
+
+    it 'uses anchor as implicit reference when no explicit reference set' do
+      store.add(value: 50.0, domain: :financial)
+      result = store.reference_frame(value: 100.0, domain: :financial)
+      expect(result[:gain_or_loss]).to eq(:gain)
+    end
+  end
+
+  describe '#decay_all' do
+    it 'decays all anchors and returns pruned count' do
+      store.add(value: 10.0, domain: :financial)
+      pruned = store.decay_all
+      expect(pruned).to be >= 0
+    end
+
+    it 'prunes anchors that fall below ANCHOR_FLOOR' do
+      anchor = store.add(value: 10.0, domain: :financial)
+      anchor.instance_variable_set(:@strength, Legion::Extensions::Agentic::Learning::Anchoring::Helpers::Constants::ANCHOR_FLOOR - 0.001)
+      store.decay_all
+      expect(store.domains).not_to include(:financial)
+    end
+
+    it 'retains anchors above floor' do
+      store.add(value: 10.0, domain: :financial)
+      store.decay_all
+      all = store.instance_variable_get(:@anchors)[:financial]
+      expect(all).not_to be_nil
+    end
+  end
+
+  describe '#shift_reference' do
+    it 'sets new reference point for domain' do
+      store.shift_reference(domain: :financial, new_reference: 100.0)
+      refs = store.instance_variable_get(:@references)
+      expect(refs[:financial]).to eq(100.0)
+    end
+
+    it 'returns old and new reference' do
+      store.shift_reference(domain: :financial, new_reference: 50.0)
+      result = store.shift_reference(domain: :financial, new_reference: 100.0)
+      expect(result[:old_reference]).to eq(50.0)
+      expect(result[:new_reference]).to eq(100.0)
+    end
+
+    it 'marks shift as significant when diff >= REFERENCE_SHIFT_THRESHOLD' do
+      store.shift_reference(domain: :temporal, new_reference: 0.0)
+      result = store.shift_reference(domain: :temporal, new_reference: 1.0)
+      expect(result[:significant]).to be true
+    end
+
+    it 'marks shift as not significant when diff < REFERENCE_SHIFT_THRESHOLD' do
+      store.shift_reference(domain: :temporal, new_reference: 0.0)
+      result = store.shift_reference(domain: :temporal, new_reference: 0.1)
+      expect(result[:significant]).to be false
+    end
+  end
+
+  describe '#domains' do
+    it 'returns empty array when no anchors' do
+      expect(store.domains).to be_empty
+    end
+
+    it 'returns list of active domains' do
+      store.add(value: 1.0, domain: :financial)
+      store.add(value: 2.0, domain: :temporal)
+      expect(store.domains).to match_array(%i[financial temporal])
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns summary hash' do
+      store.add(value: 10.0, domain: :financial)
+      h = store.to_h
+      expect(h).to include(:total_anchors, :domain_count, :domains, :references)
+    end
+
+    it 'reflects correct total_anchors count' do
+      store.add(value: 10.0, domain: :financial)
+      store.add(value: 20.0, domain: :financial)
+      expect(store.to_h[:total_anchors]).to eq(2)
+    end
+  end
+end

data/spec/legion/extensions/agentic/learning/anchoring/helpers/constants_spec.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Learning::Anchoring::Helpers::Constants do
+  it 'defines DEFAULT_ANCHOR_WEIGHT as 0.6' do
+    expect(described_module::DEFAULT_ANCHOR_WEIGHT).to eq(0.6)
+  end
+
+  it 'defines ADJUSTMENT_RATE as 0.1' do
+    expect(described_module::ADJUSTMENT_RATE).to eq(0.1)
+  end
+
+  it 'defines ANCHOR_DECAY as 0.02' do
+    expect(described_module::ANCHOR_DECAY).to eq(0.02)
+  end
+
+  it 'defines ANCHOR_FLOOR as 0.05' do
+    expect(described_module::ANCHOR_FLOOR).to eq(0.05)
+  end
+
+  it 'defines MAX_ANCHORS_PER_DOMAIN as 20' do
+    expect(described_module::MAX_ANCHORS_PER_DOMAIN).to eq(20)
+  end
+
+  it 'defines MAX_DOMAINS as 50' do
+    expect(described_module::MAX_DOMAINS).to eq(50)
+  end
+
+  it 'defines REFERENCE_SHIFT_THRESHOLD as 0.3' do
+    expect(described_module::REFERENCE_SHIFT_THRESHOLD).to eq(0.3)
+  end
+
+  it 'defines LOSS_AVERSION_FACTOR as 2.25' do
+    expect(described_module::LOSS_AVERSION_FACTOR).to eq(2.25)
+  end
+
+  it 'defines ANCHOR_LABELS with 4 entries' do
+    expect(described_module::ANCHOR_LABELS.size).to eq(4)
+  end
+
+  it 'ANCHOR_LABELS maps high strength to :strong' do
+    label = described_module::ANCHOR_LABELS.find { |range, _| range.cover?(0.9) }&.last
+    expect(label).to eq(:strong)
+  end
+
+  it 'ANCHOR_LABELS maps mid strength to :moderate' do
+    label = described_module::ANCHOR_LABELS.find { |range, _| range.cover?(0.6) }&.last
+    expect(label).to eq(:moderate)
+  end
+
+  it 'ANCHOR_LABELS maps low strength to :weak' do
+    label = described_module::ANCHOR_LABELS.find { |range, _| range.cover?(0.3) }&.last
+    expect(label).to eq(:weak)
+  end
+
+  it 'ANCHOR_LABELS maps very low strength to :fading' do
+    label = described_module::ANCHOR_LABELS.find { |range, _| range.cover?(0.1) }&.last
+    expect(label).to eq(:fading)
+  end
+
+  def described_module
+    Legion::Extensions::Agentic::Learning::Anchoring::Helpers::Constants
+  end
+end

data/spec/legion/extensions/agentic/learning/anchoring/runners/anchoring_spec.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/learning/anchoring/client'
+
+RSpec.describe Legion::Extensions::Agentic::Learning::Anchoring::Runners::Anchoring do
+  let(:client) { Legion::Extensions::Agentic::Learning::Anchoring::Client.new }
+
+  describe '#record_anchor' do
+    it 'returns success: true' do
+      result = client.record_anchor(value: 100.0, domain: :financial)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns anchor hash' do
+      result = client.record_anchor(value: 100.0, domain: :financial)
+      expect(result[:anchor]).to include(:id, :value, :domain, :strength)
+    end
+
+    it 'uses :general domain by default' do
+      result = client.record_anchor(value: 50.0)
+      expect(result[:anchor][:domain]).to eq(:general)
+    end
+
+    it 'accepts keyword splat' do
+      expect { client.record_anchor(value: 10.0, extra: :ignored) }.not_to raise_error
+    end
+  end
+
+  describe '#evaluate_estimate' do
+    it 'returns success: true' do
+      result = client.evaluate_estimate(estimate: 100.0, domain: :financial)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns no-pull when domain has no anchors' do
+      result = client.evaluate_estimate(estimate: 100.0, domain: :noanchor)
+      expect(result[:pull_strength]).to eq(0.0)
+      expect(result[:anchored_estimate]).to eq(100.0)
+    end
+
+    it 'biases estimate toward anchor when anchor exists' do
+      client.record_anchor(value: 50.0, domain: :financial)
+      result = client.evaluate_estimate(estimate: 100.0, domain: :financial)
+      expect(result[:anchored_estimate]).to be < 100.0
+      expect(result[:anchored_estimate]).to be > 50.0
+    end
+
+    it 'includes pull_strength, anchor_value, correction' do
+      client.record_anchor(value: 50.0, domain: :financial)
+      result = client.evaluate_estimate(estimate: 100.0, domain: :financial)
+      expect(result).to include(:pull_strength, :anchor_value, :correction)
+    end
+  end
+
+  describe '#reference_frame' do
+    it 'returns success: true' do
+      result = client.reference_frame(value: 100.0, domain: :financial)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns neutral for domain without reference' do
+      result = client.reference_frame(value: 100.0, domain: :empty_domain)
+      expect(result[:gain_or_loss]).to eq(:neutral)
+    end
+
+    it 'detects gain after setting reference' do
+      client.shift_reference(domain: :financial, new_reference: 50.0)
+      result = client.reference_frame(value: 100.0, domain: :financial)
+      expect(result[:gain_or_loss]).to eq(:gain)
+    end
+
+    it 'detects loss after setting reference' do
+      client.shift_reference(domain: :financial, new_reference: 100.0)
+      result = client.reference_frame(value: 50.0, domain: :financial)
+      expect(result[:gain_or_loss]).to eq(:loss)
+    end
+
+    it 'applies loss aversion factor to losses' do
+      client.shift_reference(domain: :financial, new_reference: 100.0)
+      result = client.reference_frame(value: 50.0, domain: :financial)
+      expect(result[:magnitude]).to be_within(0.001).of(50.0 * 2.25)
+    end
+  end
+
+  describe '#de_anchor' do
+    it 'returns success: true' do
+      result = client.de_anchor(estimate: 100.0, domain: :empty_de)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns original estimate with zero bias when no anchor' do
+      result = client.de_anchor(estimate: 100.0, domain: :no_anchor_domain)
+      expect(result[:corrected_estimate]).to eq(100.0)
+      expect(result[:anchor_bias]).to eq(0.0)
+    end
+
+    it 'returns corrected estimate that removes anchor bias' do
+      client.record_anchor(value: 50.0, domain: :financial)
+      result = client.de_anchor(estimate: 100.0, domain: :financial)
+      expect(result[:corrected_estimate]).to be > 100.0
+    end
+
+    it 'returns anchor_value when anchor present' do
+      client.record_anchor(value: 50.0, domain: :financial)
+      result = client.de_anchor(estimate: 100.0, domain: :financial)
+      expect(result[:anchor_value]).to eq(50.0)
+    end
+
+    it 'includes original_estimate' do
+      client.record_anchor(value: 50.0, domain: :financial)
+      result = client.de_anchor(estimate: 100.0, domain: :financial)
+      expect(result[:original_estimate]).to eq(100.0)
+    end
+  end
+
+  describe '#shift_reference' do
+    it 'returns success: true' do
+      result = client.shift_reference(domain: :financial, new_reference: 100.0)
+      expect(result[:success]).to be true
+    end
+
+    it 'includes domain, old_reference, new_reference, significant' do
+      result = client.shift_reference(domain: :financial, new_reference: 100.0)
+      expect(result).to include(:domain, :old_reference, :new_reference, :significant)
+    end
+
+    it 'marks large shift as significant' do
+      client.shift_reference(domain: :financial, new_reference: 0.0)
+      result = client.shift_reference(domain: :financial, new_reference: 1.0)
+      expect(result[:significant]).to be true
+    end
+  end
+
+  describe '#update_anchoring' do
+    it 'returns success: true' do
+      result = client.update_anchoring
+      expect(result[:success]).to be true
+    end
+
+    it 'returns pruned count' do
+      result = client.update_anchoring
+      expect(result).to have_key(:pruned)
+    end
+
+    it 'decays existing anchors' do
+      client.record_anchor(value: 100.0, domain: :financial)
+      anchor = client.anchor_store.strongest(domain: :financial)
+      before_strength = anchor.strength
+      client.update_anchoring
+      expect(anchor.strength).to be < before_strength
+    end
+  end
+
+  describe '#domain_anchors' do
+    it 'returns success: true' do
+      result = client.domain_anchors(domain: :financial)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns empty anchors for unknown domain' do
+      result = client.domain_anchors(domain: :no_such_domain)
+      expect(result[:count]).to eq(0)
+      expect(result[:anchors]).to eq([])
+    end
+
+    it 'returns anchors for known domain' do
+      client.record_anchor(value: 100.0, domain: :financial)
+      result = client.domain_anchors(domain: :financial)
+      expect(result[:count]).to eq(1)
+      expect(result[:anchors].first[:value]).to eq(100.0)
+    end
+
+    it 'includes strongest anchor' do
+      client.record_anchor(value: 100.0, domain: :financial)
+      result = client.domain_anchors(domain: :financial)
+      expect(result[:strongest]).not_to be_nil
+    end
+  end
+
+  describe '#anchoring_stats' do
+    it 'returns success: true' do
+      result = client.anchoring_stats
+      expect(result[:success]).to be true
+    end
+
+    it 'includes total_anchors, domain_count, domains' do
+      result = client.anchoring_stats
+      expect(result).to include(:total_anchors, :domain_count, :domains)
+    end
+
+    it 'reflects anchor counts' do
+      client.record_anchor(value: 10.0, domain: :financial)
+      client.record_anchor(value: 20.0, domain: :temporal)
+      result = client.anchoring_stats
+      expect(result[:total_anchors]).to eq(2)
+      expect(result[:domain_count]).to eq(2)
+    end
+  end
+end

data/spec/legion/extensions/agentic/learning/catalyst/client_spec.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Learning::Catalyst::Client do
+  subject(:client) { described_class.new }
+
+  it 'includes Runners::CognitiveCatalyst' do
+    expect(client).to respond_to(:create_catalyst)
+    expect(client).to respond_to(:create_reaction)
+    expect(client).to respond_to(:apply_catalyst)
+    expect(client).to respond_to(:attempt_reaction)
+    expect(client).to respond_to(:recharge)
+    expect(client).to respond_to(:list_catalysts)
+    expect(client).to respond_to(:catalyst_status)
+  end
+
+  it 'can create and then apply a catalyst to a reaction' do
+    engine = Legion::Extensions::Agentic::Learning::Catalyst::Helpers::CatalystEngine.new
+    cat = client.create_catalyst(catalyst_type: :experience, domain: :learning,
+                                 potency: 0.9, specificity: 0.9, engine: engine)
+    rxn = client.create_reaction(reaction_type: :synthesis, reactants: %w[a b], engine: engine)
+    result = client.apply_catalyst(catalyst_id: cat[:catalyst][:id],
+                                   reaction_id: rxn[:reaction][:id],
+                                   engine:      engine)
+    expect(result[:success]).to be true
+    expect(result[:activation_energy]).to be < 0.6
+  end
+
+  it 'can complete a full catalyst workflow: create -> apply -> attempt -> report' do
+    engine = Legion::Extensions::Agentic::Learning::Catalyst::Helpers::CatalystEngine.new
+    cat = client.create_catalyst(catalyst_type: :insight, domain: :reasoning,
+                                 potency: 1.0, specificity: 1.0, engine: engine)
+    rxn = client.create_reaction(reaction_type:     :decomposition,
+                                 reactants:         %w[complex_idea],
+                                 activation_energy: 0.1,
+                                 engine:            engine)
+    client.apply_catalyst(catalyst_id: cat[:catalyst][:id],
+                          reaction_id: rxn[:reaction][:id],
+                          engine:      engine)
+    result = client.attempt_reaction(reaction_id:  rxn[:reaction][:id],
+                                     energy_input: 0.8,
+                                     engine:       engine)
+    expect(result[:completed]).to be true
+    expect(result[:catalyzed]).to be true
+    status = client.catalyst_status(engine: engine)
+    expect(status[:catalyzed_count]).to eq(1)
+    expect(status[:catalyzed_rate]).to eq(1.0)
+  end
+
+  it 'maintains separate state per client instance' do
+    c1 = described_class.new
+    c2 = described_class.new
+    c1.create_catalyst(catalyst_type: :insight, domain: :d)
+    s1 = c1.catalyst_status
+    s2 = c2.catalyst_status
+    expect(s1[:total_catalysts]).to eq(1)
+    expect(s2[:total_catalysts]).to eq(0)
+  end
+end