lex-synapse 0.4.13 → 0.4.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 140dd32d856f6a661d423c72a6f7fcc2424a789342e72d656c25302903d7eda9
-  data.tar.gz: 89651542649d74fc871576b608172a4d941cb6b25322a073a54a947458eb369e
+  metadata.gz: '037082609e6545e0a3581981a602d49afdd4a532cf4b15d166f0cf04fd3a746f'
+  data.tar.gz: 42c81c769ef9f4367dec25d4713d5ab4bc4eb1491b88478bb365d5cbd3e2521e
 SHA512:
-  metadata.gz: c852c9b3dad49309789b63563244983b075a5d13711efd46d3c83118bd0ec49058d7b7a1a9e4279ea0a9445ec3c3184845701b3389e70676960f3fad7fb74f5a
-  data.tar.gz: bd6602b930def1ccac2ef61933c659844f959bd219d06267c696143f04802058eda62ccebaa988a45707424b73fd4c2ccdace4207809dabe173c5e61150e11ad
+  metadata.gz: a5f60904a36dcf8fb276c75683485a7c4ef8207b9b1f1b6c03cae33bd392fa85d4fc44beb605aeae62f492be50be546b90b209021361d1105c9adc43306bfe21
+  data.tar.gz: '059f003e2a808fe705e315b8c7c75c01631ac97ff86c2f675467dd563f37106ea039fc4aaddf32ad89315d4290226e0308d209c0e3df8ebd89644584ab315de9'

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [0.4.15] - 2026-10-29
+### Fixed
+- Treat missing configured conditioner/transformer capabilities as unavailable rather than successful learning; retain legitimate observe/filter pass-through.
+- Attribute reactive proposals to the signal created by that evaluation and report actual transformation execution.
+- Restore standalone pain-triggered reversion, ignore pending evaluations in completed-outcome failure streaks, and return restored confidence.
+- Make mutation/revert writes transactional and keep history versions unambiguous across repeated reversion, retaining actual before/after snapshots.
+
+## [0.4.14] - 2026-06-01
+### Fixed
+- Homeostasis actor: convert raw signal counts to signals/minute for correct spike/drought comparison; batch all updates in a single DB transaction
+- Evaluate runner: prevent double confidence adjustment when validation fails (`run_transform` already adjusts)
+- Revert mutation: use unique version (`synapse.version + 1`) instead of `restored_version` to avoid version collision
+
 ## [0.4.13] - 2026-05-07
 ### Fixed
 - `Homeostasis` actor: replace per-synapse `signals_dataset.count` with a single batched `GROUP BY` query to eliminate N+1 pool contention that caused `Sequel::PoolTimeout` on Postgres

data/lib/legion/extensions/synapse/actors/blast_radius.rb

@@ -31,7 +31,7 @@ module Legion
             false
           end
 
-          def action(**_opts)
+          def action(**)
             compute
           end
         end

data/lib/legion/extensions/synapse/actors/decay.rb

@@ -11,7 +11,7 @@ module Legion
           def check_subtask? = false
           def generate_task? = false
 
-          def action(**_opts)
+          def action(**)
             return { status: :skipped, reason: :no_data } unless defined?(Legion::Data)
 
             Data::Model.define_synapse_model

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

@@ -11,42 +11,56 @@ module Legion
           def check_subtask? = false
           def generate_task? = false
 
-          def action(**_opts)
+          def action(**)
             return { status: :skipped, reason: :no_data } unless defined?(Legion::Data)
 
             results = { spikes: 0, droughts: 0, updated: 0 }
             return results unless defined?(Legion::Extensions::Synapse::Data::Model::Synapse)
 
             cutoff = Time.now - 60
+            window_seconds = 60.0
+            signal_model = Legion::Extensions::Synapse::Data::Model::SynapseSignal
+            synapse_model = Legion::Extensions::Synapse::Data::Model::Synapse
 
-            active_synapses = Legion::Extensions::Synapse::Data::Model::Synapse
-                              .where(status: 'active')
-                              .where { baseline_throughput > 0 } # rubocop:disable Style/NumericPredicate
-                              .all
+            # Single query: count signals per synapse in the last 60s window
+            signal_counts = signal_model.where { created_at > cutoff }
+                                        .group_and_count(:synapse_id)
+                                        .as_hash(:synapse_id, :count)
 
+            # Fetch only active synapses with a nonzero baseline — eager-load to avoid N+1
+            active_synapses = synapse_model.where(status: 'active')
+                                           .where { baseline_throughput > 0 } # rubocop:disable Style/NumericPredicate
+                                           .all
             return results if active_synapses.empty?
 
-            signal_counts = Legion::Extensions::Synapse::Data::Model::SynapseSignal
-                            .where(synapse_id: active_synapses.map(&:id))
-                            .where { created_at > cutoff }
-                            .group_and_count(:synapse_id)
-                            .as_hash(:synapse_id, :count)
+            # Collect updates in memory, then apply in a single batch to avoid connection churn
+            updates = []
 
             active_synapses.each do |synapse|
               baseline = synapse.baseline_throughput
-              current  = signal_counts.fetch(synapse.id, 0).to_f
+              # Convert raw count in the window to signals/minute for apples-to-apples comparison
+              current  = (signal_counts.fetch(synapse.id, 0).to_f / window_seconds) * 60.0
 
-              if Helpers::Homeostasis.spike?(current, baseline, duration_seconds: 60)
+              if Helpers::Homeostasis.spike?(current, baseline, duration_seconds: window_seconds)
                 results[:spikes] += 1
-              elsif Helpers::Homeostasis.drought?(current, baseline, silent_seconds: 60)
+              elsif Helpers::Homeostasis.drought?(current, baseline, silent_seconds: window_seconds)
                 results[:droughts] += 1
               end
 
               new_baseline = Helpers::Homeostasis.update_baseline(baseline, current)
-              synapse.update(baseline_throughput: new_baseline)
+              updates << { synapse_id: synapse.id, baseline_throughput: new_baseline }
               results[:updated] += 1
             end
 
+            # Batch-update all baselines in a single transaction
+            unless updates.empty?
+              synapse_model.db.transaction do
+                updates.each do |u|
+                  synapse_model.where(id: u[:synapse_id]).update(baseline_throughput: u[:baseline_throughput])
+                end
+              end
+            end
+
             results
           end
         end

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

@@ -20,7 +20,7 @@ module Legion
             TIER_CRITICAL => 3.0
           }.freeze
 
-          def compute(**_opts)
+          def compute(**)
             Data::Model.define_synapse_model
             return { success: false, error: 'data unavailable' } unless data_available?
 

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

@@ -27,6 +27,14 @@ module Legion
 
             # Step 1: Attention check
             attention_result = check_attention(synapse, payload, mode, conditioner_client)
+            # Unavailable execution is not evidence for confidence or proposal learning.
+            if attention_result[:unavailable]
+              return {
+                success: mode == :observe, mode: mode, passed: attention_result[:passed],
+                transformed: false, result: payload, error: attention_result[:error],
+                latency_ms: ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :millisecond) - start_time
+              }
+            end
 
             # Step 2: Transform (if attention passed and confidence allows)
             transform_result = if attention_result[:passed] && Helpers::Confidence.can_transform?(synapse.confidence)
@@ -36,18 +44,26 @@ module Legion
                                end
 
             elapsed = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :millisecond) - start_time
+            if transform_result[:unavailable]
+              return {
+                success: false, mode: mode, passed: attention_result[:passed],
+                transformed: false, result: payload, error: transform_result[:error], latency_ms: elapsed
+              }
+            end
 
             # 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)
+            signal_record = record_signal(synapse, attention_result[:passed], transform_result[:success], elapsed)
+
+            # Step 4: Adjust confidence (skip if run_transform already penalized for validation failure)
+            new_confidence = synapse.confidence
+            unless transform_result[:validation_failure]
+              event = transform_result[:success] ? :success : :failure
+              new_confidence = Helpers::Confidence.adjust(synapse.confidence, event)
+              synapse.update(confidence: new_confidence)
+            end
 
             # Step 5: Generate proposals if autonomous
             if Helpers::Confidence.can_self_modify?(new_confidence) && Helpers::Proposals.reactive?
-              signal_record = Data::Model::SynapseSignal.where(synapse_id: synapse.id).order(Sequel.desc(:id)).first
               propose_reactive(
                 synapse: synapse, payload: payload, signal_id: signal_record&.id,
                 attention_result: attention_result, transform_result: transform_result,
@@ -59,7 +75,7 @@ module Legion
               success:     transform_result[:success],
               mode:        mode,
               passed:      attention_result[:passed],
-              transformed: transform_result[:success],
+              transformed: transform_result[:transformed] == true,
               result:      transform_result[:result],
               latency_ms:  elapsed
             }
@@ -69,13 +85,10 @@ module Legion
 
           def check_attention(synapse, payload, mode, conditioner_client)
             return { passed: true } if synapse.attention.nil? || synapse.attention.empty?
+            return { passed: mode == :observe, unavailable: true, error: 'conditioner unavailable' } unless conditioner_client.respond_to?(:evaluate)
 
-            passed = if conditioner_client
-                       result = conditioner_client.evaluate(conditions: Legion::JSON.load(synapse.attention), values: payload)
-                       result[:valid]
-                     else
-                       true
-                     end
+            result = conditioner_client.evaluate(conditions: Legion::JSON.load(synapse.attention), values: payload)
+            passed = result[:valid]
 
             # In OBSERVE mode, always pass through regardless of result
             passed = true if mode == :observe
@@ -85,7 +98,7 @@ module Legion
 
           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
+            return { success: false, result: payload, unavailable: true, error: 'transformer unavailable' } unless transformer_client.respond_to?(:transform)
 
             transform_def = Legion::JSON.load(synapse.transform)
             result = transformer_client.transform(
@@ -96,11 +109,11 @@ module Legion
             )
 
             if result[:success]
-              { success: true, result: result[:result] }
+              { success: true, transformed: 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] }
+              { success: false, result: payload, error: result[:errors], validation_failure: true }
             end
           end
 

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

@@ -19,23 +19,25 @@ module Legion
             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)
+            synapse.db.transaction do
+              synapse.lock!
+              before_state = snapshot(synapse)
+              new_version = [synapse.version, synapse.mutations_dataset.max(:version) || 1].max + 1
+              apply_changes(synapse, mutation_type, changes)
+              synapse.update(version: new_version)
+              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
+              )
 
-            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 }
+              { success: true, version: new_version, synapse_id: synapse.id }
+            end
           end
 
           private
@@ -46,7 +48,8 @@ module Legion
               transform:        synapse.transform,
               routing_strategy: synapse.routing_strategy,
               confidence:       synapse.confidence,
-              status:           synapse.status
+              status:           synapse.status,
+              version:          synapse.version
             }
           end
 

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

@@ -3,12 +3,15 @@
 require_relative '../helpers/confidence'
 require_relative '../data/models/synapse'
 require_relative '../data/models/synapse_signal'
+require_relative 'revert'
 
 module Legion
   module Extensions
     module Synapse
       module Runners
         module Pain
+          include Legion::Extensions::Synapse::Runners::Revert
+
           CONSECUTIVE_FAILURE_THRESHOLD = 3
 
           def handle_pain(synapse_id:, task_id: nil)
@@ -40,6 +43,11 @@ module Legion
               result[:action] = :auto_revert
               revert_result = revert(synapse_id: synapse_id, trigger: 'pain')
               result[:reverted] = revert_result[:success] == true
+              if result[:reverted]
+                synapse.refresh
+                new_confidence = synapse.confidence
+                result[:confidence] = new_confidence
+              end
             end
 
             # Check if confidence dropped below autonomy threshold
@@ -59,6 +67,7 @@ module Legion
 
           def count_consecutive_failures(synapse)
             recent = synapse.signals_dataset
+                            .exclude(downstream_outcome: nil)
                             .order(Sequel.desc(:id))
                             .limit(CONSECUTIVE_FAILURE_THRESHOLD)
                             .all

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

@@ -14,44 +14,45 @@ module Legion
             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 }
+            synapse.db.transaction do
+              synapse.lock!
+              mutation_version = to_version || synapse.version
+              next { success: false, error: 'no previous version' } if mutation_version < 2
+
+              mutation = Data::Model::SynapseMutation.where(
+                synapse_id: synapse.id,
+                version:    mutation_version
+              ).first
+
+              next { success: false, error: "mutation version #{mutation_version} not found" } unless mutation
+
+              before_state = Legion::JSON.load(mutation.before_state)
+              restored_version = before_state[:version] || (mutation_version - 1)
+              revert_version = [synapse.version, synapse.mutations_dataset.max(:version) || 1].max + 1
+              current_state = synapse.values.slice(:attention, :transform, :routing_strategy, :confidence, :status, :version)
+              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
+              )
+
+              mutation.update(outcome: 'reverted')
+              restored_state = synapse.values.slice(:attention, :transform, :routing_strategy, :confidence, :status, :version)
+              Data::Model::SynapseMutation.create(
+                synapse_id:    synapse.id,
+                version:       revert_version,
+                mutation_type: 'confidence_changed',
+                before_state:  Legion::JSON.dump(current_state),
+                after_state:   Legion::JSON.dump(restored_state),
+                trigger:       trigger,
+                outcome:       'reverted'
+              )
+
+              { success: true, reverted_to: restored_version, synapse_id: synapse.id }
+            end
           end
         end
       end

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

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module Synapse
-      VERSION = '0.4.13'
+      VERSION = '0.4.15'
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-synapse
 version: !ruby/object:Gem::Version
-  version: 0.4.13
+  version: 0.4.15
 platform: ruby
 authors:
 - Esity