lex-dream 0.1.1

data/lib/legion/extensions/dream/runners/dream_cycle.rb

@@ -0,0 +1,324 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Dream
+      module Runners
+        module DreamCycle
+          extend self
+
+          CONSOLIDATION_CANDIDATE_THRESHOLD = 5
+
+          EMERGENT_UNRESOLVED = lambda { |trace|
+            return true if trace[:unresolved] == true
+
+            # Episodic traces with high emotional intensity that haven't been reinforced
+            return true if trace[:trace_type] == :episodic &&
+                           trace[:reinforcement_count].zero? &&
+                           trace[:emotional_intensity] >= 0.5
+
+            # Any trace with low confidence that hasn't been reinforced
+            return true if trace[:confidence].is_a?(Numeric) &&
+                           trace[:confidence] < 0.4 &&
+                           trace[:reinforcement_count].zero?
+
+            # Semantic/procedural traces with negative valence (potential concerns worth examining)
+            return true if %i[semantic procedural].include?(trace[:trace_type]) &&
+                           trace[:emotional_valence].is_a?(Numeric) &&
+                           trace[:emotional_valence] < -0.3 &&
+                           trace[:reinforcement_count] <= 1
+
+            # Unreinforced traces with moderate-high intensity (emotionally salient but unprocessed)
+            return true if trace[:reinforcement_count].zero? &&
+                           trace[:emotional_intensity].is_a?(Numeric) &&
+                           trace[:emotional_intensity] >= 0.6
+
+            false
+          }
+
+          def execute_dream_cycle(**)
+            @phase_data = {}
+            results = {}
+
+            unless memory
+              Legion::Logging.warn '[dream] skipping cycle: lex-memory not available'
+              return { status: :skipped, reason: :memory_not_available }
+            end
+
+            # Reload from cache to pick up traces written by other runners (e.g. coldstart)
+            store = memory.send(:default_store)
+            store.reload if store.respond_to?(:reload)
+
+            Legion::Logging.info '[dream] cycle starting'
+            Helpers::Constants::DREAM_CYCLE_PHASES.each do |phase|
+              Legion::Logging.debug "[dream] starting phase: #{phase}"
+              results[phase] = send(:"phase_#{phase}")
+            rescue StandardError => e
+              Legion::Logging.error "[dream] phase #{phase} failed: #{e.message}"
+              Legion::Logging.error "[dream] #{e.backtrace&.first(3)&.join("\n")}"
+              results[phase] = { error: e.message }
+            end
+            # Flush cache-backed store after all phases
+            store = memory.send(:default_store)
+            store.flush if store.respond_to?(:flush)
+
+            # Write human-readable dream journal before clearing state
+            Helpers::DreamJournal.write_entry(results: results, phase_data: @phase_data, dream_store: dream_store)
+
+            Legion::Logging.info "[dream] cycle complete: #{results.keys.join(', ')}"
+            { status: :completed, phases: results }
+          end
+
+          def phase_memory_audit(**)
+            store = memory.send(:default_store)
+            decay_result   = memory.decay_cycle(store: store)
+            migrate_result = memory.migrate_tier(store: store)
+
+            candidates = store.all_traces.select do |t|
+              t[:trace_type] == :episodic &&
+                t[:reinforcement_count] >= CONSOLIDATION_CANDIDATE_THRESHOLD &&
+                t[:strength] < Legion::Extensions::Memory::Helpers::Trace::STARTING_STRENGTHS[:episodic]
+            end
+            candidates.each do |t|
+              t[:consolidation_candidate] = true
+              store.store(t)
+            end
+
+            unresolved = store.all_traces.select(&EMERGENT_UNRESOLVED)
+            @phase_data[:unresolved_traces] = unresolved
+
+            Legion::Logging.debug "[dream] memory_audit: decayed=#{decay_result[:decayed]} pruned=#{decay_result[:pruned]} " \
+                                  "migrated=#{migrate_result[:migrated]} candidates=#{candidates.size} unresolved=#{unresolved.size}"
+            {
+              decayed:                  decay_result[:decayed],
+              pruned:                   decay_result[:pruned],
+              migrated:                 migrate_result[:migrated],
+              consolidation_candidates: candidates.size,
+              unresolved_count:         unresolved.size
+            }
+          end
+
+          def phase_association_walk(**)
+            store       = memory.send(:default_store)
+            start_trace = Helpers::AssociationWalker.select_start_trace(store: store)
+
+            unless start_trace
+              @phase_data[:walk_results] = []
+              return { walk_results: [], start_trace: nil }
+            end
+
+            known   = Set.new(dream_store.walk_results.map { |w| w[:path].join('->') })
+            results = Helpers::AssociationWalker.walk(
+              store: store, start_id: start_trace[:trace_id], known_paths: known
+            )
+
+            results.each do |wr|
+              dream_store.record_walk_result(
+                source_id: start_trace[:trace_id], path: wr[:path], novelty_score: wr[:novelty_score]
+              )
+              wr[:path].each_cons(2) do |a_id, b_id|
+                memory.hebbian_link(trace_id_a: a_id, trace_id_b: b_id, store: store)
+              end
+            end
+
+            @phase_data[:walk_results] = results
+            Legion::Logging.debug "[dream] association_walk: start=#{start_trace[:trace_id][0..7]} results=#{results.size}"
+            { walk_results: results, start_trace: start_trace[:trace_id] }
+          end
+
+          def phase_contradiction_resolution(**)
+            store    = memory.send(:default_store)
+            detected = Helpers::ContradictionDetector.detect(store: store)
+            use_llm  = Helpers::LlmEnhancer.available?
+
+            resolutions = detected.map do |contradiction|
+              trace_a = store.get(contradiction[:trace_ids][0])
+              trace_b = store.get(contradiction[:trace_ids][1])
+
+              result = resolve_single_contradiction(
+                trace_a, trace_b, contradiction, store, use_llm
+              )
+
+              dream_store.record_contradiction(
+                trace_ids:  contradiction[:trace_ids],
+                domain:     contradiction[:domain],
+                resolution: result[:resolution]
+              )
+              result.merge(
+                domain:    contradiction[:domain],
+                valence_a: contradiction[:valence_a],
+                valence_b: contradiction[:valence_b]
+              )
+            end
+
+            @phase_data[:contradictions] = resolutions
+            resolved_count = resolutions.count { |r| r[:resolution] == :resolved }
+            Legion::Logging.debug "[dream] contradiction_resolution: detected=#{detected.size} " \
+                                  "resolved=#{resolved_count} llm=#{use_llm}"
+            { detected: detected.size, resolutions: resolutions }
+          end
+
+          def resolve_single_contradiction(trace_a, trace_b, contradiction, store, use_llm)
+            # Try LLM-enhanced resolution first
+            if use_llm && trace_a && trace_b
+              llm_result = Helpers::LlmEnhancer.resolve_contradiction(
+                trace_a, trace_b,
+                strategy: Helpers::Constants::CONTRADICTION_RESOLUTION_STRATEGY
+              )
+              if llm_result
+                apply_contradiction_result(llm_result, store)
+                return llm_result
+              end
+            end
+
+            # Mechanical fallback — ContradictionDetector.resolve mutates traces in-place
+            Helpers::ContradictionDetector.resolve(
+              trace_ids: contradiction[:trace_ids],
+              store:     store,
+              strategy:  Helpers::Constants::CONTRADICTION_RESOLUTION_STRATEGY
+            )
+          end
+
+          def apply_contradiction_result(result, store)
+            return unless result[:resolution] == :resolved
+
+            winner = store.get(result[:winner_id])
+            loser  = store.get(result[:loser_id])
+            return unless winner && loser
+
+            now = Time.now.utc
+            winner[:strength]        = [winner[:strength] + 0.1, 1.0].min
+            winner[:peak_strength]   = [winner[:peak_strength], winner[:strength]].max
+            winner[:last_reinforced] = now
+            store.store(winner)
+
+            loser[:strength] = [loser[:strength] - 0.1, 0.0].max
+            store.store(loser)
+          end
+
+          def phase_identity_entropy_check(**)
+            unless identity
+              Legion::Logging.warn '[dream] skipping identity_entropy_check: lex-identity not available'
+              return { status: :skipped, reason: :identity_not_available }
+            end
+
+            result = identity.check_entropy(observations: {})
+            dream_store.record_entropy(
+              entropy:        result[:entropy],
+              classification: result[:classification],
+              trend:          result[:trend]
+            )
+            @phase_data[:entropy] = result
+            Legion::Logging.debug "[dream] identity_entropy: #{result[:classification]} trend=#{result[:trend]}"
+            result
+          end
+
+          def phase_agenda_formation(**)
+            unresolved = @phase_data[:unresolved_traces] || []
+            contradictions = @phase_data[:contradictions] || []
+            walk_results  = @phase_data[:walk_results] || []
+            entropy       = @phase_data[:entropy] || {}
+
+            # Try LLM-synthesized agenda first
+            items = if Helpers::LlmEnhancer.available?
+                      Helpers::LlmEnhancer.synthesize_agenda(
+                        unresolved_traces: unresolved,
+                        contradictions:    contradictions,
+                        walk_results:      walk_results,
+                        entropy:           entropy
+                      )
+                    end
+
+            # Mechanical fallback
+            items ||= Helpers::Agenda.build_from_phases(
+              unresolved_traces: unresolved,
+              contradictions:    contradictions,
+              walk_results:      walk_results,
+              entropy:           entropy
+            )
+
+            items.each do |item|
+              dream_store.add_agenda_item(type: item[:type], content: item[:content], weight: item[:weight])
+            end
+            Legion::Logging.debug "[dream] agenda_formation: #{items.size} items (llm=#{Helpers::LlmEnhancer.available?})"
+            { agenda_items: items.size }
+          end
+
+          def phase_consolidation_commit(**)
+            # Snapshot agenda before clearing — used by dream journal
+            @phase_data[:agenda_snapshot] = dream_store.agenda.dup
+            store  = memory.send(:default_store)
+            traces = Helpers::Agenda.to_semantic_traces(dream_store.agenda)
+            traces.each { |t| store.store(t) }
+
+            Array(@phase_data[:unresolved_traces]).each do |t|
+              trace = store.get(t[:trace_id])
+              next unless trace
+
+              trace[:unresolved] = false
+              store.store(trace)
+            end
+
+            dream_store.expire_stale!
+            dream_store.clear
+            Legion::Logging.info "[dream] consolidation_commit: #{traces.size} traces written to memory"
+            { traces_written: traces.size, dream_store_cleared: true }
+          end
+
+          def phase_dream_reflection(**)
+            return { status: :skipped, reason: :extension_not_loaded } unless reflection_available?
+
+            reflection_runner = Object.new.extend(Legion::Extensions::Reflection::Runners::Reflection)
+            result = reflection_runner.reflect(tick_results: @phase_data)
+
+            @phase_data[:dream_health] = result[:cognitive_health]
+            Legion::Logging.debug "[dream] dream_reflection: health=#{result[:cognitive_health]} reflections=#{result[:reflections_generated]}"
+            result
+          end
+
+          def phase_dream_narration(**)
+            return { status: :skipped, reason: :extension_not_loaded } unless narrator_available?
+
+            narrator_runner = Object.new.extend(Legion::Extensions::Narrator::Runners::Narrator)
+            result = narrator_runner.narrate(tick_results: @phase_data, cognitive_state: { source: :dream })
+
+            Legion::Logging.debug "[dream] dream_narration: mood=#{result[:mood]}"
+            result
+          end
+
+          include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+          private
+
+          def memory
+            @memory ||= Legion::Extensions::Memory::Client.new if defined?(Legion::Extensions::Memory::Client)
+          end
+
+          def identity
+            @identity ||= Object.new.extend(Legion::Extensions::Identity::Runners::Identity) if defined?(Legion::Extensions::Identity::Runners::Identity)
+          end
+
+          def reflection_available?
+            Legion::Extensions.const_defined?(:Reflection) &&
+              Legion::Extensions::Reflection.const_defined?(:Runners) &&
+              Legion::Extensions::Reflection::Runners.const_defined?(:Reflection)
+          rescue StandardError
+            false
+          end
+
+          def narrator_available?
+            Legion::Extensions.const_defined?(:Narrator) &&
+              Legion::Extensions::Narrator.const_defined?(:Runners) &&
+              Legion::Extensions::Narrator::Runners.const_defined?(:Narrator)
+          rescue StandardError
+            false
+          end
+
+          def dream_store
+            @dream_store ||= Helpers::DreamStore.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/dream/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Dream
+      VERSION = '0.1.1'
+    end
+  end
+end

data/lib/legion/extensions/dream.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/dream/version'
+require 'legion/extensions/dream/helpers/constants'
+require 'legion/extensions/dream/helpers/dream_store'
+require 'legion/extensions/dream/helpers/association_walker'
+require 'legion/extensions/dream/helpers/contradiction_detector'
+require 'legion/extensions/dream/helpers/agenda'
+require 'legion/extensions/dream/helpers/dream_journal'
+require 'legion/extensions/dream/helpers/llm_enhancer'
+require 'legion/extensions/dream/runners/dream_cycle'
+require 'legion/extensions/dream/client'
+
+module Legion
+  module Extensions
+    module Dream
+      extend Legion::Extensions::Core if Legion::Extensions.const_defined? :Core
+    end
+  end
+end

data/logs/dreams/dream-2026-03-14_064520.md

@@ -0,0 +1,49 @@
+# Dream Cycle — 2026-03-14 06:45:20 UTC
+
+## Phase 1: Memory Audit
+
+- Traces decayed: 0
+- Traces pruned: 0
+- Tier migrations: 0
+- Consolidation candidates: 0
+- Unresolved traces found: 0
+
+## Phase 2: Association Walk
+
+- Start trace: none
+- Paths found: 0
+
+## Phase 3: Contradiction Resolution
+
+- Contradictions detected: 0
+- Resolved: 0
+- Unresolvable: 0
+
+## Phase 4: Identity Entropy
+
+- Classification: normal
+- Trend: stable
+- Entropy value: 0.5
+
+## Phase 5: Agenda Formation
+
+- Total agenda items: 0
+
+## Phase 6: Consolidation Commit
+
+- Traces written to memory: 0
+- Dream store cleared: true
+
+---
+
+## Summary
+
+| Metric | Value |
+|--------|-------|
+| Traces decayed | 0 |
+| Unresolved found | 0 |
+| Associations walked | 0 |
+| Contradictions detected | 0 |
+| Contradictions resolved | 0 |
+| Agenda items formed | 0 |
+| Traces consolidated | 0 |

data/logs/dreams/dream-2026-03-14_064546.md

@@ -0,0 +1,49 @@
+# Dream Cycle — 2026-03-14 06:45:46 UTC
+
+## Phase 1: Memory Audit
+
+- Traces decayed: 0
+- Traces pruned: 0
+- Tier migrations: 0
+- Consolidation candidates: 0
+- Unresolved traces found: 0
+
+## Phase 2: Association Walk
+
+- Start trace: none
+- Paths found: 0
+
+## Phase 3: Contradiction Resolution
+
+- Contradictions detected: 0
+- Resolved: 0
+- Unresolvable: 0
+
+## Phase 4: Identity Entropy
+
+- Classification: normal
+- Trend: stable
+- Entropy value: 0.5
+
+## Phase 5: Agenda Formation
+
+- Total agenda items: 0
+
+## Phase 6: Consolidation Commit
+
+- Traces written to memory: 0
+- Dream store cleared: true
+
+---
+
+## Summary
+
+| Metric | Value |
+|--------|-------|
+| Traces decayed | 0 |
+| Unresolved found | 0 |
+| Associations walked | 0 |
+| Contradictions detected | 0 |
+| Contradictions resolved | 0 |
+| Agenda items formed | 0 |
+| Traces consolidated | 0 |

data/logs/dreams/dream-2026-03-14_065244.md

@@ -0,0 +1,49 @@
+# Dream Cycle — 2026-03-14 06:52:44 UTC
+
+## Phase 1: Memory Audit
+
+- Traces decayed: 0
+- Traces pruned: 0
+- Tier migrations: 0
+- Consolidation candidates: 0
+- Unresolved traces found: 0
+
+## Phase 2: Association Walk
+
+- Start trace: none
+- Paths found: 0
+
+## Phase 3: Contradiction Resolution
+
+- Contradictions detected: 0
+- Resolved: 0
+- Unresolvable: 0
+
+## Phase 4: Identity Entropy
+
+- Classification: normal
+- Trend: stable
+- Entropy value: 0.5
+
+## Phase 5: Agenda Formation
+
+- Total agenda items: 0
+
+## Phase 6: Consolidation Commit
+
+- Traces written to memory: 0
+- Dream store cleared: true
+
+---
+
+## Summary
+
+| Metric | Value |
+|--------|-------|
+| Traces decayed | 0 |
+| Unresolved found | 0 |
+| Associations walked | 0 |
+| Contradictions detected | 0 |
+| Contradictions resolved | 0 |
+| Agenda items formed | 0 |
+| Traces consolidated | 0 |

data/logs/dreams/dream-2026-03-14_065358.md

@@ -0,0 +1,49 @@
+# Dream Cycle — 2026-03-14 06:53:58 UTC
+
+## Phase 1: Memory Audit
+
+- Traces decayed: 0
+- Traces pruned: 0
+- Tier migrations: 0
+- Consolidation candidates: 0
+- Unresolved traces found: 0
+
+## Phase 2: Association Walk
+
+- Start trace: none
+- Paths found: 0
+
+## Phase 3: Contradiction Resolution
+
+- Contradictions detected: 0
+- Resolved: 0
+- Unresolvable: 0
+
+## Phase 4: Identity Entropy
+
+- Classification: normal
+- Trend: stable
+- Entropy value: 0.5
+
+## Phase 5: Agenda Formation
+
+- Total agenda items: 0
+
+## Phase 6: Consolidation Commit
+
+- Traces written to memory: 0
+- Dream store cleared: true
+
+---
+
+## Summary
+
+| Metric | Value |
+|--------|-------|
+| Traces decayed | 0 |
+| Unresolved found | 0 |
+| Associations walked | 0 |
+| Contradictions detected | 0 |
+| Contradictions resolved | 0 |
+| Agenda items formed | 0 |
+| Traces consolidated | 0 |

data/logs/dreams/dream-2026-03-14_065435.md

@@ -0,0 +1,49 @@
+# Dream Cycle — 2026-03-14 06:54:35 UTC
+
+## Phase 1: Memory Audit
+
+- Traces decayed: 0
+- Traces pruned: 0
+- Tier migrations: 0
+- Consolidation candidates: 0
+- Unresolved traces found: 0
+
+## Phase 2: Association Walk
+
+- Start trace: none
+- Paths found: 0
+
+## Phase 3: Contradiction Resolution
+
+- Contradictions detected: 0
+- Resolved: 0
+- Unresolvable: 0
+
+## Phase 4: Identity Entropy
+
+- Classification: normal
+- Trend: stable
+- Entropy value: 0.5
+
+## Phase 5: Agenda Formation
+
+- Total agenda items: 0
+
+## Phase 6: Consolidation Commit
+
+- Traces written to memory: 0
+- Dream store cleared: true
+
+---
+
+## Summary
+
+| Metric | Value |
+|--------|-------|
+| Traces decayed | 0 |
+| Unresolved found | 0 |
+| Associations walked | 0 |
+| Contradictions detected | 0 |
+| Contradictions resolved | 0 |
+| Agenda items formed | 0 |
+| Traces consolidated | 0 |

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: lex-dream
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Esity
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: legion-gaia
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Autonomous dream cycle for brain-modeled agentic AI — memory consolidation,
+  association walking, contradiction resolution, and agenda formation
+email:
+- matthewdiverson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/ci.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- CLAUDE.md
+- Gemfile
+- README.md
+- lex-dream.gemspec
+- lib/legion/extensions/dream.rb
+- lib/legion/extensions/dream/actors/dream_cycle.rb
+- lib/legion/extensions/dream/client.rb
+- lib/legion/extensions/dream/helpers/agenda.rb
+- lib/legion/extensions/dream/helpers/association_walker.rb
+- lib/legion/extensions/dream/helpers/constants.rb
+- lib/legion/extensions/dream/helpers/contradiction_detector.rb
+- lib/legion/extensions/dream/helpers/dream_journal.rb
+- lib/legion/extensions/dream/helpers/dream_store.rb
+- lib/legion/extensions/dream/helpers/llm_enhancer.rb
+- lib/legion/extensions/dream/runners/dream_cycle.rb
+- lib/legion/extensions/dream/version.rb
+- logs/dreams/dream-2026-03-14_064520.md
+- logs/dreams/dream-2026-03-14_064546.md
+- logs/dreams/dream-2026-03-14_065244.md
+- logs/dreams/dream-2026-03-14_065358.md
+- logs/dreams/dream-2026-03-14_065435.md
+homepage: https://github.com/LegionIO/lex-dream
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-dream
+  source_code_uri: https://github.com/LegionIO/lex-dream
+  documentation_uri: https://github.com/LegionIO/lex-dream
+  changelog_uri: https://github.com/LegionIO/lex-dream
+  bug_tracker_uri: https://github.com/LegionIO/lex-dream/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: LEX Dream
+test_files: []