lex-agentic-self 0.1.0

data/spec/legion/extensions/agentic/self/self_talk/helpers/self_talk_engine_spec.rb

@@ -0,0 +1,239 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Self::SelfTalk::Helpers::SelfTalkEngine do
+  subject(:engine) { described_class.new }
+
+  def add_voice(name: 'TestVoice', type: :analyst, volume: 0.5)
+    result = engine.register_voice(name: name, voice_type: type, volume: volume)
+    result[:voice][:id]
+  end
+
+  def add_dialogue(topic: 'Test topic')
+    result = engine.start_dialogue(topic: topic)
+    result[:dialogue][:id]
+  end
+
+  describe '#register_voice' do
+    it 'registers a valid voice' do
+      result = engine.register_voice(name: 'Critic', voice_type: :critic)
+      expect(result[:registered]).to be true
+      expect(result[:voice][:name]).to eq('Critic')
+    end
+
+    it 'returns unknown_type for invalid voice_type' do
+      result = engine.register_voice(name: 'X', voice_type: :unknown_type)
+      expect(result[:registered]).to be false
+      expect(result[:reason]).to eq(:unknown_type)
+    end
+
+    it 'returns max_voices when limit reached' do
+      stub_const('Legion::Extensions::Agentic::Self::SelfTalk::Helpers::Constants::MAX_VOICES', 1)
+      engine.register_voice(name: 'First', voice_type: :critic)
+      result = engine.register_voice(name: 'Second', voice_type: :analyst)
+      expect(result[:registered]).to be false
+      expect(result[:reason]).to eq(:max_voices)
+    end
+
+    it 'stores all registered voices' do
+      add_voice(name: 'V1', type: :critic)
+      add_voice(name: 'V2', type: :encourager)
+      expect(engine.voices.size).to eq(2)
+    end
+  end
+
+  describe '#start_dialogue' do
+    it 'creates a dialogue with the given topic' do
+      result = engine.start_dialogue(topic: 'What should I do?')
+      expect(result[:started]).to be true
+      expect(result[:dialogue][:topic]).to eq('What should I do?')
+    end
+
+    it 'stores the dialogue' do
+      add_dialogue
+      expect(engine.dialogues.size).to eq(1)
+    end
+
+    it 'prunes oldest dialogue when MAX_DIALOGUES is reached' do
+      stub_const('Legion::Extensions::Agentic::Self::SelfTalk::Helpers::Constants::MAX_DIALOGUES', 2)
+      id1 = add_dialogue(topic: 'First')
+      add_dialogue(topic: 'Second')
+      add_dialogue(topic: 'Third')
+      expect(engine.dialogues.key?(id1)).to be false
+      expect(engine.dialogues.size).to eq(2)
+    end
+  end
+
+  describe '#add_turn' do
+    let(:voice_id)    { add_voice }
+    let(:dialogue_id) { add_dialogue }
+
+    it 'adds a turn successfully' do
+      result = engine.add_turn(dialogue_id: dialogue_id, voice_id: voice_id, content: 'My thought')
+      expect(result[:added]).to be true
+    end
+
+    it 'returns dialogue_not_found for unknown dialogue' do
+      result = engine.add_turn(dialogue_id: 'bad-id', voice_id: voice_id, content: 'x')
+      expect(result[:reason]).to eq(:dialogue_not_found)
+    end
+
+    it 'returns voice_not_found for unknown voice' do
+      result = engine.add_turn(dialogue_id: dialogue_id, voice_id: 'bad-voice', content: 'x')
+      expect(result[:reason]).to eq(:voice_not_found)
+    end
+
+    it 'returns voice_inactive when voice is muted' do
+      engine.voices[voice_id].mute!
+      result = engine.add_turn(dialogue_id: dialogue_id, voice_id: voice_id, content: 'x')
+      expect(result[:reason]).to eq(:voice_inactive)
+    end
+  end
+
+  describe '#conclude_dialogue' do
+    it 'concludes an open dialogue' do
+      id = add_dialogue
+      result = engine.conclude_dialogue(dialogue_id: id, summary: 'Decision made')
+      expect(result[:concluded]).to be true
+    end
+
+    it 'returns not_found for unknown dialogue' do
+      result = engine.conclude_dialogue(dialogue_id: 'bad', summary: 'x')
+      expect(result[:reason]).to eq(:not_found)
+    end
+  end
+
+  describe '#deadlock_dialogue' do
+    it 'deadlocks an open dialogue' do
+      id = add_dialogue
+      result = engine.deadlock_dialogue(dialogue_id: id)
+      expect(result[:deadlocked]).to be true
+    end
+
+    it 'returns not_found for unknown dialogue' do
+      result = engine.deadlock_dialogue(dialogue_id: 'bad')
+      expect(result[:reason]).to eq(:not_found)
+    end
+  end
+
+  describe '#active_dialogues' do
+    it 'returns only open dialogues' do
+      id1 = add_dialogue(topic: 'Open')
+      id2 = add_dialogue(topic: 'Concluded')
+      engine.conclude_dialogue(dialogue_id: id2, summary: 'done')
+      expect(engine.active_dialogues.map { |d| d.to_h[:id] }).to include(id1)
+      expect(engine.active_dialogues.map { |d| d.to_h[:id] }).not_to include(id2)
+    end
+  end
+
+  describe '#concluded_dialogues' do
+    it 'returns only concluded dialogues' do
+      id = add_dialogue(topic: 'Test')
+      engine.conclude_dialogue(dialogue_id: id, summary: 'done')
+      expect(engine.concluded_dialogues.size).to eq(1)
+    end
+  end
+
+  describe '#dominant_voice' do
+    it 'returns nil when no voices' do
+      expect(engine.dominant_voice).to be_nil
+    end
+
+    it 'returns the voice with highest volume' do
+      add_voice(name: 'Low', type: :critic, volume: 0.2)
+      add_voice(name: 'High', type: :encourager, volume: 0.9)
+      expect(engine.dominant_voice.name).to eq('High')
+    end
+
+    it 'ignores inactive voices' do
+      id1 = add_voice(name: 'Loud', type: :analyst, volume: 0.9)
+      add_voice(name: 'Quiet', type: :rebel, volume: 0.3)
+      engine.voices[id1].mute!
+      expect(engine.dominant_voice.name).to eq('Quiet')
+    end
+  end
+
+  describe '#quietest_voice' do
+    it 'returns nil when no voices' do
+      expect(engine.quietest_voice).to be_nil
+    end
+
+    it 'returns the voice with lowest volume' do
+      add_voice(name: 'Low', type: :critic, volume: 0.2)
+      add_voice(name: 'High', type: :encourager, volume: 0.9)
+      expect(engine.quietest_voice.name).to eq('Low')
+    end
+  end
+
+  describe '#voice_balance' do
+    it 'returns empty hash when no voices' do
+      expect(engine.voice_balance).to eq({})
+    end
+
+    it 'returns proportional volumes' do
+      add_voice(name: 'V1', type: :critic, volume: 0.5)
+      add_voice(name: 'V2', type: :analyst, volume: 0.5)
+      balance = engine.voice_balance
+      expect(balance.values.sum).to be_within(0.001).of(1.0)
+    end
+  end
+
+  describe '#amplify_voice' do
+    it 'increases voice volume' do
+      id = add_voice(volume: 0.5)
+      result = engine.amplify_voice(voice_id: id, amount: 0.1)
+      expect(result[:amplified]).to be true
+      expect(result[:volume]).to be_within(0.001).of(0.6)
+    end
+
+    it 'returns not_found for unknown voice' do
+      result = engine.amplify_voice(voice_id: 'bad')
+      expect(result[:reason]).to eq(:not_found)
+    end
+  end
+
+  describe '#dampen_voice' do
+    it 'decreases voice volume' do
+      id = add_voice(volume: 0.5)
+      result = engine.dampen_voice(voice_id: id, amount: 0.1)
+      expect(result[:dampened]).to be true
+      expect(result[:volume]).to be_within(0.001).of(0.4)
+    end
+
+    it 'returns not_found for unknown voice' do
+      result = engine.dampen_voice(voice_id: 'bad')
+      expect(result[:reason]).to eq(:not_found)
+    end
+  end
+
+  describe '#dialogue_report' do
+    it 'returns found: false for unknown dialogue' do
+      expect(engine.dialogue_report(dialogue_id: 'bad')[:found]).to be false
+    end
+
+    it 'returns the dialogue and voice positions' do
+      vid = add_voice(name: 'Analyst')
+      did = add_dialogue
+      engine.add_turn(dialogue_id: did, voice_id: vid, content: 'Thought', position: :support, strength: 0.7)
+      report = engine.dialogue_report(dialogue_id: did)
+      expect(report[:found]).to be true
+      expect(report[:dialogue]).to be_a(Hash)
+      expect(report[:voice_positions]).to be_a(Hash)
+      expect(report[:voice_positions]['Analyst']).to be_within(0.001).of(0.7)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns summary hash' do
+      h = engine.to_h
+      expect(h).to include(:voice_count, :dialogue_count, :active_dialogue_count, :dominant_voice, :quietest_voice, :voice_balance)
+    end
+
+    it 'reflects registered voices and dialogues' do
+      add_voice
+      add_dialogue
+      h = engine.to_h
+      expect(h[:voice_count]).to eq(1)
+      expect(h[:dialogue_count]).to eq(1)
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/self_talk/runners/self_talk_llm_spec.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/self/self_talk/client'
+
+RSpec.describe Legion::Extensions::Agentic::Self::SelfTalk::Runners::SelfTalk, 'LLM integration' do
+  let(:client) { Legion::Extensions::Agentic::Self::SelfTalk::Client.new }
+
+  def register_voice(name: 'Analyst', type: :analyst)
+    result = client.register_voice(name: name, voice_type: type)
+    result[:voice][:id]
+  end
+
+  def start_dialogue(topic: 'Shall we proceed?')
+    result = client.start_dialogue(topic: topic)
+    result[:dialogue][:id]
+  end
+
+  describe '#generate_voice_turn' do
+    context 'when LLM is available and returns a valid turn' do
+      before do
+        llm_result = { content: 'The evidence strongly supports this decision.', position: :support }
+        allow(Legion::Extensions::Agentic::Self::SelfTalk::Helpers::LlmEnhancer).to receive(:available?).and_return(true)
+        allow(Legion::Extensions::Agentic::Self::SelfTalk::Helpers::LlmEnhancer).to receive(:generate_turn).and_return(llm_result)
+      end
+
+      it 'returns generated: true with source: :llm' do
+        vid = register_voice
+        did = start_dialogue
+        result = client.generate_voice_turn(dialogue_id: did, voice_id: vid)
+        expect(result[:generated]).to be true
+        expect(result[:source]).to eq(:llm)
+      end
+
+      it 'adds a turn to the dialogue' do
+        vid = register_voice
+        did = start_dialogue
+        client.generate_voice_turn(dialogue_id: did, voice_id: vid)
+        report = client.dialogue_report(dialogue_id: did)
+        expect(report[:dialogue][:turn_count]).to eq(1)
+      end
+
+      it 'includes turn data in result' do
+        vid = register_voice
+        did = start_dialogue
+        result = client.generate_voice_turn(dialogue_id: did, voice_id: vid)
+        expect(result[:turn]).to be_a(Hash)
+      end
+    end
+
+    context 'when LLM is available but returns nil' do
+      before do
+        allow(Legion::Extensions::Agentic::Self::SelfTalk::Helpers::LlmEnhancer).to receive(:available?).and_return(true)
+        allow(Legion::Extensions::Agentic::Self::SelfTalk::Helpers::LlmEnhancer).to receive(:generate_turn).and_return(nil)
+      end
+
+      it 'falls back to mechanical stub with source: :mechanical' do
+        vid = register_voice
+        did = start_dialogue
+        result = client.generate_voice_turn(dialogue_id: did, voice_id: vid)
+        expect(result[:generated]).to be true
+        expect(result[:source]).to eq(:mechanical)
+      end
+
+      it 'adds a clarify-position turn with stub content' do
+        vid = register_voice(name: 'Analyst', type: :analyst)
+        did = start_dialogue(topic: 'My topic')
+        client.generate_voice_turn(dialogue_id: did, voice_id: vid)
+        report = client.dialogue_report(dialogue_id: did)
+        expect(report[:dialogue][:turn_count]).to eq(1)
+      end
+    end
+
+    context 'when LLM is unavailable' do
+      before do
+        allow(Legion::Extensions::Agentic::Self::SelfTalk::Helpers::LlmEnhancer).to receive(:available?).and_return(false)
+      end
+
+      it 'uses mechanical stub with source: :mechanical' do
+        vid = register_voice
+        did = start_dialogue(topic: 'Test topic')
+        result = client.generate_voice_turn(dialogue_id: did, voice_id: vid)
+        expect(result[:generated]).to be true
+        expect(result[:source]).to eq(:mechanical)
+        expect(result[:turn]).to be_a(Hash)
+      end
+    end
+
+    context 'when dialogue is not found' do
+      it 'returns generated: false with reason' do
+        vid = register_voice
+        result = client.generate_voice_turn(dialogue_id: 'bad-id', voice_id: vid)
+        expect(result[:generated]).to be false
+        expect(result[:reason]).to eq(:dialogue_not_found)
+      end
+    end
+
+    context 'when voice is not found' do
+      it 'returns generated: false with reason' do
+        did = start_dialogue
+        result = client.generate_voice_turn(dialogue_id: did, voice_id: 'bad-voice-id')
+        expect(result[:generated]).to be false
+        expect(result[:reason]).to eq(:voice_not_found)
+      end
+    end
+  end
+
+  describe '#conclude_dialogue auto-summary' do
+    context 'when no summary is provided and LLM is available' do
+      before do
+        llm_result = { summary: 'The voices reached a tentative agreement.', recommendation: :support }
+        allow(Legion::Extensions::Agentic::Self::SelfTalk::Helpers::LlmEnhancer).to receive(:available?).and_return(true)
+        allow(Legion::Extensions::Agentic::Self::SelfTalk::Helpers::LlmEnhancer).to receive(:summarize_dialogue).and_return(llm_result)
+      end
+
+      it 'generates an LLM summary and concludes the dialogue' do
+        did = start_dialogue
+        result = client.conclude_dialogue(dialogue_id: did)
+        expect(result[:concluded]).to be true
+      end
+
+      it 'stores the LLM summary as the conclusion' do
+        did = start_dialogue
+        client.conclude_dialogue(dialogue_id: did)
+        report = client.dialogue_report(dialogue_id: did)
+        expect(report[:dialogue][:conclusion]).to eq('The voices reached a tentative agreement.')
+      end
+    end
+
+    context 'when no summary is provided and LLM returns nil' do
+      before do
+        allow(Legion::Extensions::Agentic::Self::SelfTalk::Helpers::LlmEnhancer).to receive(:available?).and_return(true)
+        allow(Legion::Extensions::Agentic::Self::SelfTalk::Helpers::LlmEnhancer).to receive(:summarize_dialogue).and_return(nil)
+      end
+
+      it 'falls back to mechanical default summary' do
+        did = start_dialogue
+        result = client.conclude_dialogue(dialogue_id: did)
+        expect(result[:concluded]).to be true
+        report = client.dialogue_report(dialogue_id: did)
+        expect(report[:dialogue][:conclusion]).to eq('Dialogue concluded')
+      end
+    end
+
+    context 'when no summary is provided and LLM is unavailable' do
+      before do
+        allow(Legion::Extensions::Agentic::Self::SelfTalk::Helpers::LlmEnhancer).to receive(:available?).and_return(false)
+      end
+
+      it 'uses mechanical default summary' do
+        did = start_dialogue
+        result = client.conclude_dialogue(dialogue_id: did)
+        expect(result[:concluded]).to be true
+        report = client.dialogue_report(dialogue_id: did)
+        expect(report[:dialogue][:conclusion]).to eq('Dialogue concluded')
+      end
+    end
+
+    context 'when an explicit summary is provided' do
+      it 'uses the provided summary regardless of LLM availability' do
+        allow(Legion::Extensions::Agentic::Self::SelfTalk::Helpers::LlmEnhancer).to receive(:available?).and_return(true)
+        did = start_dialogue
+        result = client.conclude_dialogue(dialogue_id: did, summary: 'We decided to wait.')
+        expect(result[:concluded]).to be true
+        report = client.dialogue_report(dialogue_id: did)
+        expect(report[:dialogue][:conclusion]).to eq('We decided to wait.')
+      end
+    end
+  end
+end

data/spec/legion/extensions/agentic/self/self_talk/runners/self_talk_spec.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/agentic/self/self_talk/client'
+
+RSpec.describe Legion::Extensions::Agentic::Self::SelfTalk::Runners::SelfTalk do
+  let(:client) { Legion::Extensions::Agentic::Self::SelfTalk::Client.new }
+
+  def register_voice(name: 'Test', type: :analyst)
+    result = client.register_voice(name: name, voice_type: type)
+    result[:voice][:id]
+  end
+
+  def start_dialogue(topic: 'Test topic')
+    result = client.start_dialogue(topic: topic)
+    result[:dialogue][:id]
+  end
+
+  describe '#register_voice' do
+    it 'registers a valid voice' do
+      result = client.register_voice(name: 'Critic', voice_type: :critic)
+      expect(result[:registered]).to be true
+    end
+
+    it 'includes voice data in result' do
+      result = client.register_voice(name: 'Encourager', voice_type: :encourager)
+      expect(result[:voice][:name]).to eq('Encourager')
+      expect(result[:voice][:voice_type]).to eq(:encourager)
+    end
+
+    it 'rejects unknown voice type' do
+      result = client.register_voice(name: 'X', voice_type: :bogus)
+      expect(result[:registered]).to be false
+    end
+
+    it 'accepts bias_direction' do
+      result = client.register_voice(name: 'Pragmatist', voice_type: :pragmatist, bias_direction: :practical)
+      expect(result[:registered]).to be true
+    end
+  end
+
+  describe '#start_dialogue' do
+    it 'starts a new dialogue' do
+      result = client.start_dialogue(topic: 'Shall we proceed?')
+      expect(result[:started]).to be true
+      expect(result[:dialogue][:topic]).to eq('Shall we proceed?')
+    end
+
+    it 'returns a dialogue with a UUID id' do
+      result = client.start_dialogue(topic: 'x')
+      expect(result[:dialogue][:id]).to match(/\A[0-9a-f-]{36}\z/)
+    end
+  end
+
+  describe '#add_turn' do
+    it 'adds a turn with valid voice and dialogue' do
+      vid = register_voice
+      did = start_dialogue
+      result = client.add_turn(dialogue_id: did, voice_id: vid, content: 'A thought')
+      expect(result[:added]).to be true
+    end
+
+    it 'returns not found reason for bad dialogue' do
+      vid = register_voice
+      result = client.add_turn(dialogue_id: 'bad', voice_id: vid, content: 'x')
+      expect(result[:added]).to be false
+      expect(result[:reason]).to eq(:dialogue_not_found)
+    end
+
+    it 'returns not found reason for bad voice' do
+      did = start_dialogue
+      result = client.add_turn(dialogue_id: did, voice_id: 'bad', content: 'x')
+      expect(result[:added]).to be false
+      expect(result[:reason]).to eq(:voice_not_found)
+    end
+
+    it 'accepts position and strength' do
+      vid = register_voice
+      did = start_dialogue
+      result = client.add_turn(dialogue_id: did, voice_id: vid, content: 'x', position: :oppose, strength: 0.9)
+      expect(result[:added]).to be true
+      expect(result[:turn][:position]).to eq(:oppose)
+    end
+  end
+
+  describe '#conclude_dialogue' do
+    it 'concludes an open dialogue' do
+      did = start_dialogue
+      result = client.conclude_dialogue(dialogue_id: did, summary: 'Agreed')
+      expect(result[:concluded]).to be true
+    end
+
+    it 'returns not_found for unknown dialogue' do
+      result = client.conclude_dialogue(dialogue_id: 'nope', summary: 'x')
+      expect(result[:reason]).to eq(:not_found)
+    end
+  end
+
+  describe '#deadlock_dialogue' do
+    it 'deadlocks an open dialogue' do
+      did = start_dialogue
+      result = client.deadlock_dialogue(dialogue_id: did)
+      expect(result[:deadlocked]).to be true
+    end
+
+    it 'returns not_found for unknown dialogue' do
+      result = client.deadlock_dialogue(dialogue_id: 'nope')
+      expect(result[:reason]).to eq(:not_found)
+    end
+  end
+
+  describe '#amplify_voice' do
+    it 'increases voice volume' do
+      vid = register_voice
+      client.amplify_voice(voice_id: vid, amount: 0.2)
+      result = client.amplify_voice(voice_id: vid, amount: 0.0)
+      expect(result[:amplified]).to be true
+    end
+
+    it 'returns not_found for unknown voice' do
+      result = client.amplify_voice(voice_id: 'nope')
+      expect(result[:reason]).to eq(:not_found)
+    end
+  end
+
+  describe '#dampen_voice' do
+    it 'decreases voice volume' do
+      vid = register_voice
+      result = client.dampen_voice(voice_id: vid, amount: 0.1)
+      expect(result[:dampened]).to be true
+    end
+
+    it 'returns not_found for unknown voice' do
+      result = client.dampen_voice(voice_id: 'nope')
+      expect(result[:reason]).to eq(:not_found)
+    end
+  end
+
+  describe '#dialogue_report' do
+    it 'returns found: false for unknown dialogue' do
+      result = client.dialogue_report(dialogue_id: 'nope')
+      expect(result[:found]).to be false
+    end
+
+    it 'returns dialogue and voice positions' do
+      vid = register_voice(name: 'Analyst')
+      did = start_dialogue(topic: 'Report test')
+      client.add_turn(dialogue_id: did, voice_id: vid, content: 'Strong opinion', position: :support, strength: 0.8)
+      result = client.dialogue_report(dialogue_id: did)
+      expect(result[:found]).to be true
+      expect(result[:voice_positions]).to be_a(Hash)
+    end
+  end
+
+  describe '#self_talk_status' do
+    it 'returns summary hash' do
+      result = client.self_talk_status
+      expect(result).to include(:voice_count, :dialogue_count, :active_dialogue_count)
+    end
+
+    it 'reflects registered voices' do
+      register_voice
+      result = client.self_talk_status
+      expect(result[:voice_count]).to eq(1)
+    end
+  end
+
+  describe '#decay_voices' do
+    it 'returns decayed count and voices array' do
+      register_voice
+      result = client.decay_voices
+      expect(result).to include(:decayed, :voices)
+    end
+
+    it 'decrements volume on active voices' do
+      vid = register_voice
+      client.amplify_voice(voice_id: vid, amount: 0.3)
+      result = client.decay_voices
+      expect(result[:decayed]).to eq(1)
+      expect(result[:voices].first[:volume]).to be < 1.0
+    end
+
+    it 'returns zero decayed when no voices registered' do
+      result = client.decay_voices
+      expect(result[:decayed]).to eq(0)
+      expect(result[:voices]).to eq([])
+    end
+
+    it 'includes id, name, and volume in each voice entry' do
+      register_voice(name: 'Critic', type: :critic)
+      result = client.decay_voices
+      voice = result[:voices].first
+      expect(voice).to include(:id, :name, :volume)
+      expect(voice[:name]).to eq('Critic')
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+
+module Legion
+  module Logging
+    def self.debug(_msg); end
+    def self.info(_msg); end
+    def self.warn(_msg); end
+    def self.error(_msg); end
+    def self.fatal(_msg); end
+  end
+
+  module Extensions
+    module Core
+      def self.extended(_base); end
+    end
+
+    module Helpers
+      module Lex
+        def self.included(_base); end
+      end
+    end
+  end
+end
+
+# rubocop:disable Lint/EmptyClass, Style/OneClassPerFile
+module Legion
+  module Extensions
+    module Actors
+      class Every; end
+      class Once; end
+    end
+  end
+end
+$LOADED_FEATURES << 'legion/extensions/actors/every'
+$LOADED_FEATURES << 'legion/extensions/actors/once'
+# rubocop:enable Lint/EmptyClass, Style/OneClassPerFile
+
+require 'legion/extensions/agentic/self'
+
+RSpec.configure do |config|
+  config.example_status_persistence_file_path = '.rspec_status'
+  config.disable_monkey_patching!
+  config.expect_with(:rspec) { |c| c.syntax = :expect }
+end