lex-agentic-language 0.1.11 → 0.1.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 79cfb7e1534a2010a54b836636c9a5406fefda03bb97cb700f131f1a92a6e77c
-  data.tar.gz: 026cd8c1a5831eed7555d231471595bb2d3ab5ba832d3a98c90646c01baa54f4
+  metadata.gz: 15ffb64c29e1d193b5d11e2d295089b0aa6042babc91e3a2014662787c2cb843
+  data.tar.gz: a11688c4ba708f91fcd67518e02b105f70f48498ffdb7c4b3497e5ec7c62e975
 SHA512:
-  metadata.gz: 347a89a7300d788e8b76b1882c52ab280ad99c8ed1c38981cc7de53071dbf905678b086847d9923b7fa9242a08189e78adc658a7f553aace3b0669712d466119
-  data.tar.gz: 3b15a51fe618f5f478c48182688803a626558eca1d20a66093b5cdf384e3dbc53e41a96f61a3c4360711273cda056154cc997ac62b84a6a3de5e986519a9a0b4
+  metadata.gz: a79d9ec42c57d35f8d045707964baff90d4c0b8e91b393b5cf39b8f493182e09ee5a14fbb1b6da41250c005be7ae18d4147effc50060d02774e8b8ba5c91c754
+  data.tar.gz: 268b712c158554a3d0530b7e47197e9c8abb78d3ce060150be9db83d52f33e662eb47de47e0be45d8550a67df687c1b914d02a0e2ea74e02bb92a52d5b11b63f

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [0.1.13] - 2026-10-29
+### Fixed
+- Only invoke narrator LLM enhancement for observations actually consumed by the narrative prompt, not dream provenance or phase bookkeeping.
+- Preserve explicitly observed zero values while applying missing-value defaults only during prompt rendering.
+
+## [0.1.12] - 2026-06-01
+### Fixed
+- `SpeechStream#append` used `:"utt_#{@counter}"` (interpolated Symbol) causing unbounded Symbol allocation — changed to String ID
+- `Utterance#resolve_mode` and `#resolve_voice` called `to_sym` on arbitrary user input — replaced with safe string-based lookup returning only pre-existing constant Symbols
+- `InnerVoice#switch_voice` called `to_sym` on user input — added `resolve_voice` helper with same safe pattern
+- `CognitiveGrammar` runner called `.to_h` on nil when engine rejects invalid input — added nil guards returning structured error responses
+
 ## [0.1.11] - 2026-05-07
 ### Fixed
 - Narrator LLM enhancement now sends native chat message payloads with system/user roles while preserving legacy session fallback for older test doubles.

data/README.md

@@ -5,7 +5,7 @@ Domain consolidation gem for language processing and communication. Bundles 9 su
 ## Overview
 
 **Gem**: `lex-agentic-language`
-**Version**: 0.1.9
+**Version**: 0.1.13
 **Namespace**: `Legion::Extensions::Agentic::Language`
 
 ## Sub-Modules

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

@@ -40,6 +40,8 @@ module Legion
               def create_blend(space_a_id:, space_b_id:, blend_type: :double_scope, **)
                 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)
+                return { success: false, reason: :invalid_blend_type } unless blend
+
                 { success: true, blend: blend.to_h }
               rescue ArgumentError => e
                 log.debug "[conceptual_blending] blend failed: #{e.message}"

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

@@ -17,6 +17,8 @@ module Legion
                   expression_type: expression_type,
                   domain:          domain
                 )
+                return { created: false, reason: :invalid_expression_type } unless construction
+
                 log.debug "[cognitive_grammar] created construction form=#{form} type=#{expression_type} domain=#{domain}"
                 construction.to_h
               end
@@ -34,6 +36,8 @@ module Legion
                   dynamicity:      dynamicity,
                   construction_id: construction_id
                 )
+                return { created: false, reason: :invalid_parameters } unless construal
+
                 log.debug "[cognitive_grammar] created construal scene=#{scene} figure=#{figure}"
                 construal.to_h
               end

data/lib/legion/extensions/agentic/language/inner_speech/helpers/inner_voice.rb

@@ -32,8 +32,8 @@ module Legion
               end
 
               def switch_voice(voice:)
-                sym = voice.to_sym
-                return nil unless VOICE_TYPES.include?(sym)
+                sym = resolve_voice(voice)
+                return nil unless sym
 
                 old_voice = @active_voice
                 @active_voice = sym
@@ -128,6 +128,14 @@ module Legion
 
               private
 
+              def resolve_voice(voice)
+                return voice if voice.is_a?(Symbol) && VOICE_TYPES.include?(voice)
+
+                voice_str = voice.to_s
+                index = VOICE_TYPES.map(&:to_s).index(voice_str)
+                index ? VOICE_TYPES[index] : nil
+              end
+
               def record_event(type, **details)
                 @history << { type: type, at: Time.now.utc }.merge(details)
                 @history.shift while @history.size > MAX_HISTORY

data/lib/legion/extensions/agentic/language/inner_speech/helpers/speech_stream.rb

@@ -21,7 +21,7 @@ module Legion
 
                 @counter += 1
                 utterance = Utterance.new(
-                  id:      :"utt_#{@counter}",
+                  id:      "utt_#{@counter}",
                   content: content,
                   mode:    mode,
                   **

data/lib/legion/extensions/agentic/language/inner_speech/helpers/utterance.rb

@@ -84,13 +84,19 @@ module Legion
               end
 
               def resolve_mode(mode)
-                sym = mode.to_sym
-                SPEECH_MODES.include?(sym) ? sym : :narrating
+                return mode if mode.is_a?(Symbol) && SPEECH_MODES.include?(mode)
+
+                mode_str = mode.to_s
+                index = SPEECH_MODES.map(&:to_s).index(mode_str)
+                index ? SPEECH_MODES[index] : :narrating
               end
 
               def resolve_voice(voice)
-                sym = voice.to_sym
-                VOICE_TYPES.include?(sym) ? sym : :rational
+                return voice if voice.is_a?(Symbol) && VOICE_TYPES.include?(voice)
+
+                voice_str = voice.to_s
+                index = VOICE_TYPES.map(&:to_s).index(voice_str)
+                index ? VOICE_TYPES[index] : :rational
               end
             end
           end

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

@@ -13,8 +13,8 @@ module Legion
               def narrate(tick_results: {}, cognitive_state: {}, **)
                 entry = Helpers::Synthesizer.narrate(tick_results: tick_results, cognitive_state: cognitive_state)
 
-                if Helpers::LlmEnhancer.available? && meaningful_for_llm?(tick_results, cognitive_state)
-                  sections_data = build_llm_sections_data(tick_results, cognitive_state, entry)
+                sections_data = build_llm_sections_data(tick_results, cognitive_state) if Helpers::LlmEnhancer.available?
+                if sections_data && meaningful_hash?(sections_data)
                   llm_result = Helpers::LlmEnhancer.narrate(sections_data: sections_data)
                   if llm_result
                     entry = entry.merge(narrative: llm_result, source: :llm)
@@ -103,10 +103,6 @@ module Legion
                 @journal ||= Helpers::Journal.new
               end
 
-              def meaningful_for_llm?(tick_results, cognitive_state)
-                meaningful_hash?(tick_results) || meaningful_hash?(cognitive_state)
-              end
-
               def meaningful_hash?(value)
                 return false unless value.is_a?(Hash)
 
@@ -122,15 +118,14 @@ module Legion
                 end
               end
 
-              def build_llm_sections_data(tick_results, cognitive_state, entry)
+              def build_llm_sections_data(tick_results, cognitive_state)
                 {
                   emotion:    llm_emotion_data(tick_results, cognitive_state),
                   curiosity:  llm_curiosity_data(tick_results, cognitive_state),
                   prediction: llm_prediction_data(tick_results, cognitive_state),
                   memory:     llm_memory_data(tick_results, cognitive_state),
                   attention:  llm_attention_data(tick_results, cognitive_state),
-                  reflection: llm_reflection_data(cognitive_state),
-                  mood:       entry[:mood]
+                  reflection: llm_reflection_data(cognitive_state)
                 }
               end
 
@@ -138,8 +133,8 @@ module Legion
                 v = tick_results[:emotional_evaluation] || {}
                 g = tick_results[:gut_instinct] || cognitive_state[:gut] || {}
                 {
-                  valence: v[:valence] || cognitive_state.dig(:emotion, :valence) || 0.0,
-                  arousal: v[:arousal] || cognitive_state.dig(:emotion, :arousal) || 0.5,
+                  valence: v[:valence] || cognitive_state.dig(:emotion, :valence),
+                  arousal: v[:arousal] || cognitive_state.dig(:emotion, :arousal),
                   gut:     g[:signal] || g[:gut_signal]
                 }
               end
@@ -148,8 +143,8 @@ module Legion
                 c = cognitive_state[:curiosity] || {}
                 w = tick_results[:working_memory_integration] || {}
                 {
-                  intensity:    c[:intensity] || w[:curiosity_intensity] || 0.0,
-                  wonder_count: c[:active_count] || w[:active_wonders] || 0,
+                  intensity:    c[:intensity] || w[:curiosity_intensity],
+                  wonder_count: c[:active_count] || w[:active_wonders],
                   top_wonder:   c[:top_question] || w[:top_question]
                 }
               end
@@ -158,8 +153,8 @@ module Legion
                 p = tick_results[:prediction_engine] || {}
                 s = cognitive_state[:prediction] || {}
                 {
-                  confidence: p[:confidence] || s[:confidence] || 0.0,
-                  pending:    s[:pending_count] || 0,
+                  confidence: p[:confidence] || s[:confidence],
+                  pending:    s[:pending_count],
                   mode:       p[:mode] || s[:mode]
                 }
               end
@@ -168,8 +163,8 @@ module Legion
                 m = cognitive_state[:memory] || {}
                 c = tick_results[:memory_consolidation] || {}
                 {
-                  trace_count: m[:trace_count] || c[:remaining] || 0,
-                  health:      m[:health] || 1.0
+                  trace_count: m[:trace_count] || c[:remaining],
+                  health:      m[:health]
                 }
               end
 
@@ -177,8 +172,8 @@ module Legion
                 a = tick_results[:sensory_processing] || {}
                 f = cognitive_state[:attention_status] || {}
                 {
-                  spotlight:       a[:spotlight] || 0,
-                  peripheral:      a[:peripheral] || 0,
+                  spotlight:       a[:spotlight],
+                  peripheral:      a[:peripheral],
                   focused_domains: extract_focused_domains_for_llm(f)
                 }
               end
@@ -186,8 +181,8 @@ module Legion
               def llm_reflection_data(cognitive_state)
                 r = cognitive_state[:reflection] || {}
                 {
-                  health:              r[:health] || 1.0,
-                  pending_adaptations: r[:pending_adaptations] || r[:unacted_count] || 0
+                  health:              r[:health],
+                  pending_adaptations: r[:pending_adaptations] || r[:unacted_count]
                 }
               end
 

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Agentic
       module Language
-        VERSION = '0.1.11'
+        VERSION = '0.1.13'
       end
     end
   end

data/spec/legion/extensions/agentic/language/inner_speech/runners/inner_speech_spec.rb

@@ -11,7 +11,7 @@ RSpec.describe Legion::Extensions::Agentic::Language::InnerSpeech::Runners::Inne
     it 'creates an utterance' do
       result = host.inner_speak(content: 'testing', mode: :planning)
       expect(result[:success]).to be true
-      expect(result[:utterance_id]).to be_a(Symbol)
+      expect(result[:utterance_id]).to be_a(String)
       expect(result[:mode]).to eq(:planning)
     end
   end

data/spec/legion/extensions/agentic/language/narrator/runners/narrator_llm_spec.rb

@@ -47,6 +47,30 @@ RSpec.describe Legion::Extensions::Agentic::Language::Narrator::Runners::Narrato
       expect(result).not_to have_key(:source)
       expect(result[:narrative]).to be_a(String)
     end
+
+    it 'does not invoke an LLM for dream provenance and phase bookkeeping alone' do
+      expect(chat_double).not_to receive(:ask)
+
+      result = client.narrate(
+        tick_results:    { tick_seq: 42, memory_consolidation: { success: true },
+                           emotional_evaluation: { status: :completed } },
+        cognitive_state: { source: :dream }
+      )
+
+      expect(result).not_to have_key(:source)
+      expect(client.current_narrative[:narrative]).to eq(result[:narrative])
+    end
+
+    it 'narrates an explicitly observed zero rather than treating it as missing input' do
+      expect(chat_double).to receive(:ask).with(include('Valence: 0.0'))
+
+      result = client.narrate(
+        tick_results:    { emotional_evaluation: { valence: 0.0 } },
+        cognitive_state: { source: :dream }
+      )
+
+      expect(result[:source]).to eq(:llm)
+    end
   end
 
   describe '#narrate with LLM available but narrate returns nil' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-agentic-language
 version: !ruby/object:Gem::Version
-  version: 0.1.11
+  version: 0.1.13
 platform: ruby
 authors:
 - Esity