lex-synapse 0.2.2

data/lib/legion/extensions/synapse/runners/pain.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative '../helpers/confidence'
+require_relative '../data/models/synapse'
+require_relative '../data/models/synapse_signal'
+
+module Legion
+  module Extensions
+    module Synapse
+      module Runners
+        module Pain
+          CONSECUTIVE_FAILURE_THRESHOLD = 3
+
+          def handle_pain(synapse_id:, task_id: nil)
+            synapse = Data::Model::Synapse[synapse_id]
+            return { success: false, error: 'synapse not found' } unless synapse
+
+            # Record failed signal
+            Data::Model::SynapseSignal.create(
+              synapse_id:         synapse.id,
+              task_id:            task_id,
+              passed_attention:   true,
+              transform_success:  true,
+              downstream_outcome: 'failed'
+            )
+
+            # Adjust confidence
+            new_confidence = Helpers::Confidence.adjust(synapse.confidence, :failure)
+            synapse.update(confidence: new_confidence)
+
+            # Check consecutive failures
+            consecutive = count_consecutive_failures(synapse)
+
+            result = { success: true, confidence: new_confidence, consecutive_failures: consecutive }
+
+            # Auto-revert on 3+ consecutive failures
+            if consecutive >= CONSECUTIVE_FAILURE_THRESHOLD
+              result[:action] = :auto_revert
+              result[:reverted] = true
+            end
+
+            # Check if confidence dropped below autonomy threshold
+            new_mode = Helpers::Confidence.autonomy_mode(new_confidence)
+            result[:mode] = new_mode
+
+            # Dampen if failure rate is extreme
+            if should_dampen_from_pain?(synapse)
+              synapse.update(status: 'dampened')
+              result[:dampened] = true
+            end
+
+            result
+          end
+
+          private
+
+          def count_consecutive_failures(synapse)
+            recent = synapse.signals_dataset
+                            .order(Sequel.desc(:id))
+                            .limit(CONSECUTIVE_FAILURE_THRESHOLD)
+                            .all
+            recent.take_while { |s| s.downstream_outcome == 'failed' }.size
+          end
+
+          def should_dampen_from_pain?(synapse)
+            window_start = Time.now - 300
+            recent = synapse.signals_dataset
+                            .where(downstream_outcome: 'failed')
+                            .where { created_at >= window_start }
+                            .count
+            baseline_signals = [synapse.baseline_throughput * 5, 5].max
+            recent > (baseline_signals * 2)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/synapse/runners/promote.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative '../data/models/synapse'
+require_relative '../data/models/synapse_mutation'
+
+module Legion
+  module Extensions
+    module Synapse
+      module Runners
+        module Promote
+          CONFIDENCE_THRESHOLD = 0.9
+          STABILITY_HOURS = 24
+
+          def promote(synapse_id: nil, **)
+            candidates = if synapse_id
+                           s = Data::Model::Synapse[synapse_id]
+                           s ? [s] : []
+                         else
+                           find_promotable
+                         end
+
+            promoted = []
+            candidates.each do |synapse|
+              next unless promotable?(synapse)
+
+              entry = build_knowledge_entry(synapse)
+              promoted << entry
+            end
+
+            {
+              success:  true,
+              promoted: promoted,
+              count:    promoted.size
+            }
+          end
+
+          private
+
+          def find_promotable
+            Data::Model::Synapse
+              .where { confidence >= CONFIDENCE_THRESHOLD }
+              .where(status: 'active')
+              .all
+          end
+
+          def promotable?(synapse)
+            return false if synapse.confidence < CONFIDENCE_THRESHOLD
+            return false unless synapse.status == 'active'
+
+            recent_reverts = synapse.mutations_dataset
+                                    .where(outcome: 'reverted')
+                                    .where { created_at >= Time.now - (STABILITY_HOURS * 3600) }
+                                    .count
+            recent_reverts.zero?
+          end
+
+          def build_knowledge_entry(synapse)
+            {
+              content_type: 'synapse_pattern',
+              content:      Legion::JSON.dump(
+                source_function_id: synapse.source_function_id,
+                target_function_id: synapse.target_function_id,
+                attention:          synapse.attention,
+                transform:          synapse.transform,
+                routing_strategy:   synapse.routing_strategy,
+                confidence:         synapse.confidence,
+                origin:             synapse.origin,
+                version:            synapse.version
+              ),
+              tags:         ['synapse', "origin:#{synapse.origin}", "route:#{synapse.routing_strategy}"],
+              source_agent: 'lex-synapse',
+              synapse_id:   synapse.id
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/synapse/runners/report.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative '../data/models/synapse'
+require_relative '../data/models/synapse_mutation'
+require_relative '../data/models/synapse_signal'
+
+module Legion
+  module Extensions
+    module Synapse
+      module Runners
+        module Report
+          def report(synapse_id:)
+            synapse = Data::Model::Synapse[synapse_id]
+            return { success: false, error: 'synapse not found' } unless synapse
+
+            signals = synapse.signals_dataset
+            window_start = Time.now - 86_400
+            recent_signals = signals.where { created_at >= window_start }
+
+            total_recent = recent_signals.count
+            successful = recent_signals.where(downstream_outcome: 'success').count
+            success_rate = total_recent.positive? ? (successful.to_f / total_recent).round(4) : 0.0
+
+            last_mutation = synapse.mutations_dataset.order(Sequel.desc(:id)).first
+
+            {
+              success:       true,
+              synapse_id:    synapse.id,
+              confidence:    synapse.confidence,
+              status:        synapse.status,
+              origin:        synapse.origin,
+              version:       synapse.version,
+              signals_24h:   total_recent,
+              success_rate:  success_rate,
+              total_signals: signals.count,
+              last_mutation: if last_mutation
+                               {
+                                 type:    last_mutation.mutation_type,
+                                 trigger: last_mutation.trigger,
+                                 version: last_mutation.version,
+                                 outcome: last_mutation.outcome
+                               }
+                             end
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/synapse/runners/retrieve.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative '../data/models/synapse'
+require_relative '../helpers/confidence'
+
+module Legion
+  module Extensions
+    module Synapse
+      module Runners
+        module Retrieve
+          SEED_CONFIDENCE_THRESHOLD = 0.7
+
+          def retrieve_and_seed(knowledge_entries:, **)
+            seeded = []
+
+            knowledge_entries.each do |entry|
+              next unless entry[:confidence] && entry[:confidence] >= SEED_CONFIDENCE_THRESHOLD
+              next unless entry[:content_type] == 'synapse_pattern'
+
+              pattern = parse_pattern(entry)
+              next unless pattern
+              next if synapse_exists?(pattern[:source_function_id], pattern[:target_function_id])
+
+              synapse = Data::Model::Synapse.create(
+                source_function_id: pattern[:source_function_id],
+                target_function_id: pattern[:target_function_id],
+                attention:          pattern[:attention],
+                transform:          pattern[:transform],
+                routing_strategy:   pattern[:routing_strategy] || 'direct',
+                origin:             'seeded',
+                confidence:         Helpers::Confidence.starting_score(:seeded),
+                status:             'active'
+              )
+              seeded << { id: synapse.id, source: pattern[:source_function_id], target: pattern[:target_function_id] }
+            end
+
+            { success: true, seeded: seeded, count: seeded.size }
+          end
+
+          private
+
+          def parse_pattern(entry)
+            content = entry[:content]
+            return nil unless content
+
+            content.is_a?(String) ? Legion::JSON.load(content) : content
+          rescue StandardError
+            nil
+          end
+
+          def synapse_exists?(source_id, target_id)
+            Data::Model::Synapse.where(
+              source_function_id: source_id,
+              target_function_id: target_id
+            ).any?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/synapse/runners/revert.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative '../data/models/synapse'
+require_relative '../data/models/synapse_mutation'
+
+module Legion
+  module Extensions
+    module Synapse
+      module Runners
+        module Revert
+          def revert(synapse_id:, to_version: nil, trigger: 'pain')
+            synapse = Data::Model::Synapse[synapse_id]
+            return { success: false, error: 'synapse not found' } unless synapse
+
+            # to_version specifies which mutation record to look up (by version number).
+            # Reverting mutation at version N restores its before_state, landing at N-1.
+            mutation_version = to_version || synapse.version
+            return { success: false, error: 'no previous version' } if mutation_version < 2
+
+            mutation = Data::Model::SynapseMutation.where(
+              synapse_id: synapse.id,
+              version:    mutation_version
+            ).first
+
+            return { success: false, error: "mutation version #{mutation_version} not found" } unless mutation
+
+            restored_version = mutation_version - 1
+            before_state = Legion::JSON.load(mutation.before_state)
+            synapse.update(
+              attention:        before_state[:attention],
+              transform:        before_state[:transform],
+              routing_strategy: before_state[:routing_strategy],
+              confidence:       before_state[:confidence] || synapse.confidence,
+              status:           before_state[:status] || synapse.status,
+              version:          restored_version
+            )
+
+            # Mark the reverted mutation
+            mutation.update(outcome: 'reverted')
+
+            # Record the revert as a new mutation
+            Data::Model::SynapseMutation.create(
+              synapse_id:    synapse.id,
+              version:       restored_version,
+              mutation_type: 'confidence_changed',
+              before_state:  mutation.after_state,
+              after_state:   mutation.before_state,
+              trigger:       trigger,
+              outcome:       'reverted'
+            )
+
+            { success: true, reverted_to: restored_version, synapse_id: synapse.id }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/synapse/transport/exchanges/synapse.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Synapse
+      module Transport
+        module Exchanges
+          if defined?(Legion::Transport::Exchanges::Task)
+            class Synapse < Legion::Transport::Exchanges::Task
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/synapse/transport/messages/pain.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Synapse
+      module Transport
+        module Messages
+          if defined?(Legion::Transport::Message)
+            class Pain < Legion::Transport::Message
+              def routing_key
+                'synapse.pain'
+              end
+
+              def exchange
+                Legion::Transport::Exchanges::Task
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/synapse/transport/messages/signal.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Synapse
+      module Transport
+        module Messages
+          if defined?(Legion::Transport::Message)
+            class Signal < Legion::Transport::Message
+              def routing_key
+                'synapse.signal'
+              end
+
+              def exchange
+                Legion::Transport::Exchanges::Task
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/synapse/transport/queues/evaluate.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Synapse
+      module Transport
+        module Queues
+          if defined?(Legion::Transport::Queue)
+            class Evaluate < Legion::Transport::Queue
+              def queue_name
+                'synapse.evaluate'
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/synapse/transport/queues/pain.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Synapse
+      module Transport
+        module Queues
+          if defined?(Legion::Transport::Queue)
+            class Pain < Legion::Transport::Queue
+              def queue_name
+                'synapse.pain'
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/synapse/transport.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Synapse
+      module Transport
+        extend Legion::Extensions::Transport if defined?(Legion::Extensions::Transport)
+
+        def self.additional_e_to_q
+          [
+            { from: 'synapse', to: 'evaluate', routing_key: 'synapse.evaluate' },
+            { from: 'task', to: 'pain', routing_key: 'task.failed' }
+          ]
+        end
+      end
+    end
+  end
+end

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

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

data/lib/legion/extensions/synapse.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/synapse/version'
+require_relative 'synapse/client'
+
+module Legion
+  module Extensions
+    module Synapse
+      extend Legion::Extensions::Core if Legion::Extensions.const_defined? :Core
+
+      def self.data_required?
+        true
+      end
+
+      def data_required?
+        true
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: lex-synapse
+version: !ruby/object:Gem::Version
+  version: 0.2.2
+platform: ruby
+authors:
+- Esity
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: lex-conditioner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: lex-transformer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+description: Attention, transformation, and routing with confidence scoring, pain
+  signals, homeostasis, and self-governance
+email:
+- matthewdiverson@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/ci.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- CLAUDE.md
+- Gemfile
+- README.md
+- Rakefile
+- lex-synapse.gemspec
+- lib/legion/extensions/synapse.rb
+- lib/legion/extensions/synapse/actors/crystallize.rb
+- lib/legion/extensions/synapse/actors/decay.rb
+- lib/legion/extensions/synapse/actors/evaluate.rb
+- lib/legion/extensions/synapse/actors/homeostasis.rb
+- lib/legion/extensions/synapse/actors/pain.rb
+- lib/legion/extensions/synapse/client.rb
+- lib/legion/extensions/synapse/data/migrations/001_create_synapses.rb
+- lib/legion/extensions/synapse/data/migrations/002_create_synapse_mutations.rb
+- lib/legion/extensions/synapse/data/migrations/003_create_synapse_signals.rb
+- lib/legion/extensions/synapse/data/models/synapse.rb
+- lib/legion/extensions/synapse/data/models/synapse_mutation.rb
+- lib/legion/extensions/synapse/data/models/synapse_signal.rb
+- lib/legion/extensions/synapse/helpers/confidence.rb
+- lib/legion/extensions/synapse/helpers/homeostasis.rb
+- lib/legion/extensions/synapse/helpers/relationship_wrapper.rb
+- lib/legion/extensions/synapse/runners/crystallize.rb
+- lib/legion/extensions/synapse/runners/dream.rb
+- lib/legion/extensions/synapse/runners/evaluate.rb
+- lib/legion/extensions/synapse/runners/gaia_report.rb
+- lib/legion/extensions/synapse/runners/mutate.rb
+- lib/legion/extensions/synapse/runners/pain.rb
+- lib/legion/extensions/synapse/runners/promote.rb
+- lib/legion/extensions/synapse/runners/report.rb
+- lib/legion/extensions/synapse/runners/retrieve.rb
+- lib/legion/extensions/synapse/runners/revert.rb
+- lib/legion/extensions/synapse/transport.rb
+- lib/legion/extensions/synapse/transport/exchanges/synapse.rb
+- lib/legion/extensions/synapse/transport/messages/pain.rb
+- lib/legion/extensions/synapse/transport/messages/signal.rb
+- lib/legion/extensions/synapse/transport/queues/evaluate.rb
+- lib/legion/extensions/synapse/transport/queues/pain.rb
+- lib/legion/extensions/synapse/version.rb
+homepage: https://github.com/LegionIO/lex-synapse
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/LegionIO/lex-synapse
+  source_code_uri: https://github.com/LegionIO/lex-synapse
+  documentation_uri: https://github.com/LegionIO/lex-synapse
+  changelog_uri: https://github.com/LegionIO/lex-synapse/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/LegionIO/lex-synapse/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 routing layer for LegionIO task chains
+test_files: []