lex-dream 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 18c812c7de44c6dd1a06bc41c54e04cc03d88d745f47da1d72765c4d399a342f
+  data.tar.gz: 90f655a9201fe82647715d70564df33e6a29b633e2cea4857bb04316719780b6
+SHA512:
+  metadata.gz: 98b2744be8165cda9ed07087ba01ad57acb3b2dcf3179071923d265a71688c1b478e8ca5b0a029224db09254b756b856bf07de63c3ac321f85b3419ce0bbe675
+  data.tar.gz: 4cb73181be977b2681afa77002849ac000c6758b9d716d7064d507358a07cfaafd1cca30ca6fc061f247ef93bd639401a1a111d403a2815aeee6b87fff59f77a

data/.github/workflows/ci.yml

@@ -0,0 +1,16 @@
+name: CI
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  ci:
+    uses: LegionIO/.github/.github/workflows/ci.yml@main
+
+  release:
+    needs: ci
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    uses: LegionIO/.github/.github/workflows/release.yml@main
+    secrets:
+      rubygems-api-key: ${{ secrets.RUBYGEMS_API_KEY }}

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.gem
+.rspec_status
+Gemfile.lock
+logs/

data/.rspec

@@ -0,0 +1,3 @@
+--require spec_helper
+--format documentation
+--color

data/.rubocop.yml

@@ -0,0 +1,56 @@
+AllCops:
+  TargetRubyVersion: 3.4
+  NewCops: enable
+  SuggestExtensions: false
+
+Layout/LineLength:
+  Max: 160
+
+Layout/SpaceAroundEqualsInParameterDefault:
+  EnforcedStyle: space
+
+Layout/HashAlignment:
+  EnforcedHashRocketStyle: table
+  EnforcedColonStyle: table
+
+Metrics/MethodLength:
+  Max: 50
+
+Metrics/ClassLength:
+  Max: 1500
+
+Metrics/ModuleLength:
+  Max: 1500
+
+Metrics/BlockLength:
+  Max: 40
+  Exclude:
+    - 'spec/**/*'
+
+Metrics/AbcSize:
+  Max: 60
+
+Metrics/CyclomaticComplexity:
+  Max: 15
+
+Metrics/PerceivedComplexity:
+  Max: 17
+
+Style/Documentation:
+  Enabled: false
+
+Style/SymbolArray:
+  Enabled: true
+
+Style/FrozenStringLiteralComment:
+  Enabled: true
+  EnforcedStyle: always
+
+Naming/FileName:
+  Enabled: false
+
+Naming/PredicateMethod:
+  Enabled: false
+
+Gemspec/DevelopmentDependencies:
+  Enabled: false

data/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+
+## [Unreleased]
+
+## [0.1.1] - 2026-03-16
+
+### Fixed
+- Guard `DreamCycle#memory` with `defined?` check and use `Memory::Client.new` instead of fragile `Object.new.extend` pattern
+- Guard `DreamCycle#identity` with `defined?` check to prevent `NoMethodError` when lex-identity is not loaded
+- Early return in `execute_dream_cycle` when lex-memory is unavailable (logs warning instead of crashing every 5 minutes)
+- Guard `Dream::Client#initialize` against missing Memory, Identity, and Emotion extensions
+
+### Added
+- `spec/legion/extensions/dream/actors/dream_cycle_spec.rb` (7 examples) — tests for the DreamCycle actor (Every 300s)
+
+## [0.1.0] - 2026-03-13
+
+### Added
+- Initial release

data/CLAUDE.md

@@ -0,0 +1,152 @@
+# lex-dream
+
+**Level 3 Documentation**
+- **Parent**: `/Users/miverso2/rubymine/legion/extensions-agentic/CLAUDE.md`
+- **Grandparent**: `/Users/miverso2/rubymine/legion/CLAUDE.md`
+
+## Purpose
+
+Autonomous dream cycle for the LegionIO cognitive architecture. When the agent is idle, it enters `dormant_active` mode and runs an eight-phase internal consolidation cycle: memory audit, association walking, contradiction resolution, identity entropy assessment, agenda formation, consolidation commit, dream reflection, and dream narration. Dream output feeds back into lex-memory as semantic traces that surface organically through normal retrieval — no explicit surfacing mechanism.
+
+## Gem Info
+
+- **Gem name**: `lex-dream`
+- **Version**: `0.1.1`
+- **Module**: `Legion::Extensions::Dream`
+- **Ruby**: `>= 3.4`
+- **License**: MIT
+
+## File Structure
+
+```
+lib/legion/extensions/dream/
+  version.rb
+  actors/
+    dream_cycle.rb             # Periodic actor (Every 300s) — calls execute_dream_cycle
+  helpers/
+    constants.rb               # Configuration defaults, DREAM_CYCLE_PHASES list, agenda item types
+    dream_store.rb             # In-memory store for agenda, walk results, contradictions, entropy
+    association_walker.rb      # Novelty-scored multi-hop association traversal + start trace selection
+    contradiction_detector.rb  # Domain-tag overlap + valence divergence detection and resolution
+    agenda.rb                  # Phase output synthesis and semantic trace conversion
+    llm_enhancer.rb            # Optional LLM integration for contradiction resolution, agenda synthesis, and journal narration
+    dream_journal.rb           # Writes human-readable dream journal entries to logs/dreams/
+  runners/
+    dream_cycle.rb             # Eight-phase dream cycle runner (all phase methods)
+  client.rb                    # Client with dependency injection for memory/identity/emotion
+spec/
+  legion/extensions/dream/
+    actors/
+      dream_cycle_spec.rb
+    helpers/
+      dream_store_spec.rb
+      association_walker_spec.rb
+      contradiction_detector_spec.rb
+      agenda_spec.rb
+    runners/
+      dream_cycle_spec.rb
+    client_spec.rb
+    integration_spec.rb
+```
+
+## Key Constants (Helpers::Constants)
+
+```ruby
+ASSOCIATION_WALK_HOPS          = 12       # max BFS depth
+ASSOCIATION_NOVELTY_THRESHOLD  = 0.65     # min novelty to log a walk result
+CONTRADICTION_RESOLUTION_STRATEGY = :recency_weighted  # or :intensity_weighted
+ENTROPY_WINDOW                 = 7        # sessions for identity entropy trend
+AGENDA_MAX_ITEMS               = 5        # max agenda items carried forward
+DREAM_PARTITION_TTL            = 604_800  # 7 days before unrecalled items expire
+AGENDA_ITEM_TYPES              = %i[unresolved surfacing curious corrective]
+```
+
+## The Eight Dream Phases
+
+All phases execute sequentially via direct Ruby method calls (not queued through transport). Phases are defined in `Constants::DREAM_CYCLE_PHASES`.
+
+| Phase | Method | What It Does |
+|---|---|---|
+| 1. Memory Audit | `phase_memory_audit` | Runs decay + tier migration, marks consolidation candidates, collects unresolved traces using `EMERGENT_UNRESOLVED` heuristics |
+| 2. Association Walk | `phase_association_walk` | Selects highest-salience unresolved trace, BFS walks associations with novelty scoring, materializes novel links via `hebbian_link` |
+| 3. Contradiction Resolution | `phase_contradiction_resolution` | Detects opposing-valence traces by domain overlap; resolves via LLM if available, otherwise falls back to recency/intensity weighting |
+| 4. Identity Entropy Check | `phase_identity_entropy_check` | Calls `identity.check_entropy`, records result in DreamStore, flags drift as corrective agenda item |
+| 5. Agenda Formation | `phase_agenda_formation` | Synthesizes phases 1-4 into typed, weighted agenda items; uses LLM synthesis if available, mechanical fallback otherwise |
+| 6. Consolidation Commit | `phase_consolidation_commit` | Converts agenda to semantic traces in lex-memory, clears unresolved flags, expires stale dream state, flushes cache store |
+| 7. Dream Reflection | `phase_dream_reflection` | Calls `lex-reflection` to assess cognitive health of the dream cycle (skipped if extension not loaded) |
+| 8. Dream Narration | `phase_dream_narration` | Calls `lex-narrator` to produce a narrative summary (skipped if extension not loaded) |
+
+## DreamStore
+
+In-memory store owned entirely by lex-dream. The agent's private journal:
+
+- `agenda` — weighted orientation items (`:unresolved`, `:surfacing`, `:curious`, `:corrective`)
+- `walk_results` — novel association paths with novelty scores
+- `contradictions` — resolution logs with domain and outcome
+- `entropy_history` — identity entropy snapshots
+
+Items expire via `DREAM_PARTITION_TTL`. Oldest agenda items drop when `AGENDA_MAX_ITEMS` exceeded.
+
+## LLM Enhancement
+
+`Helpers::LlmEnhancer` provides optional LLM-enhanced processing:
+- `available?` — returns true when `Legion::LLM` is started
+- `resolve_contradiction(trace_a, trace_b, strategy:)` — prompts LLM to reason about which trace is more reliable; falls back to mechanical resolution if unavailable or on error
+- `synthesize_agenda(unresolved_traces:, contradictions:, walk_results:, entropy:)` — prompts LLM to synthesize agenda items from all phase data; mechanical fallback via `Helpers::Agenda.build_from_phases`
+- `narrate_journal(results, phase_data)` — prompts LLM to write a 3-5 paragraph analytical narrative for the dream journal; called by `DreamJournal.section_narrative` when LLM is available
+
+The system prompt instructs the LLM to act as the agent's internal dream processor: concise, analytical, structured reasoning only.
+
+## Dream Journal
+
+`Helpers::DreamJournal.write_entry(results:, phase_data:, dream_store:)` is called after all phases complete but before dream state is cleared. It writes a human-readable Markdown journal entry to `<Dir.pwd>/logs/dreams/dream-<timestamp>.md`. When LLM is available, `LlmEnhancer.narrate_journal` prepends an analytical reflection section before the phase-by-phase breakdown.
+
+## Client
+
+```ruby
+Client.new(memory:, identity:, emotion:)
+```
+
+Dependency clients initialized once at boot, held for process lifetime. Defaults to creating its own instances if none injected. The `dream_store` is public (`attr_reader`). All other state is private.
+
+## Organic Recall — How Dream Output Reaches Active Sessions
+
+No explicit surfacing mechanism. Dream output feeds back through normal lex-memory retrieval:
+
+- Novel associations materialized as Hebbian links → participate in `retrieve_ranked`
+- Agenda items become semantic traces with `dream:*` domain tags and high emotional intensity
+- Reinforced traces have boosted strength → win retrieval ranking
+- The agent doesn't "decide to bring something up" — relevant dream-formed knowledge surfaces contextually
+
+## Integration Points
+
+- **lex-tick**: Dream runs in `dormant_active` mode. Eight dream phases registered in `MODE_PHASES[:dormant_active]`. Tick budget is uncapped (`Float::INFINITY`).
+- **lex-memory**: Direct calls to `decay_cycle`, `migrate_tier`, `hebbian_link`. Calls `CacheStore#reload` before the cycle starts (picks up traces written by other processes). Calls `CacheStore#flush` after the cycle completes.
+- **lex-identity**: Calls `check_entropy` during phase 4 for drift detection.
+- **lex-emotion**: Uses emotional intensity/valence from traces for salience ranking and contradiction detection.
+- **lex-reflection**: Phase 7 delegates to `lex-reflection` for cognitive health assessment (optional, skipped if not loaded).
+- **lex-narrator**: Phase 8 delegates to `lex-narrator` for dream narrative generation (optional, skipped if not loaded).
+- **legion-llm**: LlmEnhancer checks `Legion::LLM.started?` to determine if LLM-enhanced resolution/synthesis is available.
+
+## Transition Rules (in lex-tick)
+
+```
+dormant → dormant_active:    no signals for 1800s (DREAM_IDLE_THRESHOLD)
+dormant_active → sentinel:   high-salience signal (>= 0.7) or human_direct
+dormant_active → dormant:    dream cycle completes (dream_complete: true)
+sentinel → dormant_active:   no signals for 600s (SENTINEL_TO_DREAM_THRESHOLD)
+```
+
+## Development Notes
+
+- Actor namespace is `module Actor` (singular), matching the pattern used in other agentic extensions
+- Actor runner function is `execute_dream_cycle` (not `run_dream_cycle`)
+- `memory.send(:default_store)` needed because `default_store` is private on the memory runner
+- `store.reload` and `store.flush` are called defensively with `respond_to?` guards (only implemented by `CacheStore`, not `Store`)
+- `EMERGENT_UNRESOLVED` lambda defines five heuristics for finding unprocessed traces beyond the simple `unresolved: true` flag — episodic with zero reinforcement and high emotion, low-confidence unreinforced, negative-valence semantic/procedural, high-intensity unreinforced
+- Phase methods collect data into `@phase_data` for use by later phases and for the dream journal
+- `@phase_data[:agenda_snapshot]` is taken at the start of `phase_consolidation_commit` before `dream_store.clear` is called, preserving the snapshot for the dream journal
+- `dream_store.clear` is called at the end of `consolidation_commit` to reset state for the next dream cycle
+- Dream reflection and narration phases return `{ status: :skipped, reason: :extension_not_loaded }` when their dependencies are absent — the cycle completes normally
+- Guards: `memory` uses `defined?(Legion::Extensions::Memory::Client)`, `identity` uses `defined?(Legion::Extensions::Identity::Runners::Identity)` — avoids crashes when extensions are not loaded
+- All state is in-memory (consistent with v0.1.1 pattern across agentic extensions)

data/Gemfile

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec
+
+group :test do
+  gem 'lex-emotion', path: '../lex-emotion'
+  gem 'lex-identity', path: '../lex-identity'
+  gem 'lex-memory', path: '../lex-memory'
+  gem 'lex-tick', path: '../lex-tick'
+  gem 'rspec', '~> 3.0'
+  gem 'rubocop', require: false
+  gem 'rubocop-rspec', require: false
+end
+
+gem 'legion-gaia', path: '../../legion-gaia'

data/README.md

@@ -0,0 +1,56 @@
+# lex-dream
+
+Autonomous dream cycle for the [LegionIO](https://github.com/LegionIO/LegionIO) cognitive architecture. When the agent is idle, it runs an eight-phase internal consolidation cycle: memory audit, association walking, contradiction resolution, identity entropy assessment, agenda formation, consolidation commit, dream reflection, and dream narration.
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem 'lex-dream'
+```
+
+## How It Works
+
+Dream output feeds back into lex-memory as semantic traces with `dream:*` domain tags. These surface organically through normal retrieval ranking -- no explicit surfacing mechanism needed.
+
+### The Eight Dream Phases
+
+| Phase | What It Does |
+|-------|-------------|
+| Memory Audit | Runs decay + tier migration, marks consolidation candidates, collects unresolved traces |
+| Association Walk | BFS walks associations from highest-salience unresolved trace, materializes novel Hebbian links |
+| Contradiction Resolution | Detects opposing-valence traces by domain; resolves via LLM if available, else mechanical fallback |
+| Identity Entropy Check | Calls lex-identity entropy assessment, flags drift as corrective agenda item |
+| Agenda Formation | Synthesizes phases 1-4 into typed, weighted agenda items (LLM synthesis when available) |
+| Consolidation Commit | Converts agenda to semantic traces in lex-memory, clears dream state |
+| Dream Reflection | Assesses cognitive health of the dream cycle via lex-reflection (skipped if not loaded) |
+| Dream Narration | Produces a narrative summary via lex-narrator (skipped if not loaded) |
+
+### Agenda Item Types
+
+- `:unresolved` -- traces that need attention
+- `:surfacing` -- unresolvable contradictions
+- `:curious` -- novel associations discovered during walk
+- `:corrective` -- identity entropy drift detected
+
+## Dependencies
+
+- `lex-memory` -- trace storage, decay, Hebbian linking, cache reload/flush
+- `lex-identity` -- entropy assessment
+- `lex-emotion` -- emotional intensity for salience ranking
+- `lex-reflection` -- optional cognitive health assessment (dream_reflection phase)
+- `lex-narrator` -- optional narrative generation (dream_narration phase)
+- `legion-llm` -- optional LLM enhancement for contradiction resolution, agenda synthesis, and journal narration
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec
+bundle exec rubocop
+```
+
+## License
+
+MIT

data/lex-dream.gemspec

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/dream/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lex-dream'
+  spec.version       = Legion::Extensions::Dream::VERSION
+  spec.authors       = ['Esity']
+  spec.email         = ['matthewdiverson@gmail.com']
+
+  spec.summary       = 'LEX Dream'
+  spec.description   = 'Autonomous dream cycle for brain-modeled agentic AI — memory consolidation, ' \
+                       'association walking, contradiction resolution, and agenda formation'
+  spec.homepage      = 'https://github.com/LegionIO/lex-dream'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = '>= 3.4'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/LegionIO/lex-dream'
+  spec.metadata['documentation_uri'] = 'https://github.com/LegionIO/lex-dream'
+  spec.metadata['changelog_uri'] = 'https://github.com/LegionIO/lex-dream'
+  spec.metadata['bug_tracker_uri'] = 'https://github.com/LegionIO/lex-dream/issues'
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.require_paths = ['lib']
+  spec.add_development_dependency 'legion-gaia'
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/actors/every'
+
+module Legion
+  module Extensions
+    module Dream
+      module Actor
+        class DreamCycle < Legion::Extensions::Actors::Every
+          def runner_class
+            Legion::Extensions::Dream::Runners::DreamCycle
+          end
+
+          def runner_function
+            'execute_dream_cycle'
+          end
+
+          def time
+            300
+          end
+
+          def run_now?
+            false
+          end
+
+          def use_runner?
+            false
+          end
+
+          def check_subtask?
+            false
+          end
+
+          def generate_task?
+            false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Dream
+      class Client
+        include Runners::DreamCycle
+
+        attr_reader :dream_store
+
+        def initialize(memory: nil, identity: nil, emotion: nil, **)
+          @memory      = memory   || (Legion::Extensions::Memory::Client.new if defined?(Legion::Extensions::Memory::Client))
+          @identity    = identity || (Legion::Extensions::Identity::Client.new if defined?(Legion::Extensions::Identity::Client))
+          @emotion     = emotion  || (Legion::Extensions::Emotion::Client.new if defined?(Legion::Extensions::Emotion::Client))
+          @dream_store = Helpers::DreamStore.new
+          @phase_data  = {}
+        end
+
+        private
+
+        attr_reader :memory, :identity, :emotion, :phase_data
+      end
+    end
+  end
+end

data/lib/legion/extensions/dream/helpers/agenda.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Dream
+      module Helpers
+        module Agenda
+          module_function
+
+          def build_from_phases(phase_outputs)
+            now   = Time.now.utc
+
+            items = Array(phase_outputs[:unresolved_traces]).map do |trace|
+              {
+                type:       :unresolved,
+                content:    { trace_id: trace[:trace_id] },
+                weight:     trace[:emotional_intensity],
+                created_at: now
+              }
+            end
+
+            Array(phase_outputs[:contradictions]).each do |contradiction|
+              next unless contradiction[:resolution] == :unresolvable
+
+              items << {
+                type:       :surfacing,
+                content:    { trace_ids: contradiction[:trace_ids], domain: contradiction[:domain] },
+                weight:     0.7,
+                created_at: now
+              }
+            end
+
+            Array(phase_outputs[:walk_results]).each do |result|
+              items << {
+                type:       :curious,
+                content:    { trace_id: result[:trace_id], path: result[:path] },
+                weight:     result[:novelty_score],
+                created_at: now
+              }
+            end
+
+            entropy = phase_outputs[:entropy] || {}
+            if entropy[:classification] == :high_entropy && entropy[:trend] == :rising
+              items << {
+                type:       :corrective,
+                content:    { classification: entropy[:classification], trend: entropy[:trend] },
+                weight:     entropy[:entropy],
+                created_at: now
+              }
+            end
+
+            items
+          end
+
+          def to_semantic_traces(agenda_items)
+            agenda_items.map do |item|
+              Legion::Extensions::Memory::Helpers::Trace.new_trace(
+                type:                :semantic,
+                content_payload:     { dream_agenda: item[:type], **item[:content] },
+                emotional_intensity: item[:weight],
+                domain_tags:         ["dream:#{item[:type]}"],
+                origin:              :direct_experience
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/dream/helpers/association_walker.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Dream
+      module Helpers
+        module AssociationWalker
+          module_function
+
+          def walk(store:, start_id:, max_hops: Constants::ASSOCIATION_WALK_HOPS, # rubocop:disable Metrics/ParameterLists
+                   novelty_threshold: Constants::ASSOCIATION_NOVELTY_THRESHOLD,
+                   known_paths: Set.new, **)
+            raw = store.walk_associations(start_id: start_id, max_hops: max_hops)
+
+            raw.filter_map do |result|
+              score = compute_novelty(
+                path:        result[:path],
+                depth:       result[:depth],
+                store:       store,
+                known_paths: known_paths
+              )
+              next if score < novelty_threshold
+
+              result.merge(novelty_score: score)
+            end
+          end
+
+          def select_start_trace(store:)
+            # Prefer episodic unresolved traces, fall back to any high-intensity unresolved
+            candidates = store.all_traces.select do |t|
+              t[:unresolved] == true ||
+                (t[:trace_type] == :episodic && t[:reinforcement_count].zero? && t[:emotional_intensity] >= 0.5) ||
+                (t[:confidence].is_a?(Numeric) && t[:confidence] < 0.4 && t[:reinforcement_count].zero?)
+            end
+            candidates.max_by { |t| t[:emotional_intensity] }
+          end
+
+          def compute_novelty(path:, depth:, store:, known_paths:)
+            path_key = path.join('->')
+            return 0.0 if known_paths.include?(path_key)
+
+            depth_factor = depth / Constants::ASSOCIATION_WALK_HOPS.to_f
+
+            type_diversity = path.map { |id| store.get(id)&.dig(:trace_type) }.compact.uniq.size
+            type_factor    = type_diversity / path.size.to_f
+
+            ((depth_factor * 0.4) + (type_factor * 0.6)).clamp(0.0, 1.0)
+          end
+
+          private :compute_novelty
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/dream/helpers/constants.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Dream
+      module Helpers
+        module Constants
+          ASSOCIATION_WALK_HOPS          = 12
+          ASSOCIATION_NOVELTY_THRESHOLD  = 0.65
+          CONTRADICTION_RESOLUTION_STRATEGY = :recency_weighted
+          ENTROPY_WINDOW                 = 7
+          AGENDA_MAX_ITEMS               = 5
+          DREAM_PARTITION_TTL            = 604_800
+          AGENDA_ITEM_TYPES              = %i[unresolved surfacing curious corrective].freeze
+
+          DREAM_CYCLE_PHASES = %i[
+            memory_audit
+            association_walk
+            contradiction_resolution
+            identity_entropy_check
+            agenda_formation
+            consolidation_commit
+            dream_reflection
+            dream_narration
+          ].freeze
+        end
+      end
+    end
+  end
+end