active_harness 0.2.14 → 0.2.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6a42e03d329e638e3119d0a259a2286f05a0ec1603b8c2c81636e4ac041ebf9d
-  data.tar.gz: 074cf7e1558d9efee20cd17c3405665be00ef29c30574289b54d6e2251ebeacc
+  metadata.gz: cc551806a5848e9157c21ee668ee38c139a55c46fb7e8c2a6a2e8022200c90cb
+  data.tar.gz: f6110846af88ce73b7fe7a30221d18960a58e80adeaf01e2b19b5e14fac0640d
 SHA512:
-  metadata.gz: 3397bd1901b3062030b3a41dc327ed1fd7053ef5d90e8e53d0ebb820375054f112cc80e70e528282703277e90137310318d026c456950f86ae755a09aca4e473
-  data.tar.gz: 7137703c7469a5f1cd8adfb121fd5047231387890756325f7e035955c7a23dab3bd0dfaf22c223343a9fb006279b6b352c01f1cf443da6cfcf60c3e26227cac3
+  metadata.gz: d8884d36a5da2581707584068acc7315a00d417bd88a7776d1702c375e05470257c21cedb6c323fec5aa75562e6f118d635ae1b1a2053d3e7d60b48b0aca8d3f
+  data.tar.gz: 02fa25dca8678816e76b2c2b2fad6131e26a7aa8b5a97cb78a5bcee84d7a9923507eb5981d0508663ecced5a6eb85c5f92799a00d80b59098252dc08438ff22f

data/lib/active_harness/tribunal/dsl.rb

@@ -9,13 +9,46 @@ module ActiveHarness
         tribunal_config[:agents] = list.flatten
       end
 
-      # Class-level process block — defines how to compute the verdict from results.
+      # Class-level process block — defines how to compute the verdict from all results.
+      # Receives the full results array; return value becomes #verdict.
+      # Takes priority over +verdict+ strategy if both are declared.
       #
       #   process { |results| results.all? { |r| r.parsed["result"] == true } }
-      #   process { |results| results.count { |r| r.parsed["result"] == true } >= 2 }
       def process(&block)
         tribunal_config[:process] = block
       end
+
+      # Declarative verdict — built-in aggregation strategy with a per-result evaluator.
+      #
+      # Strategies:
+      #   :unanimous  — verdict true when every successful result evaluates to true
+      #   :majority   — verdict true when more than half of successful results evaluate to true
+      #
+      # Options:
+      #   may_fail: N — tolerate up to N agent errors before raising AllAgentsFailed
+      #                 (default: nil — raise only when all agents fail, preserving legacy behavior)
+      #
+      # The block receives a single Result and must return a truthy/falsy value.
+      #
+      #   verdict :unanimous do |result|
+      #     result.parsed["result"] == true
+      #   end
+      #
+      #   verdict :majority, may_fail: 1 do |result|
+      #     result.parsed["result"] == true
+      #   end
+      VALID_STRATEGIES = %i[unanimous majority].freeze
+
+      def verdict(strategy, may_fail: nil, &block)
+        unless VALID_STRATEGIES.include?(strategy)
+          raise ArgumentError,
+            "Unknown verdict strategy :#{strategy}. Valid strategies: #{VALID_STRATEGIES.map { |s| ":#{s}" }.join(", ")}"
+        end
+
+        tribunal_config[:strategy]       = strategy
+        tribunal_config[:may_fail]       = may_fail
+        tribunal_config[:evaluate_block] = block
+      end
     end
   end
 end

data/lib/active_harness/tribunal/processing.rb

@@ -0,0 +1,44 @@
+module ActiveHarness
+  class Tribunal
+    # Instance-level process block — overrides class-level block.
+    #
+    #   tribunal.process { |results| results.count { |r| r.parsed["ok"] } >= 2 }
+    def process(&block)
+      @process_block = block
+      self
+    end
+
+    private
+
+    # Selects and executes the verdict computation in order of priority:
+    #   1. Instance-level process block (set via tribunal.process { ... })
+    #   2. Class-level process block    (set via `process do ... end` in subclass)
+    #   3. Class-level strategy         (set via `verdict :unanimous/:majority`)
+    #   4. nil                          (no verdict computation declared)
+    def compute_verdict(results)
+      if @process_block
+        @process_block.call(results)
+      elsif @strategy
+        apply_strategy(@strategy, results)
+      end
+    end
+
+    # Built-in aggregation strategies.
+    #
+    # Without an evaluate_block every successful result is treated as a positive vote.
+    # With an evaluate_block the block decides whether each result counts as positive.
+    #
+    # :unanimous — all positive votes required
+    # :majority  — more than 50% positive votes required
+    def apply_strategy(strategy, results)
+      evaluate = @evaluate_block || ->(r) { r }
+      votes    = results.map { |r| evaluate.call(r) ? true : false }
+      positive = votes.count(true)
+
+      case strategy
+      when :unanimous then positive == votes.size
+      when :majority  then positive > votes.size / 2.0
+      end
+    end
+  end
+end

data/lib/active_harness/tribunal.rb

@@ -50,7 +50,8 @@ module ActiveHarness
     attr_reader :results, :errors, :verdict, :execution_time, :agent_execution_times
 
     def initialize(input: nil, context: {}, agents: nil, timeout: 7,
-                   stream: nil, agent_event_stream: nil, tribunal_event_stream: nil)
+                   stream: nil, agent_event_stream: nil, tribunal_event_stream: nil,
+                   may_fail: :_unset)
       config = self.class.tribunal_config
 
       @input                 = input
@@ -58,6 +59,9 @@ module ActiveHarness
       @agents                = agents || config[:agents]
       @timeout               = timeout
       @process_block         = config[:process]
+      @strategy              = config[:strategy]
+      @evaluate_block        = config[:evaluate_block]
+      @may_fail              = may_fail == :_unset ? config[:may_fail] : may_fail
       @hooks                 = config[:hooks].dup
       @stream                = stream
       @agent_event_stream    = agent_event_stream
@@ -69,12 +73,6 @@ module ActiveHarness
       @agent_execution_times = []
     end
 
-    # Instance-level process block — overrides class-level block.
-    def process(&block)
-      @process_block = block
-      self
-    end
-
     # Run all agents in parallel, then compute the verdict.
     # Returns self so calls can be chained: tribunal.call.verdict
     #
@@ -125,13 +123,13 @@ module ActiveHarness
 
       run_hook(:after_call, @results, @errors)
 
-      if @results.empty?
-        messages = @errors.map { |e| "#{e[:agent]}: #{e[:error].message}" }.join("; ")
-        raise Errors::AllAgentsFailed, "All agents failed — #{messages}"
-      end
+      # If all agents failed, raise an exception.
+      # Otherwise, compute the verdict based on successful results.
+      check_failure_threshold!
 
       verdict_input = transform_hook(:before_verdict, @results)
-      @verdict = @process_block ? @process_block.call(verdict_input) : nil
+      @verdict      = compute_verdict(verdict_input)
+      
       run_hook(:after_verdict, @verdict)
 
       self
@@ -139,6 +137,19 @@ module ActiveHarness
 
     private
 
+    def check_failure_threshold!
+      if !@may_fail.nil? && @errors.size > @may_fail
+        raise Errors::AllAgentsFailed,
+          "Too many agents failed (#{@errors.size} > may_fail: #{@may_fail}) — #{error_summary}"
+      elsif @results.empty?
+        raise Errors::AllAgentsFailed, "All agents failed — #{error_summary}"
+      end
+    end
+
+    def error_summary
+      @errors.map { |e| "#{e[:agent]}: #{e[:error].message}" }.join("; ")
+    end
+
     def resolve_agents
       @agents.map do |agent|
         if agent.is_a?(Class)
@@ -161,3 +172,4 @@ end
 
 require_relative "tribunal/hooks"
 require_relative "tribunal/dsl"
+require_relative "tribunal/processing"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_harness
 version: !ruby/object:Gem::Version
-  version: 0.2.14
+  version: 0.2.15
 platform: ruby
 authors:
 - the-teacher
@@ -74,6 +74,7 @@ files:
 - lib/active_harness/tribunal.rb
 - lib/active_harness/tribunal/dsl.rb
 - lib/active_harness/tribunal/hooks.rb
+- lib/active_harness/tribunal/processing.rb
 - lib/generators/active_harness/agent/agent_generator.rb
 - lib/generators/active_harness/agent/templates/agent.rb.tt
 - lib/generators/active_harness/install/install_generator.rb