lex-synapse 0.2.2

data/lib/legion/extensions/synapse/data/migrations/002_create_synapse_mutations.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+Sequel.migration do
+  up do
+    create_table(:synapse_mutations) do
+      primary_key :id
+      foreign_key :synapse_id, :synapses, null: false, index: true
+      Integer  :version,       null: false
+      String   :mutation_type, null: false, size: 50
+      String   :before_state,  text: true
+      String   :after_state,   text: true
+      String   :trigger,       null: false, size: 50
+      String   :outcome,       size: 50
+      DateTime :created_at,    null: false, default: Sequel::CURRENT_TIMESTAMP
+    end
+  end
+
+  down do
+    drop_table :synapse_mutations
+  end
+end

data/lib/legion/extensions/synapse/data/migrations/003_create_synapse_signals.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+Sequel.migration do
+  up do
+    create_table(:synapse_signals) do
+      primary_key :id
+      foreign_key :synapse_id, :synapses, null: false, index: true
+      Integer    :task_id
+      TrueClass  :passed_attention,   default: false
+      TrueClass  :transform_success,  default: false
+      String     :downstream_outcome, size: 50
+      Integer    :latency_ms
+      DateTime   :created_at, null: false, default: Sequel::CURRENT_TIMESTAMP
+    end
+  end
+
+  down do
+    drop_table :synapse_signals
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Synapse
+      module Data
+        module Model
+          class Synapse < Sequel::Model(:synapses)
+            one_to_many :mutations, class: 'Legion::Extensions::Synapse::Data::Model::SynapseMutation'
+            one_to_many :signals,   class: 'Legion::Extensions::Synapse::Data::Model::SynapseSignal'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/synapse/data/models/synapse_mutation.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Synapse
+      module Data
+        module Model
+          class SynapseMutation < Sequel::Model(:synapse_mutations)
+            many_to_one :synapse, class: 'Legion::Extensions::Synapse::Data::Model::Synapse'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/synapse/data/models/synapse_signal.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Synapse
+      module Data
+        module Model
+          class SynapseSignal < Sequel::Model(:synapse_signals)
+            many_to_one :synapse, class: 'Legion::Extensions::Synapse::Data::Model::Synapse'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/synapse/helpers/confidence.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Synapse
+      module Helpers
+        module Confidence
+          VALID_STATUSES = %w[active observing dampened].freeze
+          EVALUABLE_STATUSES = %w[active observing].freeze
+          VALID_ORIGINS = %w[explicit emergent seeded].freeze
+          VALID_OUTCOMES = %w[success failed].freeze
+
+          STARTING_SCORES = { explicit: 0.7, emergent: 0.3, seeded: 0.5 }.freeze
+          ADJUSTMENTS = {
+            success:            0.02,
+            failure:            -0.05,
+            validation_failure: -0.03,
+            consecutive_bonus:  0.05
+          }.freeze
+          DECAY_RATE = 0.998
+          CONSECUTIVE_BONUS_THRESHOLD = 50
+
+          AUTONOMY_RANGES = {
+            observe:    0.0..0.3,
+            filter:     0.3..0.6,
+            transform:  0.6..0.8,
+            autonomous: 0.8..1.0
+          }.freeze
+
+          class << self
+            def starting_score(origin)
+              STARTING_SCORES.fetch(origin.to_sym, 0.5)
+            end
+
+            def adjust(confidence, event, consecutive_successes: 0)
+              delta = ADJUSTMENTS.fetch(event, 0)
+              result = confidence + delta
+              result += ADJUSTMENTS[:consecutive_bonus] if event == :success && consecutive_successes > CONSECUTIVE_BONUS_THRESHOLD
+              clamp(result)
+            end
+
+            def decay(confidence, hours: 1)
+              clamp(confidence * (DECAY_RATE**hours))
+            end
+
+            def autonomy_mode(confidence)
+              AUTONOMY_RANGES.each do |mode, range|
+                return mode if range.include?(confidence)
+              end
+              :observe
+            end
+
+            def can_filter?(confidence)
+              confidence >= 0.3
+            end
+
+            def can_transform?(confidence)
+              confidence >= 0.6
+            end
+
+            def can_self_modify?(confidence)
+              confidence >= 0.8
+            end
+
+            private
+
+            def clamp(value)
+              value.clamp(0.0, 1.0)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/synapse/helpers/homeostasis.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Synapse
+      module Helpers
+        module Homeostasis
+          SPIKE_MULTIPLIER = 3.0
+          SPIKE_DURATION_SECONDS = 60
+          DROUGHT_MULTIPLIER = 10.0
+
+          class << self
+            def spike?(current_throughput, baseline_throughput, duration_seconds: 0)
+              return false if baseline_throughput <= 0
+
+              current_throughput > (baseline_throughput * SPIKE_MULTIPLIER) &&
+                duration_seconds >= SPIKE_DURATION_SECONDS
+            end
+
+            def drought?(current_throughput, baseline_throughput, silent_seconds: 0)
+              return false if baseline_throughput <= 0
+
+              avg_interval = 60.0 / baseline_throughput
+              current_throughput.zero? && silent_seconds >= (avg_interval * DROUGHT_MULTIPLIER)
+            end
+
+            def update_baseline(current_baseline, new_sample, alpha: 0.1)
+              ((1 - alpha) * current_baseline) + (alpha * new_sample)
+            end
+
+            def should_dampen?(current_throughput, baseline_throughput, duration_seconds: 0)
+              spike?(current_throughput, baseline_throughput, duration_seconds: duration_seconds)
+            end
+
+            def should_flag_for_review?(current_throughput, baseline_throughput, silent_seconds: 0)
+              drought?(current_throughput, baseline_throughput, silent_seconds: silent_seconds)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/synapse/helpers/relationship_wrapper.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative '../data/models/synapse'
+require_relative 'confidence'
+
+module Legion
+  module Extensions
+    module Synapse
+      module Helpers
+        module RelationshipWrapper
+          class << self
+            def wrap(relationship)
+              existing = Data::Model::Synapse.where(relationship_id: relationship[:id]).first
+              return existing if existing
+
+              Data::Model::Synapse.create(
+                source_function_id: relationship[:trigger_function_id],
+                target_function_id: relationship[:function_id],
+                relationship_id:    relationship[:id],
+                attention:          relationship[:conditions],
+                transform:          relationship[:transformation],
+                routing_strategy:   'direct',
+                origin:             'explicit',
+                confidence:         Confidence.starting_score(:explicit),
+                status:             'active'
+              )
+            end
+
+            def unwrap(synapse_id)
+              synapse = Data::Model::Synapse[synapse_id]
+              return { success: false, error: 'synapse not found' } unless synapse
+              return { success: false, error: 'not a wrapped relationship' } unless synapse.relationship_id
+
+              synapse.destroy
+              { success: true, relationship_id: synapse.relationship_id }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative '../helpers/confidence'
+require_relative '../data/models/synapse'
+
+module Legion
+  module Extensions
+    module Synapse
+      module Runners
+        module Crystallize
+          EMERGENCE_THRESHOLD = 20
+
+          def crystallize(signal_pairs: [], threshold: EMERGENCE_THRESHOLD)
+            created = []
+
+            signal_pairs.each do |pair|
+              next if pair[:count] < threshold
+              next if synapse_exists?(pair[:source_function_id], pair[:target_function_id])
+
+              synapse = Data::Model::Synapse.create(
+                source_function_id: pair[:source_function_id],
+                target_function_id: pair[:target_function_id],
+                origin:             'emergent',
+                confidence:         Helpers::Confidence.starting_score(:emergent),
+                status:             'observing'
+              )
+              created << { id: synapse.id, source: pair[:source_function_id], target: pair[:target_function_id] }
+            end
+
+            { success: true, created: created, count: created.size }
+          end
+
+          private
+
+          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/dream.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require_relative '../data/models/synapse'
+require_relative '../data/models/synapse_mutation'
+require_relative '../helpers/confidence'
+
+module Legion
+  module Extensions
+    module Synapse
+      module Runners
+        module Dream
+          def dream_replay(synapse_id: nil, **)
+            synapses = if synapse_id
+                         s = Data::Model::Synapse[synapse_id]
+                         s ? [s] : []
+                       else
+                         Data::Model::Synapse.where { version > 1 }.all
+                       end
+
+            replays = synapses.map { |s| replay_mutations(s) }
+
+            {
+              success: true,
+              replays: replays,
+              count:   replays.size
+            }
+          end
+
+          def dream_simulate(synapse_id:, mutation_type:, changes:, **)
+            synapse = Data::Model::Synapse[synapse_id]
+            return { success: false, error: 'synapse not found' } unless synapse
+
+            before = snapshot_state(synapse)
+            simulated = apply_simulated_changes(before, mutation_type, changes)
+            simulated_confidence = Helpers::Confidence.adjust(
+              simulated[:confidence] || synapse.confidence,
+              :success
+            )
+            simulated_mode = Helpers::Confidence.autonomy_mode(simulated_confidence)
+
+            {
+              success:              true,
+              synapse_id:           synapse.id,
+              before:               before,
+              simulated:            simulated,
+              simulated_confidence: simulated_confidence,
+              simulated_mode:       simulated_mode,
+              recommendation:       simulated_confidence > synapse.confidence ? :apply : :skip
+            }
+          end
+
+          private
+
+          def replay_mutations(synapse)
+            mutations = synapse.mutations_dataset.order(:version).all
+            timeline = mutations.map do |m|
+              {
+                version:       m.version,
+                mutation_type: m.mutation_type,
+                trigger:       m.trigger,
+                outcome:       m.outcome,
+                created_at:    m.created_at
+              }
+            end
+
+            {
+              synapse_id:      synapse.id,
+              current_version: synapse.version,
+              origin:          synapse.origin,
+              confidence:      synapse.confidence,
+              mutation_count:  mutations.size,
+              timeline:        timeline,
+              reverts:         mutations.count { |m| m.outcome == 'reverted' },
+              net_trend:       synapse.confidence >= 0.5 ? :improving : :declining
+            }
+          end
+
+          def snapshot_state(synapse)
+            {
+              attention:        synapse.attention,
+              transform:        synapse.transform,
+              routing_strategy: synapse.routing_strategy,
+              confidence:       synapse.confidence,
+              status:           synapse.status
+            }
+          end
+
+          def apply_simulated_changes(state, mutation_type, changes)
+            simulated = state.dup
+            case mutation_type
+            when 'attention_adjusted'
+              simulated[:attention] = changes[:attention] if changes[:attention]
+            when 'transform_adjusted'
+              simulated[:transform] = changes[:transform] if changes[:transform]
+            when 'route_changed'
+              simulated[:routing_strategy] = changes[:routing_strategy] if changes[:routing_strategy]
+            when 'confidence_changed'
+              simulated[:confidence] = changes[:confidence] if changes[:confidence]
+            end
+            simulated
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+# 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 Evaluate
+          def evaluate(synapse_id:, payload: {}, conditioner_client: nil, transformer_client: nil)
+            synapse = Data::Model::Synapse[synapse_id]
+            return { success: false, error: 'synapse not found' } unless synapse
+            return { success: false, error: 'synapse not active' } unless Helpers::Confidence::EVALUABLE_STATUSES.include?(synapse.status)
+
+            mode = Helpers::Confidence.autonomy_mode(synapse.confidence)
+            start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+
+            # Step 1: Attention check
+            attention_result = check_attention(synapse, payload, mode, conditioner_client)
+
+            # Step 2: Transform (if attention passed and confidence allows)
+            transform_result = if attention_result[:passed] && Helpers::Confidence.can_transform?(synapse.confidence)
+                                 run_transform(synapse, payload, transformer_client)
+                               else
+                                 { success: attention_result[:passed], result: payload }
+                               end
+
+            elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond) - start_time
+
+            # Step 3: Record signal
+            record_signal(synapse, attention_result[:passed], transform_result[:success], elapsed)
+
+            # Step 4: Adjust confidence
+            event = transform_result[:success] ? :success : :failure
+            new_confidence = Helpers::Confidence.adjust(synapse.confidence, event)
+            synapse.update(confidence: new_confidence)
+
+            {
+              success:     transform_result[:success],
+              mode:        mode,
+              passed:      attention_result[:passed],
+              transformed: transform_result[:success],
+              result:      transform_result[:result],
+              latency_ms:  elapsed
+            }
+          end
+
+          private
+
+          def check_attention(synapse, payload, mode, conditioner_client)
+            return { passed: true } if synapse.attention.nil? || synapse.attention.empty?
+
+            passed = if conditioner_client
+                       result = conditioner_client.evaluate(conditions: Legion::JSON.load(synapse.attention), values: payload)
+                       result[:valid]
+                     else
+                       true
+                     end
+
+            # In OBSERVE mode, always pass through regardless of result
+            passed = true if mode == :observe
+
+            { passed: passed }
+          end
+
+          def run_transform(synapse, payload, transformer_client)
+            return { success: true, result: payload } if synapse.transform.nil? || synapse.transform.empty?
+            return { success: true, result: payload } unless transformer_client
+
+            transform_def = Legion::JSON.load(synapse.transform)
+            result = transformer_client.transform(
+              transformation: transform_def[:template] || transform_def[:transformation],
+              payload:        payload,
+              engine:         transform_def[:engine]&.to_sym,
+              schema:         transform_def[:schema]
+            )
+
+            if result[:success]
+              { success: true, result: result[:result] }
+            else
+              new_conf = Helpers::Confidence.adjust(synapse.confidence, :validation_failure)
+              synapse.update(confidence: new_conf)
+              { success: false, result: payload, error: result[:errors] }
+            end
+          end
+
+          def record_signal(synapse, passed_attention, transform_success, latency_ms)
+            Data::Model::SynapseSignal.create(
+              synapse_id:        synapse.id,
+              passed_attention:  passed_attention,
+              transform_success: transform_success,
+              latency_ms:        latency_ms.to_i
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative '../data/models/synapse'
+require_relative '../data/models/synapse_signal'
+require_relative '../helpers/confidence'
+
+module Legion
+  module Extensions
+    module Synapse
+      module Runners
+        module GaiaReport
+          def gaia_summary(**)
+            synapses = Data::Model::Synapse.all
+            active = synapses.select { |s| s.status == 'active' }
+            dampened = synapses.select { |s| s.status == 'dampened' }
+            observing = synapses.select { |s| s.status == 'observing' }
+
+            pain_threshold = 0.3
+            elevated_pain = active.select { |s| s.confidence < pain_threshold }
+
+            {
+              success:             true,
+              total_synapses:      synapses.size,
+              active_count:        active.size,
+              dampened_count:      dampened.size,
+              observing_count:     observing.size,
+              elevated_pain_count: elevated_pain.size,
+              avg_confidence:      avg_confidence(active),
+              emergent_candidates: observing.size,
+              health_score:        compute_health_score(active, dampened, elevated_pain)
+            }
+          end
+
+          def gaia_reflection(**)
+            summary = gaia_summary
+            recent_mutations = Data::Model::SynapseMutation
+                               .where { created_at >= Time.now - 3600 }
+                               .all
+
+            {
+              success:           true,
+              summary:           summary,
+              mutations_1h:      recent_mutations.size,
+              mutation_types:    recent_mutations.map(&:mutation_type).tally,
+              mutation_triggers: recent_mutations.map(&:trigger).tally
+            }
+          end
+
+          private
+
+          def avg_confidence(synapses)
+            return 0.0 if synapses.empty?
+
+            (synapses.sum(&:confidence) / synapses.size).round(4)
+          end
+
+          def compute_health_score(active, dampened, elevated_pain)
+            return 1.0 if active.empty? && dampened.empty?
+
+            total = active.size + dampened.size
+            healthy = active.size - elevated_pain.size
+            (healthy.to_f / total).round(4).clamp(0.0, 1.0)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative '../data/models/synapse'
+require_relative '../data/models/synapse_mutation'
+
+module Legion
+  module Extensions
+    module Synapse
+      module Runners
+        module Mutate
+          VALID_MUTATION_TYPES = %w[attention_adjusted transform_adjusted route_changed confidence_changed].freeze
+          VALID_TRIGGERS = %w[hebbian pain dream gaia manual].freeze
+
+          def mutate(synapse_id:, mutation_type:, changes:, trigger:)
+            synapse = Data::Model::Synapse[synapse_id]
+            return { success: false, error: 'synapse not found' } unless synapse
+            return { success: false, error: "invalid mutation_type: #{mutation_type}" } unless VALID_MUTATION_TYPES.include?(mutation_type)
+            return { success: false, error: "invalid trigger: #{trigger}" } unless VALID_TRIGGERS.include?(trigger)
+
+            before_state = snapshot(synapse)
+            apply_changes(synapse, mutation_type, changes)
+            after_state = snapshot(synapse)
+
+            new_version = synapse.version + 1
+            synapse.update(version: new_version)
+
+            Data::Model::SynapseMutation.create(
+              synapse_id:    synapse.id,
+              version:       new_version,
+              mutation_type: mutation_type,
+              before_state:  Legion::JSON.dump(before_state),
+              after_state:   Legion::JSON.dump(after_state),
+              trigger:       trigger
+            )
+
+            { success: true, version: new_version, synapse_id: synapse.id }
+          end
+
+          private
+
+          def snapshot(synapse)
+            {
+              attention:        synapse.attention,
+              transform:        synapse.transform,
+              routing_strategy: synapse.routing_strategy,
+              confidence:       synapse.confidence,
+              status:           synapse.status
+            }
+          end
+
+          def apply_changes(synapse, mutation_type, changes)
+            case mutation_type
+            when 'attention_adjusted'
+              synapse.update(attention: changes[:attention]) if changes[:attention]
+            when 'transform_adjusted'
+              synapse.update(transform: changes[:transform]) if changes[:transform]
+            when 'route_changed'
+              synapse.update(routing_strategy: changes[:routing_strategy]) if changes[:routing_strategy]
+            when 'confidence_changed'
+              synapse.update(confidence: changes[:confidence]) if changes[:confidence]
+            end
+          end
+        end
+      end
+    end
+  end
+end