lex-cognitive-boundary 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8531830d314da99e92950ba57165b26f405e5a75950038f9a0e1310e198662bd
+  data.tar.gz: 947a41d2f19e39bcafc4d6d507aca0846b7f96181f610555645d7788ba9902c6
+SHA512:
+  metadata.gz: 2f6d4d6f43054595474ab937a65cd57e3b5a1c0db51e348d18578e6b546cc67695ba785bf5e8f794aba15c280c6efcf32bef0b702833f9c3f327443d1ccacbce
+  data.tar.gz: ab00e7a0af21c262dab7ce413ffdcbc7fadd41805ed080d068a631355825358fd34d9c370bac84c56e5830a3ca7c30bb6df83741d37848189013d37fccf6e2bf

data/.github/workflows/ci.yml

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

data/.gitignore

@@ -0,0 +1,2 @@
+.rspec_status
+Gemfile.lock

data/.rspec

@@ -0,0 +1,4 @@
+--format documentation
+--color
+--require spec_helper
+--order random

data/.rubocop.yml

@@ -0,0 +1,40 @@
+AllCops:
+  NewCops: enable
+  TargetRubyVersion: 3.4
+
+Style/Documentation:
+  Enabled: false
+
+Naming/PredicateMethod:
+  Enabled: false
+
+Metrics/ClassLength:
+  Max: 150
+
+Metrics/MethodLength:
+  Max: 25
+
+Metrics/AbcSize:
+  Max: 25
+
+Metrics/ParameterLists:
+  Max: 8
+  MaxOptionalParameters: 8
+
+Layout/HashAlignment:
+  EnforcedColonStyle: table
+  EnforcedHashRocketStyle: table
+
+Metrics/BlockLength:
+  Exclude:
+    - 'spec/**/*'
+
+Style/FrozenStringLiteralComment:
+  Enabled: true
+
+Style/StringLiterals:
+  EnforcedStyle: single_quotes
+
+Style/OneClassPerFile:
+  Exclude:
+    - 'spec/spec_helper.rb'

data/CLAUDE.md

@@ -0,0 +1,77 @@
+# lex-cognitive-boundary
+
+**Level 3 Documentation**
+- **Parent**: `/Users/miverso2/rubymine/legion/extensions-agentic/CLAUDE.md`
+- **Grandparent**: `/Users/miverso2/rubymine/legion/CLAUDE.md`
+
+## Purpose
+
+Models permeable cognitive boundaries with integrity tracking and breach detection. Boundaries represent the membranes between cognitive domains (cognitive, emotional, social, informational, temporal, authority, privacy). Each boundary has a permeability score and integrity score; violations degrade both.
+
+## Gem Info
+
+- **Gem name**: `lex-cognitive-boundary`
+- **Version**: `0.1.0`
+- **Module**: `Legion::Extensions::CognitiveBoundary`
+- **Ruby**: `>= 3.4`
+- **License**: MIT
+
+## File Structure
+
+```
+lib/legion/extensions/cognitive_boundary/
+  cognitive_boundary.rb
+  version.rb
+  client.rb
+  helpers/
+    constants.rb
+    boundary.rb
+    boundary_engine.rb
+  runners/
+    cognitive_boundary.rb
+```
+
+## Key Constants
+
+From `helpers/constants.rb`:
+
+- `BOUNDARY_TYPES` — `%i[cognitive emotional social informational temporal authority privacy]`
+- `MAX_BOUNDARIES` = `100`, `MAX_VIOLATIONS` = `500`
+- `DEFAULT_PERMEABILITY` = `0.5`, `PERMEABILITY_BOOST` = `0.05`, `PERMEABILITY_DECAY` = `0.03`
+- `BREACH_THRESHOLD` = `0.8` (permeability >= this = breached boundary)
+- `PERMEABILITY_LABELS` — `0.8+` = `:open`, `0.6` = `:permeable`, `0.4` = `:selective`, `0.2` = `:guarded`, below = `:sealed`
+- `INTEGRITY_LABELS` — `0.8+` = `:intact`, `0.6` = `:stable`, `0.4` = `:stressed`, `0.2` = `:compromised`, below = `:breached`
+
+## Runners
+
+All methods in `Runners::CognitiveBoundary`:
+
+- `create_boundary(name:, boundary_type: :cognitive, permeability: DEFAULT_PERMEABILITY)` — creates a new named boundary
+- `open_boundary(boundary_id:, amount: PERMEABILITY_BOOST)` — increases permeability
+- `close_boundary(boundary_id:, amount: PERMEABILITY_BOOST)` — decreases permeability
+- `violate_boundary(boundary_id:)` — records a violation; degrades integrity
+- `repair_boundary(boundary_id:)` — recovers integrity
+- `seal_boundary(boundary_id:)` — sets permeability to minimum (sealed state)
+- `breached_boundaries` — returns all boundaries where permeability >= `BREACH_THRESHOLD`
+- `boundaries_by_type(boundary_type:)` — filters by type
+- `overall_integrity` — average integrity across all boundaries
+- `overall_permeability` — average permeability across all boundaries
+- `boundary_report` — full report with all boundaries and aggregate metrics
+
+## Helpers
+
+- `BoundaryEngine` — manages boundaries and violation log. `overall_integrity` and `overall_permeability` are arithmetic means.
+- `Boundary` — named boundary with `permeability`, `integrity`, `boundary_type`, `violation_count`. Methods: `open!`, `close!`, `violate!`, `repair!`, `seal!`, `breached?`.
+
+## Integration Points
+
+- `lex-privatecore` enforces privacy boundaries; this extension models them as permeable objects with integrity degradation, enabling upstream callers to monitor boundary health.
+- `lex-consent` manages authority and autonomy boundaries — the consent tier maps naturally to boundary permeability (higher consent = more open boundary).
+- `lex-tick` can check `breached_boundaries` in safety phases to detect when cognitive or emotional boundaries have been overwhelmed.
+
+## Development Notes
+
+- `Boundary` names are stored as-is (not coerced to symbols). Callers should use consistent naming conventions.
+- `violate_boundary` decrements integrity; `repair_boundary` recovers it. Neither crosses zero (clamped).
+- `BREACH_THRESHOLD = 0.8` for permeability, not integrity — a boundary is breached when it is too open, not when integrity is too low. These are separate dimensions.
+- `MAX_VIOLATIONS = 500` is a history cap on the violation log, not a per-boundary limit.

data/Gemfile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec
+
+group :development, :test do
+  gem 'rspec', '~> 3.13'
+  gem 'rubocop', '~> 1.75'
+  gem 'rubocop-rspec'
+end
+
+gem 'legion-gaia', path: '../../legion-gaia'

data/Gemfile.lock

@@ -0,0 +1,78 @@
+PATH
+  remote: .
+  specs:
+    lex-cognitive-boundary (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.8.9)
+      public_suffix (>= 2.0.2, < 8.0)
+    ast (2.4.3)
+    bigdecimal (4.0.1)
+    diff-lcs (1.6.2)
+    json (2.19.1)
+    json-schema (6.2.0)
+      addressable (~> 2.8)
+      bigdecimal (>= 3.1, < 5)
+    language_server-protocol (3.17.0.5)
+    lint_roller (1.1.0)
+    mcp (0.8.0)
+      json-schema (>= 4.1)
+    parallel (1.27.0)
+    parser (3.3.10.2)
+      ast (~> 2.4.1)
+      racc
+    prism (1.9.0)
+    public_suffix (7.0.5)
+    racc (1.8.1)
+    rainbow (3.1.1)
+    regexp_parser (2.11.3)
+    rspec (3.13.2)
+      rspec-core (~> 3.13.0)
+      rspec-expectations (~> 3.13.0)
+      rspec-mocks (~> 3.13.0)
+    rspec-core (3.13.6)
+      rspec-support (~> 3.13.0)
+    rspec-expectations (3.13.5)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-mocks (3.13.8)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.13.0)
+    rspec-support (3.13.7)
+    rubocop (1.85.1)
+      json (~> 2.3)
+      language_server-protocol (~> 3.17.0.2)
+      lint_roller (~> 1.1.0)
+      mcp (~> 0.6)
+      parallel (~> 1.10)
+      parser (>= 3.3.0.2)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 2.9.3, < 3.0)
+      rubocop-ast (>= 1.49.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 4.0)
+    rubocop-ast (1.49.1)
+      parser (>= 3.3.7.2)
+      prism (~> 1.7)
+    rubocop-rspec (3.9.0)
+      lint_roller (~> 1.1)
+      rubocop (~> 1.81)
+    ruby-progressbar (1.13.0)
+    unicode-display_width (3.2.0)
+      unicode-emoji (~> 4.1)
+    unicode-emoji (4.2.0)
+
+PLATFORMS
+  arm64-darwin-25
+  ruby
+
+DEPENDENCIES
+  lex-cognitive-boundary!
+  rspec (~> 3.13)
+  rubocop (~> 1.75)
+  rubocop-rspec
+
+BUNDLED WITH
+   2.6.9

data/README.md

@@ -0,0 +1,39 @@
+# lex-cognitive-boundary
+
+Cognitive boundary enforcement for LegionIO. Models permeable cognitive boundaries with integrity tracking and breach detection.
+
+## What It Does
+
+Cognitive boundaries are the membranes between domains of thought, feeling, and authority. This extension gives each boundary a permeability score (how open it is to external influence) and an integrity score (how intact the membrane is). Violations degrade integrity; deliberate repair restores it. Breached boundaries (too open) are flagged for attention.
+
+Boundary types include cognitive, emotional, social, informational, temporal, authority, and privacy — mapping to the real boundaries an agent must maintain between its own processing and external influence.
+
+## Usage
+
+```ruby
+client = Legion::Extensions::CognitiveBoundary::Client.new
+
+boundary = client.create_boundary(
+  name: 'emotional_regulation',
+  boundary_type: :emotional,
+  permeability: 0.4
+)
+
+client.violate_boundary(boundary_id: boundary[:boundary][:id])
+client.repair_boundary(boundary_id: boundary[:boundary][:id])
+
+client.breached_boundaries
+client.boundary_report
+```
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec
+bundle exec rubocop
+```
+
+## License
+
+MIT

data/lex-cognitive-boundary.gemspec

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/cognitive_boundary/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lex-cognitive-boundary'
+  spec.version       = Legion::Extensions::CognitiveBoundary::VERSION
+  spec.authors       = ['Esity']
+  spec.email         = ['matthewdiverson@gmail.com']
+
+  spec.summary       = 'Cognitive boundary enforcement for LegionIO'
+  spec.description   = 'Models permeable cognitive boundaries with integrity tracking and breach detection'
+  spec.homepage      = 'https://github.com/LegionIO/lex-cognitive-boundary'
+  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/main/README.md"
+  spec.metadata['changelog_uri']       = "#{spec.homepage}/blob/main/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|
+      f.match(%r{\A(?:test|spec|features)/})
+    end
+  end
+  spec.require_paths = ['lib']
+  spec.add_development_dependency 'legion-gaia'
+end

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

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

data/lib/legion/extensions/cognitive_boundary/helpers/boundary.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module CognitiveBoundary
+      module Helpers
+        class Boundary
+          include Constants
+
+          attr_reader :id, :name, :boundary_type, :permeability, :violations,
+                      :created_at
+
+          def initialize(name:, boundary_type: :cognitive, permeability: DEFAULT_PERMEABILITY)
+            @id           = SecureRandom.uuid
+            @name         = name
+            @boundary_type = boundary_type.to_sym
+            @permeability = permeability.to_f.clamp(0.0, 1.0)
+            @violations   = 0
+            @created_at   = Time.now.utc
+          end
+
+          def integrity
+            base = 1.0 - (@violations * 0.05)
+            [base, 0.0].max.round(10)
+          end
+
+          def integrity_label
+            match = INTEGRITY_LABELS.find { |range, _| range.cover?(integrity) }
+            match ? match.last : :breached
+          end
+
+          def permeability_label
+            match = PERMEABILITY_LABELS.find { |range, _| range.cover?(@permeability) }
+            match ? match.last : :sealed
+          end
+
+          def breached?
+            @permeability >= BREACH_THRESHOLD || integrity < 0.2
+          end
+
+          def open!(amount: PERMEABILITY_BOOST)
+            @permeability = (@permeability + amount).clamp(0.0, 1.0).round(10)
+            self
+          end
+
+          def close!(amount: PERMEABILITY_BOOST)
+            @permeability = (@permeability - amount).clamp(0.0, 1.0).round(10)
+            self
+          end
+
+          def violate!
+            @violations += 1
+            self
+          end
+
+          def repair!
+            @violations = [(@violations - 1), 0].max
+            self
+          end
+
+          def seal!
+            @permeability = 0.0
+            self
+          end
+
+          def to_h
+            {
+              id:                 @id,
+              name:               @name,
+              boundary_type:      @boundary_type,
+              permeability:       @permeability,
+              permeability_label: permeability_label,
+              integrity:          integrity,
+              integrity_label:    integrity_label,
+              breached:           breached?,
+              violations:         @violations,
+              created_at:         @created_at
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_boundary/helpers/boundary_engine.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveBoundary
+      module Helpers
+        class BoundaryEngine
+          include Constants
+
+          def initialize
+            @boundaries = {}
+          end
+
+          def create_boundary(name:, boundary_type: :cognitive,
+                              permeability: DEFAULT_PERMEABILITY)
+            prune_if_needed
+            boundary = Boundary.new(
+              name:          name,
+              boundary_type: boundary_type,
+              permeability:  permeability
+            )
+            @boundaries[boundary.id] = boundary
+            boundary
+          end
+
+          def open_boundary(boundary_id:, amount: PERMEABILITY_BOOST)
+            boundary = @boundaries[boundary_id]
+            return nil unless boundary
+
+            boundary.open!(amount: amount)
+          end
+
+          def close_boundary(boundary_id:, amount: PERMEABILITY_BOOST)
+            boundary = @boundaries[boundary_id]
+            return nil unless boundary
+
+            boundary.close!(amount: amount)
+          end
+
+          def violate_boundary(boundary_id:)
+            boundary = @boundaries[boundary_id]
+            return nil unless boundary
+
+            boundary.violate!
+          end
+
+          def repair_boundary(boundary_id:)
+            boundary = @boundaries[boundary_id]
+            return nil unless boundary
+
+            boundary.repair!
+          end
+
+          def seal_boundary(boundary_id:)
+            boundary = @boundaries[boundary_id]
+            return nil unless boundary
+
+            boundary.seal!
+          end
+
+          def breached_boundaries
+            @boundaries.values.select(&:breached?)
+          end
+
+          def boundaries_by_type(boundary_type:)
+            bt = boundary_type.to_sym
+            @boundaries.values.select { |b| b.boundary_type == bt }
+          end
+
+          def most_violated(limit: 5)
+            @boundaries.values.sort_by { |b| -b.violations }.first(limit)
+          end
+
+          def overall_integrity
+            return 1.0 if @boundaries.empty?
+
+            scores = @boundaries.values.map(&:integrity)
+            (scores.sum / scores.size).round(10)
+          end
+
+          def overall_permeability
+            return 0.5 if @boundaries.empty?
+
+            perms = @boundaries.values.map(&:permeability)
+            (perms.sum / perms.size).round(10)
+          end
+
+          def boundary_report
+            {
+              total_boundaries:     @boundaries.size,
+              breached_count:       breached_boundaries.size,
+              overall_integrity:    overall_integrity,
+              overall_permeability: overall_permeability,
+              most_violated:        most_violated(limit: 3).map(&:to_h)
+            }
+          end
+
+          def to_h
+            {
+              total_boundaries:     @boundaries.size,
+              breached_count:       breached_boundaries.size,
+              overall_integrity:    overall_integrity,
+              overall_permeability: overall_permeability
+            }
+          end
+
+          private
+
+          def prune_if_needed
+            return if @boundaries.size < MAX_BOUNDARIES
+
+            least_violated = @boundaries.values.min_by(&:violations)
+            @boundaries.delete(least_violated.id) if least_violated
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveBoundary
+      module Helpers
+        module Constants
+          MAX_BOUNDARIES = 100
+          MAX_VIOLATIONS = 500
+
+          DEFAULT_PERMEABILITY = 0.5
+          PERMEABILITY_BOOST = 0.05
+          PERMEABILITY_DECAY = 0.03
+          BREACH_THRESHOLD = 0.8
+
+          PERMEABILITY_LABELS = {
+            (0.8..)     => :open,
+            (0.6...0.8) => :permeable,
+            (0.4...0.6) => :selective,
+            (0.2...0.4) => :guarded,
+            (..0.2)     => :sealed
+          }.freeze
+
+          INTEGRITY_LABELS = {
+            (0.8..)     => :intact,
+            (0.6...0.8) => :stable,
+            (0.4...0.6) => :stressed,
+            (0.2...0.4) => :compromised,
+            (..0.2)     => :breached
+          }.freeze
+
+          BOUNDARY_TYPES = %i[
+            cognitive emotional social informational
+            temporal authority privacy
+          ].freeze
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveBoundary
+      module Runners
+        module CognitiveBoundary
+          include Helpers::Constants
+
+          include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+          def create_boundary(name:, engine: nil, boundary_type: :cognitive,
+                              permeability: DEFAULT_PERMEABILITY, **)
+            eng = engine || default_engine
+            boundary = eng.create_boundary(name: name, boundary_type: boundary_type,
+                                           permeability: permeability)
+            { success: true, boundary: boundary.to_h }
+          end
+
+          def open_boundary(boundary_id:, engine: nil, amount: PERMEABILITY_BOOST, **)
+            eng = engine || default_engine
+            result = eng.open_boundary(boundary_id: boundary_id, amount: amount)
+            return { success: false, error: 'boundary not found' } unless result
+
+            { success: true, boundary: result.to_h }
+          end
+
+          def close_boundary(boundary_id:, engine: nil, amount: PERMEABILITY_BOOST, **)
+            eng = engine || default_engine
+            result = eng.close_boundary(boundary_id: boundary_id, amount: amount)
+            return { success: false, error: 'boundary not found' } unless result
+
+            { success: true, boundary: result.to_h }
+          end
+
+          def violate_boundary(boundary_id:, engine: nil, **)
+            eng = engine || default_engine
+            result = eng.violate_boundary(boundary_id: boundary_id)
+            return { success: false, error: 'boundary not found' } unless result
+
+            { success: true, boundary: result.to_h }
+          end
+
+          def repair_boundary(boundary_id:, engine: nil, **)
+            eng = engine || default_engine
+            result = eng.repair_boundary(boundary_id: boundary_id)
+            return { success: false, error: 'boundary not found' } unless result
+
+            { success: true, boundary: result.to_h }
+          end
+
+          def seal_boundary(boundary_id:, engine: nil, **)
+            eng = engine || default_engine
+            result = eng.seal_boundary(boundary_id: boundary_id)
+            return { success: false, error: 'boundary not found' } unless result
+
+            { success: true, boundary: result.to_h }
+          end
+
+          def breached_boundaries(engine: nil, **)
+            eng = engine || default_engine
+            breached = eng.breached_boundaries.map(&:to_h)
+            { success: true, breached: breached, count: breached.size }
+          end
+
+          def boundaries_by_type(boundary_type:, engine: nil, **)
+            eng = engine || default_engine
+            boundaries = eng.boundaries_by_type(boundary_type: boundary_type).map(&:to_h)
+            { success: true, boundaries: boundaries, count: boundaries.size }
+          end
+
+          def overall_integrity(engine: nil, **)
+            eng = engine || default_engine
+            { success: true, integrity: eng.overall_integrity }
+          end
+
+          def overall_permeability(engine: nil, **)
+            eng = engine || default_engine
+            { success: true, permeability: eng.overall_permeability }
+          end
+
+          def boundary_report(engine: nil, **)
+            eng = engine || default_engine
+            { success: true, report: eng.boundary_report }
+          end
+
+          private
+
+          def default_engine
+            @default_engine ||= Helpers::BoundaryEngine.new
+          end
+        end
+      end
+    end
+  end
+end

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

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

data/lib/legion/extensions/cognitive_boundary.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative 'cognitive_boundary/version'
+require_relative 'cognitive_boundary/helpers/constants'
+require_relative 'cognitive_boundary/helpers/boundary'
+require_relative 'cognitive_boundary/helpers/boundary_engine'
+require_relative 'cognitive_boundary/runners/cognitive_boundary'
+require_relative 'cognitive_boundary/client'
+
+module Legion
+  module Extensions
+    module CognitiveBoundary
+    end
+  end
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: lex-cognitive-boundary
+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 permeable cognitive boundaries with integrity tracking and breach
+  detection
+email:
+- matthewdiverson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/ci.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- CLAUDE.md
+- Gemfile
+- Gemfile.lock
+- README.md
+- lex-cognitive-boundary.gemspec
+- lib/legion/extensions/cognitive_boundary.rb
+- lib/legion/extensions/cognitive_boundary/client.rb
+- lib/legion/extensions/cognitive_boundary/helpers/boundary.rb
+- lib/legion/extensions/cognitive_boundary/helpers/boundary_engine.rb
+- lib/legion/extensions/cognitive_boundary/helpers/constants.rb
+- lib/legion/extensions/cognitive_boundary/runners/cognitive_boundary.rb
+- lib/legion/extensions/cognitive_boundary/version.rb
+homepage: https://github.com/LegionIO/lex-cognitive-boundary
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-cognitive-boundary
+  source_code_uri: https://github.com/LegionIO/lex-cognitive-boundary
+  documentation_uri: https://github.com/LegionIO/lex-cognitive-boundary/blob/main/README.md
+  changelog_uri: https://github.com/LegionIO/lex-cognitive-boundary/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/LegionIO/lex-cognitive-boundary/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 boundary enforcement for LegionIO
+test_files: []