lex-agentic-self 0.1.0

data/spec/legion/extensions/agentic/self/agency/helpers/efficacy_model_spec.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Self::Agency::Helpers::EfficacyModel do
+  subject(:model) { described_class.new }
+
+  let(:constants) { Legion::Extensions::Agentic::Self::Agency::Helpers::Constants }
+
+  describe '#initialize' do
+    it 'starts with empty domains' do
+      expect(model.domains).to eq({})
+    end
+
+    it 'starts with empty history' do
+      expect(model.history).to eq([])
+    end
+  end
+
+  describe '#efficacy_for' do
+    it 'returns default for unknown domains' do
+      expect(model.efficacy_for(:coding)).to eq(constants::DEFAULT_EFFICACY)
+    end
+
+    it 'initializes the domain on first access' do
+      model.efficacy_for(:coding)
+      expect(model.domains).to have_key(:coding)
+    end
+  end
+
+  describe '#efficacy_label' do
+    it 'returns :uncertain for default efficacy' do
+      expect(model.efficacy_label(:new_domain)).to eq(:uncertain)
+    end
+  end
+
+  describe '#record_outcome' do
+    it 'records a success event and increases efficacy' do
+      initial = model.efficacy_for(:coding)
+      event = Legion::Extensions::Agentic::Self::Agency::Helpers::OutcomeEvent.new(domain: :coding, outcome_type: :success)
+      model.record_outcome(event)
+      expect(model.efficacy_for(:coding)).to be > initial
+    end
+
+    it 'records a failure event and decreases efficacy' do
+      initial = model.efficacy_for(:coding)
+      event = Legion::Extensions::Agentic::Self::Agency::Helpers::OutcomeEvent.new(domain: :coding, outcome_type: :failure)
+      model.record_outcome(event)
+      expect(model.efficacy_for(:coding)).to be < initial
+    end
+
+    it 'clamps efficacy within bounds' do
+      20.times do
+        event = Legion::Extensions::Agentic::Self::Agency::Helpers::OutcomeEvent.new(domain: :x, outcome_type: :success)
+        model.record_outcome(event)
+      end
+      expect(model.efficacy_for(:x)).to be <= constants::EFFICACY_CEILING
+
+      20.times do
+        event = Legion::Extensions::Agentic::Self::Agency::Helpers::OutcomeEvent.new(domain: :y, outcome_type: :failure)
+        model.record_outcome(event)
+      end
+      expect(model.efficacy_for(:y)).to be >= constants::EFFICACY_FLOOR
+    end
+
+    it 'applies vicarious multiplier' do
+      mastery = Legion::Extensions::Agentic::Self::Agency::Helpers::OutcomeEvent.new(domain: :a, outcome_type: :success, source: :mastery)
+      vicarious = Legion::Extensions::Agentic::Self::Agency::Helpers::OutcomeEvent.new(domain: :b, outcome_type: :success, source: :vicarious)
+
+      model.record_outcome(mastery)
+      model.record_outcome(vicarious)
+
+      # Mastery should have stronger effect than vicarious
+      expect(model.efficacy_for(:a)).to be > model.efficacy_for(:b)
+    end
+
+    it 'applies persuasion multiplier' do
+      event = Legion::Extensions::Agentic::Self::Agency::Helpers::OutcomeEvent.new(domain: :coding, outcome_type: :success, source: :persuasion)
+      initial = model.efficacy_for(:coding)
+      model.record_outcome(event)
+      # Persuasion has weaker effect than mastery
+      delta_persuasion = model.efficacy_for(:coding) - initial
+
+      model2 = described_class.new
+      mastery = Legion::Extensions::Agentic::Self::Agency::Helpers::OutcomeEvent.new(domain: :coding, outcome_type: :success, source: :mastery)
+      initial2 = model2.efficacy_for(:coding)
+      model2.record_outcome(mastery)
+      delta_mastery = model2.efficacy_for(:coding) - initial2
+
+      expect(delta_mastery).to be > delta_persuasion
+    end
+
+    it 'stores event in history' do
+      event = Legion::Extensions::Agentic::Self::Agency::Helpers::OutcomeEvent.new(domain: :coding, outcome_type: :success)
+      model.record_outcome(event)
+      expect(model.history.size).to eq(1)
+    end
+
+    it 'trims history at MAX_TOTAL_HISTORY' do
+      (constants::MAX_TOTAL_HISTORY + 10).times do
+        event = Legion::Extensions::Agentic::Self::Agency::Helpers::OutcomeEvent.new(domain: :coding, outcome_type: :success)
+        model.record_outcome(event)
+      end
+      expect(model.history.size).to eq(constants::MAX_TOTAL_HISTORY)
+    end
+  end
+
+  describe '#decay_all' do
+    it 'moves efficacy toward default' do
+      event = Legion::Extensions::Agentic::Self::Agency::Helpers::OutcomeEvent.new(domain: :coding, outcome_type: :success)
+      5.times { model.record_outcome(event) }
+      high = model.efficacy_for(:coding)
+
+      model.decay_all
+      expect(model.efficacy_for(:coding)).to be < high
+    end
+
+    it 'trims excess domains' do
+      (constants::MAX_DOMAINS + 5).times do |i|
+        model.efficacy_for(:"domain_#{i}")
+      end
+      model.decay_all
+      expect(model.domain_count).to be <= constants::MAX_DOMAINS
+    end
+  end
+
+  describe '#domain_history' do
+    it 'filters history by domain' do
+      event_a = Legion::Extensions::Agentic::Self::Agency::Helpers::OutcomeEvent.new(domain: :a, outcome_type: :success)
+      event_b = Legion::Extensions::Agentic::Self::Agency::Helpers::OutcomeEvent.new(domain: :b, outcome_type: :failure)
+      model.record_outcome(event_a)
+      model.record_outcome(event_b)
+      expect(model.domain_history(:a).size).to eq(1)
+    end
+  end
+
+  describe '#success_rate' do
+    it 'returns 0 for empty domain' do
+      expect(model.success_rate(:empty)).to eq(0.0)
+    end
+
+    it 'computes correct rate' do
+      3.times do
+        event = Legion::Extensions::Agentic::Self::Agency::Helpers::OutcomeEvent.new(domain: :x, outcome_type: :success)
+        model.record_outcome(event)
+      end
+      event = Legion::Extensions::Agentic::Self::Agency::Helpers::OutcomeEvent.new(domain: :x, outcome_type: :failure)
+      model.record_outcome(event)
+      expect(model.success_rate(:x)).to eq(0.75)
+    end
+  end
+
+  describe '#strongest_domains / #weakest_domains' do
+    before do
+      model.record_outcome(Legion::Extensions::Agentic::Self::Agency::Helpers::OutcomeEvent.new(domain: :strong, outcome_type: :success))
+      model.record_outcome(Legion::Extensions::Agentic::Self::Agency::Helpers::OutcomeEvent.new(domain: :strong, outcome_type: :success))
+      model.record_outcome(Legion::Extensions::Agentic::Self::Agency::Helpers::OutcomeEvent.new(domain: :weak, outcome_type: :failure))
+      model.record_outcome(Legion::Extensions::Agentic::Self::Agency::Helpers::OutcomeEvent.new(domain: :weak, outcome_type: :failure))
+    end
+
+    it 'returns strongest domains first' do
+      top = model.strongest_domains(1)
+      expect(top.keys.first).to eq(:strong)
+    end
+
+    it 'returns weakest domains first' do
+      bottom = model.weakest_domains(1)
+      expect(bottom.keys.first).to eq(:weak)
+    end
+  end
+
+  describe '#overall_efficacy' do
+    it 'returns default when empty' do
+      expect(model.overall_efficacy).to eq(constants::DEFAULT_EFFICACY)
+    end
+
+    it 'returns average across domains' do
+      model.efficacy_for(:a)
+      model.efficacy_for(:b)
+      expect(model.overall_efficacy).to eq(constants::DEFAULT_EFFICACY)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a snapshot hash' do
+      h = model.to_h
+      expect(h).to include(:domain_count, :overall_efficacy, :history_size, :domains)
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/agency/helpers/outcome_event_spec.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Self::Agency::Helpers::OutcomeEvent do
+  subject(:event) { described_class.new(domain: :coding, outcome_type: :success) }
+
+  describe '#initialize' do
+    it 'generates a uuid' do
+      expect(event.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores domain' do
+      expect(event.domain).to eq(:coding)
+    end
+
+    it 'stores outcome_type' do
+      expect(event.outcome_type).to eq(:success)
+    end
+
+    it 'defaults source to mastery' do
+      expect(event.source).to eq(:mastery)
+    end
+
+    it 'defaults magnitude to 1.0' do
+      expect(event.magnitude).to eq(1.0)
+    end
+
+    it 'defaults attribution to full_agency' do
+      expect(event.attribution).to eq(:full_agency)
+    end
+
+    it 'clamps magnitude to 0..1' do
+      high = described_class.new(domain: :x, outcome_type: :success, magnitude: 5.0)
+      low = described_class.new(domain: :x, outcome_type: :success, magnitude: -1.0)
+      expect(high.magnitude).to eq(1.0)
+      expect(low.magnitude).to eq(0.0)
+    end
+
+    it 'records timestamp' do
+      expect(event.timestamp).to be_a(Time)
+    end
+  end
+
+  describe '#success?' do
+    it 'returns true for success' do
+      expect(event.success?).to be true
+    end
+
+    it 'returns true for partial_success' do
+      partial = described_class.new(domain: :x, outcome_type: :partial_success)
+      expect(partial.success?).to be true
+    end
+
+    it 'returns false for failure' do
+      failure = described_class.new(domain: :x, outcome_type: :failure)
+      expect(failure.success?).to be false
+    end
+
+    it 'returns false for unexpected' do
+      unexpected = described_class.new(domain: :x, outcome_type: :unexpected)
+      expect(unexpected.success?).to be false
+    end
+  end
+
+  describe '#attributed_magnitude' do
+    it 'scales magnitude by attribution level' do
+      full = described_class.new(domain: :x, outcome_type: :success, attribution: :full_agency)
+      low = described_class.new(domain: :x, outcome_type: :success, attribution: :low_agency)
+      expect(full.attributed_magnitude).to be > low.attributed_magnitude
+    end
+
+    it 'returns 0 for no_agency' do
+      none = described_class.new(domain: :x, outcome_type: :success, attribution: :no_agency)
+      expect(none.attributed_magnitude).to eq(0.0)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns all fields' do
+      h = event.to_h
+      expect(h).to include(:id, :domain, :outcome_type, :source, :magnitude, :attribution, :success, :attributed_magnitude, :timestamp)
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/agency/runners/agency_spec.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Agentic::Self::Agency::Runners::Agency do
+  let(:runner) do
+    obj = Object.new
+    obj.extend(described_class)
+    obj
+  end
+
+  describe '#record_mastery' do
+    it 'records a success and increases efficacy' do
+      result = runner.record_mastery(domain: :coding, outcome_type: :success)
+      expect(result[:success]).to be true
+      expect(result[:efficacy]).to be > 0.5
+    end
+
+    it 'records a failure and decreases efficacy' do
+      result = runner.record_mastery(domain: :coding, outcome_type: :failure)
+      expect(result[:success]).to be true
+      expect(result[:efficacy]).to be < 0.5
+    end
+
+    it 'respects attribution level' do
+      full = runner.record_mastery(domain: :a, outcome_type: :success, attribution: :full_agency)
+      runner2 = Object.new.extend(described_class)
+      low = runner2.record_mastery(domain: :a, outcome_type: :success, attribution: :low_agency)
+      expect(full[:efficacy]).to be > low[:efficacy]
+    end
+  end
+
+  describe '#record_vicarious' do
+    it 'has weaker effect than mastery' do
+      runner.record_mastery(domain: :a, outcome_type: :success)
+      mastery_efficacy = runner.efficacy_model.efficacy_for(:a)
+
+      runner2 = Object.new.extend(described_class)
+      runner2.record_vicarious(domain: :a, outcome_type: :success)
+      vicarious_efficacy = runner2.efficacy_model.efficacy_for(:a)
+
+      expect(mastery_efficacy).to be > vicarious_efficacy
+    end
+  end
+
+  describe '#record_persuasion' do
+    it 'increases efficacy for positive persuasion' do
+      result = runner.record_persuasion(domain: :public_speaking, positive: true)
+      expect(result[:success]).to be true
+      expect(result[:efficacy]).to be > 0.5
+    end
+
+    it 'decreases efficacy for negative persuasion' do
+      result = runner.record_persuasion(domain: :public_speaking, positive: false)
+      expect(result[:efficacy]).to be < 0.5
+    end
+  end
+
+  describe '#record_physiological' do
+    it 'increases efficacy for positive states' do
+      result = runner.record_physiological(domain: :exercise, state: :energized)
+      expect(result[:success]).to be true
+      expect(result[:efficacy]).to be >= 0.5
+    end
+
+    it 'decreases efficacy for negative states' do
+      result = runner.record_physiological(domain: :exercise, state: :exhausted)
+      expect(result[:efficacy]).to be < 0.5
+    end
+  end
+
+  describe '#update_agency' do
+    it 'decays efficacy and returns stats' do
+      runner.record_mastery(domain: :coding, outcome_type: :success)
+      result = runner.update_agency
+      expect(result[:success]).to be true
+      expect(result[:stats]).to include(:domain_count, :overall_efficacy)
+    end
+  end
+
+  describe '#check_efficacy' do
+    it 'returns efficacy details for a domain' do
+      runner.record_mastery(domain: :coding, outcome_type: :success)
+      result = runner.check_efficacy(domain: :coding)
+      expect(result[:success]).to be true
+      expect(result[:domain]).to eq(:coding)
+      expect(result[:label]).to be_a(Symbol)
+      expect(result[:success_rate]).to be_a(Float)
+    end
+  end
+
+  describe '#should_attempt?' do
+    it 'recommends attempting when efficacy is above threshold' do
+      5.times { runner.record_mastery(domain: :coding, outcome_type: :success) }
+      result = runner.should_attempt?(domain: :coding, threshold: 0.3)
+      expect(result[:should_attempt]).to be true
+    end
+
+    it 'discourages attempting when efficacy is below threshold' do
+      5.times { runner.record_mastery(domain: :new_thing, outcome_type: :failure) }
+      result = runner.should_attempt?(domain: :new_thing, threshold: 0.5)
+      expect(result[:should_attempt]).to be false
+    end
+  end
+
+  describe '#strongest_domains' do
+    it 'returns the highest-efficacy domains' do
+      3.times { runner.record_mastery(domain: :strong, outcome_type: :success) }
+      runner.record_mastery(domain: :weak, outcome_type: :failure)
+      result = runner.strongest_domains(count: 1)
+      expect(result[:success]).to be true
+      expect(result[:domains].keys.first).to eq(:strong)
+    end
+  end
+
+  describe '#weakest_domains' do
+    it 'returns the lowest-efficacy domains' do
+      runner.record_mastery(domain: :strong, outcome_type: :success)
+      3.times { runner.record_mastery(domain: :weak, outcome_type: :failure) }
+      result = runner.weakest_domains(count: 1)
+      expect(result[:domains].keys.first).to eq(:weak)
+    end
+  end
+
+  describe '#agency_stats' do
+    it 'returns overall stats' do
+      result = runner.agency_stats
+      expect(result[:success]).to be true
+      expect(result[:stats]).to include(:domain_count, :overall_efficacy, :history_size, :domains)
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/anchor/client_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::Anchor::Client do
+  subject(:client) { described_class.new }
+
+  it 'includes the runner module' do
+    expect(described_class.ancestors).to include(
+      Legion::Extensions::Agentic::Self::Anchor::Runners::CognitiveAnchor
+    )
+  end
+
+  it 'responds to create_anchor' do
+    expect(client).to respond_to(:create_anchor)
+  end
+
+  it 'responds to apply_bias' do
+    expect(client).to respond_to(:apply_bias)
+  end
+
+  it 'responds to anchor_status' do
+    expect(client).to respond_to(:anchor_status)
+  end
+
+  it 'can create anchor and apply bias through client' do
+    result = client.create_anchor(anchor_type: :number, domain: :test, content: 'price anchor')
+    expect(result[:success]).to be true
+    bias_result = client.apply_bias(anchor_id: result[:anchor][:id], new_value: 0.8)
+    expect(bias_result[:success]).to be true
+  end
+end

data/spec/legion/extensions/agentic/self/anchor/helpers/anchor_engine_spec.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::Anchor::Helpers::AnchorEngine do
+  subject(:engine) { described_class.new }
+
+  let(:default_attrs) { { anchor_type: :belief, domain: :reasoning, content: 'first impression' } }
+
+  describe '#create_anchor' do
+    it 'creates and stores an anchor' do
+      a = engine.create_anchor(**default_attrs)
+      expect(a).to be_a(Legion::Extensions::Agentic::Self::Anchor::Helpers::Anchor)
+      expect(engine.all_anchors.size).to eq(1)
+    end
+
+    it 'raises when limit reached' do
+      stub_const('Legion::Extensions::Agentic::Self::Anchor::Helpers::Constants::MAX_ANCHORS', 1)
+      engine.create_anchor(**default_attrs)
+      expect do
+        engine.create_anchor(anchor_type: :number, domain: :t, content: 'x')
+      end.to raise_error(ArgumentError, /anchor limit/)
+    end
+  end
+
+  describe '#create_chain' do
+    it 'creates a chain linked to anchor' do
+      a = engine.create_anchor(**default_attrs)
+      c = engine.create_chain(anchor_id: a.id)
+      expect(c.anchor_id).to eq(a.id)
+    end
+
+    it 'raises for unknown anchor' do
+      expect do
+        engine.create_chain(anchor_id: 'bad')
+      end.to raise_error(ArgumentError, /anchor not found/)
+    end
+  end
+
+  describe '#apply_bias' do
+    it 'pulls value toward anchor reference' do
+      a = engine.create_anchor(**default_attrs, reference_value: 0.3, grip: 0.8, weight: 0.6)
+      result = engine.apply_bias(anchor_id: a.id, new_value: 0.9)
+      expect(result[:biased]).to be < 0.9
+      expect(result[:shift]).to be > 0
+    end
+  end
+
+  describe '#drag_anchor' do
+    it 'increases anchor grip' do
+      a = engine.create_anchor(**default_attrs, grip: 0.5)
+      engine.drag_anchor(anchor_id: a.id)
+      expect(a.grip).to be > 0.5
+    end
+  end
+
+  describe '#drift_all!' do
+    it 'drifts all anchors' do
+      a = engine.create_anchor(**default_attrs)
+      initial = a.grip
+      engine.drift_all!
+      expect(a.grip).to be < initial
+    end
+  end
+
+  describe '#wear_all_chains!' do
+    it 'wears all chains' do
+      a = engine.create_anchor(**default_attrs)
+      c = engine.create_chain(anchor_id: a.id)
+      initial = c.flexibility
+      engine.wear_all_chains!
+      expect(c.flexibility).to be < initial
+    end
+  end
+
+  describe '#anchors_by_type' do
+    it 'returns counts per type' do
+      engine.create_anchor(**default_attrs)
+      engine.create_anchor(anchor_type: :number, domain: :t, content: 'x')
+      counts = engine.anchors_by_type
+      expect(counts[:belief]).to eq(1)
+      expect(counts[:number]).to eq(1)
+    end
+  end
+
+  describe '#strongest_anchors' do
+    it 'returns sorted by grip descending' do
+      engine.create_anchor(**default_attrs, grip: 0.3)
+      a2 = engine.create_anchor(anchor_type: :number, domain: :t, content: 'x', grip: 0.9)
+      expect(engine.strongest_anchors(limit: 1).first).to eq(a2)
+    end
+  end
+
+  describe '#chains_for' do
+    it 'returns chains for a specific anchor' do
+      a = engine.create_anchor(**default_attrs)
+      engine.create_chain(anchor_id: a.id)
+      engine.create_chain(anchor_id: a.id, material: :rope)
+      expect(engine.chains_for(a.id).size).to eq(2)
+    end
+  end
+
+  describe '#anchor_report' do
+    it 'returns comprehensive hash' do
+      engine.create_anchor(**default_attrs)
+      report = engine.anchor_report
+      expect(report).to include(:total_anchors, :total_chains, :by_type,
+                                :ironclad_count, :drifting_count, :avg_grip)
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/anchor/helpers/anchor_spec.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::Anchor::Helpers::Anchor do
+  subject(:anchor) do
+    described_class.new(anchor_type: :belief, domain: :reasoning, content: 'first impression')
+  end
+
+  describe '#initialize' do
+    it 'assigns a UUID' do
+      expect(anchor.id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'sets anchor_type' do
+      expect(anchor.anchor_type).to eq(:belief)
+    end
+
+    it 'defaults reference_value to 0.5' do
+      expect(anchor.reference_value).to eq(0.5)
+    end
+
+    it 'defaults grip to 0.7' do
+      expect(anchor.grip).to eq(0.7)
+    end
+
+    it 'defaults weight to 0.5' do
+      expect(anchor.weight).to eq(0.5)
+    end
+
+    it 'clamps grip to 0..1' do
+      a = described_class.new(anchor_type: :number, domain: :t, content: 'x', grip: 5.0)
+      expect(a.grip).to eq(1.0)
+    end
+
+    it 'raises on unknown type' do
+      expect do
+        described_class.new(anchor_type: :magic, domain: :t, content: 'x')
+      end.to raise_error(ArgumentError, /unknown anchor type/)
+    end
+  end
+
+  describe '#drag!' do
+    it 'increases grip' do
+      initial = anchor.grip
+      anchor.drag!
+      expect(anchor.grip).to eq((initial + 0.06).round(10))
+    end
+  end
+
+  describe '#drift!' do
+    it 'decreases grip' do
+      initial = anchor.grip
+      anchor.drift!
+      expect(anchor.grip).to eq((initial - 0.03).round(10))
+    end
+  end
+
+  describe '#bias_pull' do
+    it 'pulls new value toward reference' do
+      anchor.grip = 0.8
+      anchor.weight = 0.5
+      biased = anchor.bias_pull(0.9)
+      expect(biased).to be < 0.9
+      expect(biased).to be > 0.5
+    end
+
+    it 'has no effect with zero grip' do
+      anchor.grip = 0.0
+      expect(anchor.bias_pull(0.9)).to eq(0.9)
+    end
+
+    it 'returns reference when grip and weight are 1.0' do
+      anchor.grip = 1.0
+      anchor.weight = 1.0
+      expect(anchor.bias_pull(0.9)).to eq(anchor.reference_value)
+    end
+  end
+
+  describe '#ironclad?' do
+    it 'returns false at default' do
+      expect(anchor).not_to be_ironclad
+    end
+
+    it 'returns true at 0.8+' do
+      anchor.grip = 0.85
+      expect(anchor).to be_ironclad
+    end
+  end
+
+  describe '#drifting?' do
+    it 'returns false at default' do
+      expect(anchor).not_to be_drifting
+    end
+
+    it 'returns true below 0.2' do
+      anchor.grip = 0.1
+      expect(anchor).to be_drifting
+    end
+  end
+
+  describe '#heavy?' do
+    it 'returns false at default' do
+      expect(anchor).not_to be_heavy
+    end
+
+    it 'returns true at 0.7+' do
+      anchor.weight = 0.8
+      expect(anchor).to be_heavy
+    end
+  end
+
+  describe '#grip_label' do
+    it 'returns :firm at default' do
+      expect(anchor.grip_label).to eq(:firm)
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all expected keys' do
+      expected = %i[id anchor_type domain content reference_value grip weight
+                    grip_label ironclad drifting created_at]
+      expect(anchor.to_h.keys).to match_array(expected)
+    end
+  end
+end