lex-cognitive-dwell 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '083991382a820bcb5efce7990358f9b62dfe275c50b1192007ecb1dabd8f29ff'
+  data.tar.gz: f912d80e94ac82fc7a05521d207f815f7a92641c293834339cab598e0895c4e4
+SHA512:
+  metadata.gz: 77353af88cf0948623549061d73903d474e42c2a8536846fb32f5344bf078c62fe547270264669addab356e9704a2d015369ca5855a28c237b20505689b30125
+  data.tar.gz: 46191064d7a67ce8ebfc24783140995c4db538cd4eb3ecdf9c1214f0650c5791cf8e2101f1b334015956b469369fa9381f180494d71b46a88035a4f05a76becb

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,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.gem
+Gemfile.lock
+.rspec_status

data/.rspec

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

data/.rubocop.yml

@@ -0,0 +1,37 @@
+AllCops:
+  NewCops: enable
+  TargetRubyVersion: 3.4
+
+Style/Documentation:
+  Enabled: false
+
+Naming/PredicateMethod:
+  Enabled: false
+
+Naming/PredicatePrefix:
+  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/OneClassPerFile:
+  Exclude:
+    - 'spec/spec_helper.rb'

data/CLAUDE.md

@@ -0,0 +1,79 @@
+# lex-cognitive-dwell
+
+**Level 3 Documentation**
+- **Parent**: `/Users/miverso2/rubymine/legion/extensions-agentic/CLAUDE.md`
+- **Grandparent**: `/Users/miverso2/rubymine/legion/CLAUDE.md`
+
+## Purpose
+
+Models how long the system lingers on topics based on salience, novelty, emotional intensity, and complexity. Detects sticky topics and rumination. Provides attention-as-duration modeling: some topics naturally attract longer dwell times; others are fleeting. Rumination is detected when dwell time reaches critical levels.
+
+## Gem Info
+
+- **Gem name**: `lex-cognitive-dwell`
+- **Version**: `0.1.0`
+- **Module**: `Legion::Extensions::CognitiveDwell`
+- **Ruby**: `>= 3.4`
+- **License**: MIT
+
+## File Structure
+
+```
+lib/legion/extensions/cognitive_dwell/
+  cognitive_dwell.rb
+  version.rb
+  client.rb
+  helpers/
+    constants.rb
+    dwell_engine.rb
+    dwell_topic.rb
+  runners/
+    cognitive_dwell.rb
+```
+
+## Key Constants
+
+From `helpers/constants.rb`:
+
+- `TOPIC_TYPES` — `%i[problem concept conversation task memory emotion plan decision observation]`
+- `MAX_TOPICS` = `200`, `MAX_DWELL_HISTORY` = `500`
+- `BASE_DWELL` = `0.3`
+- Dwell score weights: `SALIENCE_WEIGHT` = `0.25`, `NOVELTY_WEIGHT` = `0.25`, `EMOTION_WEIGHT` = `0.3`, `COMPLEXITY_WEIGHT` = `0.2`
+- `DWELL_DECAY` = `0.05`, `ENGAGEMENT_BOOST` = `0.08`
+- `STICKY_THRESHOLD` = `0.7`, `FLEETING_THRESHOLD` = `0.2`, `RUMINATION_THRESHOLD` = `0.9`
+- `DWELL_LABELS` — `0.8+` = `:stuck`, `0.6` = `:engrossed`, `0.4` = `:attending`, `0.2` = `:browsing`, below = `:fleeting`
+- `ENGAGEMENT_LABELS` — `0.8+` = `:deeply_engaged` through below `0.2` = `:disengaged`
+- `DISENGAGE_LABELS` — `0.8+` = `:very_hard` through below `0.2` = `:effortless`
+
+## Runners
+
+All methods in `Runners::CognitiveDwell`:
+
+- `add_topic(content:, topic_type: :concept, salience: 0.5, novelty: 0.5, emotional_intensity: 0.3, complexity: 0.5)` — adds a topic with initial dwell score computed from weighted inputs
+- `focus_on(topic_id:)` — boosts engagement score on a topic; increases dwell time
+- `disengage(topic_id:, force: 0.0)` — reduces engagement; `force` parameter accelerates disengagement
+- `decay(engine: nil)` — applies dwell decay to all topics; returns decayed count
+- `current_topic` — the topic with the highest current dwell score
+- `sticky_topics` — topics above `STICKY_THRESHOLD` (dwell >= 0.7)
+- `ruminating_topics` — topics above `RUMINATION_THRESHOLD` (dwell >= 0.9)
+- `most_engaging(limit: 5)` — top topics by engagement score
+- `dwell_report` — full report: totals, sticky count, rumination count, average dwell
+- `status` — engine summary
+
+## Helpers
+
+- `DwellEngine` — manages topics. Dwell score = `BASE_DWELL + (salience * SALIENCE_WEIGHT) + (novelty * NOVELTY_WEIGHT) + (emotional_intensity * EMOTION_WEIGHT) + (complexity * COMPLEXITY_WEIGHT)`. `decay_all!` applies `DWELL_DECAY` to all topics.
+- `DwellTopic` — has `content`, `topic_type`, `dwell_score`, `engagement`, `salience`, `novelty`, `emotional_intensity`, `complexity`. `focus!` boosts engagement. `disengage!(force)` reduces both dwell and engagement.
+
+## Integration Points
+
+- `lex-cognitive-echo` models residual activation from past processing — dwell is the active attention complement: echo is background, dwell is foreground.
+- `lex-tick` can check `ruminating_topics` in the health phase to detect unhealthy attention loops and trigger defusion or disengagement.
+- Emotional weight (`EMOTION_WEIGHT = 0.3`) is the highest single factor — emotionally intense topics naturally attract longer dwell, modeling the affect-attention link.
+
+## Development Notes
+
+- `current_topic` returns the single highest-dwell topic — the agent's most attended-to concept at any moment.
+- `RUMINATION_THRESHOLD = 0.9` is deliberately high — rumination is a clinical-level concern, not normal engagement.
+- `disengage(force: 0.0)` with default force is gentle; `force: 1.0` enables hard disengagement override.
+- Dwell decay applies to all topics including the current topic — active engagement requires periodic `focus_on` calls to maintain dwell level.

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/README.md

@@ -0,0 +1,43 @@
+# lex-cognitive-dwell
+
+Cognitive dwell time modeling for LegionIO. Models how long the system lingers on topics based on salience, novelty, emotional intensity, and complexity. Detects sticky topics and rumination.
+
+## What It Does
+
+Not all topics receive equal attention. This extension models dwell time — how long a topic captures cognitive focus — as a weighted function of salience, novelty, emotional intensity, and complexity. Topics with high emotional intensity (weight 0.3) attract the most attention; salience and novelty each contribute equally (0.25); complexity adds a smaller pull (0.2). Dwell decays over time unless actively reinforced by focus.
+
+Three critical thresholds: sticky (0.7, noteworthy persistence), and rumination (0.9, unhealthy fixation requiring intervention).
+
+## Usage
+
+```ruby
+client = Legion::Extensions::CognitiveDwell::Client.new
+
+topic = client.add_topic(
+  content: 'unresolved question about consent tier promotion criteria',
+  topic_type: :problem,
+  salience: 0.8,
+  novelty: 0.6,
+  emotional_intensity: 0.7,
+  complexity: 0.5
+)
+
+client.focus_on(topic_id: topic[:topic][:id])
+client.sticky_topics
+client.ruminating_topics
+
+client.decay   # call each tick
+client.dwell_report
+```
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec
+bundle exec rubocop
+```
+
+## License
+
+MIT

data/lex-cognitive-dwell.gemspec

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/cognitive_dwell/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lex-cognitive-dwell'
+  spec.version       = Legion::Extensions::CognitiveDwell::VERSION
+  spec.authors       = ['Esity']
+  spec.email         = ['matthewdiverson@gmail.com']
+
+  spec.summary       = 'Cognitive dwell time modeling for LegionIO'
+  spec.description   = 'Models how long the system lingers on topics based on salience, novelty, emotional ' \
+                       'intensity, and complexity. Detects sticky topics and rumination.'
+  spec.homepage      = 'https://github.com/LegionIO/lex-cognitive-dwell'
+  spec.license       = 'MIT'
+
+  spec.required_ruby_version = '>= 3.4'
+
+  spec.metadata['homepage_uri']      = spec.homepage
+  spec.metadata['source_code_uri']   = 'https://github.com/LegionIO/lex-cognitive-dwell'
+  spec.metadata['documentation_uri'] = 'https://github.com/LegionIO/lex-cognitive-dwell/blob/master/README.md'
+  spec.metadata['changelog_uri']     = 'https://github.com/LegionIO/lex-cognitive-dwell/blob/master/CHANGELOG.md'
+  spec.metadata['bug_tracker_uri']   = 'https://github.com/LegionIO/lex-cognitive-dwell/issues'
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.require_paths = ['lib']
+  spec.add_development_dependency 'legion-gaia'
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveDwell
+      class Client
+        include Runners::CognitiveDwell
+
+        def initialize(engine: nil)
+          @default_engine = engine || Helpers::DwellEngine.new
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveDwell
+      module Helpers
+        module Constants
+          MAX_TOPICS = 200
+          MAX_DWELL_HISTORY = 500
+
+          # Dwell dynamics
+          BASE_DWELL = 0.3
+          SALIENCE_WEIGHT = 0.25
+          NOVELTY_WEIGHT = 0.25
+          EMOTION_WEIGHT = 0.3
+          COMPLEXITY_WEIGHT = 0.2
+          DWELL_DECAY = 0.05
+          ENGAGEMENT_BOOST = 0.08
+
+          # Thresholds
+          STICKY_THRESHOLD = 0.7
+          FLEETING_THRESHOLD = 0.2
+          RUMINATION_THRESHOLD = 0.9
+
+          # Topic types
+          TOPIC_TYPES = %i[
+            problem concept conversation task memory
+            emotion plan decision observation
+          ].freeze
+
+          # Dwell duration labels
+          DWELL_LABELS = {
+            (0.8..)     => :stuck,
+            (0.6...0.8) => :engrossed,
+            (0.4...0.6) => :attending,
+            (0.2...0.4) => :browsing,
+            (..0.2)     => :fleeting
+          }.freeze
+
+          # Engagement labels
+          ENGAGEMENT_LABELS = {
+            (0.8..)     => :deeply_engaged,
+            (0.6...0.8) => :engaged,
+            (0.4...0.6) => :moderate,
+            (0.2...0.4) => :light,
+            (..0.2)     => :disengaged
+          }.freeze
+
+          # Disengagement difficulty labels
+          DISENGAGE_LABELS = {
+            (0.8..)     => :very_hard,
+            (0.6...0.8) => :hard,
+            (0.4...0.6) => :moderate,
+            (0.2...0.4) => :easy,
+            (..0.2)     => :effortless
+          }.freeze
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_dwell/helpers/dwell_engine.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveDwell
+      module Helpers
+        class DwellEngine
+          include Constants
+
+          def initialize
+            @topics = {}
+            @current_topic_id = nil
+          end
+
+          def add_topic(content:, topic_type: :concept, salience: 0.5,
+                        novelty: 0.5, emotional_intensity: 0.3, complexity: 0.5)
+            prune_if_needed
+            topic = DwellTopic.new(
+              content: content, topic_type: topic_type, salience: salience,
+              novelty: novelty, emotional_intensity: emotional_intensity, complexity: complexity
+            )
+            @topics[topic.id] = topic
+            topic
+          end
+
+          def focus_on(topic_id:)
+            topic = @topics[topic_id]
+            return nil unless topic
+
+            topic.engage!
+            @current_topic_id = topic_id
+            topic
+          end
+
+          def disengage(topic_id:, force: 0.0)
+            topic = @topics[topic_id]
+            return nil unless topic
+
+            topic.disengage!(force: force)
+            @current_topic_id = nil if @current_topic_id == topic_id
+            topic
+          end
+
+          def decay_all!
+            @topics.each_value(&:decay!)
+            { topics_decayed: @topics.size }
+          end
+
+          def current_topic
+            @topics[@current_topic_id]
+          end
+
+          def sticky_topics
+            @topics.values.select(&:sticky?)
+          end
+
+          def fleeting_topics
+            @topics.values.select(&:fleeting?)
+          end
+
+          def ruminating_topics
+            @topics.values.select(&:ruminating?)
+          end
+
+          def most_engaging(limit: 5)
+            @topics.values.sort_by { |t| -t.dwell_level }.first(limit)
+          end
+
+          def hardest_to_disengage(limit: 5)
+            @topics.values.sort_by { |t| -t.disengagement_difficulty }.first(limit)
+          end
+
+          def average_dwell
+            return BASE_DWELL if @topics.empty?
+
+            vals = @topics.values.map(&:dwell_level)
+            (vals.sum / vals.size).round(10)
+          end
+
+          def average_disengagement_difficulty
+            return 0.0 if @topics.empty?
+
+            vals = @topics.values.map(&:disengagement_difficulty)
+            (vals.sum / vals.size).round(10)
+          end
+
+          def dwell_report
+            {
+              total_topics:                     @topics.size,
+              current_topic:                    current_topic&.to_h,
+              sticky_count:                     sticky_topics.size,
+              fleeting_count:                   fleeting_topics.size,
+              ruminating_count:                 ruminating_topics.size,
+              average_dwell:                    average_dwell,
+              average_disengagement_difficulty: average_disengagement_difficulty,
+              most_engaging:                    most_engaging(limit: 3).map(&:to_h)
+            }
+          end
+
+          def to_h
+            {
+              total_topics:     @topics.size,
+              current_topic_id: @current_topic_id,
+              sticky_count:     sticky_topics.size,
+              ruminating_count: ruminating_topics.size,
+              average_dwell:    average_dwell
+            }
+          end
+
+          private
+
+          def prune_if_needed
+            return if @topics.size < MAX_TOPICS
+
+            least_engaged = @topics.values.min_by(&:dwell_level)
+            @topics.delete(least_engaged.id) if least_engaged
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_dwell/helpers/dwell_topic.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Legion
+  module Extensions
+    module CognitiveDwell
+      module Helpers
+        class DwellTopic
+          include Constants
+
+          attr_reader :id, :content, :topic_type, :salience, :novelty,
+                      :emotional_intensity, :complexity, :dwell_level,
+                      :engagement_count, :created_at
+
+          def initialize(content:, topic_type: :concept, salience: 0.5,
+                         novelty: 0.5, emotional_intensity: 0.3, complexity: 0.5)
+            @id                  = SecureRandom.uuid
+            @content             = content
+            @topic_type          = topic_type.to_sym
+            @salience            = salience.to_f.clamp(0.0, 1.0).round(10)
+            @novelty             = novelty.to_f.clamp(0.0, 1.0).round(10)
+            @emotional_intensity = emotional_intensity.to_f.clamp(0.0, 1.0).round(10)
+            @complexity          = complexity.to_f.clamp(0.0, 1.0).round(10)
+            @dwell_level         = compute_initial_dwell
+            @engagement_count    = 0
+            @created_at          = Time.now.utc
+          end
+
+          def engage!
+            @engagement_count += 1
+            @dwell_level = (@dwell_level + ENGAGEMENT_BOOST).clamp(0.0, 1.0).round(10)
+            self
+          end
+
+          def decay!
+            @dwell_level = (@dwell_level - DWELL_DECAY).clamp(0.0, 1.0).round(10)
+            @novelty = (@novelty - 0.02).clamp(0.0, 1.0).round(10)
+            self
+          end
+
+          def disengage!(force: 0.0)
+            reduction = (0.1 + force).clamp(0.0, 1.0)
+            @dwell_level = (@dwell_level - reduction).clamp(0.0, 1.0).round(10)
+            self
+          end
+
+          def sticky?
+            @dwell_level >= STICKY_THRESHOLD
+          end
+
+          def fleeting?
+            @dwell_level <= FLEETING_THRESHOLD
+          end
+
+          def ruminating?
+            @dwell_level >= RUMINATION_THRESHOLD
+          end
+
+          def disengagement_difficulty
+            ((@emotional_intensity * 0.4) + (@dwell_level * 0.4) + (@complexity * 0.2)).round(10)
+          end
+
+          def dwell_label
+            match = DWELL_LABELS.find { |range, _| range.cover?(@dwell_level) }
+            match ? match.last : :fleeting
+          end
+
+          def engagement_label
+            score = ((@dwell_level * 0.6) + (@salience * 0.4)).round(10)
+            match = ENGAGEMENT_LABELS.find { |range, _| range.cover?(score) }
+            match ? match.last : :disengaged
+          end
+
+          def disengage_label
+            match = DISENGAGE_LABELS.find { |range, _| range.cover?(disengagement_difficulty) }
+            match ? match.last : :effortless
+          end
+
+          def to_h
+            {
+              id:                       @id,
+              content:                  @content,
+              topic_type:               @topic_type,
+              salience:                 @salience,
+              novelty:                  @novelty,
+              emotional_intensity:      @emotional_intensity,
+              complexity:               @complexity,
+              dwell_level:              @dwell_level,
+              dwell_label:              dwell_label,
+              sticky:                   sticky?,
+              fleeting:                 fleeting?,
+              ruminating:               ruminating?,
+              disengagement_difficulty: disengagement_difficulty,
+              disengage_label:          disengage_label,
+              engagement_count:         @engagement_count,
+              engagement_label:         engagement_label,
+              created_at:               @created_at
+            }
+          end
+
+          private
+
+          def compute_initial_dwell
+            (BASE_DWELL +
+             (@salience * SALIENCE_WEIGHT) +
+             (@novelty * NOVELTY_WEIGHT) +
+             (@emotional_intensity * EMOTION_WEIGHT) +
+             (@complexity * COMPLEXITY_WEIGHT)).clamp(0.0, 1.0).round(10)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveDwell
+      module Runners
+        module CognitiveDwell
+          include Legion::Extensions::Helpers::Lex if defined?(Legion::Extensions::Helpers::Lex)
+
+          def add_topic(content:, topic_type: :concept, salience: 0.5,
+                        novelty: 0.5, emotional_intensity: 0.3, complexity: 0.5, engine: nil, **)
+            eng = engine || default_engine
+            topic = eng.add_topic(content: content, topic_type: topic_type, salience: salience,
+                                  novelty: novelty, emotional_intensity: emotional_intensity,
+                                  complexity: complexity)
+            { success: true, topic: topic.to_h }
+          end
+
+          def focus_on(topic_id:, engine: nil, **)
+            eng = engine || default_engine
+            topic = eng.focus_on(topic_id: topic_id)
+            return { success: false, error: 'topic not found' } unless topic
+
+            { success: true, topic: topic.to_h }
+          end
+
+          def disengage(topic_id:, force: 0.0, engine: nil, **)
+            eng = engine || default_engine
+            topic = eng.disengage(topic_id: topic_id, force: force)
+            return { success: false, error: 'topic not found' } unless topic
+
+            { success: true, topic: topic.to_h }
+          end
+
+          def decay(engine: nil, **)
+            eng = engine || default_engine
+            result = eng.decay_all!
+            { success: true, **result }
+          end
+
+          def current_topic(engine: nil, **)
+            eng = engine || default_engine
+            topic = eng.current_topic
+            return { success: false, error: 'no current topic' } unless topic
+
+            { success: true, topic: topic.to_h }
+          end
+
+          def sticky_topics(engine: nil, **)
+            eng = engine || default_engine
+            { success: true, topics: eng.sticky_topics.map(&:to_h) }
+          end
+
+          def ruminating_topics(engine: nil, **)
+            eng = engine || default_engine
+            { success: true, topics: eng.ruminating_topics.map(&:to_h) }
+          end
+
+          def most_engaging(limit: 5, engine: nil, **)
+            eng = engine || default_engine
+            { success: true, topics: eng.most_engaging(limit: limit).map(&:to_h) }
+          end
+
+          def dwell_report(engine: nil, **)
+            eng = engine || default_engine
+            { success: true, report: eng.dwell_report }
+          end
+
+          def status(engine: nil, **)
+            eng = engine || default_engine
+            { success: true, **eng.to_h }
+          end
+
+          private
+
+          def default_engine
+            @default_engine ||= Helpers::DwellEngine.new
+          end
+        end
+      end
+    end
+  end
+end

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

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

data/lib/legion/extensions/cognitive_dwell.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'cognitive_dwell/version'
+require_relative 'cognitive_dwell/helpers/constants'
+require_relative 'cognitive_dwell/helpers/dwell_topic'
+require_relative 'cognitive_dwell/helpers/dwell_engine'
+require_relative 'cognitive_dwell/runners/cognitive_dwell'
+require_relative 'cognitive_dwell/client'
+
+module Legion
+  module Extensions
+    module CognitiveDwell
+      extend Legion::Extensions::Core if defined?(Legion::Extensions::Core)
+    end
+  end
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: lex-cognitive-dwell
+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 how long the system lingers on topics based on salience, novelty,
+  emotional intensity, and complexity. Detects sticky topics and rumination.
+email:
+- matthewdiverson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/ci.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- CLAUDE.md
+- Gemfile
+- README.md
+- lex-cognitive-dwell.gemspec
+- lib/legion/extensions/cognitive_dwell.rb
+- lib/legion/extensions/cognitive_dwell/client.rb
+- lib/legion/extensions/cognitive_dwell/helpers/constants.rb
+- lib/legion/extensions/cognitive_dwell/helpers/dwell_engine.rb
+- lib/legion/extensions/cognitive_dwell/helpers/dwell_topic.rb
+- lib/legion/extensions/cognitive_dwell/runners/cognitive_dwell.rb
+- lib/legion/extensions/cognitive_dwell/version.rb
+homepage: https://github.com/LegionIO/lex-cognitive-dwell
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-cognitive-dwell
+  source_code_uri: https://github.com/LegionIO/lex-cognitive-dwell
+  documentation_uri: https://github.com/LegionIO/lex-cognitive-dwell/blob/master/README.md
+  changelog_uri: https://github.com/LegionIO/lex-cognitive-dwell/blob/master/CHANGELOG.md
+  bug_tracker_uri: https://github.com/LegionIO/lex-cognitive-dwell/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 dwell time modeling for LegionIO
+test_files: []