lex-agentic-inference 0.1.0

data/spec/legion/extensions/agentic/inference/analogical/runners/analogical_reasoning_spec.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/inference/analogical/client'
+
+RSpec.describe Legion::Extensions::Agentic::Inference::Analogical::Runners::AnalogicalReasoning do
+  let(:client) { Legion::Extensions::Agentic::Inference::Analogical::Client.new }
+
+  let(:base_params) do
+    {
+      source_domain: :solar_system,
+      target_domain: :atom,
+      mappings:      { sun: :nucleus, planet: :electron },
+      mapping_type:  :relational
+    }
+  end
+
+  describe '#create_analogy' do
+    it 'creates an analogy and returns success hash' do
+      result = client.create_analogy(**base_params)
+      expect(result[:success]).to be true
+      expect(result[:analogy_id]).to match(/\A[0-9a-f-]{36}\z/)
+      expect(result[:source_domain]).to eq(:solar_system)
+      expect(result[:target_domain]).to eq(:atom)
+    end
+
+    it 'defaults mapping_type to relational' do
+      result = client.create_analogy(
+        source_domain: :water,
+        target_domain: :electricity,
+        mappings:      { pressure: :voltage }
+      )
+      expect(result[:success]).to be true
+      expect(result[:mapping_type]).to eq(:relational)
+    end
+
+    it 'rejects invalid mapping type' do
+      result = client.create_analogy(
+        source_domain: :a, target_domain: :b, mappings: {}, mapping_type: :nonexistent
+      )
+      expect(result[:success]).to be false
+      expect(result[:error]).to eq(:invalid_mapping_type)
+    end
+
+    it 'accepts all valid mapping types' do
+      %i[attribute relational system].each do |type|
+        result = client.create_analogy(
+          source_domain: :src, target_domain: :tgt, mappings: {}, mapping_type: type
+        )
+        expect(result[:success]).to be true
+      end
+    end
+
+    it 'includes state in result' do
+      result = client.create_analogy(**base_params)
+      expect(Legion::Extensions::Agentic::Inference::Analogical::Helpers::Constants::ANALOGY_STATES)
+        .to include(result[:state])
+    end
+  end
+
+  describe '#find_analogies' do
+    it 'finds analogies by domain' do
+      client.create_analogy(**base_params)
+      result = client.find_analogies(domain: :solar_system)
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(1)
+      expect(result[:analogies]).to be_an(Array)
+    end
+
+    it 'returns empty when domain not found' do
+      result = client.find_analogies(domain: :unknown)
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(0)
+    end
+  end
+
+  describe '#apply_analogy' do
+    let(:analogy_id) do
+      client.create_analogy(**base_params)[:analogy_id]
+    end
+
+    it 'applies mapping successfully' do
+      result = client.apply_analogy(analogy_id: analogy_id, source_element: :sun)
+      expect(result[:success]).to be true
+      expect(result[:mapped]).to be true
+      expect(result[:target_element]).to eq(:nucleus)
+    end
+
+    it 'returns success: true with mapped: false for unknown element' do
+      result = client.apply_analogy(analogy_id: analogy_id, source_element: :asteroid)
+      expect(result[:success]).to be true
+      expect(result[:mapped]).to be false
+    end
+
+    it 'returns found: false for unknown analogy_id' do
+      result = client.apply_analogy(analogy_id: 'nope', source_element: :sun)
+      expect(result[:success]).to be true
+      expect(result[:found]).to be false
+    end
+  end
+
+  describe '#evaluate_similarity' do
+    it 'returns a similarity score' do
+      result = client.evaluate_similarity(
+        source: { role: :center, relation: :attracts },
+        target: { role: :center, relation: :attracts }
+      )
+      expect(result[:success]).to be true
+      expect(result[:similarity_score]).to be_a(Float)
+    end
+
+    it 'indicates when score is above threshold' do
+      result = client.evaluate_similarity(
+        source: { role: :center, relation: :attracts, type: :massive },
+        target: { role: :center, relation: :attracts, type: :massive }
+      )
+      expect(result[:above_threshold]).to be true
+    end
+
+    it 'indicates when score is below threshold' do
+      result = client.evaluate_similarity(
+        source: { alpha: :one },
+        target: { beta: :two }
+      )
+      expect(result[:above_threshold]).to be false
+    end
+
+    it 'includes threshold in result' do
+      result = client.evaluate_similarity(source: {}, target: {})
+      expect(result[:threshold]).to eq(Legion::Extensions::Agentic::Inference::Analogical::Helpers::Constants::SIMILARITY_THRESHOLD)
+    end
+  end
+
+  describe '#cross_domain_transfer' do
+    let(:analogy_id) { client.create_analogy(**base_params)[:analogy_id] }
+
+    it 'transfers knowledge across domains' do
+      result = client.cross_domain_transfer(
+        analogy_id:       analogy_id,
+        source_knowledge: { sun: 'gravitational center' }
+      )
+      expect(result[:success]).to be true
+      expect(result[:transferred]).to be true
+      expect(result[:result][:nucleus]).to eq('gravitational center')
+    end
+
+    it 'returns success with transferred: false for unknown analogy' do
+      result = client.cross_domain_transfer(analogy_id: 'nope', source_knowledge: {})
+      expect(result[:success]).to be true
+      expect(result[:transferred]).to be false
+    end
+  end
+
+  describe '#reinforce_analogy' do
+    let(:analogy_id) { client.create_analogy(**base_params)[:analogy_id] }
+
+    it 'reinforces on success' do
+      result = client.reinforce_analogy(analogy_id: analogy_id, success: true)
+      expect(result[:success]).to be true
+      expect(result[:reinforced]).to be true
+      expect(result[:strength]).to be_a(Float)
+    end
+
+    it 'weakens on failure' do
+      create_result = client.create_analogy(**base_params)
+      initial_strength = create_result[:strength]
+      client.reinforce_analogy(analogy_id: create_result[:analogy_id], success: false)
+      find_result = client.find_analogies(domain: :solar_system)
+      final_strength = find_result[:analogies].first[:strength]
+      expect(final_strength).to be < initial_strength
+    end
+
+    it 'returns not_found for unknown analogy' do
+      result = client.reinforce_analogy(analogy_id: 'nope', success: true)
+      expect(result[:success]).to be true
+      expect(result[:reinforced]).to be false
+    end
+  end
+
+  describe '#productive_analogies' do
+    it 'returns only productive analogies' do
+      client.create_analogy(**base_params, strength: 0.9)
+      result = client.productive_analogies
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(1)
+    end
+
+    it 'returns empty when no productive analogies' do
+      client.create_analogy(**base_params)
+      result = client.productive_analogies
+      expect(result[:success]).to be true
+      expect(result[:count]).to eq(0)
+    end
+  end
+
+  describe '#update_analogical_reasoning' do
+    it 'performs decay and pruning' do
+      client.create_analogy(**base_params)
+      result = client.update_analogical_reasoning
+      expect(result[:success]).to be true
+      expect(result[:pruned]).to be_a(Integer)
+    end
+  end
+
+  describe '#analogical_reasoning_stats' do
+    it 'returns stats hash' do
+      client.create_analogy(**base_params)
+      result = client.analogical_reasoning_stats
+      expect(result[:success]).to be true
+      expect(result[:total_analogies]).to eq(1)
+      expect(result[:total_domains]).to eq(2)
+    end
+  end
+end

data/spec/legion/extensions/agentic/inference/argument_mapping/client_spec.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::ArgumentMapping::Client do
+  let(:client) { described_class.new }
+
+  it 'responds to all runner methods' do
+    expect(client).to respond_to(:create_argument)
+    expect(client).to respond_to(:add_argument_ground)
+    expect(client).to respond_to(:add_argument_backing)
+    expect(client).to respond_to(:add_argument_rebuttal)
+    expect(client).to respond_to(:assess_argument_strength)
+    expect(client).to respond_to(:sound_arguments_report)
+    expect(client).to respond_to(:rebutted_arguments_report)
+    expect(client).to respond_to(:strongest_arguments_report)
+    expect(client).to respond_to(:update_argument_mapping)
+    expect(client).to respond_to(:argument_mapping_stats)
+  end
+end

data/spec/legion/extensions/agentic/inference/argument_mapping/helpers/argument_engine_spec.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::ArgumentMapping::Helpers::ArgumentEngine do
+  subject(:engine) { described_class.new }
+
+  describe '#initialize' do
+    it 'starts with empty arguments' do
+      expect(engine.arguments).to be_empty
+    end
+
+    it 'starts with empty history' do
+      expect(engine.history).to be_empty
+    end
+  end
+
+  describe '#create_argument' do
+    it 'creates an argument and returns success' do
+      result = engine.create_argument(claim: 'The sky is blue')
+      expect(result[:success]).to be true
+      expect(result[:argument][:claim]).to eq('The sky is blue')
+    end
+
+    it 'assigns a unique id' do
+      r1 = engine.create_argument(claim: 'Claim A')
+      r2 = engine.create_argument(claim: 'Claim B')
+      expect(r1[:argument][:id]).not_to eq(r2[:argument][:id])
+    end
+
+    it 'stores argument in @arguments' do
+      engine.create_argument(claim: 'Test claim')
+      expect(engine.arguments).not_to be_empty
+    end
+
+    it 'accepts warrant and qualifier' do
+      result = engine.create_argument(
+        claim:     'AI should be regulated',
+        warrant:   'Unregulated AI poses risks',
+        qualifier: :certainly
+      )
+      expect(result[:argument][:warrant]).to eq('Unregulated AI poses risks')
+      expect(result[:argument][:qualifier]).to eq(:certainly)
+    end
+
+    it 'returns failure when max arguments reached' do
+      Legion::Extensions::Agentic::Inference::ArgumentMapping::Helpers::Constants::MAX_ARGUMENTS.times do |i|
+        engine.create_argument(claim: "Claim #{i}")
+      end
+      result = engine.create_argument(claim: 'One more')
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:max_arguments_reached)
+    end
+
+    it 'adds an entry to history' do
+      engine.create_argument(claim: 'Some claim')
+      expect(engine.history).not_to be_empty
+    end
+  end
+
+  describe '#add_ground' do
+    let(:argument_id) { engine.create_argument(claim: 'Test')[:argument][:id] }
+
+    it 'adds a ground to the argument' do
+      result = engine.add_ground(argument_id: argument_id, ground: 'Evidence A')
+      expect(result[:success]).to be true
+      expect(result[:argument][:grounds]).to include('Evidence A')
+    end
+
+    it 'returns failure for unknown argument_id' do
+      result = engine.add_ground(argument_id: 'bad_id', ground: 'Evidence')
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:not_found)
+    end
+  end
+
+  describe '#add_backing' do
+    let(:argument_id) { engine.create_argument(claim: 'Test')[:argument][:id] }
+
+    it 'adds backing to the argument' do
+      result = engine.add_backing(argument_id: argument_id, backing: 'Source A')
+      expect(result[:success]).to be true
+      expect(result[:argument][:backing]).to include('Source A')
+    end
+
+    it 'returns failure for unknown argument_id' do
+      result = engine.add_backing(argument_id: 'bad_id', backing: 'Source')
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:not_found)
+    end
+  end
+
+  describe '#add_rebuttal' do
+    let(:argument_id) { engine.create_argument(claim: 'Test')[:argument][:id] }
+
+    it 'adds a rebuttal to the argument' do
+      result = engine.add_rebuttal(argument_id: argument_id, content: 'Counter-point', impact: 0.7)
+      expect(result[:success]).to be true
+      expect(result[:argument][:rebuttals].first[:content]).to eq('Counter-point')
+    end
+
+    it 'returns failure for unknown argument_id' do
+      result = engine.add_rebuttal(argument_id: 'bad_id', content: 'Counter')
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:not_found)
+    end
+  end
+
+  describe '#assess_argument' do
+    let(:argument_id) do
+      id = engine.create_argument(claim: 'Test', warrant: 'Because')[:argument][:id]
+      3.times { |i| engine.add_ground(argument_id: id, ground: "G#{i}") }
+      id
+    end
+
+    it 'returns a full assessment for a known argument' do
+      result = engine.assess_argument(argument_id: argument_id)
+      expect(result[:success]).to be true
+      expect(result).to include(:strength, :strength_label, :sound, :rebutted)
+      expect(result[:ground_count]).to eq(3)
+    end
+
+    it 'returns failure for unknown argument' do
+      result = engine.assess_argument(argument_id: 'nope')
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:not_found)
+    end
+  end
+
+  describe '#sound_arguments' do
+    it 'returns only sound arguments' do
+      id = engine.create_argument(claim: 'Sound claim', warrant: 'Solid warrant')[:argument][:id]
+      3.times { |i| engine.add_ground(argument_id: id, ground: "G#{i}") }
+      2.times { |i| engine.add_backing(argument_id: id, backing: "B#{i}") }
+
+      engine.create_argument(claim: 'Weak claim')
+
+      expect(engine.sound_arguments.size).to eq(1)
+      expect(engine.sound_arguments.first.claim).to eq('Sound claim')
+    end
+  end
+
+  describe '#rebutted_arguments' do
+    it 'returns only rebutted arguments' do
+      id = engine.create_argument(claim: 'Test claim')[:argument][:id]
+      engine.add_rebuttal(argument_id: id, content: 'Major objection', impact: 0.9)
+
+      engine.create_argument(claim: 'Unrebutted claim')
+
+      expect(engine.rebutted_arguments.size).to eq(1)
+    end
+  end
+
+  describe '#arguments_by_domain' do
+    it 'returns arguments matching the given domain' do
+      engine.create_argument(claim: 'Policy claim', domain: :policy)
+      engine.create_argument(claim: 'Science claim', domain: :science)
+      engine.create_argument(claim: 'Another policy', domain: :policy)
+
+      results = engine.arguments_by_domain(domain: :policy)
+      expect(results.size).to eq(2)
+      results.each { |a| expect(a.domain).to eq(:policy) }
+    end
+  end
+
+  describe '#strongest_arguments' do
+    before do
+      3.times do |i|
+        id = engine.create_argument(claim: "Claim #{i}", warrant: "Warrant #{i}")[:argument][:id]
+        i.times { |j| engine.add_ground(argument_id: id, ground: "G#{j}") }
+      end
+    end
+
+    it 'returns arguments sorted by descending strength' do
+      results = engine.strongest_arguments(limit: 3)
+      strengths = results.map(&:strength)
+      expect(strengths).to eq(strengths.sort.reverse)
+    end
+
+    it 'respects the limit parameter' do
+      results = engine.strongest_arguments(limit: 2)
+      expect(results.size).to be <= 2
+    end
+  end
+
+  describe '#weakest_arguments' do
+    before do
+      3.times do |i|
+        id = engine.create_argument(claim: "Claim #{i}", warrant: "Warrant #{i}")[:argument][:id]
+        i.times { |j| engine.add_ground(argument_id: id, ground: "G#{j}") }
+      end
+    end
+
+    it 'returns arguments sorted by ascending strength' do
+      results = engine.weakest_arguments(limit: 3)
+      strengths = results.map(&:strength)
+      expect(strengths).to eq(strengths.sort)
+    end
+  end
+
+  describe '#decay_all' do
+    it 'returns the argument count' do
+      engine.create_argument(claim: 'A')
+      engine.create_argument(claim: 'B')
+      expect(engine.decay_all).to eq(2)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns stats summary' do
+      h = engine.to_h
+      expect(h).to include(:total_arguments, :sound_arguments, :rebutted_arguments, :history_entries)
+    end
+
+    it 'reflects current counts' do
+      engine.create_argument(claim: 'Test')
+      expect(engine.to_h[:total_arguments]).to eq(1)
+    end
+  end
+end

data/spec/legion/extensions/agentic/inference/argument_mapping/helpers/argument_spec.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Inference::ArgumentMapping::Helpers::Argument do
+  subject(:argument) do
+    described_class.new(
+      id:        'arg_1',
+      claim:     'We should invest in renewable energy',
+      domain:    :policy,
+      warrant:   'Renewable energy reduces carbon emissions',
+      qualifier: :probably
+    )
+  end
+
+  describe '#initialize' do
+    it 'sets id, claim, domain, warrant, qualifier' do
+      expect(argument.id).to eq('arg_1')
+      expect(argument.claim).to eq('We should invest in renewable energy')
+      expect(argument.domain).to eq(:policy)
+      expect(argument.warrant).to eq('Renewable energy reduces carbon emissions')
+      expect(argument.qualifier).to eq(:probably)
+    end
+
+    it 'starts with empty grounds, backing, and rebuttals' do
+      expect(argument.grounds).to be_empty
+      expect(argument.backing).to be_empty
+      expect(argument.rebuttals).to be_empty
+    end
+
+    it 'defaults qualifier to :presumably when not specified' do
+      a = described_class.new(id: 'x', claim: 'Some claim', domain: :general)
+      expect(a.qualifier).to eq(:presumably)
+    end
+
+    it 'defaults warrant to nil' do
+      a = described_class.new(id: 'x', claim: 'Some claim', domain: :general)
+      expect(a.warrant).to be_nil
+    end
+
+    it 'sets created_at' do
+      expect(argument.created_at).not_to be_nil
+    end
+  end
+
+  describe '#add_ground' do
+    it 'appends a ground to the grounds array' do
+      argument.add_ground(ground: 'Solar prices fell 90% in a decade')
+      expect(argument.grounds).to include('Solar prices fell 90% in a decade')
+    end
+
+    it 'accumulates multiple grounds' do
+      argument.add_ground(ground: 'Ground one')
+      argument.add_ground(ground: 'Ground two')
+      expect(argument.grounds.size).to eq(2)
+    end
+  end
+
+  describe '#add_backing' do
+    it 'appends backing to the backing array' do
+      argument.add_backing(backing: 'IPCC report 2023')
+      expect(argument.backing).to include('IPCC report 2023')
+    end
+
+    it 'accumulates multiple backing entries' do
+      argument.add_backing(backing: 'Study A')
+      argument.add_backing(backing: 'Study B')
+      expect(argument.backing.size).to eq(2)
+    end
+  end
+
+  describe '#add_rebuttal' do
+    it 'appends a rebuttal with content and impact' do
+      argument.add_rebuttal(content: 'High upfront costs', impact: 0.6)
+      expect(argument.rebuttals.size).to eq(1)
+      expect(argument.rebuttals.first[:content]).to eq('High upfront costs')
+      expect(argument.rebuttals.first[:impact]).to eq(0.6)
+    end
+
+    it 'defaults impact to 0.5' do
+      argument.add_rebuttal(content: 'Some objection')
+      expect(argument.rebuttals.first[:impact]).to eq(0.5)
+    end
+
+    it 'clamps impact above 1.0' do
+      argument.add_rebuttal(content: 'Too strong', impact: 1.5)
+      expect(argument.rebuttals.first[:impact]).to eq(1.0)
+    end
+
+    it 'clamps impact below 0.0' do
+      argument.add_rebuttal(content: 'Too weak', impact: -0.5)
+      expect(argument.rebuttals.first[:impact]).to eq(0.0)
+    end
+  end
+
+  describe '#strength' do
+    context 'with no grounds, no warrant, no backing' do
+      it 'returns 0.0 for bare argument' do
+        a = described_class.new(id: 'x', claim: 'Claim', domain: :general)
+        expect(a.strength).to eq(0.0)
+      end
+    end
+
+    context 'with warrant only' do
+      it 'contributes warrant_score * WARRANT_WEIGHT' do
+        a = described_class.new(id: 'x', claim: 'Claim', domain: :general, warrant: 'Because')
+        expected = 0.8 * Legion::Extensions::Agentic::Inference::ArgumentMapping::Helpers::Constants::WARRANT_WEIGHT
+        expect(a.strength).to be_within(0.001).of(expected)
+      end
+    end
+
+    context 'with full grounds (3+), warrant, full backing (2+)' do
+      before do
+        3.times { |i| argument.add_ground(ground: "Ground #{i}") }
+        2.times { |i| argument.add_backing(backing: "Backing #{i}") }
+      end
+
+      it 'reaches maximum non-rebutted score' do
+        consts = Legion::Extensions::Agentic::Inference::ArgumentMapping::Helpers::Constants
+        expected = (1.0 * consts::GROUND_WEIGHT) +
+                   (0.8 * consts::WARRANT_WEIGHT) +
+                   (1.0 * consts::BACKING_WEIGHT)
+        expect(argument.strength).to be_within(0.001).of(expected)
+      end
+    end
+
+    context 'with a devastating rebuttal' do
+      before do
+        3.times { |i| argument.add_ground(ground: "Ground #{i}") }
+        argument.add_rebuttal(content: 'Fatal objection', impact: 1.0)
+      end
+
+      it 'reduces strength due to rebuttal penalty' do
+        a_no_rebuttal = described_class.new(
+          id: 'y', claim: 'Claim', domain: :general, warrant: 'Because'
+        )
+        3.times { |i| a_no_rebuttal.add_ground(ground: "G#{i}") }
+        expect(argument.strength).to be < a_no_rebuttal.strength
+      end
+    end
+
+    it 'is clamped to 0..1' do
+      3.times { |i| argument.add_ground(ground: "G#{i}") }
+      2.times { |i| argument.add_backing(backing: "B#{i}") }
+      expect(argument.strength).to be >= 0.0
+      expect(argument.strength).to be <= 1.0
+    end
+  end
+
+  describe '#strength_label' do
+    it 'returns :compelling for strength >= 0.8' do
+      3.times { |i| argument.add_ground(ground: "G#{i}") }
+      2.times { |i| argument.add_backing(backing: "B#{i}") }
+      label = argument.strength_label
+      expect(%i[compelling strong]).to include(label)
+    end
+
+    it 'returns :fallacious for zero-strength argument' do
+      a = described_class.new(id: 'x', claim: 'Empty', domain: :general)
+      expect(a.strength_label).to eq(:fallacious)
+    end
+  end
+
+  describe '#sound?' do
+    context 'when strength >= 0.6, warrant present, grounds non-empty' do
+      before do
+        3.times { |i| argument.add_ground(ground: "Ground #{i}") }
+        2.times { |i| argument.add_backing(backing: "Backing #{i}") }
+      end
+
+      it 'returns true' do
+        expect(argument.sound?).to be true
+      end
+    end
+
+    context 'when warrant is nil' do
+      it 'returns false' do
+        a = described_class.new(id: 'x', claim: 'Claim', domain: :general)
+        3.times { |i| a.add_ground(ground: "G#{i}") }
+        expect(a.sound?).to be false
+      end
+    end
+
+    context 'when grounds is empty' do
+      it 'returns false' do
+        a = described_class.new(id: 'x', claim: 'Claim', domain: :general, warrant: 'Because')
+        expect(a.sound?).to be false
+      end
+    end
+
+    context 'when strength is below 0.6' do
+      it 'returns false' do
+        a = described_class.new(id: 'x', claim: 'Claim', domain: :general, warrant: 'Because')
+        a.add_ground(ground: 'One ground')
+        a.add_rebuttal(content: 'Strong objection', impact: 0.9)
+        expect(a.sound?).to be false
+      end
+    end
+  end
+
+  describe '#rebutted?' do
+    it 'returns false when there are no rebuttals' do
+      expect(argument.rebutted?).to be false
+    end
+
+    it 'returns false when all rebuttals have impact <= 0.5' do
+      argument.add_rebuttal(content: 'Minor point', impact: 0.4)
+      expect(argument.rebutted?).to be false
+    end
+
+    it 'returns true when any rebuttal has impact > 0.5' do
+      argument.add_rebuttal(content: 'Major objection', impact: 0.8)
+      expect(argument.rebutted?).to be true
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with all expected keys' do
+      h = argument.to_h
+      expect(h).to include(
+        :id, :claim, :domain, :grounds, :warrant, :backing,
+        :qualifier, :rebuttals, :strength, :strength_label,
+        :sound, :rebutted, :created_at
+      )
+    end
+
+    it 'reflects current state' do
+      argument.add_ground(ground: 'Evidence A')
+      h = argument.to_h
+      expect(h[:grounds]).to include('Evidence A')
+    end
+  end
+end