lex-cognitive-zeitgeist 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 226b7e1ceb0957c06b2834e644e4a7b96eaa2cfffdf010f8db4fd9bf78426e5e
+  data.tar.gz: e422848c93bf5e2c4b9a0d878503161652640574e852a8b4f4989e03d1ea6118
+SHA512:
+  metadata.gz: 1f5188ea227b211c1ada23e059e65795b068b3e6bc7bec7a8eaee2c0b5eca369fdf8bbf5cf5fd3932d4ef6e47a633edf73c411d3235cfef432b964e213708094
+  data.tar.gz: 64b0a0699ad11414fb1a07fd1a1397969148a4d6daf677783a25dd3665934dd0a96dad9b095b092f93d9e3e92891b29172226e9fde7f07cd7a1626859f0d206a

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 @@
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,44 @@
+AllCops:
+  TargetRubyVersion: 3.4
+  NewCops: enable
+  SuggestExtensions: false
+
+Layout/LineLength:
+  Max: 160
+
+Layout/SpaceAroundEqualsInParameterDefault:
+  EnforcedStyle: space
+
+Layout/HashAlignment:
+  EnforcedHashRocketStyle: table
+  EnforcedColonStyle: table
+
+Metrics/ParameterLists:
+  Max: 8
+  MaxOptionalParameters: 8
+
+Metrics/MethodLength:
+  Max: 25
+
+Metrics/ClassLength:
+  Max: 150
+
+Metrics/AbcSize:
+  Max: 25
+
+Metrics/BlockLength:
+  Exclude:
+    - 'spec/**/*'
+
+Style/Documentation:
+  Enabled: false
+
+Style/OneClassPerFile:
+  Exclude:
+    - 'spec/spec_helper.rb'
+
+Naming/PredicateMethod:
+  Enabled: false
+
+Naming/PredicatePrefix:
+  Enabled: false

data/CLAUDE.md

@@ -0,0 +1,124 @@
+# lex-cognitive-zeitgeist
+
+**Level 3 Leaf Documentation**
+- **Parent**: `/Users/miverso2/rubymine/legion/extensions-agentic/CLAUDE.md`
+- **Gem**: `lex-cognitive-zeitgeist`
+- **Version**: 0.1.0
+- **Namespace**: `Legion::Extensions::CognitiveZeitgeist`
+
+## Purpose
+
+Captures the aggregate "spirit of the moment" across cognitive subsystems by ingesting signals from multiple sources and computing collective mood, convergence, and momentum. Named after the German concept of the "spirit of the age" — the pervasive cognitive atmosphere emerging from all active subsystem signals rather than any individual source. Surfaces dominant themes, rising/falling domain trends, and alerts when subsystems diverge.
+
+## Gem Info
+
+- **Gemspec**: `lex-cognitive-zeitgeist.gemspec`
+- **Require**: `lex-cognitive-zeitgeist`
+- **Ruby**: >= 3.4
+- **License**: MIT
+- **Homepage**: https://github.com/LegionIO/lex-cognitive-zeitgeist
+
+## File Structure
+
+```
+lib/legion/extensions/cognitive_zeitgeist/
+  version.rb
+  helpers/
+    constants.rb          # Signal domains, label tables for mood/convergence/momentum
+    cognitive_signal.rb   # CognitiveSignal class — one subsystem signal
+    trend_window.rb       # TrendWindow — sliding window over recent signals
+    zeitgeist_engine.rb   # ZeitgeistEngine — registry, analytics
+    client.rb             # Client lives at helpers/client.rb (unusual location)
+  runners/
+    cognitive_zeitgeist.rb  # Runner module — public API
+```
+
+Note: `client.rb` is at `helpers/client.rb`, not the standard `lib/legion/extensions/cognitive_zeitgeist/client.rb`.
+
+## Key Constants
+
+| Constant | Value | Meaning |
+|---|---|---|
+| `MAX_SIGNALS` | 1000 | Ring buffer for all ingested signals |
+| `WINDOW_SIZE` | 100 | Sliding window size for `TrendWindow` |
+| `DEFAULT_INTENSITY` | 0.5 | Default signal intensity |
+| `MOMENTUM_THRESHOLD` | 0.3 | Absolute momentum threshold for `accelerating?` / `decelerating?` |
+| `CONVERGENCE_THRESHOLD` | 0.7 | `convergence_alert?` if above this (not used — see `DIVERGENCE_THRESHOLD`) |
+| `DIVERGENCE_THRESHOLD` | 0.3 | `divergence_alert?` if cognitive_convergence < this |
+
+`SIGNAL_DOMAINS`: `[:threat, :opportunity, :curiosity, :anxiety, :creativity, :routine, :social, :abstract]`
+
+Mood labels (applied to normalized valence, -1..1 mapped to 0..1): `0.8+` = `:euphoric`, `0.6..0.8` = `:elevated`, `0.4..0.6` = `:neutral`, `0.2..0.4` = `:subdued`, `< 0.2` = `:suppressed`
+
+Convergence labels: `0.8+` = `:unified`, `0.6..0.8` = `:aligned`, `0.4..0.6` = `:mixed`, `0.2..0.4` = `:fragmented`, `< 0.2` = `:divergent`
+
+Momentum labels (can be negative): `0.6+` = `:surging`, `0.3..0.6` = `:building`, `0.0..0.3` = `:steady`, `-0.3..0.0` = `:fading`, `< -0.3` = `:collapsing`
+
+`Constants.label_for(labels_hash, value)` — iterates hash by range cover; returns nil if no match.
+
+## Key Classes
+
+### `Helpers::CognitiveSignal`
+
+One signal from a cognitive subsystem.
+
+- Fields: `id` (UUID), `source_subsystem` (symbol), `domain` (symbol), `intensity` (0.0–1.0), `valence` (-1.0–1.0), `timestamp`
+- `valence` is bidirectional (-1.0 negative through +1.0 positive) — unlike most other extensions which use unsigned intensity
+
+### `Helpers::TrendWindow`
+
+Sliding window (default 100 signals) for local trend analysis.
+
+- `add(signal)` — appends and shifts oldest when over `window_size`; returns `self`
+- `dominant_domain` — domain with highest total intensity weight across window signals
+- `dominant_valence` — intensity-weighted mean valence across window
+- `momentum` — delta between second-half avg intensity and first-half avg intensity; positive = accelerating
+- `accelerating?` — momentum > 0.3; `decelerating?` — momentum < -0.3
+
+### `Helpers::ZeitgeistEngine`
+
+Central registry and analytics engine.
+
+- `ingest(source_subsystem:, domain:, intensity:, valence:, timestamp:)` — creates `CognitiveSignal`, appends to `@signals` (ring buffer), adds to `@trend_window`
+- `dominant_themes(limit:)` — domains ranked by total intensity weight; returns `[{ domain:, weight: }]`
+- `collective_mood` — intensity-weighted mean valence across all signals; returns -1.0..1.0
+- `cognitive_convergence` — ratio of subsystems whose dominant domain matches the overall dominant domain; returns 1.0 if <= 1 subsystem; returns 0.5 if no overall dominant found
+- `rising_domains(window_size:)` / `falling_domains(window_size:)` — compare recent half to earlier half of signals; return `[{ domain:, delta: }]` sorted by magnitude
+- `divergence_alert?` — `cognitive_convergence < DIVERGENCE_THRESHOLD` (0.3)
+- `zeitgeist_report` — full report: signal_count, dominant_themes, collective_mood, mood_label, convergence, convergence_label, momentum, momentum_label, rising_domains, falling_domains, divergence_alert, trend_window
+
+Mood normalization: `normalize_mood(mood_value) = (mood + 1.0) / 2.0` — maps -1..1 to 0..1 before label lookup.
+
+## Runners
+
+Module: `Legion::Extensions::CognitiveZeitgeist::Runners::CognitiveZeitgeist`
+
+| Runner | Key Args | Returns |
+|---|---|---|
+| `ingest_signal` | `source_subsystem:`, `domain:`, `intensity:`, `valence:` | `{ success:, signal: }` |
+| `zeitgeist_report` | — | full report merged with `success: true` |
+| `collective_mood` | — | `{ success:, mood:, mood_label: }` |
+| `cognitive_convergence` | — | `{ success:, convergence:, convergence_label:, divergence_alert: }` |
+| `dominant_themes` | `limit:` | `{ success:, themes:, count: }` |
+| `rising_domains` | — | `{ success:, domains:, count: }` |
+| `falling_domains` | — | `{ success:, domains:, count: }` |
+| `trend_window_status` | — | `{ success:, trend_window:, momentum_label: }` |
+
+All runners accept optional `engine:` keyword for test injection.
+
+## Integration Points
+
+- `ingest_signal` should be called by `lex-tick` phase handlers after each phase completes, passing the originating subsystem and domain
+- `divergence_alert?` can trigger conflict escalation in `lex-conflict` when subsystems are pulling in incompatible directions
+- `collective_mood` provides a cross-subsystem mood aggregate that `lex-emotion` can use to modulate valence
+- `dominant_themes` reveals what domains are consuming the most cognitive bandwidth
+- All state is in-memory per `ZeitgeistEngine` instance
+
+## Development Notes
+
+- `client.rb` is at `helpers/client.rb` — an unusual location for this gem; not at the standard top-level path
+- Valence is signed (-1.0 to 1.0) in this extension; mood label lookup requires normalizing to 0..1 via `(mood + 1.0) / 2.0`
+- `cognitive_convergence` returns 1.0 when only one subsystem has ingested signals (no divergence possible) and 0.5 when no overall dominant domain can be determined
+- `rising_domains` requires `signals.size >= window_size` (default 50) — returns empty array if insufficient history
+- Momentum labels cover negative values (`:fading`, `:collapsing`) — unique among the label tables in this extension category
+- `CONVERGENCE_THRESHOLD` (0.7) is defined but not used; only `DIVERGENCE_THRESHOLD` (0.3) drives alert logic

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-zeitgeist (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-zeitgeist!
+  rspec (~> 3.13)
+  rubocop (~> 1.75)
+  rubocop-rspec
+
+BUNDLED WITH
+   2.6.9

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Esity
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,64 @@
+# lex-cognitive-zeitgeist
+
+A LegionIO cognitive architecture extension that captures the aggregate cognitive atmosphere across subsystems. Named after the German "spirit of the age" — surfaces dominant themes, collective mood, convergence, and momentum from the stream of signals flowing through the cognitive system.
+
+## What It Does
+
+Ingests **cognitive signals** from multiple subsystems and computes cross-cutting metrics:
+
+- **Collective mood**: intensity-weighted mean valence across all signals (-1.0 to +1.0)
+- **Cognitive convergence**: ratio of subsystems focused on the same dominant domain; low convergence triggers a divergence alert
+- **Momentum**: whether signal intensity is accelerating or fading in the recent window
+- **Dominant themes**: domains with highest total intensity weight
+- **Rising/falling domains**: comparing recent activity to historical baseline
+
+## Usage
+
+```ruby
+require 'lex-cognitive-zeitgeist'
+
+client = Legion::Extensions::CognitiveZeitgeist::Client.new
+
+# Ingest signals from different subsystems
+client.ingest_signal(source_subsystem: :emotion, domain: :anxiety, intensity: 0.7, valence: -0.6)
+client.ingest_signal(source_subsystem: :prediction, domain: :threat, intensity: 0.8, valence: -0.4)
+client.ingest_signal(source_subsystem: :memory, domain: :curiosity, intensity: 0.5, valence: 0.3)
+
+# Get collective mood
+client.collective_mood
+# => { success: true, mood: -0.4, mood_label: :subdued }
+
+# Check whether subsystems are aligned
+client.cognitive_convergence
+# => { success: true, convergence: 0.67, convergence_label: :aligned, divergence_alert: false }
+
+# Dominant themes (by intensity weight)
+client.dominant_themes(limit: 3)
+# => { success: true, themes: [{ domain: :threat, weight: 0.8 }, ...], count: 3 }
+
+# Rising and falling domains
+client.rising_domains
+# => { success: true, domains: [{ domain: :threat, delta: 0.3 }], count: 1 }
+
+# Trend window status
+client.trend_window_status
+# => { success: true, trend_window: { size: 3, dominant_domain: :threat, momentum: 0.1, ... }, momentum_label: :steady }
+
+# Full zeitgeist report
+client.zeitgeist_report
+# => { success: true, signal_count: 3, dominant_themes: [...], collective_mood: -0.4,
+#      mood_label: :subdued, convergence: 0.67, convergence_label: :aligned,
+#      momentum: 0.1, momentum_label: :steady, divergence_alert: false, ... }
+```
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec
+bundle exec rubocop
+```
+
+## License
+
+MIT

data/lex-cognitive-zeitgeist.gemspec

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'lib/legion/extensions/cognitive_zeitgeist/version'
+
+Gem::Specification.new do |spec|
+  spec.name    = 'lex-cognitive-zeitgeist'
+  spec.version = Legion::Extensions::CognitiveZeitgeist::VERSION
+  spec.authors = ['Esity']
+  spec.email   = ['matthewdiverson@gmail.com']
+
+  spec.summary     = 'Collective cognitive zeitgeist detection for LegionIO agents'
+  spec.description = 'Detects the overall mood and trending concerns across all cognitive subsystems. ' \
+                     'Captures what the agent mind is collectively focused on via signal ingestion, ' \
+                     'trend windows, convergence scoring, and divergence alerts.'
+  spec.homepage    = 'https://github.com/LegionIO/lex-cognitive-zeitgeist'
+  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-zeitgeist'
+  spec.metadata['documentation_uri']     = 'https://github.com/LegionIO/lex-cognitive-zeitgeist'
+  spec.metadata['changelog_uri']         = 'https://github.com/LegionIO/lex-cognitive-zeitgeist/blob/master/CHANGELOG.md'
+  spec.metadata['bug_tracker_uri']       = 'https://github.com/LegionIO/lex-cognitive-zeitgeist/issues'
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  spec.files = IO.popen(%w[git ls-files -z], chdir: __dir__, err: IO::NULL) do |ls|
+    ls.readlines("\x0", chomp: true)
+  end
+
+  spec.require_paths = ['lib']
+  spec.add_development_dependency 'legion-gaia'
+end

data/lib/legion/extensions/cognitive_zeitgeist/helpers/client.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveZeitgeist
+      module Helpers
+        class Client
+          include Runners::CognitiveZeitgeist
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_zeitgeist/helpers/cognitive_signal.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveZeitgeist
+      module Helpers
+        class CognitiveSignal
+          attr_reader :id, :source_subsystem, :domain, :intensity, :valence, :timestamp
+
+          def initialize(source_subsystem:, domain:, intensity: Constants::DEFAULT_INTENSITY,
+                         valence: 0.0, timestamp: nil)
+            @id               = SecureRandom.uuid
+            @source_subsystem = source_subsystem.to_sym
+            @domain           = domain.to_sym
+            @intensity        = intensity.to_f.clamp(0.0, 1.0)
+            @valence          = valence.to_f.clamp(-1.0, 1.0)
+            @timestamp        = timestamp || Time.now.utc
+          end
+
+          def to_h
+            {
+              id:               @id,
+              source_subsystem: @source_subsystem,
+              domain:           @domain,
+              intensity:        @intensity.round(10),
+              valence:          @valence.round(10),
+              timestamp:        @timestamp.iso8601
+            }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveZeitgeist
+      module Helpers
+        module Constants
+          MAX_SIGNALS          = 1000
+          WINDOW_SIZE          = 100
+          DEFAULT_INTENSITY    = 0.5
+          MOMENTUM_THRESHOLD   = 0.3
+          CONVERGENCE_THRESHOLD = 0.7
+          DIVERGENCE_THRESHOLD = 0.3
+
+          SIGNAL_DOMAINS = %i[
+            threat
+            opportunity
+            curiosity
+            anxiety
+            creativity
+            routine
+            social
+            abstract
+          ].freeze
+
+          MOOD_LABELS = {
+            (0.8..)     => :euphoric,
+            (0.6...0.8) => :elevated,
+            (0.4...0.6) => :neutral,
+            (0.2...0.4) => :subdued,
+            (..0.2)     => :suppressed
+          }.freeze
+
+          CONVERGENCE_LABELS = {
+            (0.8..)     => :unified,
+            (0.6...0.8) => :aligned,
+            (0.4...0.6) => :mixed,
+            (0.2...0.4) => :fragmented,
+            (..0.2)     => :divergent
+          }.freeze
+
+          MOMENTUM_LABELS = {
+            (0.6..)      => :surging,
+            (0.3...0.6)  => :building,
+            (0.0...0.3)  => :steady,
+            (-0.3...0.0) => :fading,
+            (..-0.3)     => :collapsing
+          }.freeze
+
+          def self.label_for(labels_hash, value)
+            labels_hash.each do |range, label|
+              return label if range.cover?(value)
+            end
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/cognitive_zeitgeist/helpers/trend_window.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module CognitiveZeitgeist
+      module Helpers
+        class TrendWindow
+          include Constants
+
+          attr_reader :signals, :window_size
+
+          def initialize(window_size: WINDOW_SIZE)
+            @signals     = []
+            @window_size = window_size
+          end
+
+          def add(signal)
+            @signals << signal
+            @signals.shift while @signals.size > @window_size
+            self
+          end
+
+          def dominant_domain
+            return nil if @signals.empty?
+
+            counts = Hash.new(0.0)
+            @signals.each { |s| counts[s.domain] += s.intensity }
+            counts.max_by { |_d, weight| weight }&.first
+          end
+
+          def dominant_valence
+            return 0.0 if @signals.empty?
+
+            weighted_sum = @signals.sum { |s| s.valence * s.intensity }
+            total_intensity = @signals.sum(&:intensity)
+            return 0.0 if total_intensity.zero?
+
+            (weighted_sum / total_intensity).clamp(-1.0, 1.0).round(10)
+          end
+
+          def momentum
+            return 0.0 if @signals.size < 2
+
+            half = @signals.size / 2
+            first_half  = @signals.first(half)
+            second_half = @signals.last(half)
+
+            avg_intensity = ->(arr) { arr.sum(&:intensity) / arr.size.to_f }
+            delta = avg_intensity.call(second_half) - avg_intensity.call(first_half)
+            delta.clamp(-1.0, 1.0).round(10)
+          end
+
+          def accelerating?
+            momentum > MOMENTUM_THRESHOLD
+          end
+
+          def decelerating?
+            momentum < -MOMENTUM_THRESHOLD
+          end
+
+          def to_h
+            {
+              size:             @signals.size,
+              window_size:      @window_size,
+              dominant_domain:  dominant_domain,
+              dominant_valence: dominant_valence,
+              momentum:         momentum,
+              accelerating:     accelerating?,
+              decelerating:     decelerating?
+            }
+          end
+        end
+      end
+    end
+  end
+end