lex-agentic-integration 0.1.0

data/spec/legion/extensions/agentic/integration/labyrinth/helpers/constants_spec.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Labyrinth::Helpers::Constants do
+  describe 'NODE_TYPES' do
+    it 'includes all expected node types' do
+      expected = %i[corridor junction dead_end entrance exit minotaur_lair]
+      expect(described_class::NODE_TYPES).to eq(expected)
+    end
+
+    it 'is frozen' do
+      expect(described_class::NODE_TYPES).to be_frozen
+    end
+  end
+
+  describe 'MAX_LABYRINTHS' do
+    it 'is a positive integer' do
+      expect(described_class::MAX_LABYRINTHS).to be_a(Integer)
+      expect(described_class::MAX_LABYRINTHS).to be_positive
+    end
+  end
+
+  describe 'MAX_NODES' do
+    it 'is a positive integer' do
+      expect(described_class::MAX_NODES).to be_a(Integer)
+      expect(described_class::MAX_NODES).to be_positive
+    end
+  end
+
+  describe 'COMPLEXITY_LABELS' do
+    it 'covers the full 0..1 range' do
+      [0.0, 0.1, 0.3, 0.5, 0.7, 0.9, 1.0].each do |score|
+        match = described_class::COMPLEXITY_LABELS.any? { |range, _| range.cover?(score) }
+        expect(match).to be(true), "score #{score} not covered by COMPLEXITY_LABELS"
+      end
+    end
+
+    it 'maps low scores to :trivial' do
+      label = described_class::COMPLEXITY_LABELS.find { |r, _| r.cover?(0.05) }&.last
+      expect(label).to eq(:trivial)
+    end
+
+    it 'maps high scores to :labyrinthine' do
+      label = described_class::COMPLEXITY_LABELS.find { |r, _| r.cover?(0.95) }&.last
+      expect(label).to eq(:labyrinthine)
+    end
+  end
+
+  describe 'DANGER_LABELS' do
+    it 'covers the full 0..1 range' do
+      [0.0, 0.24, 0.3, 0.6, 0.8, 1.0].each do |level|
+        match = described_class::DANGER_LABELS.any? { |range, _| range.cover?(level) }
+        expect(match).to be(true), "level #{level} not covered by DANGER_LABELS"
+      end
+    end
+
+    it 'maps low danger to :safe' do
+      label = described_class::DANGER_LABELS.find { |r, _| r.cover?(0.1) }&.last
+      expect(label).to eq(:safe)
+    end
+
+    it 'maps high danger to :lethal' do
+      label = described_class::DANGER_LABELS.find { |r, _| r.cover?(0.9) }&.last
+      expect(label).to eq(:lethal)
+    end
+  end
+
+  describe 'MINOTAUR_DANGER_LEVEL' do
+    it 'is >= 0.5' do
+      expect(described_class::MINOTAUR_DANGER_LEVEL).to be >= 0.5
+    end
+  end
+end

data/spec/legion/extensions/agentic/integration/labyrinth/helpers/labyrinth_engine_spec.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Labyrinth::Helpers::LabyrinthEngine do
+  subject(:engine) { described_class.new }
+
+  let(:lab_id) do
+    result = engine.create_labyrinth(name: 'Test Maze')
+    result.labyrinth_id
+  end
+
+  describe '#create_labyrinth' do
+    it 'creates a new labyrinth and returns it' do
+      lab = engine.create_labyrinth(name: 'Puzzle', domain: :logic)
+      expect(lab).to be_a(Legion::Extensions::Agentic::Integration::Labyrinth::Helpers::Labyrinth)
+      expect(lab.name).to eq('Puzzle')
+      expect(lab.domain).to eq(:logic)
+    end
+
+    it 'uses provided labyrinth_id' do
+      lab = engine.create_labyrinth(name: 'Custom', labyrinth_id: 'my-id')
+      expect(lab.labyrinth_id).to eq('my-id')
+    end
+
+    it 'generates a UUID when labyrinth_id is not provided' do
+      lab = engine.create_labyrinth(name: 'Auto')
+      expect(lab.labyrinth_id).to match(/\A[0-9a-f-]{36}\z/)
+    end
+
+    it 'raises ArgumentError at MAX_LABYRINTHS' do
+      max = Legion::Extensions::Agentic::Integration::Labyrinth::Helpers::Constants::MAX_LABYRINTHS
+      max.times { |i| engine.create_labyrinth(name: "lab #{i}") }
+      expect { engine.create_labyrinth(name: 'overflow') }.to raise_error(ArgumentError, /max labyrinths/)
+    end
+
+    it 'stores the labyrinth in @labyrinths' do
+      lab = engine.create_labyrinth(name: 'Stored')
+      expect(engine.labyrinths[lab.labyrinth_id]).to eq(lab)
+    end
+  end
+
+  describe '#add_node_to' do
+    it 'adds a corridor node' do
+      node = engine.add_node_to(labyrinth_id: lab_id, node_type: :corridor, content: 'a dark hallway')
+      expect(node.node_type).to eq(:corridor)
+      expect(node.content).to eq('a dark hallway')
+    end
+
+    it 'auto-assigns danger level for minotaur_lair' do
+      node = engine.add_node_to(labyrinth_id: lab_id, node_type: :minotaur_lair)
+      expect(node.danger_level).to eq(Legion::Extensions::Agentic::Integration::Labyrinth::Helpers::Constants::MINOTAUR_DANGER_LEVEL)
+    end
+
+    it 'uses provided node_id' do
+      node = engine.add_node_to(labyrinth_id: lab_id, node_type: :corridor, node_id: 'fixed-id')
+      expect(node.node_id).to eq('fixed-id')
+    end
+
+    it 'raises ArgumentError for unknown labyrinth' do
+      expect do
+        engine.add_node_to(labyrinth_id: 'nonexistent', node_type: :corridor)
+      end.to raise_error(ArgumentError, /not found/)
+    end
+  end
+
+  describe '#connect_nodes' do
+    let(:from_id) { engine.add_node_to(labyrinth_id: lab_id, node_type: :entrance).node_id }
+    let(:to_id) { engine.add_node_to(labyrinth_id: lab_id, node_type: :corridor).node_id }
+
+    it 'connects two nodes bidirectionally by default' do
+      engine.connect_nodes(labyrinth_id: lab_id, from_id: from_id, to_id: to_id)
+      lab = engine.labyrinths[lab_id]
+      expect(lab.nodes[from_id].connections).to include(to_id)
+      expect(lab.nodes[to_id].connections).to include(from_id)
+    end
+
+    it 'connects one-way when bidirectional: false' do
+      engine.connect_nodes(labyrinth_id: lab_id, from_id: from_id, to_id: to_id, bidirectional: false)
+      lab = engine.labyrinths[lab_id]
+      expect(lab.nodes[from_id].connections).to include(to_id)
+      expect(lab.nodes[to_id].connections).not_to include(from_id)
+    end
+
+    it 'returns a result hash' do
+      result = engine.connect_nodes(labyrinth_id: lab_id, from_id: from_id, to_id: to_id)
+      expect(result[:connected]).to be(true)
+      expect(result[:from]).to eq(from_id)
+      expect(result[:to]).to eq(to_id)
+    end
+  end
+
+  describe '#move' do
+    before do
+      engine.add_node_to(labyrinth_id: lab_id, node_type: :entrance, node_id: 'entrance')
+      engine.add_node_to(labyrinth_id: lab_id, node_type: :corridor, node_id: 'corridor')
+      engine.connect_nodes(labyrinth_id: lab_id, from_id: 'entrance', to_id: 'corridor')
+    end
+
+    it 'moves to a connected node and returns result hash' do
+      result = engine.move(labyrinth_id: lab_id, node_id: 'corridor')
+      expect(result[:success]).to be(true)
+      expect(result[:node_id]).to eq('corridor')
+      expect(result[:node_type]).to eq(:corridor)
+      expect(result[:path_length]).to eq(1)
+    end
+
+    it 'includes minotaur check result' do
+      result = engine.move(labyrinth_id: lab_id, node_id: 'corridor')
+      expect(result[:minotaur]).to be_a(Hash)
+      expect(result[:minotaur][:encountered]).to be(false)
+    end
+  end
+
+  describe '#backtrack' do
+    before do
+      engine.add_node_to(labyrinth_id: lab_id, node_type: :entrance, node_id: 'entrance')
+      engine.add_node_to(labyrinth_id: lab_id, node_type: :corridor, node_id: 'corridor')
+      engine.connect_nodes(labyrinth_id: lab_id, from_id: 'entrance', to_id: 'corridor')
+      engine.move(labyrinth_id: lab_id, node_id: 'corridor')
+    end
+
+    it 'backtracks to previous node' do
+      result = engine.backtrack(labyrinth_id: lab_id)
+      expect(result[:success]).to be(true)
+      expect(result[:node_id]).to eq('entrance')
+    end
+
+    it 'returns failure when no breadcrumbs' do
+      engine.backtrack(labyrinth_id: lab_id)
+      result = engine.backtrack(labyrinth_id: lab_id)
+      expect(result[:success]).to be(false)
+      expect(result[:reason]).to eq(:no_breadcrumbs)
+    end
+  end
+
+  describe '#follow_thread' do
+    before do
+      engine.add_node_to(labyrinth_id: lab_id, node_type: :entrance, node_id: 'entrance')
+      engine.add_node_to(labyrinth_id: lab_id, node_type: :corridor, node_id: 'corridor')
+      engine.connect_nodes(labyrinth_id: lab_id, from_id: 'entrance', to_id: 'corridor')
+    end
+
+    it 'follows to the first unvisited node' do
+      result = engine.follow_thread(labyrinth_id: lab_id)
+      expect(result[:success]).to be(true)
+      expect(result[:node_id]).to eq('corridor')
+    end
+
+    it 'returns thread_exhausted when nothing unvisited' do
+      engine.labyrinths[lab_id].nodes['corridor'].visited = true
+      result = engine.follow_thread(labyrinth_id: lab_id)
+      expect(result[:success]).to be(false)
+      expect(result[:reason]).to eq(:thread_exhausted)
+    end
+  end
+
+  describe '#check_minotaur' do
+    before do
+      engine.add_node_to(labyrinth_id: lab_id, node_type: :minotaur_lair, node_id: 'lair', content: 'sunk cost fallacy')
+    end
+
+    it 'returns encountered: true when on minotaur_lair' do
+      engine.labyrinths[lab_id].instance_variable_set(:@current_node_id, 'lair')
+      result = engine.check_minotaur(labyrinth_id: lab_id)
+      expect(result[:encountered]).to be(true)
+      expect(result[:misconception]).to eq('sunk cost fallacy')
+      expect(result[:danger_label]).to be_a(Symbol)
+    end
+
+    it 'returns encountered: false for safe node' do
+      engine.add_node_to(labyrinth_id: lab_id, node_type: :corridor, node_id: 'safe')
+      engine.labyrinths[lab_id].instance_variable_set(:@current_node_id, 'safe')
+      result = engine.check_minotaur(labyrinth_id: lab_id)
+      expect(result[:encountered]).to be(false)
+    end
+  end
+
+  describe '#labyrinth_report' do
+    before do
+      engine.add_node_to(labyrinth_id: lab_id, node_type: :entrance, node_id: 'entrance')
+      engine.add_node_to(labyrinth_id: lab_id, node_type: :dead_end, node_id: 'dead')
+      engine.add_node_to(labyrinth_id: lab_id, node_type: :exit, node_id: 'exit')
+    end
+
+    it 'returns a comprehensive report hash' do
+      report = engine.labyrinth_report(labyrinth_id: lab_id)
+      expect(report).to include(:labyrinth_id, :name, :node_count, :nodes_by_type, :visited_count, :breadcrumb_trail, :lost)
+    end
+
+    it 'includes nodes_by_type breakdown' do
+      report = engine.labyrinth_report(labyrinth_id: lab_id)
+      expect(report[:nodes_by_type]).to include(entrance: 1, dead_end: 1, exit: 1)
+    end
+  end
+
+  describe '#list_labyrinths' do
+    it 'returns empty array initially' do
+      fresh = described_class.new
+      expect(fresh.list_labyrinths).to eq([])
+    end
+
+    it 'lists all created labyrinths' do
+      fresh = described_class.new
+      fresh.create_labyrinth(name: 'A')
+      fresh.create_labyrinth(name: 'B')
+      list = fresh.list_labyrinths
+      expect(list.size).to eq(2)
+      expect(list.map { |l| l[:name] }).to include('A', 'B')
+    end
+  end
+
+  describe '#delete_labyrinth' do
+    it 'removes the labyrinth' do
+      result = engine.delete_labyrinth(labyrinth_id: lab_id)
+      expect(result[:deleted]).to be(true)
+      expect(engine.labyrinths).not_to have_key(lab_id)
+    end
+
+    it 'raises ArgumentError for unknown labyrinth' do
+      expect { engine.delete_labyrinth(labyrinth_id: 'nope') }.to raise_error(ArgumentError, /not found/)
+    end
+  end
+end

data/spec/legion/extensions/agentic/integration/labyrinth/helpers/labyrinth_spec.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Labyrinth::Helpers::Labyrinth do
+  let(:labyrinth_id) { 'lab-001' }
+  let(:labyrinth) { described_class.new(labyrinth_id: labyrinth_id, name: 'Test Maze', domain: :reasoning) }
+
+  let(:node_class) { Legion::Extensions::Agentic::Integration::Labyrinth::Helpers::Node }
+
+  def make_node(id, type, **)
+    node_class.new(node_id: id, node_type: type, **)
+  end
+
+  describe '#initialize' do
+    it 'creates a labyrinth with correct attributes' do
+      expect(labyrinth.labyrinth_id).to eq(labyrinth_id)
+      expect(labyrinth.name).to eq('Test Maze')
+      expect(labyrinth.domain).to eq(:reasoning)
+      expect(labyrinth.nodes).to eq({})
+      expect(labyrinth.breadcrumbs).to eq([])
+      expect(labyrinth.current_node_id).to be_nil
+      expect(labyrinth.solved).to be(false)
+    end
+  end
+
+  describe '#add_node' do
+    it 'adds a node to the labyrinth' do
+      node = make_node('n1', :corridor)
+      labyrinth.add_node(node)
+      expect(labyrinth.nodes['n1']).to eq(node)
+    end
+
+    it 'sets current_node_id to entrance node' do
+      entrance = make_node('entrance-1', :entrance)
+      labyrinth.add_node(entrance)
+      expect(labyrinth.current_node_id).to eq('entrance-1')
+    end
+
+    it 'does not override current_node_id once set' do
+      entrance = make_node('entrance-1', :entrance)
+      entrance2 = make_node('entrance-2', :entrance)
+      labyrinth.add_node(entrance)
+      labyrinth.add_node(entrance2)
+      expect(labyrinth.current_node_id).to eq('entrance-1')
+    end
+
+    it 'raises ArgumentError for non-Node argument' do
+      expect { labyrinth.add_node('not a node') }.to raise_error(ArgumentError, /must be a/)
+    end
+
+    it 'raises ArgumentError when MAX_NODES exceeded' do
+      max = Legion::Extensions::Agentic::Integration::Labyrinth::Helpers::Constants::MAX_NODES
+      max.times { |i| labyrinth.add_node(make_node("n#{i}", :corridor)) }
+      expect { labyrinth.add_node(make_node('overflow', :corridor)) }.to raise_error(ArgumentError, /max nodes/)
+    end
+  end
+
+  describe '#move_to!' do
+    before do
+      entrance = make_node('entrance', :entrance)
+      corridor = make_node('corridor', :corridor)
+      exit_node = make_node('exit', :exit)
+      entrance.connect!('corridor')
+      corridor.connect!('entrance')
+      corridor.connect!('exit')
+      exit_node.connect!('corridor')
+      labyrinth.add_node(entrance)
+      labyrinth.add_node(corridor)
+      labyrinth.add_node(exit_node)
+    end
+
+    it 'moves to a connected node' do
+      labyrinth.move_to!('corridor')
+      expect(labyrinth.current_node_id).to eq('corridor')
+    end
+
+    it 'marks the target node as visited' do
+      labyrinth.move_to!('corridor')
+      expect(labyrinth.nodes['corridor'].visited).to be(true)
+    end
+
+    it 'drops a breadcrumb on the previous node' do
+      labyrinth.move_to!('corridor')
+      expect(labyrinth.breadcrumbs).to include('entrance')
+    end
+
+    it 'sets solved when moving to exit' do
+      labyrinth.move_to!('corridor')
+      labyrinth.move_to!('exit')
+      expect(labyrinth.solved?).to be(true)
+    end
+
+    it 'raises ArgumentError for unknown node_id' do
+      expect { labyrinth.move_to!('unknown') }.to raise_error(ArgumentError, /not found/)
+    end
+
+    it 'raises ArgumentError when not connected' do
+      expect { labyrinth.move_to!('exit') }.to raise_error(ArgumentError, /not connected/)
+    end
+  end
+
+  describe '#backtrack!' do
+    before do
+      entrance = make_node('entrance', :entrance)
+      corridor = make_node('corridor', :corridor)
+      entrance.connect!('corridor')
+      corridor.connect!('entrance')
+      labyrinth.add_node(entrance)
+      labyrinth.add_node(corridor)
+      labyrinth.move_to!('corridor')
+    end
+
+    it 'returns nil when no breadcrumbs' do
+      empty_lab = described_class.new(labyrinth_id: 'x', name: 'x')
+      expect(empty_lab.backtrack!).to be_nil
+    end
+
+    it 'moves back to the previous node' do
+      labyrinth.backtrack!
+      expect(labyrinth.current_node_id).to eq('entrance')
+    end
+  end
+
+  describe '#follow_thread' do
+    before do
+      entrance = make_node('entrance', :entrance)
+      corridor = make_node('corridor', :corridor)
+      entrance.connect!('corridor')
+      corridor.connect!('entrance')
+      labyrinth.add_node(entrance)
+      labyrinth.add_node(corridor)
+    end
+
+    it 'moves to the first unvisited connected node' do
+      result = labyrinth.follow_thread
+      expect(result).not_to be_nil
+      expect(labyrinth.current_node_id).to eq('corridor')
+    end
+
+    it 'returns nil when all connections are visited' do
+      labyrinth.nodes['corridor'].visited = true
+      result = labyrinth.follow_thread
+      expect(result).to be_nil
+    end
+
+    it 'returns nil when current node is nil' do
+      empty_lab = described_class.new(labyrinth_id: 'x', name: 'x')
+      expect(empty_lab.follow_thread).to be_nil
+    end
+  end
+
+  describe '#path_length' do
+    it 'returns 0 when no moves made' do
+      expect(labyrinth.path_length).to eq(0)
+    end
+
+    it 'returns breadcrumb count' do
+      entrance = make_node('entrance', :entrance)
+      corridor = make_node('corridor', :corridor)
+      entrance.connect!('corridor')
+      corridor.connect!('entrance')
+      labyrinth.add_node(entrance)
+      labyrinth.add_node(corridor)
+      labyrinth.move_to!('corridor')
+      expect(labyrinth.path_length).to eq(1)
+    end
+  end
+
+  describe '#complexity' do
+    it 'returns 0.0 for empty labyrinth' do
+      expect(labyrinth.complexity).to eq(0.0)
+    end
+
+    it 'is higher with more dead ends and minotaur lairs' do
+      labyrinth.add_node(make_node('d1', :dead_end))
+      labyrinth.add_node(make_node('d2', :dead_end))
+      labyrinth.add_node(make_node('m1', :minotaur_lair))
+      expect(labyrinth.complexity).to be > 0.0
+    end
+
+    it 'is clamped between 0.0 and 1.0' do
+      labyrinth.add_node(make_node('m1', :minotaur_lair))
+      expect(labyrinth.complexity).to be_between(0.0, 1.0)
+    end
+
+    it 'rounds to 10 decimal places' do
+      labyrinth.add_node(make_node('n1', :corridor))
+      expect(labyrinth.complexity.to_s.split('.').last.to_s.length).to be <= 10
+    end
+  end
+
+  describe '#complexity_label' do
+    it 'returns a symbol' do
+      labyrinth.add_node(make_node('n1', :corridor))
+      expect(labyrinth.complexity_label).to be_a(Symbol)
+    end
+
+    it 'returns :trivial for a labyrinth with only well-connected corridors' do
+      # A junction connected to several corridors — no dead ends, no minotaurs
+      j = make_node('j', :junction)
+      c1 = make_node('c1', :corridor)
+      c2 = make_node('c2', :corridor)
+      c3 = make_node('c3', :corridor)
+      j.connect!('c1')
+      j.connect!('c2')
+      j.connect!('c3')
+      c1.connect!('j')
+      c2.connect!('j')
+      c3.connect!('j')
+      labyrinth.add_node(j)
+      labyrinth.add_node(c1)
+      labyrinth.add_node(c2)
+      labyrinth.add_node(c3)
+      expect(labyrinth.complexity_label).to eq(:trivial)
+    end
+  end
+
+  describe '#solved?' do
+    it 'returns false by default' do
+      expect(labyrinth.solved?).to be(false)
+    end
+  end
+
+  describe '#lost?' do
+    it 'returns false with no current node' do
+      expect(labyrinth.lost?).to be(false)
+    end
+  end
+
+  describe '#to_h' do
+    it 'includes expected keys' do
+      h = labyrinth.to_h
+      expect(h).to include(:labyrinth_id, :name, :domain, :node_count, :current_node_id, :path_length, :solved, :complexity, :complexity_label)
+    end
+  end
+end

data/spec/legion/extensions/agentic/integration/labyrinth/helpers/node_spec.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+RSpec.describe Legion::Extensions::Agentic::Integration::Labyrinth::Helpers::Node do
+  let(:node_id) { 'node-001' }
+
+  describe '#initialize' do
+    it 'creates a corridor node' do
+      node = described_class.new(node_id: node_id, node_type: :corridor)
+      expect(node.node_id).to eq(node_id)
+      expect(node.node_type).to eq(:corridor)
+      expect(node.visited).to be(false)
+      expect(node.connections).to eq([])
+      expect(node.danger_level).to eq(0.0)
+    end
+
+    it 'creates a minotaur_lair node' do
+      node = described_class.new(node_id: node_id, node_type: :minotaur_lair, content: 'false belief')
+      expect(node.node_type).to eq(:minotaur_lair)
+      expect(node.content).to eq('false belief')
+    end
+
+    it 'clamps danger_level to 0..1' do
+      node = described_class.new(node_id: node_id, node_type: :corridor, danger_level: 2.5)
+      expect(node.danger_level).to eq(1.0)
+
+      node2 = described_class.new(node_id: node_id, node_type: :corridor, danger_level: -1.0)
+      expect(node2.danger_level).to eq(0.0)
+    end
+
+    it 'raises ArgumentError for unknown node_type' do
+      expect do
+        described_class.new(node_id: node_id, node_type: :dungeon)
+      end.to raise_error(ArgumentError, /unknown node_type/)
+    end
+
+    it 'accepts all valid node types' do
+      Legion::Extensions::Agentic::Integration::Labyrinth::Helpers::Constants::NODE_TYPES.each do |type|
+        expect { described_class.new(node_id: "n-#{type}", node_type: type) }.not_to raise_error
+      end
+    end
+  end
+
+  describe '#connect!' do
+    it 'adds a connection' do
+      node = described_class.new(node_id: node_id, node_type: :corridor)
+      node.connect!('other-node')
+      expect(node.connections).to include('other-node')
+    end
+
+    it 'does not duplicate connections' do
+      node = described_class.new(node_id: node_id, node_type: :corridor)
+      node.connect!('other-node')
+      node.connect!('other-node')
+      expect(node.connections.count('other-node')).to eq(1)
+    end
+
+    it 'returns self for chaining' do
+      node = described_class.new(node_id: node_id, node_type: :corridor)
+      expect(node.connect!('other')).to eq(node)
+    end
+  end
+
+  describe '#disconnect!' do
+    it 'removes a connection' do
+      node = described_class.new(node_id: node_id, node_type: :corridor)
+      node.connect!('other-node')
+      node.disconnect!('other-node')
+      expect(node.connections).not_to include('other-node')
+    end
+
+    it 'returns self for chaining' do
+      node = described_class.new(node_id: node_id, node_type: :corridor)
+      expect(node.disconnect!('nonexistent')).to eq(node)
+    end
+  end
+
+  describe '#dead_end?' do
+    it 'returns true for :dead_end type' do
+      node = described_class.new(node_id: node_id, node_type: :dead_end)
+      expect(node.dead_end?).to be(true)
+    end
+
+    it 'returns true for corridor with no connections' do
+      node = described_class.new(node_id: node_id, node_type: :corridor)
+      expect(node.dead_end?).to be(true)
+    end
+
+    it 'returns false for corridor with connections' do
+      node = described_class.new(node_id: node_id, node_type: :corridor)
+      node.connect!('somewhere')
+      expect(node.dead_end?).to be(false)
+    end
+
+    it 'returns false for entrance with no connections' do
+      node = described_class.new(node_id: node_id, node_type: :entrance)
+      expect(node.dead_end?).to be(false)
+    end
+
+    it 'returns false for exit with no connections' do
+      node = described_class.new(node_id: node_id, node_type: :exit)
+      expect(node.dead_end?).to be(false)
+    end
+  end
+
+  describe '#junction?' do
+    it 'returns true for :junction type' do
+      node = described_class.new(node_id: node_id, node_type: :junction)
+      expect(node.junction?).to be(true)
+    end
+
+    it 'returns true for corridor with 3+ connections' do
+      node = described_class.new(node_id: node_id, node_type: :corridor)
+      node.connect!('a')
+      node.connect!('b')
+      node.connect!('c')
+      expect(node.junction?).to be(true)
+    end
+
+    it 'returns false for corridor with 2 connections' do
+      node = described_class.new(node_id: node_id, node_type: :corridor)
+      node.connect!('a')
+      node.connect!('b')
+      expect(node.junction?).to be(false)
+    end
+  end
+
+  describe '#dangerous?' do
+    it 'returns true for :minotaur_lair type' do
+      node = described_class.new(node_id: node_id, node_type: :minotaur_lair)
+      expect(node.dangerous?).to be(true)
+    end
+
+    it 'returns true for danger_level >= 0.5' do
+      node = described_class.new(node_id: node_id, node_type: :corridor, danger_level: 0.5)
+      expect(node.dangerous?).to be(true)
+    end
+
+    it 'returns false for safe corridor' do
+      node = described_class.new(node_id: node_id, node_type: :corridor, danger_level: 0.2)
+      expect(node.dangerous?).to be(false)
+    end
+  end
+
+  describe '#to_h' do
+    it 'returns a hash with expected keys' do
+      node = described_class.new(node_id: node_id, node_type: :junction, content: 'crossroads', danger_level: 0.3)
+      node.connect!('n2')
+      h = node.to_h
+      expect(h[:node_id]).to eq(node_id)
+      expect(h[:node_type]).to eq(:junction)
+      expect(h[:content]).to eq('crossroads')
+      expect(h[:connections]).to eq(['n2'])
+      expect(h[:visited]).to be(false)
+      expect(h[:danger_level]).to eq(0.3)
+    end
+  end
+end