lex-agentic-self 0.1.0

data/spec/legion/extensions/agentic/self/narrative_arc/helpers/arc_engine_spec.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::NarrativeArc::Helpers::ArcEngine do
+  let(:engine) { described_class.new }
+
+  def add_beat_to_arc(arc_id, beat_type: :rising_action, intensity: 0.5)
+    engine.add_beat(
+      arc_id:    arc_id,
+      content:   "Beat content for #{beat_type}",
+      beat_type: beat_type,
+      intensity: intensity
+    )
+  end
+
+  describe '#create_arc' do
+    it 'creates and returns an arc' do
+      arc = engine.create_arc(title: 'Test arc')
+      expect(arc).to be_a(Legion::Extensions::Agentic::Self::NarrativeArc::Helpers::Arc)
+    end
+
+    it 'stores the arc internally' do
+      arc = engine.create_arc(title: 'Stored arc')
+      expect(engine.get_arc(arc.arc_id)).to eq(arc)
+    end
+
+    it 'returns nil when engine is at capacity' do
+      stub_const(
+        'Legion::Extensions::Agentic::Self::NarrativeArc::Helpers::Constants::MAX_ARCS',
+        0
+      )
+      expect(engine.create_arc(title: 'overflow')).to be_nil
+    end
+  end
+
+  describe '#add_beat' do
+    let(:arc) { engine.create_arc(title: 'Arc for beats') }
+
+    it 'adds a beat successfully' do
+      result = add_beat_to_arc(arc.arc_id)
+      expect(result[:success]).to be true
+      expect(result[:beat_id]).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'returns arc_phase and tension_level in the result' do
+      result = add_beat_to_arc(arc.arc_id)
+      expect(result[:arc_phase]).to be_a(Symbol)
+      expect(result[:tension_level]).to be_a(Float)
+    end
+
+    it 'returns failure for unknown arc_id' do
+      result = engine.add_beat(arc_id: 'nonexistent', content: 'x')
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:arc_not_found)
+    end
+  end
+
+  describe '#get_arc' do
+    it 'returns nil for unknown arc_id' do
+      expect(engine.get_arc('missing')).to be_nil
+    end
+
+    it 'returns the arc object for a known id' do
+      arc = engine.create_arc(title: 'Known arc')
+      expect(engine.get_arc(arc.arc_id)).to eq(arc)
+    end
+  end
+
+  describe '#active_arcs' do
+    it 'returns arcs that are not complete' do
+      engine.create_arc(title: 'Active one')
+      engine.create_arc(title: 'Active two')
+      expect(engine.active_arcs.size).to eq(2)
+    end
+
+    it 'excludes completed arcs' do
+      arc = engine.create_arc(title: 'Will complete')
+      add_beat_to_arc(arc.arc_id, beat_type: :climax, intensity: 0.95)
+      add_beat_to_arc(arc.arc_id, beat_type: :resolution)
+      expect(engine.active_arcs).not_to include(arc)
+    end
+  end
+
+  describe '#completed_arcs' do
+    it 'returns only completed arcs' do
+      engine.create_arc(title: 'Still active')
+      arc = engine.create_arc(title: 'Will complete')
+      add_beat_to_arc(arc.arc_id, beat_type: :climax, intensity: 0.95)
+      add_beat_to_arc(arc.arc_id, beat_type: :resolution)
+
+      completed = engine.completed_arcs
+      expect(completed.size).to eq(1)
+      expect(completed.first.arc_id).to eq(arc.arc_id)
+    end
+  end
+
+  describe '#most_dramatic_arc' do
+    it 'returns nil when no arcs exist' do
+      expect(engine.most_dramatic_arc).to be_nil
+    end
+
+    it 'returns the arc with the highest dramatic score' do
+      arc_low  = engine.create_arc(title: 'Low drama')
+      arc_high = engine.create_arc(title: 'High drama')
+      add_beat_to_arc(arc_high.arc_id, beat_type: :climax, intensity: 0.95)
+      add_beat_to_arc(arc_high.arc_id, beat_type: :complication, intensity: 0.8)
+
+      expect(engine.most_dramatic_arc.arc_id).to eq(arc_high.arc_id)
+      expect(engine.most_dramatic_arc.arc_id).not_to eq(arc_low.arc_id)
+    end
+  end
+
+  describe '#tension_distribution' do
+    it 'returns empty hash when no arcs exist' do
+      expect(engine.tension_distribution).to eq({})
+    end
+
+    it 'categorizes arcs by tension label' do
+      engine.create_arc(title: 'Low tension')
+      dist = engine.tension_distribution
+      expect(dist).to be_a(Hash)
+      expect(dist.values.sum).to eq(1)
+    end
+  end
+
+  describe '#detect_narrative_patterns' do
+    it 'returns empty array with fewer than 2 arcs' do
+      engine.create_arc(title: 'Solo arc')
+      expect(engine.detect_narrative_patterns).to eq([])
+    end
+
+    it 'detects recurring_crisis pattern across arcs' do
+      2.times do |i|
+        a = engine.create_arc(title: "Crisis arc #{i}")
+        add_beat_to_arc(a.arc_id, beat_type: :crisis)
+      end
+      expect(engine.detect_narrative_patterns).to include(:recurring_crisis)
+    end
+
+    it 'detects recurring_climax pattern across arcs' do
+      2.times do |i|
+        a = engine.create_arc(title: "Climax arc #{i}")
+        add_beat_to_arc(a.arc_id, beat_type: :climax, intensity: 0.95)
+      end
+      expect(engine.detect_narrative_patterns).to include(:recurring_climax)
+    end
+
+    it 'detects unresolved_tension when an active arc is at climax level' do
+      a = engine.create_arc(title: 'High tension')
+      b = engine.create_arc(title: 'Normal')
+      50.times { a.tension_rise! }
+      expect(engine.detect_narrative_patterns).to include(:unresolved_tension)
+      expect(b).to be_a(Legion::Extensions::Agentic::Self::NarrativeArc::Helpers::Arc)
+    end
+
+    it 'detects rapid_resolution pattern for arcs with <= 3 beats' do
+      arc = engine.create_arc(title: 'Fast resolve 1')
+      second = engine.create_arc(title: 'Fast resolve 2')
+      add_beat_to_arc(arc.arc_id, beat_type: :climax, intensity: 0.95)
+      add_beat_to_arc(arc.arc_id, beat_type: :resolution)
+      expect(engine.detect_narrative_patterns).to include(:rapid_resolution)
+      expect(second).to be_a(Legion::Extensions::Agentic::Self::NarrativeArc::Helpers::Arc)
+    end
+  end
+
+  describe '#arc_report' do
+    it 'returns a structured report' do
+      engine.create_arc(title: 'Report arc')
+      report = engine.arc_report
+      expect(report[:total_arcs]).to eq(1)
+      expect(report[:active]).to eq(1)
+      expect(report[:completed]).to eq(0)
+      expect(report[:patterns]).to be_an(Array)
+      expect(report[:tension_dist]).to be_a(Hash)
+    end
+
+    it 'includes most_dramatic in report' do
+      engine.create_arc(title: 'Dramatic arc')
+      report = engine.arc_report
+      expect(report[:most_dramatic]).to be_a(Hash)
+      expect(report[:most_dramatic]).to include(:arc_id)
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/narrative_arc/helpers/arc_spec.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::NarrativeArc::Helpers::Arc do
+  let(:arc) { described_class.new(title: 'Debugging the anomaly', domain: :technical) }
+
+  let(:beat_rising) do
+    Legion::Extensions::Agentic::Self::NarrativeArc::Helpers::BeatEvent.new(
+      content: 'First clue found', beat_type: :rising_action, intensity: 0.4
+    )
+  end
+
+  let(:beat_climax) do
+    Legion::Extensions::Agentic::Self::NarrativeArc::Helpers::BeatEvent.new(
+      content: 'Root cause identified', beat_type: :climax, intensity: 0.95
+    )
+  end
+
+  let(:beat_resolution) do
+    Legion::Extensions::Agentic::Self::NarrativeArc::Helpers::BeatEvent.new(
+      content: 'Fix applied', beat_type: :resolution, intensity: 0.3
+    )
+  end
+
+  describe '#initialize' do
+    it 'assigns a uuid arc_id' do
+      expect(arc.arc_id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'starts in building phase' do
+      expect(arc.arc_phase).to eq(:building)
+    end
+
+    it 'starts with default tension' do
+      expect(arc.tension_level).to eq(Legion::Extensions::Agentic::Self::NarrativeArc::Helpers::Constants::DEFAULT_TENSION)
+    end
+
+    it 'starts with empty beats array' do
+      expect(arc.beats).to be_empty
+    end
+  end
+
+  describe '#add_beat!' do
+    it 'adds a beat and returns true' do
+      expect(arc.add_beat!(beat_rising)).to be true
+      expect(arc.beats.size).to eq(1)
+    end
+
+    it 'raises tension on rising_action beats' do
+      initial = arc.tension_level
+      arc.add_beat!(beat_rising)
+      expect(arc.tension_level).to be > initial
+    end
+
+    it 'transitions to peak phase on climax beat' do
+      arc.add_beat!(beat_climax)
+      expect(arc.arc_phase).to eq(:peak)
+    end
+
+    it 'transitions to complete phase on resolution beat after climax' do
+      arc.add_beat!(beat_climax)
+      arc.add_beat!(beat_resolution)
+      expect(arc.arc_phase).to eq(:complete)
+    end
+
+    it 'returns false when arc is complete' do
+      arc.add_beat!(beat_climax)
+      arc.add_beat!(beat_resolution)
+      expect(arc.add_beat!(beat_rising)).to be false
+    end
+  end
+
+  describe '#tension_rise!' do
+    it 'increases tension by the default rise amount' do
+      initial = arc.tension_level
+      arc.tension_rise!
+      expect(arc.tension_level).to be > initial
+    end
+
+    it 'clamps tension to 1.0' do
+      50.times { arc.tension_rise! }
+      expect(arc.tension_level).to eq(1.0)
+    end
+
+    it 'accepts a custom amount' do
+      initial = arc.tension_level
+      arc.tension_rise!(0.5)
+      expect(arc.tension_level).to be_within(0.001).of(initial + 0.5)
+    end
+  end
+
+  describe '#tension_fall!' do
+    it 'decreases tension by the default fall amount' do
+      arc.tension_rise!(0.5)
+      initial = arc.tension_level
+      arc.tension_fall!
+      expect(arc.tension_level).to be < initial
+    end
+
+    it 'clamps tension to 0.0' do
+      50.times { arc.tension_fall! }
+      expect(arc.tension_level).to eq(0.0)
+    end
+  end
+
+  describe '#climaxed?' do
+    it 'returns false for a fresh arc' do
+      expect(arc.climaxed?).to be false
+    end
+
+    it 'returns true when tension is at or above climax threshold' do
+      50.times { arc.tension_rise! }
+      expect(arc.climaxed?).to be true
+    end
+
+    it 'returns true when arc is in peak phase' do
+      arc.add_beat!(beat_climax)
+      expect(arc.climaxed?).to be true
+    end
+  end
+
+  describe '#resolved?' do
+    it 'returns false before resolution' do
+      expect(arc.resolved?).to be false
+    end
+
+    it 'returns true after resolution beat' do
+      arc.add_beat!(beat_climax)
+      arc.add_beat!(beat_resolution)
+      expect(arc.resolved?).to be true
+    end
+  end
+
+  describe '#dramatic_score' do
+    it 'returns 0.0 for an empty arc' do
+      expect(arc.dramatic_score).to eq(0.0)
+    end
+
+    it 'returns a value between 0 and 1' do
+      arc.add_beat!(beat_rising)
+      arc.add_beat!(beat_climax)
+      expect(arc.dramatic_score).to be_between(0.0, 1.0)
+    end
+
+    it 'increases after adding a high-intensity beat' do
+      arc.add_beat!(beat_rising)
+      score_before = arc.dramatic_score
+      arc.add_beat!(beat_climax)
+      expect(arc.dramatic_score).to be >= score_before
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes all required keys' do
+      h = arc.to_h
+      expect(h.keys).to include(:arc_id, :title, :domain, :arc_phase, :tension_level,
+                                :beat_count, :dramatic_score, :tension_label, :drama_label,
+                                :created_at, :resolved_at)
+    end
+
+    it 'reflects current beat count' do
+      arc.add_beat!(beat_rising)
+      expect(arc.to_h[:beat_count]).to eq(1)
+    end
+  end
+
+  describe '#advance_phase!' do
+    it 'returns the current phase' do
+      expect(arc.advance_phase!).to eq(:building)
+    end
+
+    it 'transitions to peak when tension hits climax threshold' do
+      50.times { arc.tension_rise! }
+      arc.advance_phase!
+      expect(arc.arc_phase).to eq(:peak)
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/narrative_arc/helpers/beat_event_spec.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::NarrativeArc::Helpers::BeatEvent do
+  let(:beat) { described_class.new(content: 'A key realization', beat_type: :rising_action) }
+
+  describe '#initialize' do
+    it 'assigns a uuid beat_id' do
+      expect(beat.beat_id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'stores content' do
+      expect(beat.content).to eq('A key realization')
+    end
+
+    it 'defaults intensity to 0.5' do
+      expect(beat.intensity).to eq(0.5)
+    end
+
+    it 'clamps intensity to 0..1 range' do
+      high = described_class.new(content: 'x', intensity: 5.0)
+      low  = described_class.new(content: 'x', intensity: -2.0)
+      expect(high.intensity).to eq(1.0)
+      expect(low.intensity).to eq(0.0)
+    end
+
+    it 'clamps emotional_charge to -1..1 range' do
+      positive = described_class.new(content: 'x', emotional_charge: 2.0)
+      negative = described_class.new(content: 'x', emotional_charge: -3.0)
+      expect(positive.emotional_charge).to eq(1.0)
+      expect(negative.emotional_charge).to eq(-1.0)
+    end
+
+    it 'defaults to exposition when beat_type is invalid' do
+      beat = described_class.new(content: 'x', beat_type: :invalid_type)
+      expect(beat.beat_type).to eq(:exposition)
+    end
+
+    it 'accepts all valid beat types' do
+      Legion::Extensions::Agentic::Self::NarrativeArc::Helpers::Constants::BEAT_TYPES.each do |type|
+        b = described_class.new(content: 'x', beat_type: type)
+        expect(b.beat_type).to eq(type)
+      end
+    end
+
+    it 'records created_at timestamp' do
+      expect(beat.created_at).to be_a(Time)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with all expected keys' do
+      h = beat.to_h
+      expect(h.keys).to include(:beat_id, :content, :intensity, :beat_type, :domain,
+                                :emotional_charge, :created_at)
+    end
+  end
+
+  describe '#climactic?' do
+    it 'returns true for climax beat type' do
+      climax = described_class.new(content: 'x', beat_type: :climax)
+      expect(climax.climactic?).to be true
+    end
+
+    it 'returns true when intensity is at or above climax threshold' do
+      intense = described_class.new(content: 'x', intensity: 0.9)
+      expect(intense.climactic?).to be true
+    end
+
+    it 'returns false for low-intensity non-climax beat' do
+      normal = described_class.new(content: 'x', beat_type: :rising_action, intensity: 0.3)
+      expect(normal.climactic?).to be false
+    end
+  end
+
+  describe '#resolving?' do
+    it 'returns true for falling_action' do
+      b = described_class.new(content: 'x', beat_type: :falling_action)
+      expect(b.resolving?).to be true
+    end
+
+    it 'returns true for resolution' do
+      b = described_class.new(content: 'x', beat_type: :resolution)
+      expect(b.resolving?).to be true
+    end
+
+    it 'returns true for denouement' do
+      b = described_class.new(content: 'x', beat_type: :denouement)
+      expect(b.resolving?).to be true
+    end
+
+    it 'returns false for rising_action' do
+      b = described_class.new(content: 'x', beat_type: :rising_action)
+      expect(b.resolving?).to be false
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/narrative_arc/helpers/constants_spec.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::NarrativeArc::Helpers::Constants do
+  describe 'BEAT_TYPES' do
+    it 'contains all eight Freytag beat types' do
+      expect(described_class::BEAT_TYPES).to include(
+        :exposition, :rising_action, :complication, :crisis,
+        :climax, :falling_action, :resolution, :denouement
+      )
+    end
+
+    it 'is frozen' do
+      expect(described_class::BEAT_TYPES).to be_frozen
+    end
+  end
+
+  describe 'ARC_PHASES' do
+    it 'contains all four arc phases' do
+      expect(described_class::ARC_PHASES).to eq(%i[building peak resolving complete])
+    end
+  end
+
+  describe 'tension constants' do
+    it 'defines a default tension below climax threshold' do
+      expect(described_class::DEFAULT_TENSION).to be < described_class::CLIMAX_THRESHOLD
+    end
+
+    it 'defines resolution threshold below default tension' do
+      expect(described_class::RESOLUTION_THRESHOLD).to be < described_class::DEFAULT_TENSION
+    end
+
+    it 'defines TENSION_RISE greater than TENSION_FALL' do
+      expect(described_class::TENSION_RISE).to be > described_class::TENSION_FALL
+    end
+  end
+
+  describe '.label_for' do
+    it 'returns :calm for low tension values' do
+      expect(described_class.label_for(described_class::TENSION_LABELS, 0.1)).to eq(:calm)
+    end
+
+    it 'returns :critical for high tension values' do
+      expect(described_class.label_for(described_class::TENSION_LABELS, 0.9)).to eq(:critical)
+    end
+
+    it 'returns :developing for mid-range values' do
+      expect(described_class.label_for(described_class::TENSION_LABELS, 0.35)).to eq(:developing)
+    end
+
+    it 'returns :tense for values in the tense range' do
+      expect(described_class.label_for(described_class::TENSION_LABELS, 0.65)).to eq(:tense)
+    end
+
+    it 'returns :mundane for low drama score' do
+      expect(described_class.label_for(described_class::DRAMA_LABELS, 0.1)).to eq(:mundane)
+    end
+
+    it 'returns :gripping for high drama score' do
+      expect(described_class.label_for(described_class::DRAMA_LABELS, 0.9)).to eq(:gripping)
+    end
+
+    it 'falls back to last label when value is 1.0' do
+      result = described_class.label_for(described_class::TENSION_LABELS, 1.0)
+      expect(result).to eq(:critical)
+    end
+  end
+
+  describe 'PHASE_LABELS' do
+    it 'has a description for each arc phase' do
+      described_class::ARC_PHASES.each do |phase|
+        expect(described_class::PHASE_LABELS[phase]).to be_a(String)
+      end
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/narrative_arc/runners/narrative_spec.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/self/narrative_arc/client'
+
+RSpec.describe Legion::Extensions::Agentic::Self::NarrativeArc::Runners::Narrative do
+  let(:client) { Legion::Extensions::Agentic::Self::NarrativeArc::Client.new }
+  let(:engine) { Legion::Extensions::Agentic::Self::NarrativeArc::Helpers::ArcEngine.new }
+
+  describe '#create_arc' do
+    it 'creates an arc and returns arc_id' do
+      result = client.create_arc(title: 'Debugging mystery')
+      expect(result[:success]).to be true
+      expect(result[:arc_id]).to match(/\A[0-9a-f-]{36}\z/)
+      expect(result[:arc_phase]).to eq(:building)
+    end
+
+    it 'stores arc in the engine' do
+      result = client.create_arc(title: 'Stored arc')
+      arcs = client.active_arcs
+      ids = arcs[:arcs].map { |a| a[:arc_id] }
+      expect(ids).to include(result[:arc_id])
+    end
+
+    it 'accepts custom initial tension' do
+      result = client.create_arc(title: 'Tense start', initial_tension: 0.6)
+      expect(result[:tension_level]).to eq(0.6)
+    end
+
+    it 'accepts an injected engine' do
+      result = client.create_arc(title: 'Injected', engine: engine)
+      expect(result[:success]).to be true
+    end
+
+    it 'returns failure when engine is at capacity' do
+      stub_const(
+        'Legion::Extensions::Agentic::Self::NarrativeArc::Helpers::Constants::MAX_ARCS',
+        0
+      )
+      result = client.create_arc(title: 'Overflow')
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:engine_at_capacity)
+    end
+  end
+
+  describe '#add_beat' do
+    let(:arc_id) { client.create_arc(title: 'Beat test arc')[:arc_id] }
+
+    it 'adds a beat and returns beat_id' do
+      result = client.add_beat(arc_id: arc_id, content: 'Something happened', beat_type: :rising_action)
+      expect(result[:success]).to be true
+      expect(result[:beat_id]).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'includes dramatic_score in result' do
+      result = client.add_beat(arc_id: arc_id, content: 'Escalation', beat_type: :complication, intensity: 0.7)
+      expect(result[:dramatic_score]).to be_a(Float)
+    end
+
+    it 'returns failure for unknown arc' do
+      result = client.add_beat(arc_id: 'bad-id', content: 'x')
+      expect(result[:success]).to be false
+      expect(result[:reason]).to eq(:arc_not_found)
+    end
+
+    it 'transitions arc phase as beats accumulate' do
+      client.add_beat(arc_id: arc_id, content: 'Climax!', beat_type: :climax, intensity: 0.95)
+      result = client.add_beat(arc_id: arc_id, content: 'Resolution', beat_type: :resolution)
+      expect(result[:arc_phase]).to eq(:complete)
+    end
+
+    it 'accepts an injected engine' do
+      injected_arc_id = client.create_arc(title: 'Injected arc', engine: engine)[:arc_id]
+      result = client.add_beat(arc_id: injected_arc_id, content: 'x', engine: engine)
+      expect(result[:success]).to be true
+    end
+  end
+
+  describe '#get_arc' do
+    it 'returns found arc with beats' do
+      arc_id = client.create_arc(title: 'Get test')[:arc_id]
+      client.add_beat(arc_id: arc_id, content: 'A beat')
+      result = client.get_arc(arc_id: arc_id)
+      expect(result[:found]).to be true
+      expect(result[:arc]).to include(:arc_id, :title)
+      expect(result[:beats].size).to eq(1)
+    end
+
+    it 'returns not found for missing arc' do
+      result = client.get_arc(arc_id: 'nonexistent')
+      expect(result[:found]).to be false
+    end
+  end
+
+  describe '#active_arcs' do
+    it 'returns all non-complete arcs' do
+      client.create_arc(title: 'Arc A')
+      client.create_arc(title: 'Arc B')
+      result = client.active_arcs
+      expect(result[:count]).to eq(2)
+      expect(result[:arcs].size).to eq(2)
+    end
+  end
+
+  describe '#completed_arcs' do
+    it 'returns arcs that have been resolved' do
+      arc_id = client.create_arc(title: 'Complete me')[:arc_id]
+      client.add_beat(arc_id: arc_id, content: 'Climax', beat_type: :climax, intensity: 0.95)
+      client.add_beat(arc_id: arc_id, content: 'Done', beat_type: :resolution)
+
+      result = client.completed_arcs
+      expect(result[:count]).to eq(1)
+    end
+  end
+
+  describe '#most_dramatic_arc' do
+    it 'returns not found when no arcs exist' do
+      result = client.most_dramatic_arc
+      expect(result[:found]).to be false
+    end
+
+    it 'returns the arc with the highest dramatic score' do
+      arc_a = client.create_arc(title: 'Boring')[:arc_id]
+      arc_b = client.create_arc(title: 'Gripping')[:arc_id]
+      client.add_beat(arc_id: arc_b, content: 'Explosion', beat_type: :climax, intensity: 0.99)
+      client.add_beat(arc_id: arc_b, content: 'Fallout', beat_type: :complication, intensity: 0.85)
+
+      result = client.most_dramatic_arc
+      expect(result[:found]).to be true
+      expect(result[:arc][:arc_id]).to eq(arc_b)
+      expect(result[:arc][:arc_id]).not_to eq(arc_a)
+    end
+  end
+
+  describe '#arc_report' do
+    it 'returns a complete report structure' do
+      client.create_arc(title: 'Report subject')
+      result = client.arc_report
+      expect(result[:success]).to be true
+      expect(result[:report]).to include(:total_arcs, :active, :completed, :patterns, :tension_dist)
+    end
+  end
+end