ace-assign 0.63.1 → 0.66.0

data/lib/ace/assign/cli/commands/submit_candidate.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+require_relative "protected_submission"
+module Ace
+  module Assign
+    module CLI
+      module Commands
+        class SubmitCandidate < Ace::Support::Cli::Command
+          include Ace::Support::Cli::Base
+          include ProtectedSubmission
+          desc "Submit original protected worker bundle bytes"
+          option :mapping, desc: "Installed mapping"
+          option :assignment, desc: "Original assignment"
+          option :attempt, desc: "Original attempt"
+          option :head, desc: "Exact candidate head"
+          option :candidate_generation, desc: "Expected current candidate generation (zero before first submission)"
+          option :expected_generation, desc: "Persisted authority generation"
+          option :mutation, desc: "Stable original mutation"
+          option :bundle, desc: "Bounded local byte file"
+
+          def call(**options)
+            usage = "submit-candidate with original selectors, generation, mutation and --bundle FILE"
+            client, params, mutation = submission_request(options, usage)
+            head = require_option(options, :head, usage)
+            raise Ace::Support::Cli::Error, "Head must be an exact SHA-1" unless head.match?(/\A[0-9a-f]{40}\z/)
+            params.merge!("head" => head, "candidate_generation" => integer_option(options, :candidate_generation, usage))
+            bytes = input_bytes(require_option(options, :bundle, usage), limit: 64 * 1024 * 1024)
+            parts = [bytes]
+            emit_json(upload_call(client, "submit_candidate", params, mutation, parts, :candidate))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/assign/cli/commands/submit_result.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+require_relative "protected_submission"
+require_relative "../../authority/receipt_transfer"
+module Ace
+  module Assign
+    module CLI
+      module Commands
+        class SubmitResult < Ace::Support::Cli::Command
+          include Ace::Support::Cli::Base
+          include ProtectedSubmission
+          desc "Submit original protected worker receipt bytes"
+          option :mapping, desc: "Installed mapping"
+          option :assignment, desc: "Original assignment"
+          option :attempt, desc: "Original attempt"
+          option :head, desc: "Exact candidate head"
+          option :candidate_generation, desc: "Positive candidate generation"
+          option :expected_generation, desc: "Persisted authority generation"
+          option :mutation, desc: "Stable original mutation"
+          option :receipt, desc: "Bounded local byte file"
+          option :artifact, type: :array, desc: "Ordered artifact byte files"
+
+          def call(**options)
+            usage = "submit-result with original selectors, generation, mutation and --receipt FILE"
+            client, params, mutation = submission_request(options, usage)
+            head = require_option(options, :head, usage)
+            raise Ace::Support::Cli::Error, "Head must be an exact SHA-1" unless head.match?(/\A[0-9a-f]{40}\z/)
+            params.merge!("head" => head, "candidate_generation" => integer_option(options, :candidate_generation, usage, positive: true))
+            bytes = input_bytes(require_option(options, :receipt, usage), limit: 16 * 1024)
+            receipt = input_json(bytes)
+            raise Ace::Support::Cli::Error, "Receipt must be an object" unless receipt.is_a?(Hash)
+            allowed = Models::ExecutionReceipt.from_h(receipt).to_h.keys
+            if (receipt.keys - allowed).any? || Models::ExecutionReceipt.forbidden_field?(receipt)
+              raise Ace::Support::Cli::Error, "Receipt contains unsupported fields"
+            end
+            unless receipt.values_at("assignment_id", "attempt_id", "head") == params.values_at("assignment_id", "attempt_id", "head") &&
+                Models::ExecutionReceipt::VERDICTS.include?(receipt["verdict"])
+              raise Ace::Support::Cli::Error, "Receipt identity or verdict differs"
+            end
+            files = options.fetch(:artifact, [])
+            unless files.is_a?(Array) && files.size <= 16 && !(receipt["verdict"] == "succeeded" && files.empty?)
+              raise Ace::Support::Cli::Error, "Receipt artifact declarations are invalid"
+            end
+            artifacts = files.map { |path| input_bytes(path, limit: 64 * 1024, nonempty: false) }
+            parts = [bytes, *artifacts]
+            digest = Digest::SHA256.hexdigest(bytes)
+            input = Struct.new(:parts) do
+              def count = parts.length
+              def bytes(index: 0) = parts.fetch(index)
+            end.new(parts)
+            # Reuse the maintained ordered artifact validator. This is input
+            # checking only; canonical result/producer admission remains Endcap's.
+            Ace::Assign::Authority::ReceiptTransfer.decode(input: input, receipt_sha256: digest,
+              artifact_field: "artifacts", reference_key: "path")
+            params["receipt_sha256"] = digest
+            emit_json(upload_call(client, "submit_result", params, mutation, parts, :receipt_artifacts))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/assign/cli.rb

@@ -44,6 +44,7 @@ require_relative "molecules/runtime_control_surface_runner"
 require_relative "molecules/preset_inferrer"
 require_relative "molecules/evidence_calculator"
 require_relative "molecules/evidence_journal"
+require_relative "molecules/canonical_evidence"
 require_relative "molecules/execution_identity_resolver"
 require_relative "molecules/receipt_verifier"
 require_relative "molecules/attempt_reconciler"
@@ -53,9 +54,16 @@ require_relative "organisms/assignment_executor"
 require_relative "organisms/attempt_coordinator"
 
 # Commands
-require_relative "cli/commands/create"
+require_relative "cli/commands/delivery"
 require_relative "cli/commands/assignment_target"
+require_relative "cli/commands/create"
 require_relative "cli/commands/status"
+require_relative "cli/commands/resume"
+require_relative "cli/commands/inbox_bind"
+require_relative "cli/commands/submit_candidate"
+require_relative "cli/commands/submit_result"
+require_relative "cli/commands/campaign_record_round"
+require_relative "cli/commands/campaign_export_result"
 require_relative "cli/commands/step"
 require_relative "cli/commands/start"
 require_relative "cli/commands/finish"
@@ -66,6 +74,16 @@ require_relative "cli/commands/list"
 require_relative "cli/commands/select"
 require_relative "cli/commands/fork_run"
 require_relative "cli/commands/fork_session"
+require_relative "cli/commands/authority/serve"
+require_relative "cli/commands/authority/launch"
+require_relative "cli/commands/authority/status"
+require_relative "cli/commands/authority/terminate"
+require_relative "cli/commands/authority/worker"
+require_relative "cli/commands/authority/task_context"
+require_relative "cli/commands/authority/task_context_principal"
+require_relative "cli/commands/authority/task_context_selection"
+require_relative "cli/commands/authority/inbox_context_principal"
+require_relative "cli/commands/authority/inbox_context_selection"
 require_relative "cli/commands/attempt/base"
 require_relative "cli/commands/attempt/start"
 require_relative "cli/commands/attempt/status"
@@ -84,6 +102,21 @@ module Ace
       # Application commands with descriptions (for help output)
       REGISTERED_COMMANDS = [
         ["create", "Create assignment from preset or YAML"],
+        ["authority serve", "Serve the installed protected assignment owner"],
+        ["authority launch", "Launch one mapped native gated worker"],
+        ["authority status", "Inspect protected launch ownership"],
+        ["authority terminate", "Terminate the original native gated child"],
+        ["authority worker", "Consume original authenticated prepared work"],
+        ["authority task-context", "Read captured original task context through the fixed entry"],
+        ["authority task-context-principal", "Classify the actual caller through retained protected owners"],
+        ["authority task-context-selection", "Read the authenticated original context entry selection"],
+        ["authority inbox-context-principal", "Classify the actual caller through every retained protected owner"],
+        ["authority inbox-context-selection", "Read the fixed installed inbox context selection"],
+        ["delivery", "Execute or reconcile attempt-bound forge delivery"],
+        ["submit-candidate", "Submit original protected worker candidate bytes"],
+        ["submit-result", "Submit original protected worker receipt and artifact bytes"],
+        ["campaign-export-result", "Download the original parent campaign's verified accepted result"],
+        ["campaign-record-round", "Consume canonical settled children into the original campaign store"],
         ["status", "Show assignment status"],
         ["step", "Show step instructions"],
         ["start", "Start next workable step"],
@@ -97,8 +130,9 @@ module Ace
         ["attempt start", "Start a scoped attempt for an assignment step"],
         ["attempt status", "Show attempt status for an assignment"],
         ["attempt evidence", "Read accepted current-head check evidence"],
-        ["attempt finish", "Finish an attempt with a structured execution receipt"],
-        ["attempt reconcile", "Reconcile an interrupted or uncertain attempt"]
+        ["attempt finish", "Finish a protected canonical result or an ordinary local receipt"],
+        ["attempt reconcile", "Recover an exact protected attempt or reconcile an ordinary attempt"],
+        ["inbox-bind", "Bind an original protected Inbox registration"],
       ].freeze
 
       HELP_EXAMPLES = [
@@ -110,7 +144,8 @@ module Ace
         "cat report.md | ace-assign finish     # Complete step via stdin",
         "ace-assign fork-run 010.01            # Run subtree in subprocess",
         "ace-assign attempt start --assignment ID --step 010 --project ID",
-        "ace-assign attempt finish --attempt ID --receipt receipt.json"
+        "ace-assign attempt finish --attempt ID --receipt receipt.json",
+        "ace-assign resume --assignment ID --dry-run"
       ].freeze
 
       # Captured command exit code from last run
@@ -146,7 +181,18 @@ module Ace
       end
 
       # Register commands (wrapped to capture exit codes)
+      register "authority serve", wrap_command(Commands::Authority::Serve)
+register "authority launch", wrap_command(Commands::Authority::Launch)
+register "authority status", wrap_command(Commands::Authority::Status)
+register "authority terminate", wrap_command(Commands::Authority::Terminate)
+register "authority worker", wrap_command(Commands::Authority::Worker)
+register "authority task-context", wrap_command(Commands::Authority::TaskContext)
+register "authority task-context-principal", wrap_command(Commands::Authority::TaskContextPrincipal)
+register "authority task-context-selection", wrap_command(Commands::Authority::TaskContextSelection)
+register "authority inbox-context-principal", wrap_command(Commands::Authority::InboxContextPrincipal)
+register "authority inbox-context-selection", wrap_command(Commands::Authority::InboxContextSelection)
       register "create", wrap_command(Commands::Create)
+      register "delivery", wrap_command(Commands::Delivery)
       register "status", wrap_command(Commands::Status)
       register "step", wrap_command(Commands::Step)
       register "start", wrap_command(Commands::Start)
@@ -163,6 +209,12 @@ module Ace
       register "attempt evidence", wrap_command(Commands::Attempt::Evidence)
       register "attempt finish", wrap_command(Commands::Attempt::Finish)
       register "attempt reconcile", wrap_command(Commands::Attempt::Reconcile)
+      register "resume", wrap_command(Commands::Resume)
+      register "inbox-bind", wrap_command(Commands::InboxBind)
+      register "submit-candidate", wrap_command(Commands::SubmitCandidate)
+      register "submit-result", wrap_command(Commands::SubmitResult)
+      register "campaign-export-result", wrap_command(Commands::CampaignExportResult)
+      register "campaign-record-round", wrap_command(Commands::CampaignRecordRound)
 
       # Register version command
       version_cmd = Ace::Support::Cli::VersionCommand.build(

data/lib/ace/assign/errors.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+require "ace/support/cli/error"
+
+module Ace
+  module Assign
+    # Base error class for all ace-assign exceptions.
+    # Inherits from Ace::Support::Cli::Error to support exception-based
+    # exit code pattern (per ADR-023).
+    #
+    # Subclasses should call super with appropriate exit_code.
+    class Error < Ace::Support::Cli::Error
+      def initialize(message, exit_code: 1)
+        super
+      end
+    end
+
+    # Assignment-related errors
+    module AssignmentErrors
+      class NotFound < Error
+        def initialize(message = "Assignment not found")
+          super(message, exit_code: 2)
+        end
+      end
+
+      class NoActive < Error
+        def initialize(message = "No active assignment")
+          super(message, exit_code: 2)
+        end
+      end
+    end
+
+    # Config-related errors
+    module ConfigErrors
+      class NotFound < Error
+        def initialize(message = "Configuration not found")
+          super(message, exit_code: 3)
+        end
+      end
+    end
+
+    # Step-related errors
+    module StepErrors
+      class NotFound < Error
+        def initialize(message = "Step not found")
+          super(message, exit_code: 4)
+        end
+      end
+
+      class InvalidState < Error; end
+    end
+
+    # Attempt/evidence-related errors (exit code 5)
+    module AttemptErrors
+      class InvalidTransition < Error
+        def initialize(message = "Illegal attempt state transition")
+          super(message, exit_code: 5)
+        end
+      end
+
+      class InvalidScope < Error
+        def initialize(message = "Invalid attempt scope")
+          super(message, exit_code: 5)
+        end
+      end
+
+      # Duplicate start with a conflicting binding for an owned subtree
+      class Conflict < Error
+        def initialize(message = "Conflicting active attempt for scope")
+          super(message, exit_code: 5)
+        end
+      end
+
+      class NotFound < Error
+        def initialize(message = "Attempt not found")
+          super(message, exit_code: 5)
+        end
+      end
+
+      # Untrusted or unknown execution identity; authority fails closed
+      class UnauthorizedIdentity < Error
+        def initialize(message = "Unknown or unauthorized execution identity")
+          super(message, exit_code: 5)
+        end
+      end
+
+      # Receipt failed verification (binding, head, digest, artifacts, review)
+      class ReceiptRejected < Error
+        def initialize(message = "Receipt rejected")
+          super(message, exit_code: 5)
+        end
+      end
+
+      # Byte framing failed before any business receipt could be admitted.
+      class MalformedTransfer < ReceiptRejected; end
+
+      # Recovery settled a prior effect, but did not perform this request.
+      class CurrentEffectRequired < ReceiptRejected
+        def initialize(operation:, recovered_operation:)
+          super("Recovered #{recovered_operation}; requested #{operation} still needs execution")
+        end
+      end
+
+      # Attempt state forbids the requested effect (terminal, uncertain, blocked)
+      class InvalidState < Error
+        def initialize(message = "Attempt state forbids the requested operation")
+          super(message, exit_code: 5)
+        end
+      end
+
+      # Evidence storage is missing or unwritable; external effects are blocked
+      class EvidenceUnavailable < Error
+        def initialize(message = "Evidence storage unavailable")
+          super(message, exit_code: 5)
+        end
+      end
+
+      # Complete maintenance exclusions are busy or their admission deadline expired.
+      class MaintenanceBusy < EvidenceUnavailable
+      end
+
+      # One canonical inventory row cannot fit the fixed protocol frame.
+      class BoundedResultUnavailable < EvidenceUnavailable
+      end
+
+      # Exhaustively authenticated service inventory remains unsettled.
+      class ServiceSettlementPending < EvidenceUnavailable
+      end
+
+      # Exhaustively authenticated current Inbox claims remain queued.
+      class InboxSettlementPending < EvidenceUnavailable
+      end
+
+      # Positively admitted original Inbox work remains pending, not corrupt.
+      class InboxContextPending < EvidenceUnavailable
+      end
+    end
+
+  end
+end

data/lib/ace/assign/models/assignment.rb

@@ -20,7 +20,7 @@ module Ace
       # but tests would need to be updated to provide all required fields.
       class Assignment
         attr_reader :id, :name, :description, :created_at, :updated_at, :source_config, :cache_dir, :parent,
-          :task_id, :project_id
+          :task_id, :project_id, :campaign_execution, :review_campaign
 
         # @param id [String] Unique assignment ID (6-char compact timestamp)
         # @param name [String] Human-readable assignment name
@@ -33,7 +33,7 @@ module Ace
         # @param task_id [String, nil] Source task ID attached to this assignment (nil = taskless)
         # @param project_id [String, nil] Project ID this assignment executes in
         def initialize(id:, name:, created_at:, source_config:, description: nil, updated_at: nil, cache_dir: nil,
-          parent: nil, task_id: nil, project_id: nil)
+          parent: nil, task_id: nil, project_id: nil, campaign_execution: nil, review_campaign: nil)
           @id = id.freeze
           @name = name.freeze
           @description = description&.freeze
@@ -44,6 +44,24 @@ module Ace
           @parent = parent&.freeze
           @task_id = task_id&.freeze
           @project_id = project_id&.freeze
+          if !campaign_execution.nil? && !review_campaign.nil?
+            raise ArgumentError, "assignment cannot own both parent campaign and child execution"
+          end
+          @campaign_execution = immutable_campaign_execution(campaign_execution) unless campaign_execution.nil?
+          @review_campaign = immutable_campaign_execution(review_campaign) unless review_campaign.nil?
+        end
+
+        # Keep registered definition bytes stable without retaining caller-owned
+        # mutable objects. Authority validates the closed linkage and provenance.
+        private def immutable_campaign_execution(value)
+          case value
+          when Hash
+            value.to_h { |key, item| [immutable_campaign_execution(key), immutable_campaign_execution(item)] }.freeze
+          when Array then value.map { |item| immutable_campaign_execution(item) }.freeze
+          when String then value.dup.freeze
+          when Integer, NilClass, TrueClass, FalseClass then value
+          else raise ArgumentError, "invalid campaign execution value"
+          end
         end
 
         # @return [Boolean] True when a source task is attached; taskless
@@ -65,7 +83,9 @@ module Ace
             "source_config" => source_config,
             "parent" => parent,
             "task_id" => task_id,
-            "project_id" => project_id
+            "project_id" => project_id,
+            "campaign_execution" => campaign_execution,
+            "review_campaign" => review_campaign
           }.compact
         end
 
@@ -84,7 +104,9 @@ module Ace
             cache_dir: cache_dir,
             parent: data["parent"],
             task_id: data["task_id"],
-            project_id: data["project_id"]
+            project_id: data["project_id"],
+            campaign_execution: data["campaign_execution"],
+            review_campaign: data["review_campaign"]
           )
         end
 

data/lib/ace/assign/models/evidence_event.rb

@@ -15,9 +15,11 @@ module Ace
       # metadata only.
       module EvidenceEvent
         TYPES = %w[
-          intent process_start receipt_accepted transition
+          intent process_start receipt_accepted transition attempt_stopped
           candidate_invalidated reconciliation
-          service_claim service_transition
+          service_claim service_transition service_challenge service_no_effect_challenge service_publication_challenge service_publication_issuing recovery_observation inbox_binding delivery
+          authority_mutation evidence_import proposal_state result_submitted prompt_issued prompt_outcome prompt_completion_observed input_inhibited
+          scope_provisioning scope_bound scope_native_bound scope_child_bound scope_sealed scope_closed_no_writers
         ].freeze
 
         # Build an event chained to a previous digest.

data/lib/ace/assign/molecules/assignment_manager.rb

@@ -13,7 +13,8 @@ module Ace
       # Uses ace-b36ts for assignment ID generation.
       class AssignmentManager
         # @param cache_base [String] Base cache directory
-        def initialize(cache_base: nil)
+        def initialize(cache_base: nil, selected_assignment: nil)
+          @selected_assignment = selected_assignment
           @cache_base = cache_base || Ace::Assign.cache_dir
         end
 
@@ -85,6 +86,7 @@ module Ace
         #
         # @return [Models::Assignment, nil] Most recent assignment or nil
         def find_active
+          return @selected_assignment if @selected_assignment
           return nil unless File.directory?(@cache_base)
 
           # Priority 1: use .current symlink if it exists (explicit selection)
@@ -185,6 +187,7 @@ module Ace
           )
 
           write_assignment_file(updated)
+          @selected_assignment = updated if @selected_assignment && @selected_assignment.id == updated.id
 
           # Update .latest symlink since this assignment was just updated
           update_latest_symlink(assignment.id)
@@ -259,7 +262,14 @@ module Ace
 
         def write_assignment_file(assignment)
           assignment_file = File.join(assignment.cache_dir, "assignment.yaml")
-          File.write(assignment_file, assignment.to_h.to_yaml)
+          if @selected_assignment
+            File.open(assignment_file, File::WRONLY | File::TRUNC | File::NOFOLLOW | File::NONBLOCK) do |file|
+              raise ArgumentError, "selected assignment metadata is not regular" unless file.stat.file?
+              file.write(assignment.to_h.to_yaml); file.flush; file.fsync
+            end
+          else
+            File.write(assignment_file, assignment.to_h.to_yaml)
+          end
         end
 
         def load_from_file(assignment_file)

data/lib/ace/assign/molecules/attempt_reconciler.rb

@@ -1,4 +1,7 @@
 # frozen_string_literal: true
+require_relative "canonical_attempt_state"
+
+require "json"
 
 module Ace
   module Assign
@@ -6,7 +9,7 @@ module Ace
       # Conservative classification and resolution of interrupted attempts.
       #
       # Classification of a `running` attempt found after a lost session:
-      # - no recorded process start -> `stopped` (nothing could have run)
+      # - no recorded process start -> `uncertain` (launch may be unbound)
       # - recorded process still verifiably live -> keep `running`
       # - otherwise -> `uncertain` (the operation may have completed without
       #   a durable receipt)
@@ -17,11 +20,28 @@ module Ace
       # effects are never retried automatically, and an uncertain attempt
       # without a receipt stays uncertain.
       class AttemptReconciler
+        # The protected boundary supplies authenticated original scope facts
+        # and exact kernel identities; never a runtime discovered by pane name.
+        def self.protected_observation(kernel:, binding:, observer:, lineage:)
+          return {"liveness" => "unknown"} if lineage.sealed?
+          kernel.live!(binding.fetch("process_identity"))
+          kernel.live!(binding.fetch("native_origin").fetch("server_identity"))
+          observation = observer.observe(lineage)
+          unless observation.is_a?(Hash) && observation["populated"].is_a?(Integer) && observation["populated"].positive?
+            return {"liveness" => "unknown"}
+          end
+          {"liveness" => "live", "identity" => binding.fetch("process_identity"), "runtime_binding" => binding}
+        rescue AttemptErrors::EvidenceUnavailable, Ace::Runtime::RuntimeUnavailableError
+          {"liveness" => "unknown"}
+        end
+
         # @param journal [EvidenceJournal, nil] Managed evidence journal
         # @param verifier [ReceiptVerifier, nil] Receipt verifier (coordinator supplies on use)
-        def initialize(journal: nil, verifier: nil)
+        def initialize(journal: nil, verifier: nil, observer: nil, runtime_resolver: Ace::Runtime)
           @journal = journal
           @verifier = verifier
+          @observer = observer || Ace::Runtime::Molecules::ProcessIdentity.new
+          @runtime_resolver = runtime_resolver
         end
 
         # Classify a running attempt after an interruption.
@@ -29,9 +49,11 @@ module Ace
         # @param attempt [Models::Attempt] Running attempt
         # @return [Symbol] :stopped, :live, or :uncertain
         def classify(attempt)
+          events = events_for(attempt)
+          if events.any? { |event| event["type"] == "attempt_stopped" } && CanonicalAttemptState.derive(events) == "stopped"
+            return :stopped
+          end
           return :live if process_live?(attempt)
-          return :stopped unless process_started?(attempt)
-
           :uncertain
         end
 
@@ -44,15 +66,27 @@ module Ace
         # @param attempt [Models::Attempt] Attempt to inspect
         # @return [Boolean] True when the recorded process is verifiably alive
         def process_live?(attempt)
-          pid = start_event(attempt)&.dig("payload", "pid")
-          return false unless pid
+          observation(attempt)["liveness"] == "live"
+        end
 
-          Process.kill(0, pid)
-          true
-        rescue Errno::EPERM
-          true
-        rescue Errno::ESRCH, TypeError, ArgumentError
-          false
+        def observation(attempt)
+          payload = start_event(attempt)&.dig("payload")
+          observation = @observer.observe(payload&.dig("process_identity"))
+          binding = payload&.dig("runtime_binding")
+          return observation unless binding && observation["liveness"] == "live"
+
+          live = @runtime_resolver.resolve(binding["runtime"]).process_binding(
+            pane: binding["pane"], caller_pid: binding.dig("process_identity", "pid"))
+          return observation if binding == live
+
+          observation.merge("liveness" => "unknown", "reason" => "native process/session binding changed")
+        rescue Ace::Runtime::Error
+          {"liveness" => "unknown", "observed_at" => Time.now.utc.iso8601,
+            "reason" => "native process/session observation unavailable"}
+        end
+
+        def events(attempt)
+          events_for(attempt)
         end
 
         # Runtime recorded at the attempt's process start — the boundary any
@@ -64,6 +98,11 @@ module Ace
           start_event(attempt)&.dig("payload", "runtime")
         end
 
+        def recorded_binding(attempt)
+          binding = start_event(attempt)&.dig("payload", "runtime_binding")
+          JSON.parse(JSON.generate(binding)) if binding.is_a?(Hash)
+        end
+
         private
 
         def start_event(attempt)