lex-agentic-language 0.1.0 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 664d19699b188ee30a787c5c5e24211c920e81492f03da70ed7a8d0a0359a5ad
-  data.tar.gz: 437b2eb7099d2bfeeeb8d3ed027f6f4a4fdc14f867944688b602bfd5c31dd9f3
+  metadata.gz: 10d9347e7d48c6e3313371b8641970bcb9d13c05642dbdd98ae0f025f2e7e02c
+  data.tar.gz: b6c2684ee724f7674b9623def4bd54be8191c7cb000c38e1e0adda121f63f402
 SHA512:
-  metadata.gz: '043782a4236c9b1a204170f7e06614dde8eaac0633efb623333c4b3f0b09de34d6ad4393db898f984bc1d40ccd59cf54463cb6c377bda76b06be3855b85fda94'
-  data.tar.gz: de3e90307844b393b1eb991df41ad8fe29eeb46297f2df29f8e41281f52df10d0c15d7ce32477356276d6fce30c54bfb4618330357ccd92ccbae4347116c3db2
+  metadata.gz: 22fbde5b49cfafbe968284d29c8ee9596128efbe4977dddc5b76d5affae44c8d93873c4eeb92a10371a7924de23e7113eb1b2c77a2c19ef7a6e6620c5c65e056
+  data.tar.gz: 73a363fc2b6a5f0b60b4a9725d18cb632abcce3f2c4f5b79f7977679fcebbe50f19dcb858b2e8260a32c0c949bff80ba62889f13d4616a53b822b41e1504cc96

data/CHANGELOG.md

@@ -1,6 +1,34 @@
 # Changelog
 
-## [0.1.0] - 2026-03-17
+## [Unreleased]
+
+## [0.1.3] - 2026-03-22
+
+### Changed
+- Add legion-logging, legion-settings, legion-json, legion-cache, legion-crypt, legion-data, legion-transport as runtime dependencies
+- Replace direct Legion::Logging calls with injected log helper in runner modules
+- Update spec_helper with real sub-gem helper stubs
+
+## [0.1.2] - 2026-03-18
+
+### Changed
+- Enforce BLEND_TYPES enum validation in `BlendingEngine#blend` — returns nil for invalid blend_type
+- Add 2 specs for BLEND_TYPES enforcement in blending engine spec
+
+## [0.1.1] - 2026-03-18
+
+### Changed
+- Enforce SLOT_TYPES enum validation in `Frame#add_slot` — returns nil for invalid slot_type
+- Enforce EXPRESSION_TYPES enum validation in `GrammarEngine#create_construction` — returns nil for invalid expression_type
+- Enforce SPECIFICITY_LEVELS enum validation in `GrammarEngine#create_construal` — returns nil for invalid specificity
+- Enforce SCOPE_LEVELS enum validation in `GrammarEngine#create_construal` — returns nil for invalid scope
+- Enforce DEPTHS enum validation in `Summarizer#summarize_domain` and `Summarizer#extract_key_facts` — returns nil for invalid depth
+
+## [0.1.0] - 2026-03-18
 
 ### Added
-- Initial domain gem scaffold
+- Initial release as domain consolidation gem
+- Consolidated source extensions into unified domain gem under `Legion::Extensions::Agentic::<Domain>`
+- All sub-modules loaded from single entry point
+- Full spec suite with zero failures
+- RuboCop compliance across all files

data/README.md

@@ -1,13 +1,41 @@
 # lex-agentic-language
 
-LEX agentic language domain: linguistic processing and communication
+Domain consolidation gem for language processing and communication. Bundles 9 source extensions into one loadable unit under `Legion::Extensions::Agentic::Language`.
 
-## Sub-modules
+## Overview
 
-*(populated as extensions are consolidated)*
+**Gem**: `lex-agentic-language`
+**Version**: 0.1.2
+**Namespace**: `Legion::Extensions::Agentic::Language`
+
+## Sub-Modules
+
+| Sub-Module | Source Gem | Purpose |
+|---|---|---|
+| `Language::Language` | `lex-language` | Core language processing — token parsing, semantic framing, pragmatic intent |
+| `Language::Grammar` | `lex-cognitive-grammar` | Grammatical structure processing |
+| `Language::InnerSpeech` | `lex-inner-speech` | Vygotsky inner speech — private verbal thought for problem solving |
+| `Language::Narrator` | `lex-narrator` | Real-time narrative stream of internal state (optional LLM enhancement) |
+| `Language::NarrativeReasoning` | `lex-narrative-reasoning` | Narrative as a reasoning mode — story-schema activation |
+| `Language::FrameSemantics` | `lex-frame-semantics` | Fillmore frame semantics — conceptual frames, slots, fillers |
+| `Language::PragmaticInference` | `lex-pragmatic-inference` | Gricean maxims and conversational implicature |
+| `Language::ConceptualBlending` | `lex-conceptual-blending` | Fauconnier & Turner — emergent blended structure from two input spaces |
+| `Language::ConceptualMetaphor` | `lex-conceptual-metaphor` | Lakoff & Johnson — structural mappings between conceptual domains |
 
 ## Installation
 
 ```ruby
 gem 'lex-agentic-language'
 ```
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec        # 735 examples, 0 failures
+bundle exec rubocop      # 0 offenses
+```
+
+## License
+
+MIT

data/lex-agentic-language.gemspec

@@ -24,6 +24,14 @@ Gem::Specification.new do |spec|
   end
   spec.require_paths = ['lib']
 
+  spec.add_dependency 'legion-cache', '>= 1.3.11'
+  spec.add_dependency 'legion-crypt', '>= 1.4.9'
+  spec.add_dependency 'legion-data', '>= 1.4.17'
+  spec.add_dependency 'legion-json', '>= 1.2.1'
+  spec.add_dependency 'legion-logging', '>= 1.3.2'
+  spec.add_dependency 'legion-settings', '>= 1.3.14'
+  spec.add_dependency 'legion-transport', '>= 1.3.9'
+
   spec.add_development_dependency 'rspec', '~> 3.13'
   spec.add_development_dependency 'rubocop', '~> 1.60'
   spec.add_development_dependency 'rubocop-rspec', '~> 2.26'

data/lib/legion/extensions/agentic/language/conceptual_blending/helpers/blending_engine.rb

@@ -33,6 +33,8 @@ module Legion
               end
 
               def blend(space_a_id:, space_b_id:, blend_type: :double_scope)
+                return nil unless BLEND_TYPES.include?(blend_type.to_sym)
+
                 raise ArgumentError, "Max blends (#{MAX_BLENDS}) reached" if @blends.size >= MAX_BLENDS
 
                 space_a = @spaces.fetch(space_a_id) { raise ArgumentError, "Space #{space_a_id} not found" }

data/lib/legion/extensions/agentic/language/conceptual_blending/runners/conceptual_blending.rb

@@ -11,83 +11,83 @@ module Legion
                                                           Legion::Extensions::Helpers.const_defined?(:Lex)
 
               def create_mental_space(name:, domain:, **)
-                Legion::Logging.debug "[conceptual_blending] create_space: name=#{name} domain=#{domain}"
+                log.debug "[conceptual_blending] create_space: name=#{name} domain=#{domain}"
                 space = engine.create_space(name: name, domain: domain)
                 { success: true, space: space.to_h }
               rescue ArgumentError => e
-                Legion::Logging.debug "[conceptual_blending] create_space failed: #{e.message}"
+                log.debug "[conceptual_blending] create_space failed: #{e.message}"
                 { success: false, error: e.message }
               end
 
               def add_space_element(space_id:, name:, properties: {}, **)
-                Legion::Logging.debug "[conceptual_blending] add_element: space=#{space_id} name=#{name}"
+                log.debug "[conceptual_blending] add_element: space=#{space_id} name=#{name}"
                 engine.add_element_to_space(space_id: space_id, name: name, properties: properties)
                 { success: true, space_id: space_id, element: name }
               rescue ArgumentError => e
-                Legion::Logging.debug "[conceptual_blending] add_element failed: #{e.message}"
+                log.debug "[conceptual_blending] add_element failed: #{e.message}"
                 { success: false, error: e.message }
               end
 
               def add_space_relation(space_id:, from:, to:, type:, **)
-                Legion::Logging.debug "[conceptual_blending] add_relation: space=#{space_id} #{from}->#{to} type=#{type}"
+                log.debug "[conceptual_blending] add_relation: space=#{space_id} #{from}->#{to} type=#{type}"
                 engine.add_relation_to_space(space_id: space_id, from: from, to: to, type: type)
                 { success: true, space_id: space_id, relation: { from: from, to: to, type: type } }
               rescue ArgumentError => e
-                Legion::Logging.debug "[conceptual_blending] add_relation failed: #{e.message}"
+                log.debug "[conceptual_blending] add_relation failed: #{e.message}"
                 { success: false, error: e.message }
               end
 
               def create_blend(space_a_id:, space_b_id:, blend_type: :double_scope, **)
-                Legion::Logging.debug "[conceptual_blending] blend: a=#{space_a_id} b=#{space_b_id} type=#{blend_type}"
+                log.debug "[conceptual_blending] blend: a=#{space_a_id} b=#{space_b_id} type=#{blend_type}"
                 blend = engine.blend(space_a_id: space_a_id, space_b_id: space_b_id, blend_type: blend_type)
                 { success: true, blend: blend.to_h }
               rescue ArgumentError => e
-                Legion::Logging.debug "[conceptual_blending] blend failed: #{e.message}"
+                log.debug "[conceptual_blending] blend failed: #{e.message}"
                 { success: false, error: e.message }
               end
 
               def elaborate_blend(blend_id:, emergent_property:, **)
-                Legion::Logging.debug "[conceptual_blending] elaborate: blend=#{blend_id} property=#{emergent_property}"
+                log.debug "[conceptual_blending] elaborate: blend=#{blend_id} property=#{emergent_property}"
                 blend = engine.elaborate_blend(blend_id: blend_id, emergent_property: emergent_property)
                 { success: true, blend: blend.to_h }
               rescue ArgumentError => e
-                Legion::Logging.debug "[conceptual_blending] elaborate failed: #{e.message}"
+                log.debug "[conceptual_blending] elaborate failed: #{e.message}"
                 { success: false, error: e.message }
               end
 
               def compress_blend(blend_id:, removed_element:, **)
-                Legion::Logging.debug "[conceptual_blending] compress: blend=#{blend_id} remove=#{removed_element}"
+                log.debug "[conceptual_blending] compress: blend=#{blend_id} remove=#{removed_element}"
                 blend = engine.compress_blend(blend_id: blend_id, removed_element: removed_element)
                 { success: true, blend: blend.to_h }
               rescue ArgumentError => e
-                Legion::Logging.debug "[conceptual_blending] compress failed: #{e.message}"
+                log.debug "[conceptual_blending] compress failed: #{e.message}"
                 { success: false, error: e.message }
               end
 
               def best_blends(limit: 5, **)
-                Legion::Logging.debug "[conceptual_blending] best_blends: limit=#{limit}"
+                log.debug "[conceptual_blending] best_blends: limit=#{limit}"
                 blends = engine.best_blends(limit: limit)
                 { success: true, blends: blends.map(&:to_h), count: blends.size }
               end
 
               def blend_quality(blend_id:, **)
-                Legion::Logging.debug "[conceptual_blending] blend_quality: blend=#{blend_id}"
+                log.debug "[conceptual_blending] blend_quality: blend=#{blend_id}"
                 quality = engine.blend_quality(blend_id: blend_id)
                 { success: true }.merge(quality)
               rescue ArgumentError => e
-                Legion::Logging.debug "[conceptual_blending] blend_quality failed: #{e.message}"
+                log.debug "[conceptual_blending] blend_quality failed: #{e.message}"
                 { success: false, error: e.message }
               end
 
               def update_conceptual_blending(**)
-                Legion::Logging.debug '[conceptual_blending] update: decay + prune cycle'
+                log.debug '[conceptual_blending] update: decay + prune cycle'
                 decayed = engine.decay_stale
                 pruned  = engine.prune_weak
                 { success: true, decayed: decayed, pruned: pruned }
               end
 
               def conceptual_blending_stats(**)
-                Legion::Logging.debug '[conceptual_blending] stats'
+                log.debug '[conceptual_blending] stats'
                 stats = engine.to_h
                 { success: true }.merge(stats)
               end

data/lib/legion/extensions/agentic/language/conceptual_blending/version.rb

@@ -5,7 +5,7 @@ module Legion
     module Agentic
       module Language
         module ConceptualBlending
-          VERSION = '0.1.0'
+          VERSION = '0.1.1'
         end
       end
     end

data/lib/legion/extensions/agentic/language/conceptual_metaphor/runners/conceptual_metaphor.rb

@@ -28,8 +28,8 @@ module Legion
 
                 return result unless result.is_a?(Helpers::Metaphor)
 
-                Legion::Logging.debug "[conceptual_metaphor] created #{source_domain}->#{target_domain} " \
-                                      "type=#{metaphor_type} id=#{result.id[0..7]}"
+                log.debug "[conceptual_metaphor] created #{source_domain}->#{target_domain} " \
+                          "type=#{metaphor_type} id=#{result.id[0..7]}"
                 { success: true, metaphor_id: result.id, source_domain: source_domain,
                   target_domain: target_domain, metaphor_type: metaphor_type,
                   strength: result.strength, conventionality: result.conventionality }
@@ -37,45 +37,45 @@ module Legion
 
               def apply_metaphor(metaphor_id:, source_concept:, **)
                 result = engine.apply_metaphor(metaphor_id: metaphor_id, source_concept: source_concept)
-                Legion::Logging.debug "[conceptual_metaphor] apply id=#{metaphor_id[0..7]} " \
-                                      "concept=#{source_concept} mapped=#{result[:mapped]}"
+                log.debug "[conceptual_metaphor] apply id=#{metaphor_id[0..7]} " \
+                          "concept=#{source_concept} mapped=#{result[:mapped]}"
                 { success: true }.merge(result)
               end
 
               def add_metaphor_entailment(metaphor_id:, entailment:, **)
                 result = engine.add_entailment(metaphor_id: metaphor_id, entailment: entailment)
-                Legion::Logging.debug "[conceptual_metaphor] entailment id=#{metaphor_id[0..7]} " \
-                                      "success=#{result[:success]}"
+                log.debug "[conceptual_metaphor] entailment id=#{metaphor_id[0..7]} " \
+                          "success=#{result[:success]}"
                 result
               end
 
               def find_metaphors_for(domain:, **)
                 metaphors = engine.find_by_domain(domain: domain)
-                Legion::Logging.debug "[conceptual_metaphor] find domain=#{domain} count=#{metaphors.size}"
+                log.debug "[conceptual_metaphor] find domain=#{domain} count=#{metaphors.size}"
                 { success: true, domain: domain, metaphors: metaphors.map(&:to_h), count: metaphors.size }
               end
 
               def conventional_metaphors(**)
                 metaphors = engine.conventional_metaphors
-                Legion::Logging.debug "[conceptual_metaphor] conventional count=#{metaphors.size}"
+                log.debug "[conceptual_metaphor] conventional count=#{metaphors.size}"
                 { success: true, metaphors: metaphors.map(&:to_h), count: metaphors.size }
               end
 
               def novel_metaphors(**)
                 metaphors = engine.novel_metaphors
-                Legion::Logging.debug "[conceptual_metaphor] novel count=#{metaphors.size}"
+                log.debug "[conceptual_metaphor] novel count=#{metaphors.size}"
                 { success: true, metaphors: metaphors.map(&:to_h), count: metaphors.size }
               end
 
               def strongest_metaphors(limit: 5, **)
                 metaphors = engine.strongest(limit: limit)
-                Legion::Logging.debug "[conceptual_metaphor] strongest limit=#{limit} count=#{metaphors.size}"
+                log.debug "[conceptual_metaphor] strongest limit=#{limit} count=#{metaphors.size}"
                 { success: true, metaphors: metaphors.map(&:to_h), count: metaphors.size }
               end
 
               def metaphors_by_type(metaphor_type:, **)
                 metaphors = engine.by_type(metaphor_type: metaphor_type)
-                Legion::Logging.debug "[conceptual_metaphor] by_type=#{metaphor_type} count=#{metaphors.size}"
+                log.debug "[conceptual_metaphor] by_type=#{metaphor_type} count=#{metaphors.size}"
                 { success: true, metaphor_type: metaphor_type, metaphors: metaphors.map(&:to_h),
                   count: metaphors.size }
               end
@@ -83,13 +83,13 @@ module Legion
               def update_conceptual_metaphor(**)
                 engine.decay_all
                 pruned = engine.prune_weak
-                Legion::Logging.debug "[conceptual_metaphor] decay+prune pruned=#{pruned}"
+                log.debug "[conceptual_metaphor] decay+prune pruned=#{pruned}"
                 { success: true, pruned: pruned }
               end
 
               def conceptual_metaphor_stats(**)
                 stats = engine.to_h
-                Legion::Logging.debug "[conceptual_metaphor] stats total=#{stats[:total_metaphors]}"
+                log.debug "[conceptual_metaphor] stats total=#{stats[:total_metaphors]}"
                 { success: true }.merge(stats)
               end
 

data/lib/legion/extensions/agentic/language/frame_semantics/helpers/frame.rb

@@ -23,6 +23,8 @@ module Legion
               end
 
               def add_slot(name:, slot_type: :core, required: true)
+                return nil unless SLOT_TYPES.include?(slot_type.to_sym)
+
                 @slots[name] = { type: slot_type, filler: nil, required: required }
                 self
               end

data/lib/legion/extensions/agentic/language/grammar/helpers/grammar_engine.rb

@@ -15,6 +15,8 @@ module Legion
               end
 
               def create_construction(form:, meaning:, expression_type:, domain:, activation: DEFAULT_ACTIVATION)
+                return nil unless EXPRESSION_TYPES.include?(expression_type.to_sym)
+
                 prune_constructions_if_needed
                 construction = Construction.new(
                   form:            form,
@@ -30,6 +32,9 @@ module Legion
               def create_construal(scene:, perspective:, figure:, ground:,
                                    specificity: :intermediate, scope: :local,
                                    dynamicity: 0.5, construction_id: nil)
+                return nil unless SPECIFICITY_LEVELS.include?(specificity.to_sym)
+                return nil unless SCOPE_LEVELS.include?(scope.to_sym)
+
                 prune_construals_if_needed
                 construal = Construal.new(
                   scene:           scene,

data/lib/legion/extensions/agentic/language/grammar/runners/cognitive_grammar.rb

@@ -17,7 +17,7 @@ module Legion
                   expression_type: expression_type,
                   domain:          domain
                 )
-                Legion::Logging.debug "[cognitive_grammar] created construction form=#{form} type=#{expression_type} domain=#{domain}"
+                log.debug "[cognitive_grammar] created construction form=#{form} type=#{expression_type} domain=#{domain}"
                 construction.to_h
               end
 
@@ -34,7 +34,7 @@ module Legion
                   dynamicity:      dynamicity,
                   construction_id: construction_id
                 )
-                Legion::Logging.debug "[cognitive_grammar] created construal scene=#{scene} figure=#{figure}"
+                log.debug "[cognitive_grammar] created construal scene=#{scene} figure=#{figure}"
                 construal.to_h
               end
 
@@ -44,31 +44,31 @@ module Legion
 
                 msg = "[cognitive_grammar] used construction id=#{construction_id[0..7]} " \
                       "usage_count=#{construction.usage_count} activation=#{construction.activation.round(3)}"
-                Legion::Logging.debug msg
+                log.debug msg
                 { found: true, construction: construction.to_h }
               end
 
               def construals_for_scene_report(scene:, **)
                 construals = engine.construals_for_scene(scene: scene)
-                Legion::Logging.debug "[cognitive_grammar] construals_for_scene scene=#{scene} count=#{construals.size}"
+                log.debug "[cognitive_grammar] construals_for_scene scene=#{scene} count=#{construals.size}"
                 { scene: scene, count: construals.size, construals: construals.map(&:to_h) }
               end
 
               def entrenched_constructions_report(**)
                 constructions = engine.entrenched_constructions
-                Legion::Logging.debug "[cognitive_grammar] entrenched constructions count=#{constructions.size}"
+                log.debug "[cognitive_grammar] entrenched constructions count=#{constructions.size}"
                 { count: constructions.size, constructions: constructions.map(&:to_h) }
               end
 
               def constructions_by_domain_report(domain:, **)
                 constructions = engine.constructions_by_domain(domain: domain)
-                Legion::Logging.debug "[cognitive_grammar] constructions_by_domain domain=#{domain} count=#{constructions.size}"
+                log.debug "[cognitive_grammar] constructions_by_domain domain=#{domain} count=#{constructions.size}"
                 { domain: domain, count: constructions.size, constructions: constructions.map(&:to_h) }
               end
 
               def most_used_constructions(limit: 5, **)
                 constructions = engine.most_used(limit: limit)
-                Legion::Logging.debug "[cognitive_grammar] most_used limit=#{limit} count=#{constructions.size}"
+                log.debug "[cognitive_grammar] most_used limit=#{limit} count=#{constructions.size}"
                 { limit: limit, count: constructions.size, constructions: constructions.map(&:to_h) }
               end
 
@@ -76,13 +76,13 @@ module Legion
                 engine.decay_all
                 pruned = engine.prune_inactive
                 stats  = engine.to_h
-                Legion::Logging.debug "[cognitive_grammar] update: pruned=#{pruned} remaining=#{stats[:constructions_count]}"
+                log.debug "[cognitive_grammar] update: pruned=#{pruned} remaining=#{stats[:constructions_count]}"
                 { pruned: pruned, stats: stats }
               end
 
               def cognitive_grammar_stats(**)
                 stats = engine.to_h
-                Legion::Logging.debug "[cognitive_grammar] stats constructions=#{stats[:constructions_count]} construals=#{stats[:construals_count]}"
+                log.debug "[cognitive_grammar] stats constructions=#{stats[:constructions_count]} construals=#{stats[:construals_count]}"
                 stats
               end
 

data/lib/legion/extensions/agentic/language/language/helpers/summarizer.rb

@@ -10,6 +10,8 @@ module Legion
               module_function
 
               def summarize_domain(traces, domain:, depth: :standard)
+                return nil unless Constants::DEPTHS.include?(depth.to_sym)
+
                 return empty_summary(domain) if traces.empty?
 
                 grouped = group_by_type(traces)
@@ -37,6 +39,8 @@ module Legion
               end
 
               def extract_key_facts(grouped, depth: :standard)
+                return nil unless Constants::DEPTHS.include?(depth.to_sym)
+
                 limit = case depth
                         when :brief    then 3
                         when :detailed then 15

data/lib/legion/extensions/agentic/language/language/runners/language.rb

@@ -15,8 +15,8 @@ module Legion
                 summary = Helpers::Summarizer.summarize_domain(traces, domain: domain.to_sym, depth: depth.to_sym)
                 lexicon.store_summary(domain, summary)
 
-                Legion::Logging.debug "[language] summarize domain=#{domain} traces=#{traces.size} " \
-                                      "knowledge=#{summary[:knowledge_level]}"
+                log.debug "[language] summarize domain=#{domain} traces=#{traces.size} " \
+                          "knowledge=#{summary[:knowledge_level]}"
                 summary
               end
 

data/lib/legion/extensions/agentic/language/narrative_reasoning/runners/narrative_reasoning.rb

@@ -12,7 +12,7 @@ module Legion
 
               def create_narrative(title:, domain: nil, **)
                 narrative = narrative_engine.create_narrative(title: title, domain: domain)
-                Legion::Logging.debug "[narrative_reasoning] created narrative id=#{narrative.id[0..7]} title=#{title}"
+                log.debug "[narrative_reasoning] created narrative id=#{narrative.id[0..7]} title=#{title}"
                 { success: true, narrative_id: narrative.id, title: narrative.title, arc_stage: narrative.arc_stage }
               end
 
@@ -30,10 +30,10 @@ module Legion
                 )
 
                 if event
-                  Legion::Logging.debug "[narrative_reasoning] event added id=#{event.id[0..7]} type=#{event_type}"
+                  log.debug "[narrative_reasoning] event added id=#{event.id[0..7]} type=#{event_type}"
                   { success: true, event_id: event.id, event_type: event_type, narrative_id: narrative_id }
                 else
-                  Legion::Logging.debug "[narrative_reasoning] add_event failed: narrative #{narrative_id[0..7]} not found"
+                  log.debug "[narrative_reasoning] add_event failed: narrative #{narrative_id[0..7]} not found"
                   { success: false, error: :narrative_not_found }
                 end
               end
@@ -41,7 +41,7 @@ module Legion
               def add_narrative_theme(narrative_id:, theme:, **)
                 result = narrative_engine.add_narrative_theme(narrative_id: narrative_id, theme: theme)
                 if result
-                  Legion::Logging.debug "[narrative_reasoning] theme added theme=#{theme} to #{narrative_id[0..7]}"
+                  log.debug "[narrative_reasoning] theme added theme=#{theme} to #{narrative_id[0..7]}"
                   { success: true, narrative_id: narrative_id, theme: theme }
                 else
                   { success: false, error: :narrative_not_found }
@@ -51,7 +51,7 @@ module Legion
               def advance_narrative_arc(narrative_id:, **)
                 new_stage = narrative_engine.advance_narrative(narrative_id: narrative_id)
                 if new_stage
-                  Legion::Logging.debug "[narrative_reasoning] arc advanced to #{new_stage} for #{narrative_id[0..7]}"
+                  log.debug "[narrative_reasoning] arc advanced to #{new_stage} for #{narrative_id[0..7]}"
                   { success: true, narrative_id: narrative_id, arc_stage: new_stage }
                 else
                   { success: false, error: :narrative_not_found }
@@ -63,33 +63,33 @@ module Legion
                 narrative = narrative_engine.get(narrative_id)
                 return { success: false, error: :narrative_not_found } unless narrative
 
-                Legion::Logging.debug "[narrative_reasoning] causal chain length=#{chain.size} for #{narrative_id[0..7]}"
+                log.debug "[narrative_reasoning] causal chain length=#{chain.size} for #{narrative_id[0..7]}"
                 { success: true, narrative_id: narrative_id, chain: chain, link_count: chain.size }
               end
 
               def complete_narratives(**)
                 narratives = narrative_engine.complete_narratives
-                Legion::Logging.debug "[narrative_reasoning] complete narratives count=#{narratives.size}"
+                log.debug "[narrative_reasoning] complete narratives count=#{narratives.size}"
                 { success: true, narratives: narratives.map(&:to_h), count: narratives.size }
               end
 
               def domain_narratives(domain:, **)
                 narratives = narrative_engine.by_domain(domain: domain)
-                Legion::Logging.debug "[narrative_reasoning] domain=#{domain} count=#{narratives.size}"
+                log.debug "[narrative_reasoning] domain=#{domain} count=#{narratives.size}"
                 { success: true, domain: domain, narratives: narratives.map(&:to_h), count: narratives.size }
               end
 
               def most_coherent_narratives(limit: 5, **)
                 lim = limit.to_i.clamp(1, 50)
                 narratives = narrative_engine.most_coherent(limit: lim)
-                Legion::Logging.debug "[narrative_reasoning] most_coherent limit=#{lim} returned=#{narratives.size}"
+                log.debug "[narrative_reasoning] most_coherent limit=#{lim} returned=#{narratives.size}"
                 { success: true, narratives: narratives.map(&:to_h), count: narratives.size }
               end
 
               def update_narrative_reasoning(**)
                 narrative_engine.decay_all
                 count = narrative_engine.count
-                Legion::Logging.debug "[narrative_reasoning] decay cycle complete narratives=#{count}"
+                log.debug "[narrative_reasoning] decay cycle complete narratives=#{count}"
                 { success: true, narratives_updated: count }
               end
 
@@ -97,7 +97,7 @@ module Legion
                 engine = narrative_engine
                 complete = engine.complete_narratives.size
                 most_coh = engine.most_coherent(limit: 1).first
-                Legion::Logging.debug "[narrative_reasoning] stats count=#{engine.count} complete=#{complete}"
+                log.debug "[narrative_reasoning] stats count=#{engine.count} complete=#{complete}"
                 {
                   success:             true,
                   total_narratives:    engine.count,

data/lib/legion/extensions/agentic/language/narrator/runners/narrator.rb

@@ -19,7 +19,7 @@ module Legion
                   if llm_result
                     entry = entry.merge(narrative: llm_result, source: :llm)
                     journal.append(entry)
-                    Legion::Logging.debug "[narrator] mood=#{entry[:mood]} source=llm sections=#{entry[:sections].keys.size}"
+                    log.debug "[narrator] mood=#{entry[:mood]} source=llm sections=#{entry[:sections].keys.size}"
                     return {
                       narrative: entry[:narrative],
                       mood:      entry[:mood],
@@ -31,7 +31,7 @@ module Legion
                 end
 
                 journal.append(entry)
-                Legion::Logging.debug "[narrator] mood=#{entry[:mood]} sections=#{entry[:sections].keys.size}"
+                log.debug "[narrator] mood=#{entry[:mood]} sections=#{entry[:sections].keys.size}"
 
                 {
                   narrative: entry[:narrative],

data/lib/legion/extensions/agentic/language/pragmatic_inference/runners/pragmatic_inference.rb

@@ -23,9 +23,9 @@ module Legion
                   maxim_scores:    maxim_scores
                 )
 
-                Legion::Logging.debug "[pragmatic_inference] analyzed utterance id=#{utterance.id[0..7]} " \
-                                      "speaker=#{speaker} speech_act=#{speech_act} " \
-                                      "compliance=#{utterance.overall_compliance.round(2)}"
+                log.debug "[pragmatic_inference] analyzed utterance id=#{utterance.id[0..7]} " \
+                          "speaker=#{speaker} speech_act=#{speech_act} " \
+                          "compliance=#{utterance.overall_compliance.round(2)}"
 
                 { success: true, utterance_id: utterance.id, overall_compliance: utterance.overall_compliance,
                   violated_maxims: utterance.violated_maxims }
@@ -36,7 +36,7 @@ module Legion
 
                 violations = engine.detect_violations(utterance_id: utterance_id)
 
-                Legion::Logging.debug "[pragmatic_inference] violations detected id=#{utterance_id[0..7]} count=#{violations.size}"
+                log.debug "[pragmatic_inference] violations detected id=#{utterance_id[0..7]} count=#{violations.size}"
 
                 { success: true, utterance_id: utterance_id, violations: violations, violation_count: violations.size }
               end
@@ -48,10 +48,10 @@ module Legion
                 result = engine.generate_implicature(utterance_id: utterance_id, inferred_meaning: inferred_meaning)
 
                 if result
-                  Legion::Logging.debug "[pragmatic_inference] implicature added id=#{utterance_id[0..7]}"
+                  log.debug "[pragmatic_inference] implicature added id=#{utterance_id[0..7]}"
                   { success: true, utterance_id: utterance_id, inferred_meaning: result }
                 else
-                  Legion::Logging.debug "[pragmatic_inference] implicature failed: utterance not found id=#{utterance_id[0..7]}"
+                  log.debug "[pragmatic_inference] implicature failed: utterance not found id=#{utterance_id[0..7]}"
                   { success: false, error: :utterance_not_found }
                 end
               end
@@ -61,8 +61,8 @@ module Legion
 
                 profile = engine.speaker_profile(speaker: speaker)
 
-                Legion::Logging.debug "[pragmatic_inference] speaker profile speaker=#{speaker} " \
-                                      "utterances=#{profile[:utterance_count]}"
+                log.debug "[pragmatic_inference] speaker profile speaker=#{speaker} " \
+                          "utterances=#{profile[:utterance_count]}"
 
                 { success: true, **profile }
               end
@@ -72,7 +72,7 @@ module Legion
 
                 utterances = engine.by_speech_act(speech_act: speech_act)
 
-                Legion::Logging.debug "[pragmatic_inference] by_speech_act act=#{speech_act} count=#{utterances.size}"
+                log.debug "[pragmatic_inference] by_speech_act act=#{speech_act} count=#{utterances.size}"
 
                 { success: true, speech_act: speech_act, utterances: utterances.map(&:to_h), count: utterances.size }
               end
@@ -82,7 +82,7 @@ module Legion
 
                 utterances = engine.by_speaker(speaker: speaker)
 
-                Legion::Logging.debug "[pragmatic_inference] by_speaker speaker=#{speaker} count=#{utterances.size}"
+                log.debug "[pragmatic_inference] by_speaker speaker=#{speaker} count=#{utterances.size}"
 
                 { success: true, speaker: speaker, utterances: utterances.map(&:to_h), count: utterances.size }
               end
@@ -90,7 +90,7 @@ module Legion
               def most_violated_maxim(**)
                 maxim = engine.most_violated_maxim
 
-                Legion::Logging.debug "[pragmatic_inference] most violated maxim=#{maxim.inspect}"
+                log.debug "[pragmatic_inference] most violated maxim=#{maxim.inspect}"
 
                 { success: true, maxim: maxim,
                   description: maxim ? Helpers::Constants::MAXIM_DESCRIPTIONS[maxim] : nil }
@@ -100,7 +100,7 @@ module Legion
                 cooperation = engine.overall_cooperation
                 total = engine.count
 
-                Legion::Logging.debug "[pragmatic_inference] cooperation=#{cooperation.round(2)} total=#{total}"
+                log.debug "[pragmatic_inference] cooperation=#{cooperation.round(2)} total=#{total}"
 
                 { success: true, cooperation: cooperation, utterance_count: total }
               end
@@ -108,7 +108,7 @@ module Legion
               def update_pragmatic_inference(**)
                 engine.decay_all
 
-                Legion::Logging.debug "[pragmatic_inference] decay applied to #{engine.count} utterances"
+                log.debug "[pragmatic_inference] decay applied to #{engine.count} utterances"
 
                 { success: true, decayed_count: engine.count, decay_rate: Helpers::Constants::DECAY_RATE }
               end
@@ -116,8 +116,8 @@ module Legion
               def pragmatic_inference_stats(**)
                 stats = engine.to_h
 
-                Legion::Logging.debug "[pragmatic_inference] stats: utterances=#{stats[:utterance_count]} " \
-                                      "cooperation=#{stats[:overall_cooperation]}"
+                log.debug "[pragmatic_inference] stats: utterances=#{stats[:utterance_count]} " \
+                          "cooperation=#{stats[:overall_cooperation]}"
 
                 { success: true, **stats }
               end

data/lib/legion/extensions/agentic/language/version.rb

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Agentic
       module Language
-        VERSION = '0.1.0'
+        VERSION = '0.1.3'
       end
     end
   end

data/spec/legion/extensions/agentic/language/conceptual_blending/helpers/blending_engine_spec.rb

@@ -99,6 +99,19 @@ RSpec.describe Legion::Extensions::Agentic::Language::ConceptualBlending::Helper
         engine.blend(space_a_id: 'bad', space_b_id: space_b.id)
       end.to raise_error(ArgumentError, /not found/)
     end
+
+    it 'rejects invalid blend_type' do
+      result = engine.blend(space_a_id: space_a.id, space_b_id: space_b.id, blend_type: :nonexistent_type)
+      expect(result).to be_nil
+    end
+
+    it 'accepts all BLEND_TYPES' do
+      blend_types = Legion::Extensions::Agentic::Language::ConceptualBlending::Helpers::Constants::BLEND_TYPES
+      blend_types.each do |val|
+        result = engine.blend(space_a_id: space_a.id, space_b_id: space_b.id, blend_type: val)
+        expect(result).not_to be_nil, "Expected #{val.inspect} to be accepted"
+      end
+    end
   end
 
   describe '#elaborate_blend' do

data/spec/legion/extensions/agentic/language/frame_semantics/helpers/frame_spec.rb

@@ -45,6 +45,20 @@ RSpec.describe Legion::Extensions::Agentic::Language::FrameSemantics::Helpers::F
       result = frame.add_slot(name: :seller)
       expect(result).to be(frame)
     end
+
+    it 'returns nil for invalid slot_type' do
+      result = frame.add_slot(name: :buyer, slot_type: :bogus)
+      expect(result).to be_nil
+      expect(frame.slots).not_to have_key(:buyer)
+    end
+
+    it 'accepts all valid SLOT_TYPES' do
+      Legion::Extensions::Agentic::Language::FrameSemantics::Helpers::SLOT_TYPES.each do |type|
+        f = described_class.new(name: :test, domain: :test)
+        result = f.add_slot(name: :slot, slot_type: type)
+        expect(result).to be(f)
+      end
+    end
   end
 
   describe '#fill_slot' do

data/spec/legion/extensions/agentic/language/grammar/helpers/grammar_engine_spec.rb

@@ -29,6 +29,19 @@ RSpec.describe Legion::Extensions::Agentic::Language::Grammar::Helpers::GrammarE
       expect(c.expression_type).to eq(:nominal)
       expect(c.domain).to eq('nature')
     end
+
+    it 'returns nil for invalid expression_type' do
+      result = engine.create_construction(form: 'x', meaning: 'y', expression_type: :bogus, domain: 'd')
+      expect(result).to be_nil
+      expect(engine.to_h[:constructions_count]).to eq(0)
+    end
+
+    it 'accepts all valid EXPRESSION_TYPES' do
+      Legion::Extensions::Agentic::Language::Grammar::Helpers::Constants::EXPRESSION_TYPES.each do |type|
+        c = engine.create_construction(form: 'x', meaning: 'y', expression_type: type, domain: 'd')
+        expect(c).to be_a(Legion::Extensions::Agentic::Language::Grammar::Helpers::Construction)
+      end
+    end
   end
 
   describe '#create_construal' do
@@ -48,6 +61,32 @@ RSpec.describe Legion::Extensions::Agentic::Language::Grammar::Helpers::GrammarE
       expect(c.scope).to eq(:global)
       expect(c.dynamicity).to eq(0.8)
     end
+
+    it 'returns nil for invalid specificity' do
+      result = engine.create_construal(**construal_params, specificity: :bogus)
+      expect(result).to be_nil
+      expect(engine.to_h[:construals_count]).to eq(0)
+    end
+
+    it 'accepts all valid SPECIFICITY_LEVELS' do
+      Legion::Extensions::Agentic::Language::Grammar::Helpers::Constants::SPECIFICITY_LEVELS.each do |level|
+        c = engine.create_construal(**construal_params, specificity: level)
+        expect(c).to be_a(Legion::Extensions::Agentic::Language::Grammar::Helpers::Construal)
+      end
+    end
+
+    it 'returns nil for invalid scope' do
+      result = engine.create_construal(**construal_params, scope: :bogus)
+      expect(result).to be_nil
+      expect(engine.to_h[:construals_count]).to eq(0)
+    end
+
+    it 'accepts all valid SCOPE_LEVELS' do
+      Legion::Extensions::Agentic::Language::Grammar::Helpers::Constants::SCOPE_LEVELS.each do |level|
+        c = engine.create_construal(**construal_params, scope: level)
+        expect(c).to be_a(Legion::Extensions::Agentic::Language::Grammar::Helpers::Construal)
+      end
+    end
   end
 
   describe '#use_construction' do

data/spec/legion/extensions/agentic/language/language/helpers/summarizer_spec.rb

@@ -25,6 +25,18 @@ RSpec.describe Legion::Extensions::Agentic::Language::Language::Helpers::Summari
   end
 
   describe '.summarize_domain' do
+    it 'returns nil for invalid depth' do
+      result = described_class.summarize_domain([], domain: :networking, depth: :bogus)
+      expect(result).to be_nil
+    end
+
+    it 'accepts all valid DEPTHS' do
+      Legion::Extensions::Agentic::Language::Language::Helpers::Constants::DEPTHS.each do |depth|
+        result = described_class.summarize_domain([], domain: :networking, depth: depth)
+        expect(result).not_to be_nil
+      end
+    end
+
     it 'returns empty summary for no traces' do
       result = described_class.summarize_domain([], domain: :networking)
       expect(result[:knowledge_level]).to eq(:none)
@@ -92,6 +104,18 @@ RSpec.describe Legion::Extensions::Agentic::Language::Language::Helpers::Summari
       { semantic: make_traces(10) }
     end
 
+    it 'returns nil for invalid depth' do
+      result = described_class.extract_key_facts(grouped, depth: :bogus)
+      expect(result).to be_nil
+    end
+
+    it 'accepts all valid DEPTHS' do
+      Legion::Extensions::Agentic::Language::Language::Helpers::Constants::DEPTHS.each do |depth|
+        result = described_class.extract_key_facts(grouped, depth: depth)
+        expect(result).not_to be_nil
+      end
+    end
+
     it 'limits facts by depth :brief' do
       facts = described_class.extract_key_facts(grouped, depth: :brief)
       expect(facts.size).to be <= 3

data/spec/spec_helper.rb

@@ -1,24 +1,35 @@
 # frozen_string_literal: true
 
 require 'bundler/setup'
+require 'legion/logging'
+require 'legion/settings'
+require 'legion/cache/helper'
+require 'legion/crypt/helper'
+require 'legion/data/helper'
+require 'legion/json/helper'
+require 'legion/transport/helper'
 
 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
+        include Legion::Logging::Helper
+        include Legion::Settings::Helper
+        include Legion::Cache::Helper
+        include Legion::Crypt::Helper
+        include Legion::Data::Helper
+        include Legion::JSON::Helper
+        include Legion::Transport::Helper
+      end
+    end
+
+    module Actors
+      class Every
+        include Helpers::Lex
+      end
+
+      class Once
+        include Helpers::Lex
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-agentic-language
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.3
 platform: ruby
 authors:
 - Esity
@@ -9,6 +9,104 @@ bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: legion-cache
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.11
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.11
+- !ruby/object:Gem::Dependency
+  name: legion-crypt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.9
+- !ruby/object:Gem::Dependency
+  name: legion-data
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.17
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.17
+- !ruby/object:Gem::Dependency
+  name: legion-json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+- !ruby/object:Gem::Dependency
+  name: legion-logging
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.2
+- !ruby/object:Gem::Dependency
+  name: legion-settings
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.14
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.14
+- !ruby/object:Gem::Dependency
+  name: legion-transport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.9
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement