lex-agentic-integration 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd18609f94c33ed5bd6e39e0761d071c52eaeda9a3c943d7b852cef3ea2aca9d
-  data.tar.gz: 51b7fae44fd51d62908c447f334f39bcae2722f46f74d0804d251ac8bd32bbe1
+  metadata.gz: 44af35cef10d0f6915b1bce2703f54330dc0bf92f7e3314c79956bc548577adb
+  data.tar.gz: 77b8502f617e09062c298ae4e32e86a1290b6be6d178ff3e910c39407a6ae1bf
 SHA512:
-  metadata.gz: fce716d00a57fc8b4696b7d2a0ca3b1845bfcaf9a9acb9011b5a366391431b09058b8cfb419559dd189f5edfd663385f87b605890328c33fa4ef5e48b3934d76
-  data.tar.gz: 78b9dcd521a5b86079ad9d31f78f855e5919409e054cb21c2528d37a807e3f7d26c5c35c827669e9012704244105ae079afee1ba1dfcd4958c6fbfb23e26aed5
+  metadata.gz: 520e41ef7be1d87dab9608baf81d15927f41af29e1b35bf1c50b2332fbafc1e891142a2ddb210f660eea0bd57921b9b85ffe22a550ba21bc06abcc1b492fb3d5
+  data.tar.gz: 6897020483d937060caf2c4e50aa7b413f8e8fb49f9259aa45c5785f1566c0d1bcaab2a214893ea528b07d172f715989f509e4b20b03947851018353b64a9357

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## [0.1.7] - 2026-06-01
+### Fixed
+- Nil dereference in `PhenomenalBinding::Runners::PhenomenalBinding#register_stream` — guard against `nil` return from `engine.register_stream` when stream_type is invalid; returns `{ status: :rejected, reason: :unknown_stream_type }` instead of crashing on `.salience`
+- `Tapestry::Helpers::Tapestry#age!` and `#repair!` were no-op stubs that accepted params but did nothing — now `age!` frays thread strength via a `@decay_factor` (returned as a float) and `repair!` boosts it; `to_h` includes `decay_factor`
+- `Tapestry::Helpers::Thread` class renamed to `ThreadStrand` to avoid shadowing Ruby's built-in `Thread` constant; all internal references updated
+- Removed `extend self` from `Tapestry::Runners::CognitiveTapestry`, `Labyrinth::Runners::CognitiveLabyrinth`, `Mosaic::Runners::CognitiveMosaic`, and `Mycelium::Runners::CognitiveMycelium` — standardized to instance-module pattern (`include Lex` + private `engine`/`resolve_engine`) matching all other sub-module runners
+- Standardized `include Legion::Extensions::Helpers::Lex` guard to use `const_defined?` double-check (matches project-wide pattern) in mosaic and mycelium runners
+- Updated corresponding runner specs to use `runner_host = Object.new.tap { |o| o.extend(described_class) }` pattern instead of module-level calls
+
 ## [0.1.6] - 2026-04-22
 ### Fixed
 - ThreadWalker actor now calls `follow_thread` (navigation) instead of `list_labyrinths` (read-only query)

data/lib/legion/extensions/agentic/integration/labyrinth/runners/cognitive_labyrinth.rb

@@ -7,9 +7,8 @@ module Legion
         module Labyrinth
           module Runners
             module CognitiveLabyrinth
-              extend self
-
-              include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex, false)
 
               def create_labyrinth(name:, domain: nil, labyrinth_id: nil, engine: nil, **)
                 raise ArgumentError, 'name is required' if name.nil? || name.to_s.strip.empty?

data/lib/legion/extensions/agentic/integration/mosaic/runners/cognitive_mosaic.rb

@@ -7,7 +7,8 @@ module Legion
         module Mosaic
           module Runners
             module CognitiveMosaic
-              extend self
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex, false)
 
               def create_tessera(material:, domain:, content:,
                                  color: nil, fit_quality: nil, engine: nil, **)
@@ -15,6 +16,7 @@ module Legion
                 t   = eng.create_tessera(material: material, domain: domain,
                                          content: content, color: color,
                                          fit_quality: fit_quality)
+                log.debug("[cognitive_mosaic] create_tessera: material=#{material} domain=#{domain}")
                 { success: true, tessera: t.to_h }
               rescue ArgumentError => e
                 { success: false, error: e.message }
@@ -25,6 +27,7 @@ module Legion
                 eng = resolve_engine(engine)
                 m   = eng.create_mosaic(name: name, pattern_category: pattern_category,
                                         capacity: capacity, grout_strength: grout_strength)
+                log.debug("[cognitive_mosaic] create_mosaic: name=#{name} pattern=#{pattern_category}")
                 { success: true, mosaic: m.to_h }
               rescue ArgumentError => e
                 { success: false, error: e.message }
@@ -32,8 +35,9 @@ module Legion
 
               def place_tessera(tessera_id:, mosaic_id:, engine: nil, **)
                 eng = resolve_engine(engine)
-                t   = eng.place_tessera(tessera_id: tessera_id, mosaic_id: mosaic_id)
-                { success: true, tessera: t.to_h }
+                eng.place_tessera(tessera_id: tessera_id, mosaic_id: mosaic_id)
+                log.debug("[cognitive_mosaic] place_tessera: tessera=#{tessera_id[0..7]} mosaic=#{mosaic_id[0..7]}")
+                { success: true }
               rescue ArgumentError => e
                 { success: false, error: e.message }
               end
@@ -42,22 +46,24 @@ module Legion
                 eng     = resolve_engine(engine)
                 results = eng.all_tesserae
                 results = results.select { |t| t.material == material.to_sym } if material
+                log.debug("[cognitive_mosaic] list_tesserae: count=#{results.size}")
                 { success: true, tesserae: results.map(&:to_h), count: results.size }
               end
 
               def list_mosaics(engine: nil, **)
                 eng = resolve_engine(engine)
-                { success: true, mosaics: eng.all_mosaics.map(&:to_h),
-                  count: eng.all_mosaics.size }
+                mosaics = eng.all_mosaics
+                log.debug("[cognitive_mosaic] list_mosaics: count=#{mosaics.size}")
+                { success: true, mosaics: mosaics.map(&:to_h),
+                  count: mosaics.size }
               end
 
               def mosaic_status(engine: nil, **)
                 eng = resolve_engine(engine)
+                log.debug('[cognitive_mosaic] mosaic_status')
                 { success: true, report: eng.mosaic_report }
               end
 
-              include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
-
               private
 
               def resolve_engine(engine)

data/lib/legion/extensions/agentic/integration/mycelium/runners/cognitive_mycelium.rb

@@ -7,7 +7,8 @@ module Legion
         module Mycelium
           module Runners
             module CognitiveMycelium
-              extend self
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex, false)
 
               def create_node(node_type:, domain:, content:,
                               nutrient_level: 0.5, engine: nil, **)
@@ -15,6 +16,7 @@ module Legion
                 node = eng.create_node(node_type: node_type, domain: domain,
                                        content: content,
                                        nutrient_level: nutrient_level)
+                log.debug("[cognitive_mycelium] create_node: type=#{node_type} domain=#{domain}")
                 { success: true, node: node.to_h }
               rescue ArgumentError => e
                 { success: false, error: e.message }
@@ -26,6 +28,7 @@ module Legion
                 hypha = eng.connect(source_id: source_id, target_id: target_id,
                                     nutrient_type: nutrient_type,
                                     strength: strength)
+                log.debug("[cognitive_mycelium] connect: source=#{source_id[0..7]} target=#{target_id[0..7]}")
                 { success: true, hypha: hypha.to_h }
               rescue ArgumentError => e
                 { success: false, error: e.message }
@@ -34,6 +37,7 @@ module Legion
               def transfer_nutrients(hypha_id:, engine: nil, **)
                 eng    = resolve_engine(engine)
                 result = eng.transfer_nutrients(hypha_id: hypha_id)
+                log.debug("[cognitive_mycelium] transfer_nutrients: hypha_id=#{hypha_id[0..7]}")
                 { success: true }.merge(result)
               rescue ArgumentError => e
                 { success: false, error: e.message }
@@ -43,6 +47,7 @@ module Legion
                 eng  = resolve_engine(engine)
                 body = eng.fruit!(node_id: node_id, fruiting_type: fruiting_type,
                                   content: content)
+                log.debug("[cognitive_mycelium] fruit: node_id=#{node_id[0..7]} type=#{fruiting_type}")
                 { success: true, fruiting_body: body.to_h }
               rescue ArgumentError => e
                 { success: false, error: e.message }
@@ -50,11 +55,10 @@ module Legion
 
               def network_status(engine: nil, **)
                 eng = resolve_engine(engine)
+                log.debug('[cognitive_mycelium] network_status')
                 { success: true, report: eng.network_report }
               end
 
-              include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
-
               private
 
               def resolve_engine(engine)

data/lib/legion/extensions/agentic/integration/phenomenal_binding/runners/phenomenal_binding.rb

@@ -18,9 +18,15 @@ module Legion
                   salience:    salience,
                   domain:      domain
                 )
-                log.debug("[phenomenal_binding] register_stream: type=#{stream_type} " \
-                          "salience=#{stream.salience.round(2)} domain=#{domain}")
-                { status: :registered, stream: stream.to_h }
+                if stream.nil?
+                  log.debug("[phenomenal_binding] register_stream rejected: type=#{stream_type.inspect} " \
+                            '(unknown stream_type)')
+                  { status: :rejected, reason: :unknown_stream_type, stream_type: stream_type }
+                else
+                  log.debug("[phenomenal_binding] register_stream: type=#{stream_type} " \
+                            "salience=#{stream.salience.round(2)} domain=#{domain}")
+                  { status: :registered, stream: stream.to_h }
+                end
               end
 
               def create_binding(stream_ids:, binding_type:, attention_weight: 0.5, **)

data/lib/legion/extensions/agentic/integration/qualia/runners/qualia.rb

@@ -7,7 +7,8 @@ module Legion
         module Qualia
           module Runners
             module Qualia
-              include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex, false)
 
               def create_quale(content:, modality: :abstract, quality: :smooth, texture: :fluid, vividness: nil,
                                valence: nil, engine: nil, **)

data/lib/legion/extensions/agentic/integration/tapestry/helpers/loom_engine.rb

@@ -16,7 +16,7 @@ module Legion
                               strength: nil, color: nil)
                 raise ArgumentError, 'thread limit reached' if @threads.size >= Constants::MAX_THREADS
 
-                t = Helpers::Thread.new(
+                t = Helpers::ThreadStrand.new(
                   thread_type: thread_type,
                   domain:      domain,
                   content:     content,

data/lib/legion/extensions/agentic/integration/tapestry/helpers/tapestry.rb

@@ -7,16 +7,18 @@ module Legion
         module Tapestry
           module Helpers
             class Tapestry
-              attr_reader :id, :name, :pattern, :capacity, :thread_ids, :created_at
+              attr_reader :id, :name, :pattern, :capacity, :thread_ids, :created_at,
+                          :decay_factor
 
               def initialize(name:, pattern:, capacity: 50)
                 validate_pattern!(pattern)
-                @id         = SecureRandom.uuid
-                @name       = name.to_s
-                @pattern    = pattern.to_sym
-                @capacity   = capacity.to_i.clamp(1, 500)
-                @thread_ids = []
-                @created_at = Time.now.utc
+                @id           = SecureRandom.uuid
+                @name         = name.to_s
+                @pattern      = pattern.to_sym
+                @capacity     = capacity.to_i.clamp(1, 500)
+                @thread_ids   = []
+                @created_at   = Time.now.utc
+                @decay_factor = 0.0
               end
 
               def weave_thread(thread_id)
@@ -50,10 +52,12 @@ module Legion
               end
 
               def age!(fray_rate: Constants::FRAY_RATE)
+                @decay_factor = (@decay_factor + fray_rate.abs).clamp(0.0, 1.0).round(10)
                 fray_rate
               end
 
               def repair!(boost: 0.1)
+                @decay_factor = (@decay_factor - boost.abs).clamp(0.0, 1.0).round(10)
                 boost
               end
 
@@ -110,6 +114,7 @@ module Legion
                   empty:              empty?,
                   fraying:            fraying?(threads),
                   masterwork:         masterwork?(threads),
+                  decay_factor:       decay_factor,
                   thread_ids:         @thread_ids.dup,
                   created_at:         @created_at
                 }

data/lib/legion/extensions/agentic/integration/tapestry/helpers/{thread.rb → thread_strand.rb}

@@ -6,7 +6,7 @@ module Legion
       module Integration
         module Tapestry
           module Helpers
-            class Thread
+            class ThreadStrand
               attr_reader :id, :thread_type, :domain, :content,
                           :color, :created_at, :tapestry_id
               attr_accessor :strength

data/lib/legion/extensions/agentic/integration/tapestry/runners/cognitive_tapestry.rb

@@ -7,9 +7,8 @@ module Legion
         module Tapestry
           module Runners
             module CognitiveTapestry
-              extend self
-
-              include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex, false)
 
               def spin_thread(thread_type:, domain:, content:,
                               strength: nil, color: nil, engine: nil, **)
@@ -21,6 +20,7 @@ module Legion
                   strength:    strength,
                   color:       color
                 )
+                log.debug("[cognitive_tapestry] spin_thread: type=#{thread_type} domain=#{domain}")
                 { success: true, thread: t.to_h }
               rescue ArgumentError => e
                 { success: false, error: e.message }
@@ -30,6 +30,7 @@ module Legion
                 eng = resolve_engine(engine)
                 tap = eng.create_tapestry(name: name, pattern: pattern, capacity: capacity)
                 threads_arr = eng.all_threads
+                log.debug("[cognitive_tapestry] create_tapestry: name=#{name} pattern=#{pattern}")
                 { success: true, tapestry: tap.to_h(threads_arr) }
               rescue ArgumentError => e
                 { success: false, error: e.message }
@@ -37,8 +38,9 @@ module Legion
 
               def weave(thread_id:, tapestry_id:, engine: nil, **)
                 eng = resolve_engine(engine)
-                t   = eng.weave(thread_id: thread_id, tapestry_id: tapestry_id)
-                { success: true, thread: t.to_h }
+                eng.weave(thread_id: thread_id, tapestry_id: tapestry_id)
+                log.debug("[cognitive_tapestry] weave: thread_id=#{thread_id[0..7]} tapestry_id=#{tapestry_id[0..7]}")
+                { success: true }
               rescue ArgumentError => e
                 { success: false, error: e.message }
               end
@@ -51,6 +53,7 @@ module Legion
                 results = results.select { |tap| tap.pattern == pattern.to_sym } if pattern
                 results = results.select { |tap| tap.fraying?(threads_arr) }     if fraying_only
 
+                log.debug("[cognitive_tapestry] list_tapestries: count=#{results.size}")
                 {
                   success:    true,
                   tapestries: results.map { |tap| tap.to_h(threads_arr) },
@@ -60,6 +63,7 @@ module Legion
 
               def loom_status(engine: nil, **)
                 eng = resolve_engine(engine)
+                log.debug('[cognitive_tapestry] loom_status')
                 { success: true, report: eng.tapestry_report }
               end
 

data/lib/legion/extensions/agentic/integration/tapestry.rb

@@ -4,7 +4,7 @@ require 'securerandom'
 
 require_relative 'tapestry/version'
 require_relative 'tapestry/helpers/constants'
-require_relative 'tapestry/helpers/thread'
+require_relative 'tapestry/helpers/thread_strand'
 require_relative 'tapestry/helpers/tapestry'
 require_relative 'tapestry/helpers/loom_engine'
 require_relative 'tapestry/runners/cognitive_tapestry'

data/lib/legion/extensions/agentic/integration/tessellation/runners/cognitive_tessellation.rb

@@ -7,7 +7,8 @@ module Legion
         module Tessellation
           module Runners
             module CognitiveTessellation
-              include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+              include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                          Legion::Extensions::Helpers.const_defined?(:Lex, false)
 
               def create_tile(tile_type:, shape:, domain:, coverage: nil, fit_score: nil, engine: nil, **)
                 eng = engine || @default_engine

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Agentic
       module Integration
-        VERSION = '0.1.6'
+        VERSION = '0.1.7'
       end
     end
   end

data/spec/legion/extensions/agentic/integration/mosaic/runners/cognitive_mosaic_spec.rb

@@ -3,9 +3,15 @@
 RSpec.describe Legion::Extensions::Agentic::Integration::Mosaic::Runners::CognitiveMosaic do
   let(:engine) { Legion::Extensions::Agentic::Integration::Mosaic::Helpers::MosaicEngine.new }
 
-  describe '.create_tessera' do
+  let(:runner_host) do
+    host = Object.new
+    host.extend(described_class)
+    host
+  end
+
+  describe '#create_tessera' do
     it 'returns success' do
-      result = described_class.create_tessera(
+      result = runner_host.create_tessera(
         material: :glass, domain: :reasoning, content: 'test', engine: engine
       )
       expect(result[:success]).to be true
@@ -13,16 +19,16 @@ RSpec.describe Legion::Extensions::Agentic::Integration::Mosaic::Runners::Cognit
     end
 
     it 'returns failure for invalid material' do
-      result = described_class.create_tessera(
+      result = runner_host.create_tessera(
         material: :plasma, domain: :x, content: 'y', engine: engine
       )
       expect(result[:success]).to be false
     end
   end
 
-  describe '.create_mosaic' do
+  describe '#create_mosaic' do
     it 'returns success' do
-      result = described_class.create_mosaic(
+      result = runner_host.create_mosaic(
         name: 'test', pattern_category: :geometric, engine: engine
       )
       expect(result[:success]).to be true
@@ -30,57 +36,57 @@ RSpec.describe Legion::Extensions::Agentic::Integration::Mosaic::Runners::Cognit
     end
 
     it 'returns failure for invalid pattern' do
-      result = described_class.create_mosaic(
+      result = runner_host.create_mosaic(
         name: 'x', pattern_category: :random, engine: engine
       )
       expect(result[:success]).to be false
     end
   end
 
-  describe '.place_tessera' do
+  describe '#place_tessera' do
     it 'places tessera successfully' do
       t = engine.create_tessera(material: :stone, domain: :x, content: 'a')
       m = engine.create_mosaic(name: 'wall', pattern_category: :organic)
-      result = described_class.place_tessera(
+      result = runner_host.place_tessera(
         tessera_id: t.id, mosaic_id: m.id, engine: engine
       )
       expect(result[:success]).to be true
     end
 
     it 'returns failure for missing tessera' do
-      result = described_class.place_tessera(
+      result = runner_host.place_tessera(
         tessera_id: 'nope', mosaic_id: 'nope', engine: engine
       )
       expect(result[:success]).to be false
     end
   end
 
-  describe '.list_tesserae' do
+  describe '#list_tesserae' do
     it 'returns all tesserae' do
       engine.create_tessera(material: :glass, domain: :x, content: 'a')
-      result = described_class.list_tesserae(engine: engine)
+      result = runner_host.list_tesserae(engine: engine)
       expect(result[:count]).to eq(1)
     end
 
     it 'filters by material' do
       engine.create_tessera(material: :glass, domain: :x, content: 'a')
       engine.create_tessera(material: :stone, domain: :x, content: 'b')
-      result = described_class.list_tesserae(engine: engine, material: :glass)
+      result = runner_host.list_tesserae(engine: engine, material: :glass)
       expect(result[:count]).to eq(1)
     end
   end
 
-  describe '.list_mosaics' do
+  describe '#list_mosaics' do
     it 'returns all mosaics' do
       engine.create_mosaic(name: 'a', pattern_category: :geometric)
-      result = described_class.list_mosaics(engine: engine)
+      result = runner_host.list_mosaics(engine: engine)
       expect(result[:count]).to eq(1)
     end
   end
 
-  describe '.mosaic_status' do
+  describe '#mosaic_status' do
     it 'returns report' do
-      result = described_class.mosaic_status(engine: engine)
+      result = runner_host.mosaic_status(engine: engine)
       expect(result[:success]).to be true
       expect(result[:report]).to have_key(:total_tesserae)
     end

data/spec/legion/extensions/agentic/integration/mycelium/runners/cognitive_mycelium_spec.rb

@@ -2,42 +2,47 @@
 
 RSpec.describe Legion::Extensions::Agentic::Integration::Mycelium::Runners::CognitiveMycelium do
   let(:engine) { Legion::Extensions::Agentic::Integration::Mycelium::Helpers::MyceliumEngine.new }
-  let(:runner) { described_class }
 
-  describe '.create_node' do
+  let(:runner_host) do
+    host = Object.new
+    host.extend(described_class)
+    host
+  end
+
+  describe '#create_node' do
     it 'succeeds' do
-      result = runner.create_node(node_type: :knowledge_cluster,
-                                  domain: :semantic, content: 'test',
-                                  engine: engine)
+      result = runner_host.create_node(node_type: :knowledge_cluster,
+                                       domain: :semantic, content: 'test',
+                                       engine: engine)
       expect(result[:success]).to be true
       expect(result[:node][:node_type]).to eq :knowledge_cluster
     end
 
     it 'returns failure for invalid type' do
-      result = runner.create_node(node_type: :bogus, domain: :x,
-                                  content: 'x', engine: engine)
+      result = runner_host.create_node(node_type: :bogus, domain: :x,
+                                       content: 'x', engine: engine)
       expect(result[:success]).to be false
     end
   end
 
-  describe '.connect' do
+  describe '#connect' do
     it 'creates connection' do
       n1 = engine.create_node(node_type: :knowledge_cluster,
                               domain: :semantic, content: 'a')
       n2 = engine.create_node(node_type: :skill_node, domain: :procedural,
                               content: 'b')
-      result = runner.connect(source_id: n1.id, target_id: n2.id,
-                              nutrient_type: :information, engine: engine)
+      result = runner_host.connect(source_id: n1.id, target_id: n2.id,
+                                   nutrient_type: :information, engine: engine)
       expect(result[:success]).to be true
     end
   end
 
-  describe '.fruit' do
+  describe '#fruit' do
     it 'creates fruiting body' do
       n = engine.create_node(node_type: :creative_node, domain: :creative,
                              content: 'ripe', nutrient_level: 0.9)
-      result = runner.fruit(node_id: n.id, fruiting_type: :insight,
-                            content: 'eureka', engine: engine)
+      result = runner_host.fruit(node_id: n.id, fruiting_type: :insight,
+                                 content: 'eureka', engine: engine)
       expect(result[:success]).to be true
       expect(result[:fruiting_body][:fruiting_type]).to eq :insight
     end
@@ -45,15 +50,15 @@ RSpec.describe Legion::Extensions::Agentic::Integration::Mycelium::Runners::Cogn
     it 'returns failure when not ready' do
       n = engine.create_node(node_type: :creative_node, domain: :creative,
                              content: 'x', nutrient_level: 0.2)
-      result = runner.fruit(node_id: n.id, fruiting_type: :insight,
-                            content: 'x', engine: engine)
+      result = runner_host.fruit(node_id: n.id, fruiting_type: :insight,
+                                 content: 'x', engine: engine)
       expect(result[:success]).to be false
     end
   end
 
-  describe '.network_status' do
+  describe '#network_status' do
     it 'returns report' do
-      result = runner.network_status(engine: engine)
+      result = runner_host.network_status(engine: engine)
       expect(result[:success]).to be true
       expect(result[:report]).to be_a Hash
     end

data/spec/legion/extensions/agentic/integration/tapestry/helpers/loom_engine_spec.rb

@@ -13,7 +13,7 @@ RSpec.describe Legion::Extensions::Agentic::Integration::Tapestry::Helpers::Loom
 
   describe '#spin_thread' do
     it 'returns a Thread instance' do
-      expect(spin).to be_a(Legion::Extensions::Agentic::Integration::Tapestry::Helpers::Thread)
+      expect(spin).to be_a(Legion::Extensions::Agentic::Integration::Tapestry::Helpers::ThreadStrand)
     end
 
     it 'stores the thread internally' do
@@ -63,7 +63,7 @@ RSpec.describe Legion::Extensions::Agentic::Integration::Tapestry::Helpers::Loom
 
     it 'returns the Thread' do
       result = engine.weave(thread_id: t.id, tapestry_id: tap.id)
-      expect(result).to be_a(Legion::Extensions::Agentic::Integration::Tapestry::Helpers::Thread)
+      expect(result).to be_a(Legion::Extensions::Agentic::Integration::Tapestry::Helpers::ThreadStrand)
     end
 
     it 'marks the thread as woven' do
@@ -111,7 +111,7 @@ RSpec.describe Legion::Extensions::Agentic::Integration::Tapestry::Helpers::Loom
 
     it 'returns the Thread' do
       result = engine.unravel(thread_id: t.id, tapestry_id: tap.id)
-      expect(result).to be_a(Legion::Extensions::Agentic::Integration::Tapestry::Helpers::Thread)
+      expect(result).to be_a(Legion::Extensions::Agentic::Integration::Tapestry::Helpers::ThreadStrand)
     end
 
     it 'marks thread as loose' do

data/spec/legion/extensions/agentic/integration/tapestry/helpers/tapestry_spec.rb

@@ -5,7 +5,7 @@ RSpec.describe Legion::Extensions::Agentic::Integration::Tapestry::Helpers::Tape
     described_class.new(name: 'life story', pattern: :brocade, capacity: 10)
   end
 
-  let(:thread_klass) { Legion::Extensions::Agentic::Integration::Tapestry::Helpers::Thread }
+  let(:thread_klass) { Legion::Extensions::Agentic::Integration::Tapestry::Helpers::ThreadStrand }
 
   def make_thread(type: :experience, strength: 0.5)
     thread_klass.new(thread_type: type, domain: :reasoning, content: 'event', strength: strength)

data/spec/legion/extensions/agentic/integration/tapestry/helpers/{thread_spec.rb → thread_strand_spec.rb}

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-RSpec.describe Legion::Extensions::Agentic::Integration::Tapestry::Helpers::Thread do
+RSpec.describe Legion::Extensions::Agentic::Integration::Tapestry::Helpers::ThreadStrand do
   subject(:thread) do
     described_class.new(thread_type: :experience, domain: :reasoning, content: 'a past event')
   end

data/spec/legion/extensions/agentic/integration/tapestry/runners/cognitive_tapestry_spec.rb

@@ -3,9 +3,15 @@
 RSpec.describe Legion::Extensions::Agentic::Integration::Tapestry::Runners::CognitiveTapestry do
   let(:engine) { Legion::Extensions::Agentic::Integration::Tapestry::Helpers::LoomEngine.new }
 
-  describe '.spin_thread' do
+  let(:runner_host) do
+    host = Object.new
+    host.extend(described_class)
+    host
+  end
+
+  describe '#spin_thread' do
     it 'returns success with thread hash' do
-      result = described_class.spin_thread(
+      result = runner_host.spin_thread(
         thread_type: :experience, domain: :test, content: 'something happened',
         engine: engine
       )
@@ -14,7 +20,7 @@ RSpec.describe Legion::Extensions::Agentic::Integration::Tapestry::Runners::Cogn
     end
 
     it 'returns failure for invalid thread_type' do
-      result = described_class.spin_thread(
+      result = runner_host.spin_thread(
         thread_type: :bogus, domain: :x, content: 'y', engine: engine
       )
       expect(result[:success]).to be false
@@ -22,7 +28,7 @@ RSpec.describe Legion::Extensions::Agentic::Integration::Tapestry::Runners::Cogn
     end
 
     it 'accepts optional strength and color' do
-      result = described_class.spin_thread(
+      result = runner_host.spin_thread(
         thread_type: :belief, domain: :x, content: 'core belief',
         strength: 0.8, color: :amber, engine: engine
       )
@@ -33,7 +39,7 @@ RSpec.describe Legion::Extensions::Agentic::Integration::Tapestry::Runners::Cogn
 
     it 'absorbs extra keyword args via **' do
       expect do
-        described_class.spin_thread(
+        runner_host.spin_thread(
           thread_type: :memory, domain: :x, content: 'y',
           engine: engine, unknown_key: 'ignored'
         )
@@ -41,9 +47,9 @@ RSpec.describe Legion::Extensions::Agentic::Integration::Tapestry::Runners::Cogn
     end
   end
 
-  describe '.create_tapestry' do
+  describe '#create_tapestry' do
     it 'returns success with tapestry hash' do
-      result = described_class.create_tapestry(
+      result = runner_host.create_tapestry(
         name: 'my story', pattern: :brocade, engine: engine
       )
       expect(result[:success]).to be true
@@ -52,14 +58,14 @@ RSpec.describe Legion::Extensions::Agentic::Integration::Tapestry::Runners::Cogn
     end
 
     it 'returns failure for invalid pattern' do
-      result = described_class.create_tapestry(
+      result = runner_host.create_tapestry(
         name: 'x', pattern: :hexagonal, engine: engine
       )
       expect(result[:success]).to be false
     end
 
     it 'accepts custom capacity' do
-      result = described_class.create_tapestry(
+      result = runner_host.create_tapestry(
         name: 'limited', pattern: :plain, capacity: 5, engine: engine
       )
       expect(result[:success]).to be true
@@ -67,32 +73,31 @@ RSpec.describe Legion::Extensions::Agentic::Integration::Tapestry::Runners::Cogn
     end
   end
 
-  describe '.weave' do
+  describe '#weave' do
     let(:thread_result) do
-      described_class.spin_thread(thread_type: :narrative, domain: :x, content: 'a', engine: engine)
+      runner_host.spin_thread(thread_type: :narrative, domain: :x, content: 'a', engine: engine)
     end
     let(:tapestry_result) do
-      described_class.create_tapestry(name: 'canvas', pattern: :satin, engine: engine)
+      runner_host.create_tapestry(name: 'canvas', pattern: :satin, engine: engine)
     end
 
     it 'successfully weaves thread into tapestry' do
-      result = described_class.weave(
+      result = runner_host.weave(
         thread_id:   thread_result[:thread][:id],
         tapestry_id: tapestry_result[:tapestry][:id],
         engine:      engine
       )
       expect(result[:success]).to be true
-      expect(result[:thread][:woven]).to be true
     end
 
     it 'returns failure when thread is already woven' do
-      first_tap = described_class.create_tapestry(name: 'first', pattern: :plain, engine: engine)
-      described_class.weave(
+      first_tap = runner_host.create_tapestry(name: 'first', pattern: :plain, engine: engine)
+      runner_host.weave(
         thread_id:   thread_result[:thread][:id],
         tapestry_id: first_tap[:tapestry][:id],
         engine:      engine
       )
-      result = described_class.weave(
+      result = runner_host.weave(
         thread_id:   thread_result[:thread][:id],
         tapestry_id: tapestry_result[:tapestry][:id],
         engine:      engine
@@ -102,34 +107,34 @@ RSpec.describe Legion::Extensions::Agentic::Integration::Tapestry::Runners::Cogn
     end
 
     it 'returns failure for unknown thread_id' do
-      result = described_class.weave(
+      result = runner_host.weave(
         thread_id: 'nonexistent', tapestry_id: tapestry_result[:tapestry][:id], engine: engine
       )
       expect(result[:success]).to be false
     end
 
     it 'returns failure for unknown tapestry_id' do
-      result = described_class.weave(
+      result = runner_host.weave(
         thread_id: thread_result[:thread][:id], tapestry_id: 'nonexistent', engine: engine
       )
       expect(result[:success]).to be false
     end
   end
 
-  describe '.list_tapestries' do
+  describe '#list_tapestries' do
     before do
-      described_class.create_tapestry(name: 'plain one', pattern: :plain, engine: engine)
-      described_class.create_tapestry(name: 'twill one', pattern: :twill, engine: engine)
+      runner_host.create_tapestry(name: 'plain one', pattern: :plain, engine: engine)
+      runner_host.create_tapestry(name: 'twill one', pattern: :twill, engine: engine)
     end
 
     it 'returns all tapestries when no filter' do
-      result = described_class.list_tapestries(engine: engine)
+      result = runner_host.list_tapestries(engine: engine)
       expect(result[:success]).to be true
       expect(result[:count]).to eq(2)
     end
 
     it 'filters by pattern' do
-      result = described_class.list_tapestries(engine: engine, pattern: :plain)
+      result = runner_host.list_tapestries(engine: engine, pattern: :plain)
       expect(result[:count]).to eq(1)
       expect(result[:tapestries].first[:pattern]).to eq(:plain)
     end
@@ -138,33 +143,33 @@ RSpec.describe Legion::Extensions::Agentic::Integration::Tapestry::Runners::Cogn
       weak_t = engine.spin_thread(thread_type: :emotion, domain: :x, content: 'y', strength: 0.05)
       tap3   = engine.create_tapestry(name: 'fragile', pattern: :satin, capacity: 5)
       engine.weave(thread_id: weak_t.id, tapestry_id: tap3.id)
-      result = described_class.list_tapestries(engine: engine, fraying_only: true)
+      result = runner_host.list_tapestries(engine: engine, fraying_only: true)
       expect(result[:count]).to be >= 1
     end
 
     it 'returns empty array when no match' do
-      result = described_class.list_tapestries(engine: engine, pattern: :brocade)
+      result = runner_host.list_tapestries(engine: engine, pattern: :brocade)
       expect(result[:count]).to eq(0)
       expect(result[:tapestries]).to be_empty
     end
   end
 
-  describe '.loom_status' do
+  describe '#loom_status' do
     it 'returns success with report' do
-      result = described_class.loom_status(engine: engine)
+      result = runner_host.loom_status(engine: engine)
       expect(result[:success]).to be true
       expect(result[:report]).to have_key(:total_threads)
       expect(result[:report]).to have_key(:total_tapestries)
     end
 
     it 'report includes loose_count' do
-      described_class.spin_thread(thread_type: :belief, domain: :x, content: 'y', engine: engine)
-      result = described_class.loom_status(engine: engine)
+      runner_host.spin_thread(thread_type: :belief, domain: :x, content: 'y', engine: engine)
+      result = runner_host.loom_status(engine: engine)
       expect(result[:report][:loose_count]).to eq(1)
     end
 
     it 'report includes fraying_count' do
-      result = described_class.loom_status(engine: engine)
+      result = runner_host.loom_status(engine: engine)
       expect(result[:report]).to have_key(:fraying_count)
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-agentic-integration
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - Esity
@@ -296,7 +296,7 @@ files:
 - lib/legion/extensions/agentic/integration/tapestry/helpers/constants.rb
 - lib/legion/extensions/agentic/integration/tapestry/helpers/loom_engine.rb
 - lib/legion/extensions/agentic/integration/tapestry/helpers/tapestry.rb
-- lib/legion/extensions/agentic/integration/tapestry/helpers/thread.rb
+- lib/legion/extensions/agentic/integration/tapestry/helpers/thread_strand.rb
 - lib/legion/extensions/agentic/integration/tapestry/runners/cognitive_tapestry.rb
 - lib/legion/extensions/agentic/integration/tapestry/version.rb
 - lib/legion/extensions/agentic/integration/tessellation.rb
@@ -395,7 +395,7 @@ files:
 - spec/legion/extensions/agentic/integration/tapestry/helpers/constants_spec.rb
 - spec/legion/extensions/agentic/integration/tapestry/helpers/loom_engine_spec.rb
 - spec/legion/extensions/agentic/integration/tapestry/helpers/tapestry_spec.rb
-- spec/legion/extensions/agentic/integration/tapestry/helpers/thread_spec.rb
+- spec/legion/extensions/agentic/integration/tapestry/helpers/thread_strand_spec.rb
 - spec/legion/extensions/agentic/integration/tapestry/runners/cognitive_tapestry_spec.rb
 - spec/legion/extensions/agentic/integration/tessellation/client_spec.rb
 - spec/legion/extensions/agentic/integration/tessellation/helpers/mosaic_spec.rb