lex-synapse 0.4.14 → 0.4.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ac485ed070081893c396ca551525535a381c7dd906f481768697978644611c81
-  data.tar.gz: fa1d81ddeaf2d7193b5aee2f5145077c30c6bfb9f3be70b6b943e6605af70ea0
+  metadata.gz: '037082609e6545e0a3581981a602d49afdd4a532cf4b15d166f0cf04fd3a746f'
+  data.tar.gz: 42c81c769ef9f4367dec25d4713d5ab4bc4eb1491b88478bb365d5cbd3e2521e
 SHA512:
-  metadata.gz: abbe160b11aac0d146b2fdfbddde252f9a74e85fccceba0ac9c09a155d2f181ad58e928e4fc0a423b2aaa01ec181b35721bc7b7ceb268f0d5297ba1f5ba0c776
-  data.tar.gz: c3859b52b5edb5a68ccb21fd5866acf7a6a4a2ded6dd0cbc40e37f2a0b0cf195e37c04115ae7b892bc2b2e027798c51a04b18bcddbde8c0ecdfd492f9269a955
+  metadata.gz: a5f60904a36dcf8fb276c75683485a7c4ef8207b9b1f1b6c03cae33bd392fa85d4fc44beb605aeae62f492be50be546b90b209021361d1105c9adc43306bfe21
+  data.tar.gz: '059f003e2a808fe705e315b8c7c75c01631ac97ff86c2f675467dd563f37106ea039fc4aaddf32ad89315d4290226e0308d209c0e3df8ebd89644584ab315de9'

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # 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

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,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)
 
             results = { spikes: 0, droughts: 0, updated: 0 }

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,15 +44,19 @@ 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)
+            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)
-            if transform_result[:validation_failure]
-              # run_transform already adjusted confidence; reload to get the updated value
-              new_confidence = synapse.confidence
-            else
+            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)
@@ -52,7 +64,6 @@ module Legion
 
             # 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,
@@ -64,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
             }
@@ -74,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
@@ -90,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(
@@ -101,7 +109,7 @@ 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)

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,45 +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)
-            revert_version = synapse.version + 1
-            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 (uses a unique version to avoid collision)
-            Data::Model::SynapseMutation.create(
-              synapse_id:    synapse.id,
-              version:       revert_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.14'
+      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.14
+  version: 0.4.15
 platform: ruby
 authors:
 - Esity