smith-agents 0.7.0 → 0.10.0

data/lib/smith/workflow/thread_context_snapshot.rb

@@ -15,10 +15,14 @@ module Smith
         current_deadline
         current_ledger
         current_tool_call_allowance
+        current_tool_execution_tracker
         current_tool_result_collector
         current_invocation_context
+        current_invocation_sequence
+        current_invocation
       ].freeze
       THREAD_KEYS = %i[
+        smith_attribution
         smith_call_deadline
         smith_call_ledger
         smith_failed_agent_results
@@ -68,14 +72,14 @@ module Smith
       def restore_context!
         raise WorkflowError, "thread context snapshot has already been restored" if @restored
 
-        @tool_values.each { |attribute, value| Tool.public_send("#{attribute}=", value) }
+        @tool_values.each { |attribute, value| Tool.send("#{attribute}=", value) }
         @thread_values.each { |key, value| Thread.current[key] = value }
         Smith.scoped_artifacts = @artifact_store if scoped_artifacts
         @restored = true
       end
 
       def capture_tool_values
-        tool_attributes.to_h { |attribute| [attribute, Tool.public_send(attribute)] }.freeze
+        tool_attributes.to_h { |attribute| [attribute, Tool.send(attribute)] }.freeze
       end
 
       def capture_thread_values

data/lib/smith/workflow/transition.rb

@@ -336,10 +336,7 @@ module Smith
 
           raise WorkflowError, "retry_on error classes must inherit from StandardError"
         end
-        if error_classes.any? { |error_class| error_class <= ToolCaptureFailed }
-          message = "retry_on cannot retry Smith::ToolCaptureFailed because the tool outcome may be uncertain"
-          raise WorkflowError, message
-        end
+        reject_retry_forbidden!(error_classes)
 
         ExponentialBackoff.new(
           attempts:,
@@ -352,6 +349,14 @@ module Smith
         raise WorkflowError, "retry_on #{e.message}"
       end
 
+      def reject_retry_forbidden!(error_classes)
+        forbidden = error_classes.find { |error_class| Smith::Errors.retry_forbidden_class?(error_class) }
+        return unless forbidden
+
+        label = forbidden.name || "an anonymous terminal tool-evidence error class"
+        raise WorkflowError, "retry_on cannot retry #{label} because the tool outcome may be uncertain"
+      end
+
       def normalize_deterministic_routes!(routes)
         return nil if routes.nil?
         raise WorkflowError, "deterministic routes must be an Array" unless routes.is_a?(Array)

data/lib/smith/workflow/usage_entry.rb

@@ -2,26 +2,64 @@
 
 module Smith
   class Workflow
-    # One row per agent provider call. `usage_id` is a UUID generated at
-    # recording time and stable across persist/restore so hosts can use it as an
-    # idempotency anchor.
+    # One row per provider RESPONSE within an agent provider attempt.
+    # `usage_id` is a UUID generated at recording time and stable across
+    # persist/restore so hosts can use it as an idempotency anchor.
+    #
+    # `transition`, `branch_key`, `round`, and `workflow` come from the
+    # ambient Smith::Attribution at recording time, so hosts can attribute
+    # usage to the exact step, fan-out branch, optimizer round, and (for
+    # nested workflows) the exact graph that spent it.
+    # `attempt_id` is shared by every entry the same provider attempt
+    # produced (an attempt with an N-round tool loop records N entries):
+    # join on it against the `:provider_call` trace event for the attempt's
+    # single measured duration; never sum a duration across entries. Every
+    # attempt emits its `:provider_call` (an attempt aborted by a
+    # non-provider error emits with `outcome: :aborted` before re-raising),
+    # so prefix-accounted entries always have their join target.
+    # All optional members are nil on entries restored from checkpoints written by
+    # earlier Smith versions, and nil attribution members are omitted from
+    # serialization so those documents re-serialize byte-identically.
     # rubocop:disable Style/RedundantStructKeywordInit
     UsageEntry = Struct.new(
       :usage_id,
       :agent_name,
       :model,
+      :provider,
       :input_tokens,
       :output_tokens,
       :cost,
       :attempt_kind,
       :recorded_at,
+      :transition,
+      :branch_key,
+      :round,
+      :attempt_id,
+      :workflow,
       keyword_init: true
     ) do
+      def initialize(**attributes)
+        attributes = attributes.transform_values do |value|
+          value.is_a?(String) ? value.dup.freeze : value
+        end
+        super(**attributes) # rubocop:disable Style/SuperArguments
+        freeze
+      end
+
+      # Serialization is additive only when present: nil attribution members
+      # are omitted so an entry restored from a pre-attribution checkpoint
+      # re-serializes byte-identically. Hosts that digest whole persisted
+      # documents (exact-mutation proofs) depend on this stability.
+      def to_h
+        super.reject { |key, value| value.nil? && %i[transition branch_key round attempt_id workflow].include?(key) }
+      end
+
       def self.from_h(hash)
         sym = hash.transform_keys(&:to_sym)
         filtered = sym.slice(*members)
-        filtered[:agent_name] = filtered[:agent_name].to_sym if filtered[:agent_name].is_a?(String)
-        filtered[:attempt_kind] = filtered[:attempt_kind].to_sym if filtered[:attempt_kind].is_a?(String)
+        %i[agent_name provider attempt_kind transition branch_key].each do |attribute|
+          filtered[attribute] = filtered[attribute].to_sym if filtered[attribute].is_a?(String)
+        end
         new(**filtered)
       end
     end

data/lib/smith/workflow.rb

@@ -3,11 +3,13 @@
 require "digest"
 require "json"
 require "securerandom"
-require "set"
 require "time"
 
 require_relative "workflow/agent_result"
 require_relative "workflow/branch_env"
+require_relative "workflow/failure_record"
+require_relative "workflow/failure_record_restore"
+require_relative "workflow/failure_reconstructor"
 require_relative "workflow/run_result"
 require_relative "workflow/string_snapshot"
 require_relative "workflow/usage_entry"
@@ -30,51 +32,6 @@ module Smith
 
     DEFAULT_MAX_TRANSITIONS = 100
 
-    # Reconstruct Smith error classes from `@last_failed_step` snapshots.
-    # Order matters: more-specific subclasses first, so a real DSF doesn't
-    # get caught by the WorkflowError handler. Each lambda preserves the
-    # billing-critical attributes (`retryable`, `kind`, `details`) by
-    # routing through the original constructor — Smith's retryable errors
-    # expose `attr_reader :retryable` only, with no setter, so kwargs
-    # MUST flow through `initialize`.
-    KNOWN_RECONSTRUCTORS = {
-      "Smith::ToolCaptureFailed" => ->(s) {
-        Smith::ToolCaptureFailed.from_details(s.fetch(:error_details))
-      },
-      "Smith::ToolGuardrailFailed" => ->(s) {
-        Smith::ToolGuardrailFailed.new(s[:error_message], retryable: s[:error_retryable])
-      },
-      "Smith::DeterministicStepFailure" => ->(s) {
-        Smith::DeterministicStepFailure.new(
-          s[:error_message],
-          retryable: s[:error_retryable],
-          kind:      s[:error_kind],
-          details:   s[:error_details]
-        )
-      },
-      "Smith::AgentError"        => ->(s) { Smith::AgentError.new(s[:error_message]) },
-      "Smith::DeadlineExceeded"  => ->(s) { Smith::DeadlineExceeded.new(s[:error_message]) },
-      "Smith::WorkflowError"     => ->(s) { Smith::WorkflowError.new(s[:error_message]) },
-      "Smith::Workflow::Composite::BranchFailure" => lambda { |s|
-        Smith::Workflow::Composite::BranchFailure.from_details(s[:error_details])
-      },
-      # Smith errors with non-message constructors map to compatible
-      # superclass — message preserved, original metadata (agent_name,
-      # model_used, requested_name, workflow_class, origin_state) lossy
-      # but `is_a?` classification round-trips via the superclass.
-      "Smith::BlankAgentOutputError"     => ->(s) { Smith::AgentError.new(s[:error_message]) },
-      "Smith::UnresolvedTransitionError" => ->(s) { Smith::WorkflowError.new(s[:error_message]) }
-    }.freeze
-    private_constant :KNOWN_RECONSTRUCTORS
-
-    # Families whose retryable/kind/details attributes are billing-critical.
-    # For these, the reconstruction path bypasses `const_get(...).new(message)`
-    # (which would succeed for unknown subclasses with message-only
-    # constructors but discard the kwargs) and uses the family fallback
-    # directly so the parent-class constructor preserves the attrs.
-    RETRYABLE_BEARING_FAMILIES = %w[deterministic_step_failure tool_guardrail_failed].freeze
-    private_constant :RETRYABLE_BEARING_FAMILIES
-
     attr_reader :state, :last_prepared_input, :ledger
 
     def session_messages
@@ -101,6 +58,14 @@ module Smith
       @usage_entries = []
       @usage_mutex = Mutex.new
       @last_output = nil
+      # Durable attribution of the most recent serial `execute :agent` step:
+      # { model:, provider: } of the model that actually served it (post
+      # fallback resolution), exposed to the following deterministic step as
+      # `last_agent_model` / `last_agent_provider`. `@pending_agent_execution`
+      # is the transient per-step carrier from `execute_serial_step` to
+      # `complete_step`; it is never persisted.
+      @last_agent_execution = nil
+      @pending_agent_execution = nil
       @last_failed_step = nil
       # Optimistic-locking version. Incremented on each persist!; restored
       # from the persisted payload. Adapters that support store_versioned
@@ -113,6 +78,7 @@ module Smith
       # seed_validation is :warn or :strict; nil when no seed builder
       # ran or its output was empty.
       @seed_digest = nil
+      @seed_message_count = 0
       # Idempotency marker stamped between persist-before-advance and
       # persist-after-advance under idempotency_mode :strict; restored
       # workflows with the marker set raise
@@ -199,11 +165,23 @@ module Smith
       end
     end
 
+    # Public, read-only view of the per-provider-call usage ledger, so hosts
+    # can diff usage across a step boundary without paying a full to_state
+    # serialization. The entries themselves are frozen; the returned array is
+    # a frozen copy taken under the recording mutex. Tolerates allocated but
+    # unrestored instances (no mutex yet), which have no entries.
+    def usage_entries
+      mutex = @usage_mutex
+      return [].freeze unless mutex
+
+      mutex.synchronize { @usage_entries.dup.freeze }
+    end
+
     private
 
     def initial_persist_auto_seed
       manager = self.class.context_manager
-      return [] unless manager && manager.respond_to?(:persist_mode) && manager.persist_mode == :auto
+      return [] unless manager.respond_to?(:persist_mode) && manager.persist_mode == :auto
 
       manager.persist_auto_seed.map(&:to_sym)
     end
@@ -223,31 +201,7 @@ module Smith
       return unless step_result
 
       if step_result[:error]
-        err = step_result[:error]
-        # error_family preserves classification across reconstruction
-        # even when the exact class can't be rebuilt. Order matters:
-        # specific subclasses first (DSF before WorkflowError, etc.)
-        # so a real DSF doesn't get classified as workflow_error.
-        error_family = case err
-                       when Smith::DeterministicStepFailure then "deterministic_step_failure"
-                       when Smith::ToolCaptureFailed        then "tool_capture_failed"
-                       when Smith::ToolGuardrailFailed      then "tool_guardrail_failed"
-                       when Smith::DeadlineExceeded         then "deadline_exceeded"
-                       when Smith::AgentError               then "agent_error"
-                       when Smith::WorkflowError            then "workflow_error"
-                       else                                       "other"
-                       end
-        @last_failed_step = {
-          transition: step_result[:transition],
-          from: step_result[:from],
-          to: step_result[:to],
-          error_class: err.class.name,
-          error_family: error_family,
-          error_message: err.message,
-          error_retryable: err.respond_to?(:retryable) ? err.retryable : nil,
-          error_kind:      err.respond_to?(:kind)      ? err.kind      : nil,
-          error_details:   err.respond_to?(:details)   ? err.details   : nil
-        }
+        @last_failed_step = FailureRecord.capture(step_result)
       else
         # Successful step: clear any prior failed-step snapshot
         # (workflow handled the failure and continued) and capture
@@ -255,6 +209,10 @@ module Smith
         # matches `RunResult#output`'s `.compact.first` semantics).
         @last_failed_step = nil
         @last_output = step_result[:output] if step_result.key?(:output) && !step_result[:output].nil?
+        # Capture serial agent attribution only on steps that carried it (an
+        # `execute :agent` step); deterministic steps have no :model key, so
+        # the last agent execution persists across intervening compute steps.
+        @last_agent_execution = { model: step_result[:model], provider: step_result[:provider] } if step_result.key?(:model)
       end
     end
 
@@ -275,7 +233,7 @@ module Smith
         name = @next_transition_name
         @next_transition_name = nil
         transition = self.class.find_transition(name) ||
-          raise(UnresolvedTransitionError.new(name, self.class, @state))
+                     raise(UnresolvedTransitionError.new(name, self.class, @state))
         validate_transition_origin!(transition)
         transition
       else
@@ -316,10 +274,10 @@ module Smith
       # terminal state never produces a synthetic error even if the
       # snapshot wasn't cleared.
       effective_steps = if steps.empty? && failed? && @last_failed_step
-        [reconstruct_failed_step]
-      else
-        steps
-      end
+                          [reconstruct_failed_step]
+                        else
+                          steps
+                        end
 
       RunResult.new(
         state: @state,
@@ -336,59 +294,11 @@ module Smith
     end
 
     def reconstruct_failed_step
-      snap = @last_failed_step
-      builder = KNOWN_RECONSTRUCTORS[snap[:error_class]]
-      error = if builder
-        builder.call(snap)
-      elsif RETRYABLE_BEARING_FAMILIES.include?(snap[:error_family])
-        # Skip const_get for retryable-bearing families. An unknown
-        # subclass with a message-only constructor would const_get
-        # successfully but discard the snapshot's `retryable`/`kind`/
-        # `details` (defaults to nil), and host retry classification
-        # could misclassify a retryable failure as terminal.
-        # Family fallback rebuilds the parent class with kwargs intact.
-        family_fallback(snap)
-      else
-        # Unknown subclass without retryable-bearing semantics. Try
-        # the exact class for shape preservation; fall back via family
-        # if the constructor doesn't accept message-only args (or the
-        # class doesn't exist).
-        begin
-          Kernel.const_get(snap[:error_class]).new(snap[:error_message])
-        rescue NameError, ArgumentError
-          family_fallback(snap)
-        end
-      end
-
-      # Symbol coercion on the way out: live steps carry these as
-      # symbols; JSON round-trip stringifies them; coerce back to
-      # match fresh-run shape exactly.
-      {
-        transition: normalize_transition_name(snap[:transition]),
-        from:       normalize_state_name(snap[:from]),
-        to:         normalize_state_name(snap[:to]),
-        error:      error
-      }
-    end
-
-    def family_fallback(snap)
-      case snap[:error_family]
-      when "deterministic_step_failure"
-        Smith::DeterministicStepFailure.new(
-          snap[:error_message],
-          retryable: snap[:error_retryable],
-          kind:      snap[:error_kind],
-          details:   snap[:error_details]
-        )
-      when "tool_guardrail_failed"
-        Smith::ToolGuardrailFailed.new(snap[:error_message], retryable: snap[:error_retryable])
-      when "tool_capture_failed"
-        Smith::ToolCaptureFailed.from_details(snap.fetch(:error_details))
-      when "deadline_exceeded" then Smith::DeadlineExceeded.new(snap[:error_message])
-      when "agent_error"       then Smith::AgentError.new(snap[:error_message])
-      when "workflow_error"    then Smith::WorkflowError.new(snap[:error_message])
-      else                          RuntimeError.new(snap[:error_message])
-      end
+      FailureReconstructor.new(
+        snapshot: @last_failed_step,
+        transition_normalizer: method(:normalize_transition_name),
+        state_normalizer: method(:normalize_state_name)
+      ).call
     end
 
     def seed_initial_session_messages
@@ -396,6 +306,7 @@ module Smith
       return if messages.nil?
 
       @session_messages = messages
+      @seed_message_count = messages.length
       @seed_digest = compute_seed_digest(messages)
     end
 
@@ -453,7 +364,8 @@ module Smith
     # Same rule applies to nested-workflow rollup (see
     # `nested_execution.rb`).
     def snapshot_usage_entries
-      @usage_entries.map { |entry| Workflow::UsageEntry.from_h(snapshot_value(entry.to_h)) }
+      entries = @usage_mutex.synchronize { @usage_entries.dup }
+      entries.map { |entry| Workflow::UsageEntry.from_h(snapshot_value(entry.to_h)) }
     end
 
     def tool_result_collector

data/lib/smith.rb

@@ -40,11 +40,15 @@ module Smith
   setting :trace_transitions, default: true
   setting :trace_tool_calls, default: true
   setting :trace_token_usage, default: true
+  setting :trace_provider_calls, default: true
   setting :trace_cost, default: true
   setting :trace_fields
   setting :trace_content, default: false
-  setting :trace_retention
-  setting :trace_tenant_isolation, default: false
+  # Merge the ambient Smith::Attribution fields (execution_key, transition,
+  # branch_key, round, ...) into every trace payload. Attribution keys are
+  # identifiers, not content; they still pass through any configured
+  # trace_fields allowlist, and caller-supplied keys win on conflict.
+  setting :trace_attribution, default: true
 
   # Pricing (§4.5 — model-call cost computation)
   setting :pricing, default: nil
@@ -177,6 +181,7 @@ end
 # Leaf modules (no internal dependencies)
 require_relative "smith/types"
 require_relative "smith/errors"
+require_relative "smith/tool_failure_notification_failed"
 require_relative "smith/persistence_payload_conflict"
 require_relative "smith/exponential_backoff"
 
@@ -186,6 +191,7 @@ require_relative "smith/events"
 require_relative "smith/events/subscription"
 require_relative "smith/events/bus"
 require_relative "smith/events/step_completed"
+require_relative "smith/events/step_failed"
 
 # Budget (depends on Errors)
 require_relative "smith/budget"
@@ -205,6 +211,7 @@ require_relative "smith/pricing"
 require_relative "smith/models/profile"
 require_relative "smith/models"
 require_relative "smith/models/inference"
+require_relative "smith/models/tool_routing"
 require_relative "smith/models/normalizer"
 
 # OpenAI /v1/responses routing prepend. Dormant until
@@ -254,6 +261,7 @@ require_relative "smith/context/session"
 
 # Agent (depends on RubyLLM::Agent)
 require_relative "smith/agent"
+require_relative "smith/agent/completion"
 require_relative "smith/agent/lifecycle"
 require_relative "smith/agent/registry_binding"
 require_relative "smith/agent/registry"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: smith-agents
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Samuel Ralak
@@ -117,22 +117,16 @@ dependencies:
   name: ruby_llm
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.15'
-    - - "<"
+    - - '='
       - !ruby/object:Gem::Version
-        version: '1.17'
+        version: 1.16.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.15'
-    - - "<"
+    - - '='
       - !ruby/object:Gem::Version
-        version: '1.17'
+        version: 1.16.0
 description: Smith is a workflow-first multi-agent orchestration library built on
   RubyLLM. It provides state machine modeling, typed contracts, budget enforcement,
   guardrails, and observability for agent workflows.
@@ -159,16 +153,34 @@ files:
 - lib/generators/smith/install/templates/smith.rb.tt
 - lib/smith.rb
 - lib/smith/agent.rb
+- lib/smith/agent/chat_construction.rb
+- lib/smith/agent/completion.rb
+- lib/smith/agent/completion_usage_recording.rb
+- lib/smith/agent/dynamic_configuration.rb
+- lib/smith/agent/fallback_configuration.rb
+- lib/smith/agent/invocation_preparation.rb
 - lib/smith/agent/lifecycle.rb
+- lib/smith/agent/model_reference.rb
+- lib/smith/agent/provider_attempt.rb
+- lib/smith/agent/provider_call_timing.rb
+- lib/smith/agent/provider_candidate_sequence.rb
+- lib/smith/agent/provider_completion.rb
+- lib/smith/agent/provider_failure_handling.rb
+- lib/smith/agent/provider_usage.rb
 - lib/smith/agent/registry.rb
 - lib/smith/agent/registry/execution_binding_capture.rb
 - lib/smith/agent/registry/introspection.rb
 - lib/smith/agent/registry/mutation_boundary.rb
 - lib/smith/agent/registry_binding.rb
+- lib/smith/agent/reserved_input_bridge.rb
+- lib/smith/agent/usage_entry_recording.rb
+- lib/smith/agent/usage_traces.rb
+- lib/smith/agent/usage_tracking.rb
 - lib/smith/artifacts.rb
 - lib/smith/artifacts/file.rb
 - lib/smith/artifacts/memory.rb
 - lib/smith/artifacts/scoped_store.rb
+- lib/smith/attribution.rb
 - lib/smith/budget.rb
 - lib/smith/budget/amount_contract.rb
 - lib/smith/budget/amount_representation.rb
@@ -185,6 +197,7 @@ files:
 - lib/smith/context/observation_masking.rb
 - lib/smith/context/session.rb
 - lib/smith/context/state_injection.rb
+- lib/smith/diagnostic_text.rb
 - lib/smith/doctor.rb
 - lib/smith/doctor/check.rb
 - lib/smith/doctor/checks/baseline.rb
@@ -208,15 +221,21 @@ files:
 - lib/smith/events/.keep
 - lib/smith/events/bus.rb
 - lib/smith/events/step_completed.rb
+- lib/smith/events/step_failed.rb
 - lib/smith/events/subscription.rb
 - lib/smith/exponential_backoff.rb
 - lib/smith/guardrails.rb
 - lib/smith/guardrails/runner.rb
 - lib/smith/guardrails/url_verifier.rb
 - lib/smith/models.rb
+- lib/smith/models/ambiguous_profile_error.rb
+- lib/smith/models/collision_error.rb
 - lib/smith/models/inference.rb
 - lib/smith/models/normalizer.rb
 - lib/smith/models/profile.rb
+- lib/smith/models/provider_qualified_registry.rb
+- lib/smith/models/tool_routing.rb
+- lib/smith/persisted_failure_invalid.rb
 - lib/smith/persistence_adapters.rb
 - lib/smith/persistence_adapters/active_record_connection_errors.rb
 - lib/smith/persistence_adapters/active_record_exact_predicate.rb
@@ -236,22 +255,67 @@ files:
 - lib/smith/persistence_adapters/version_expectation.rb
 - lib/smith/persistence_payload_conflict.rb
 - lib/smith/pricing.rb
+- lib/smith/pricing_configuration_error.rb
+- lib/smith/provider_permanent_failure.rb
 - lib/smith/providers/openai/responses.rb
 - lib/smith/providers/openai/routing.rb
 - lib/smith/providers/openai/tools_extensions.rb
 - lib/smith/railtie.rb
 - lib/smith/tasks/doctor.rake
 - lib/smith/tool.rb
+- lib/smith/tool/argument_container_reader.rb
+- lib/smith/tool/argument_scalar_snapshot.rb
+- lib/smith/tool/argument_snapshot.rb
+- lib/smith/tool/argument_snapshot_accounting.rb
+- lib/smith/tool/argument_snapshot_result.rb
+- lib/smith/tool/argument_snapshot_traversal.rb
+- lib/smith/tool/bounded_completion_context.rb
+- lib/smith/tool/bounded_completion_controls.rb
+- lib/smith/tool/bounded_completion_guard.rb
+- lib/smith/tool/bounded_completion_installation.rb
+- lib/smith/tool/bounded_completion_state.rb
 - lib/smith/tool/budget_enforcement.rb
+- lib/smith/tool/call_admission.rb
 - lib/smith/tool/call_allowance.rb
+- lib/smith/tool/call_allowance_counter.rb
+- lib/smith/tool/call_batch.rb
+- lib/smith/tool/call_budget.rb
+- lib/smith/tool/call_reservation.rb
 - lib/smith/tool/capability_builder.rb
 - lib/smith/tool/capture.rb
 - lib/smith/tool/capture_configuration.rb
+- lib/smith/tool/chat_execution_callbacks.rb
 - lib/smith/tool/chat_execution_context.rb
 - lib/smith/tool/compatibility.rb
+- lib/smith/tool/execution_authority.rb
+- lib/smith/tool/execution_authorization.rb
+- lib/smith/tool/execution_batch.rb
+- lib/smith/tool/execution_batch_admission.rb
+- lib/smith/tool/execution_batch_builder.rb
+- lib/smith/tool/execution_batch_collection.rb
+- lib/smith/tool/execution_batch_invocations.rb
+- lib/smith/tool/execution_batch_lifecycle.rb
+- lib/smith/tool/execution_batch_registry.rb
+- lib/smith/tool/execution_batch_requests.rb
+- lib/smith/tool/execution_batch_source_call.rb
+- lib/smith/tool/execution_batch_source_metadata.rb
+- lib/smith/tool/execution_batch_sources.rb
+- lib/smith/tool/execution_batch_state.rb
+- lib/smith/tool/execution_dispatch.rb
+- lib/smith/tool/execution_failure_handling.rb
+- lib/smith/tool/execution_lifecycle.rb
+- lib/smith/tool/execution_tracker.rb
+- lib/smith/tool/fail_fast_completion.rb
+- lib/smith/tool/graceful_completion.rb
+- lib/smith/tool/invocation.rb
+- lib/smith/tool/invocation_request.rb
+- lib/smith/tool/invocation_sequence.rb
+- lib/smith/tool/legacy_call_allowance.rb
 - lib/smith/tool/policy.rb
 - lib/smith/tool/scoped_context.rb
 - lib/smith/tool_capture_failed.rb
+- lib/smith/tool_execution_not_admitted.rb
+- lib/smith/tool_failure_notification_failed.rb
 - lib/smith/tools.rb
 - lib/smith/tools/think.rb
 - lib/smith/tools/url_fetcher.rb
@@ -314,6 +378,12 @@ files:
 - lib/smith/workflow/execution_binding_resolution.rb
 - lib/smith/workflow/execution_frame.rb
 - lib/smith/workflow/execution_result_snapshot.rb
+- lib/smith/workflow/failure_detail_snapshot.rb
+- lib/smith/workflow/failure_reconstructor.rb
+- lib/smith/workflow/failure_record.rb
+- lib/smith/workflow/failure_record_restore.rb
+- lib/smith/workflow/failure_record_text.rb
+- lib/smith/workflow/failure_record_validator.rb
 - lib/smith/workflow/fanout_execution.rb
 - lib/smith/workflow/graph.rb
 - lib/smith/workflow/graph/contract_helpers.rb
@@ -348,6 +418,7 @@ files:
 - lib/smith/workflow/graph/transition_snapshot.rb
 - lib/smith/workflow/graph/validator.rb
 - lib/smith/workflow/graph_dsl.rb
+- lib/smith/workflow/guarded_step_execution.rb
 - lib/smith/workflow/guardrail_integration.rb
 - lib/smith/workflow/identifier.rb
 - lib/smith/workflow/message_admission.rb