lex-cognitive-anchor 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 59a9a520a9d3e551fd8affba60f56d2e7d675199745b75bed909b106b38a5905
+  data.tar.gz: 9ba81b07934db4cfb3de2bec2be52abd588256761d0af1882361ad6f8d6adc4b
+SHA512:
+  metadata.gz: 657a67870dca71022858a61d53592df527681066fb55f6ace939da6f87e763e93337e6a0216a21245a8c72c59c76ba8c8c2a3be0d42e08da73ca58274793ad06
+  data.tar.gz: 45e95298b0615d6071d18e3098a59d711907b9cbfc590c9699c0eed238b965b2a595531627b0aa73529e7ce51962240eb969852ca4d083db2d1bcfad5385aa65

data/.rspec

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

data/CLAUDE.md

@@ -0,0 +1,88 @@
+# lex-cognitive-anchor
+
+**Level 3 Documentation**
+- **Parent**: `/Users/miverso2/rubymine/legion/extensions-agentic/CLAUDE.md`
+- **Grandparent**: `/Users/miverso2/rubymine/legion/CLAUDE.md`
+
+## Purpose
+
+Cognitive anchoring and belief tethering — anchor points resist change via grip, chains link anchors with material-dependent flexibility, and bias application models how anchors distort estimates.
+
+## Gem Info
+
+- **Gem name**: `lex-cognitive-anchor`
+- **Version**: `0.1.0`
+- **Module**: `Legion::Extensions::CognitiveAnchor`
+- **Ruby**: `>= 3.4`
+- **License**: MIT
+
+## File Structure
+
+```
+lib/legion/extensions/cognitive_anchor/
+  cognitive_anchor.rb            # Main extension module
+  version.rb                     # VERSION = '0.1.0'
+  client.rb                      # Client wrapper
+  helpers/
+    constants.rb                 # Anchor types, chain materials, drag/drift rates, grip/flexibility labels
+    anchor.rb                    # Anchor value object (grip, type, domain, age)
+    chain.rb                     # Chain value object (material, two anchors, flexibility)
+    anchor_store.rb              # AnchorStore — manages anchors and chains, applies bias
+  runners/
+    cognitive_anchor.rb          # Runner module (extend self) with 6 public methods
+spec/
+  (spec files)
+```
+
+## Key Constants
+
+```ruby
+ANCHOR_TYPES = %i[belief assumption experience authority number]
+CHAIN_MATERIALS = %i[steel rope wire thread cobweb]
+DRAG_RATE = 0.06      # how much grip decays when an anchor is dragged (challenged)
+DRIFT_RATE = 0.03     # passive grip decay over time
+BREAK_THRESHOLD = 0.1 # grip level at which an anchor breaks (chain severs)
+GRIP_LABELS = {
+  (0.85..) => :immovable, (0.65...0.85) => :firm, (0.45...0.65) => :moderate,
+  (0.25...0.45) => :loose, (..0.25) => :slipping
+}
+FLEXIBILITY_LABELS = {
+  steel: :rigid, rope: :flexible, wire: :semiflexible,
+  thread: :very_flexible, cobweb: :fragile
+}
+```
+
+## Runners
+
+### `Runners::CognitiveAnchor`
+
+Uses `extend self` — methods are module-level, not instance-delegating. Delegates to a per-call `engine` (parameter-injected `Helpers::AnchorStore` instance via `engine:` keyword, defaulting to a shared `@engine ||=`).
+
+- `create_anchor(name:, anchor_type:, domain: :general, grip: 0.7, engine: @engine)` — register an anchor point with initial grip
+- `create_chain(anchor_a:, anchor_b:, material:, engine: @engine)` — link two anchors with a chain of specified material; chain flexibility depends on material
+- `apply_bias(anchor_id:, estimate:, engine: @engine)` — apply the anchor's distortion to an estimate; returns adjusted estimate and bias magnitude
+- `list_anchors(engine: @engine)` — all anchors as array of hashes with grip labels
+- `anchor_status(engine: @engine)` — summary: anchor count, chain count, average grip, broken chain count
+
+## Helpers
+
+### `Helpers::AnchorStore`
+Core engine managing `@anchors` and `@chains` hashes. `apply_bias` computes how strongly the anchor distorts the given estimate based on current grip. `drag_anchor` reduces grip by `DRAG_RATE`; if grip drops below `BREAK_THRESHOLD`, all chains involving the anchor are severed. `drift_all` applies passive `DRIFT_RATE` decay to all anchors.
+
+### `Helpers::Anchor`
+Value object: name, anchor_type, domain, grip (0.0–1.0), age. `drag!` reduces grip by `DRAG_RATE` clamped to 0.0. `drift!` reduces grip by `DRIFT_RATE`. `broken?` returns true when `grip <= BREAK_THRESHOLD`. `grip_label` maps current grip to human-readable label.
+
+### `Helpers::Chain`
+Value object: material, anchor_a_id, anchor_b_id, flexibility (derived from material). `flexibility_label` maps material to label from `FLEXIBILITY_LABELS`. `active?` returns true only when neither linked anchor is broken.
+
+## Integration Points
+
+No actor defined — no automatic drift or drag. This extension models how existing beliefs and anchors resist or distort new information. Pairs with lex-anchoring (which models Kahneman/Tversky numeric anchoring and prospect theory) — these are complementary; lex-anchoring covers numeric estimation bias, lex-cognitive-anchor covers structural belief tethering. Pairs with lex-bias (anchor bias detection feeds here) and lex-belief-revision (chain breaks can trigger belief revision events).
+
+## Development Notes
+
+- `extend self` pattern: runner is a module with module-level methods; shared `@engine` lives in the module's singleton
+- `BREAK_THRESHOLD = 0.1` is intentionally low — anchors are persistent; they require sustained challenge (`drag_anchor` calls) to break
+- `DRAG_RATE (0.06) > DRIFT_RATE (0.03)`: active challenge degrades grip twice as fast as passive time decay
+- Chain material determines flexibility label only — the mechanics of chain flexibility are not yet enforced on bias calculations (stub intent)
+- `apply_bias` returns a hash with both the adjusted estimate and bias magnitude — callers must decide how to apply the adjustment

data/README.md

@@ -0,0 +1,70 @@
+# lex-cognitive-anchor
+
+Cognitive anchoring and belief tethering — anchor points resist change via grip, chains link anchors, and bias application models how they distort estimates.
+
+## What It Does
+
+Models how beliefs and assumptions act as anchors that resist revision. Each anchor has a `grip` (0.0–1.0) that decays when the anchor is challenged (`drag`) or simply ages (`drift`). Anchors can be chained together with material-dependent flexibility (steel = rigid, cobweb = fragile). When an anchor's grip falls below the break threshold, its chains sever.
+
+## Core Concept: Anchor Types and Materials
+
+```
+ANCHOR_TYPES: belief, assumption, experience, authority, number
+CHAIN_MATERIALS: steel (rigid) -> rope -> wire -> thread -> cobweb (fragile)
+```
+
+## Usage
+
+```ruby
+client = Legion::Extensions::CognitiveAnchor::Client.new
+
+# Register a strong belief anchor
+belief = client.create_anchor(
+  name: :microservices_are_always_better,
+  anchor_type: :belief,
+  domain: :architecture,
+  grip: 0.85
+)
+
+# Register an experience-based anchor
+exp = client.create_anchor(
+  name: :monolith_failure_2019,
+  anchor_type: :experience,
+  domain: :architecture,
+  grip: 0.70
+)
+
+# Chain them together with a semi-flexible wire link
+client.create_chain(
+  anchor_a: belief[:anchor][:id],
+  anchor_b: exp[:anchor][:id],
+  material: :wire
+)
+
+# Apply anchor bias to a new architectural estimate
+client.apply_bias(
+  anchor_id: belief[:anchor][:id],
+  estimate: { approach: :monolith, confidence: 0.7 }
+)
+# => { adjusted_estimate: ..., bias_magnitude: 0.72 }
+
+# Check overall anchor landscape
+client.anchor_status
+# => { anchor_count: 2, chain_count: 1, average_grip: 0.78, broken_chains: 0 }
+```
+
+## Integration
+
+Pairs with lex-anchoring (numeric anchoring and prospect theory) and lex-bias (bias detection feeds here). Pairs with lex-belief-revision — when an anchor breaks, the freed beliefs become candidates for revision.
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec
+bundle exec rubocop
+```
+
+## License
+
+MIT

data/lex-cognitive-anchor.gemspec

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/cognitive_anchor/version'
+
+Gem::Specification.new do |spec|
+  spec.name    = 'lex-cognitive-anchor'
+  spec.version = Legion::Extensions::CognitiveAnchor::VERSION
+  spec.authors = ['Esity']
+  spec.email   = ['matthewdiverson@gmail.com']
+
+  spec.summary     = 'Cognitive anchoring bias dynamics for LegionIO agentic architecture'
+  spec.description = 'Models anchoring biases where fixed reference points pull new information ' \
+                     'toward them with configurable grip, weight, and chain flexibility'
+  spec.homepage    = 'https://github.com/LegionIO/lex-cognitive-anchor'
+  spec.license     = 'MIT'
+
+  spec.required_ruby_version = '>= 3.4'
+
+  spec.metadata['homepage_uri']      = spec.homepage
+  spec.metadata['source_code_uri']   = spec.homepage
+  spec.metadata['documentation_uri'] = "#{spec.homepage}/blob/master/README.md"
+  spec.metadata['changelog_uri']     = "#{spec.homepage}/blob/master/CHANGELOG.md"
+  spec.metadata['bug_tracker_uri']   = "#{spec.homepage}/issues"
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?('spec/', '.git', '.rubocop', 'Gemfile')
+    end
+  end
+
+  spec.require_paths = ['lib']
+  spec.add_development_dependency 'legion-gaia'
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveAnchor
+      class Client
+        include Runners::CognitiveAnchor
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_anchor/helpers/anchor.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveAnchor
+      module Helpers
+        class Anchor
+          attr_reader :id, :anchor_type, :domain, :content,
+                      :reference_value, :created_at
+          attr_accessor :grip, :weight
+
+          def initialize(anchor_type:, domain:, content:,
+                         reference_value: nil, grip: nil, weight: nil)
+            validate_anchor_type!(anchor_type)
+            @id              = SecureRandom.uuid
+            @anchor_type     = anchor_type.to_sym
+            @domain          = domain.to_sym
+            @content         = content.to_s
+            @reference_value = (reference_value || 0.5).to_f.clamp(0.0, 1.0).round(10)
+            @grip            = (grip || 0.7).to_f.clamp(0.0, 1.0).round(10)
+            @weight          = (weight || 0.5).to_f.clamp(0.0, 1.0).round(10)
+            @created_at      = Time.now.utc
+          end
+
+          def drag!(rate: Constants::DRAG_RATE)
+            @grip = (@grip + rate.abs).clamp(0.0, 1.0).round(10)
+          end
+
+          def drift!(rate: Constants::DRIFT_RATE)
+            @grip = (@grip - rate.abs).clamp(0.0, 1.0).round(10)
+          end
+
+          def bias_pull(new_value)
+            pull_strength = @grip * @weight
+            adjusted = new_value + ((reference_value - new_value) * pull_strength)
+            adjusted.clamp(0.0, 1.0).round(10)
+          end
+
+          def ironclad?
+            @grip >= 0.8
+          end
+
+          def drifting?
+            @grip < 0.2
+          end
+
+          def heavy?
+            @weight >= 0.7
+          end
+
+          def light?
+            @weight < 0.3
+          end
+
+          def grip_label
+            Constants.label_for(Constants::GRIP_LABELS, @grip)
+          end
+
+          def to_h
+            {
+              id:              @id,
+              anchor_type:     @anchor_type,
+              domain:          @domain,
+              content:         @content,
+              reference_value: @reference_value,
+              grip:            @grip,
+              weight:          @weight,
+              grip_label:      grip_label,
+              ironclad:        ironclad?,
+              drifting:        drifting?,
+              created_at:      @created_at
+            }
+          end
+
+          private
+
+          def validate_anchor_type!(val)
+            return if Constants::ANCHOR_TYPES.include?(val.to_sym)
+
+            raise ArgumentError,
+                  "unknown anchor type: #{val.inspect}; " \
+                  "must be one of #{Constants::ANCHOR_TYPES.inspect}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_anchor/helpers/anchor_engine.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveAnchor
+      module Helpers
+        class AnchorEngine
+          def initialize
+            @anchors = {}
+            @chains  = {}
+          end
+
+          def create_anchor(anchor_type:, domain:, content:,
+                            reference_value: nil, grip: nil, weight: nil)
+            raise ArgumentError, 'anchor limit reached' if @anchors.size >= Constants::MAX_ANCHORS
+
+            a = Anchor.new(anchor_type: anchor_type, domain: domain, content: content,
+                           reference_value: reference_value, grip: grip, weight: weight)
+            @anchors[a.id] = a
+            a
+          end
+
+          def create_chain(anchor_id:, material: :steel, length: nil, flexibility: nil)
+            raise ArgumentError, 'chain limit reached' if @chains.size >= Constants::MAX_CHAINS
+
+            fetch_anchor(anchor_id)
+            c = Chain.new(anchor_id: anchor_id, material: material,
+                          length: length, flexibility: flexibility)
+            @chains[c.id] = c
+            c
+          end
+
+          def apply_bias(anchor_id:, new_value:)
+            anchor = fetch_anchor(anchor_id)
+            pulled = anchor.bias_pull(new_value.to_f)
+            { anchor: anchor, original: new_value.to_f, biased: pulled,
+              shift: (pulled - new_value.to_f).abs.round(10) }
+          end
+
+          def drag_anchor(anchor_id:, rate: Constants::DRAG_RATE)
+            anchor = fetch_anchor(anchor_id)
+            anchor.drag!(rate: rate)
+            anchor
+          end
+
+          def drift_all!
+            @anchors.each_value(&:drift!)
+          end
+
+          def wear_all_chains!
+            @chains.each_value(&:wear!)
+          end
+
+          def broken_chains
+            @chains.values.select(&:broken?)
+          end
+
+          def anchors_by_type
+            counts = Constants::ANCHOR_TYPES.to_h { |t| [t, 0] }
+            @anchors.each_value { |a| counts[a.anchor_type] += 1 }
+            counts
+          end
+
+          def strongest_anchors(limit: 5)
+            @anchors.values.sort_by { |a| -a.grip }.first(limit)
+          end
+
+          def weakest_anchors(limit: 5)
+            @anchors.values.sort_by(&:grip).first(limit)
+          end
+
+          def ironclad_anchors
+            @anchors.values.select(&:ironclad?)
+          end
+
+          def drifting_anchors
+            @anchors.values.select(&:drifting?)
+          end
+
+          def chains_for(anchor_id)
+            @chains.values.select { |c| c.anchor_id == anchor_id }
+          end
+
+          def avg_grip
+            return 0.0 if @anchors.empty?
+
+            (@anchors.values.sum(&:grip) / @anchors.size).round(10)
+          end
+
+          def anchor_report
+            {
+              total_anchors:  @anchors.size,
+              total_chains:   @chains.size,
+              by_type:        anchors_by_type,
+              ironclad_count: ironclad_anchors.size,
+              drifting_count: drifting_anchors.size,
+              broken_chains:  broken_chains.size,
+              avg_grip:       avg_grip
+            }
+          end
+
+          def all_anchors
+            @anchors.values
+          end
+
+          def all_chains
+            @chains.values
+          end
+
+          private
+
+          def fetch_anchor(id)
+            @anchors.fetch(id) { raise ArgumentError, "anchor not found: #{id}" }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_anchor/helpers/chain.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveAnchor
+      module Helpers
+        class Chain
+          attr_reader :id, :anchor_id, :material, :created_at
+          attr_accessor :length, :flexibility
+
+          def initialize(anchor_id:, material: :steel, length: nil, flexibility: nil)
+            validate_material!(material)
+            @id          = SecureRandom.uuid
+            @anchor_id   = anchor_id
+            @material    = material.to_sym
+            @length      = (length || 0.5).to_f.clamp(0.0, 1.0).round(10)
+            @flexibility = (flexibility || material_flexibility).to_f.clamp(0.0, 1.0).round(10)
+            @created_at  = Time.now.utc
+          end
+
+          def extend!(amount: 0.1)
+            @length = (@length + amount.abs).clamp(0.0, 1.0).round(10)
+          end
+
+          def shorten!(amount: 0.1)
+            @length = (@length - amount.abs).clamp(0.0, 1.0).round(10)
+          end
+
+          def wear!(rate: 0.05)
+            @flexibility = (@flexibility - rate.abs).clamp(0.0, 1.0).round(10)
+          end
+
+          def broken?
+            @flexibility < Constants::BREAK_THRESHOLD
+          end
+
+          def elastic?
+            @flexibility >= 0.8
+          end
+
+          def rigid?
+            @flexibility < 0.2
+          end
+
+          def short?
+            @length < 0.3
+          end
+
+          def long?
+            @length >= 0.7
+          end
+
+          def flexibility_label
+            Constants.label_for(Constants::FLEXIBILITY_LABELS, @flexibility)
+          end
+
+          def to_h
+            {
+              id:                @id,
+              anchor_id:         @anchor_id,
+              material:          @material,
+              length:            @length,
+              flexibility:       @flexibility,
+              flexibility_label: flexibility_label,
+              broken:            broken?,
+              elastic:           elastic?,
+              created_at:        @created_at
+            }
+          end
+
+          private
+
+          def validate_material!(val)
+            return if Constants::CHAIN_MATERIALS.include?(val.to_sym)
+
+            raise ArgumentError,
+                  "unknown material: #{val.inspect}; " \
+                  "must be one of #{Constants::CHAIN_MATERIALS.inspect}"
+          end
+
+          def material_flexibility
+            { steel: 0.3, rope: 0.6, wire: 0.4, thread: 0.8, cobweb: 0.9 }
+              .fetch(@material, 0.5)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveAnchor
+      module Helpers
+        module Constants
+          ANCHOR_TYPES = %i[belief assumption experience authority number].freeze
+
+          CHAIN_MATERIALS = %i[steel rope wire thread cobweb].freeze
+
+          MAX_ANCHORS = 200
+          MAX_CHAINS  = 100
+          DRAG_RATE   = 0.06
+          DRIFT_RATE  = 0.03
+          BREAK_THRESHOLD = 0.1
+
+          GRIP_LABELS = [
+            [(0.8..),      :ironclad],
+            [(0.6...0.8),  :firm],
+            [(0.4...0.6),  :moderate],
+            [(0.2...0.4),  :loose],
+            [(..0.2),      :drifting]
+          ].freeze
+
+          FLEXIBILITY_LABELS = [
+            [(0.8..),      :elastic],
+            [(0.6...0.8),  :flexible],
+            [(0.4...0.6),  :moderate],
+            [(0.2...0.4),  :rigid],
+            [(..0.2),      :brittle]
+          ].freeze
+
+          def self.label_for(table, value)
+            table.each { |range, label| return label if range.cover?(value) }
+            table.last.last
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_anchor/runners/cognitive_anchor.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveAnchor
+      module Runners
+        module CognitiveAnchor
+          extend self
+
+          def create_anchor(anchor_type:, domain:, content:,
+                            reference_value: nil, grip: nil, weight: nil, engine: nil, **)
+            eng = resolve_engine(engine)
+            a   = eng.create_anchor(anchor_type: anchor_type, domain: domain, content: content,
+                                    reference_value: reference_value, grip: grip, weight: weight)
+            { success: true, anchor: a.to_h }
+          rescue ArgumentError => e
+            { success: false, error: e.message }
+          end
+
+          def create_chain(anchor_id:, material: :steel, length: nil,
+                           flexibility: nil, engine: nil, **)
+            eng = resolve_engine(engine)
+            c   = eng.create_chain(anchor_id: anchor_id, material: material,
+                                   length: length, flexibility: flexibility)
+            { success: true, chain: c.to_h }
+          rescue ArgumentError => e
+            { success: false, error: e.message }
+          end
+
+          def apply_bias(anchor_id:, new_value:, engine: nil, **)
+            eng    = resolve_engine(engine)
+            result = eng.apply_bias(anchor_id: anchor_id, new_value: new_value)
+            { success: true, anchor: result[:anchor].to_h,
+              original: result[:original], biased: result[:biased], shift: result[:shift] }
+          rescue ArgumentError => e
+            { success: false, error: e.message }
+          end
+
+          def list_anchors(engine: nil, anchor_type: nil, **)
+            eng     = resolve_engine(engine)
+            results = eng.all_anchors
+            results = results.select { |a| a.anchor_type == anchor_type.to_sym } if anchor_type
+            { success: true, anchors: results.map(&:to_h), count: results.size }
+          end
+
+          def anchor_status(engine: nil, **)
+            eng = resolve_engine(engine)
+            { success: true, report: eng.anchor_report }
+          end
+
+          include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+          private
+
+          def resolve_engine(engine)
+            engine || default_engine
+          end
+
+          def default_engine
+            @default_engine ||= Helpers::AnchorEngine.new
+          end
+        end
+      end
+    end
+  end
+end

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

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

data/lib/legion/extensions/cognitive_anchor.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+require_relative 'cognitive_anchor/version'
+require_relative 'cognitive_anchor/helpers/constants'
+require_relative 'cognitive_anchor/helpers/anchor'
+require_relative 'cognitive_anchor/helpers/chain'
+require_relative 'cognitive_anchor/helpers/anchor_engine'
+require_relative 'cognitive_anchor/runners/cognitive_anchor'
+require_relative 'cognitive_anchor/client'
+
+module Legion
+  module Extensions
+    module CognitiveAnchor
+      extend Legion::Extensions::Core if Legion::Extensions.const_defined? :Core
+    end
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: lex-cognitive-anchor
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Esity
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: legion-gaia
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Models anchoring biases where fixed reference points pull new information
+  toward them with configurable grip, weight, and chain flexibility
+email:
+- matthewdiverson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- CLAUDE.md
+- README.md
+- lex-cognitive-anchor.gemspec
+- lib/legion/extensions/cognitive_anchor.rb
+- lib/legion/extensions/cognitive_anchor/client.rb
+- lib/legion/extensions/cognitive_anchor/helpers/anchor.rb
+- lib/legion/extensions/cognitive_anchor/helpers/anchor_engine.rb
+- lib/legion/extensions/cognitive_anchor/helpers/chain.rb
+- lib/legion/extensions/cognitive_anchor/helpers/constants.rb
+- lib/legion/extensions/cognitive_anchor/runners/cognitive_anchor.rb
+- lib/legion/extensions/cognitive_anchor/version.rb
+homepage: https://github.com/LegionIO/lex-cognitive-anchor
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-cognitive-anchor
+  source_code_uri: https://github.com/LegionIO/lex-cognitive-anchor
+  documentation_uri: https://github.com/LegionIO/lex-cognitive-anchor/blob/master/README.md
+  changelog_uri: https://github.com/LegionIO/lex-cognitive-anchor/blob/master/CHANGELOG.md
+  bug_tracker_uri: https://github.com/LegionIO/lex-cognitive-anchor/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Cognitive anchoring bias dynamics for LegionIO agentic architecture
+test_files: []