ace-assign 0.71.0 → 0.73.0

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

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-require_relative "protected_submission"
-require_relative "../../authority/campaign_round_transfer"
-
-module Ace
-  module Assign
-    module CLI
-      module Commands
-        class CampaignRecordRound < Ace::Support::Cli::Command
-          include Ace::Support::Cli::Base
-          include ProtectedSubmission
-          desc "Consume settled protected campaign children into the original R1 store"
-          option :mapping, desc: "Original installed parent mapping"
-          option :assignment, desc: "Original parent assignment"
-          option :attempt, desc: "Original parent attempt"
-          option :head, desc: "Exact parent candidate head"
-          option :candidate_generation, desc: "Exact parent candidate counter"
-          option :mutation, desc: "Stable R1 round attempt ID"
-          option :input, desc: "Closed bounded round envelope"
-          option :artifact, type: :array, desc: "Ordered report byte files"
-
-          def call(**options)
-            usage = "campaign-record-round with original parent selectors, --mutation ID and --input FILE"
-            context = protected_context(options)
-            raise AttemptErrors::EvidenceUnavailable, "Campaign consumption requires installed authority" unless context
-            params = {"assignment_id" => require_option(options, :assignment, usage),
-              "attempt_id" => require_option(options, :attempt, usage), "head" => require_option(options, :head, usage),
-              "candidate_generation" => integer_option(options, :candidate_generation, usage, positive: true)}
-            unless params["head"].match?(/\A[0-9a-f]{40}\z/)
-              raise Ace::Support::Cli::Error, "Campaign head must be an exact SHA-1"
-            end
-            context.verify_attempt_hints!(assignment_id: params.fetch("assignment_id"), attempt_id: params.fetch("attempt_id"))
-            mutation = require_option(options, :mutation, usage)
-            bytes = input_bytes(require_option(options, :input, usage), limit: 16 * 1024)
-            files = options.fetch(:artifact, [])
-            raise Ace::Support::Cli::Error, "Campaign artifacts require at most 16 files" unless files.is_a?(Array) && files.size <= 16
-            parts = [bytes, *files.map { |path| input_bytes(path, limit: 64 * 1024, nonempty: false) }]
-            params["input_sha256"] = Digest::SHA256.hexdigest(bytes)
-            input = Struct.new(:parts) do
-              def count = parts.length
-              def bytes(index:) = parts.fetch(index)
-            end.new(parts)
-            admitted = Ace::Assign::Authority::CampaignRoundTransfer.decode(input: input, sha256: params.fetch("input_sha256"))
-            unless admitted.fetch(:round).values_at("attempt_id", "head") == [mutation, params.fetch("head")]
-              raise Ace::Support::Cli::Error, "Campaign input request ID or head differs"
-            end
-            emit_json(upload_call(context.client(options: options), "campaign_record_round", params, mutation, parts, :receipt_artifacts))
-          rescue SecurityError, Ace::Runtime::RuntimeUnavailableError
-            protected_transport_unavailable!
-          rescue ArgumentError => error
-            raise Ace::Support::Cli::Error, error.message
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-require "json"
-require_relative "../../authority/protected_assignment_context"
-require_relative "../../organisms/protected_delivery_coordinator"
-
-module Ace
-  module Assign
-    module CLI
-      module Commands
-        class Delivery < Ace::Support::Cli::Command
-          desc "Execute or reconcile attempt-bound forge delivery"
-          option :assignment, required: true, desc: "Managed assignment ID"
-          option :attempt, required: true, desc: "Active delivery attempt ID"
-          option :operation, required: true, desc: "create, update, ready, review, merge, status"
-          option :parameters, desc: "JSON delivery parameters (otherwise assignment source delivery mapping)"
-          option :title, desc: "PR title"
-          option :body_file, desc: "PR description file"
-          option :tests, desc: "JSON reference to coordinator-accepted test attempt and receipt digest"
-          option :review, desc: "JSON reference to coordinator-accepted independent review attempt and receipt digest"
-          option :service_request, desc: "Original authorized PR service request ID"
-          option :mapping, desc: "Installed original protected mapping selector"
-          option :scope, desc: "Original prepared worker scope"
-          option :candidate_head, desc: "Exact original protected candidate SHA"
-          option :candidate_generation, type: :integer, desc: "Exact original protected candidate generation"
-          option :input_digest, desc: "Exact original accepted service input SHA256"
-          option :target, desc: "Exact original target repository or PR URL"
-          option :artifact_digest, desc: "Original target artifact SHA256, if present"
-
-          def initialize(protected_context: nil)
-            @protected_assignment_context = protected_context
-          end
-
-          def call(**options)
-            context = @protected_assignment_context ||= Ace::Assign::Authority::ProtectedAssignmentContext.load
-            protected = context.protected_participant? || options[:mapping] || context.mapping_hint?
-            if protected
-              unless context.protected_worker?
-                raise AttemptErrors::EvidenceUnavailable, "protected delivery is worker-only"
-              end
-              unless %w[create update ready merge status].include?(options[:operation]) && %i[title body_file tests review].all? { |key| options[key].nil? }
-                raise ArgumentError, "protected delivery accepts canonical PR results/status only; local input/evidence flags are unavailable"
-              end
-              input = context.resolve(options: options, assignment_id: options[:assignment], scope: options[:scope])
-              raise AttemptErrors::EvidenceUnavailable, "original protected prepared input is unavailable" unless input
-              result = Organisms::ProtectedDeliveryCoordinator.new(client: context.client(options: options),
-                project_id: input.work.manifest.fetch("project_id")).perform(assignment_id: options[:assignment],
-                  attempt_id: options[:attempt], operation: options[:operation], service_request_id: options[:service_request],
-                  candidate_head: options[:candidate_head], candidate_generation: options[:candidate_generation],
-                  input_digest: options[:input_digest], target: {"resource" => options[:target], "artifact_digest" => options[:artifact_digest]},
-                  parameters: read_json(options[:parameters]))
-              puts JSON.generate(json_value(result))
-              return
-            end
-            if %i[mapping scope candidate_head candidate_generation input_digest target artifact_digest].any? { |key| options[key] }
-              raise ArgumentError, "protected delivery selectors cannot select ordinary local delivery"
-            end
-            result = build_delivery.perform(assignment_id: options[:assignment], attempt_id: options[:attempt],
-              operation: options[:operation], parameters: read_json(options[:parameters]),
-              title: options[:title], body: options[:body_file] && File.read(options[:body_file]),
-              tests: read_json(options[:tests]), review: read_json(options[:review]),
-              service_request_id: options[:service_request])
-            puts JSON.generate(json_value(result))
-          rescue ArgumentError, Ace::Git::Error, Ace::Assign::Error, Ace::Runtime::RuntimeUnavailableError,
-            JSON::ParserError, SecurityError, SystemCallError => e
-            message = e.is_a?(JSON::ParserError) ? "protected installed selection unavailable" : e.message
-            raise Ace::Support::Cli::Error, message
-          end
-
-          private
-
-          def build_delivery
-            Organisms::DeliveryCoordinator.new(repo_root: Ace::Support::Fs::Molecules::ProjectRootFinder.find_or_current)
-          end
-
-          def read_json(path)
-            return nil unless path
-            bytes = File.open(path, File::RDONLY | File::NOFOLLOW | File::NONBLOCK) do |file|
-              before = file.stat
-              raise ArgumentError, "Delivery input must be a bounded regular file" unless before.file? && before.size <= 65_536
-              value = file.read(65_537)
-              after = file.stat
-              unless value && value.bytesize <= 65_536 &&
-                  [before.dev, before.ino, before.size, before.mtime, before.ctime] == [after.dev, after.ino, after.size, after.mtime, after.ctime]
-                raise ArgumentError, "Delivery input changed or exceeds its bound"
-              end
-              value
-            end
-            data = JSON.parse(bytes, max_nesting: 16, create_additions: false,
-              allow_duplicate_key: false, allow_comments: false, allow_nan: false)
-            raise ArgumentError, "Delivery input must be a JSON object" unless data.is_a?(Hash)
-            data
-          rescue JSON::ParserError
-            raise ArgumentError, "Delivery input must be valid JSON"
-          end
-
-          def json_value(value)
-            case value
-            when Hash then value.transform_values { |item| json_value(item) }
-            when Array then value.map { |item| json_value(item) }
-            else value.respond_to?(:to_h) ? json_value(value.to_h) : value
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-require_relative "attempt/base"
-
-module Ace
-  module Assign
-    module CLI
-      module Commands
-        class InboxBind < Ace::Support::Cli::Command
-          include Ace::Support::Cli::Base
-          include Attempt::Base
-
-          desc "Bind an original protected Inbox registration before scope closure"
-          option :mapping, desc: "Exact installed mapping ID"
-          option :assignment, desc: "Exact original assignment ID"
-          option :attempt, desc: "Exact original attempt ID"
-          option :event, desc: "Original Inbox event ID"
-          option :inbox_context, desc: "Installed Inbox context ID"
-          option :mutation, desc: "Stable original authority mutation ID"
-          option :expected_generation, desc: "Original authority mutation generation"
-
-          def call(**options)
-            context = protected_context(options)
-            raise AttemptErrors::EvidenceUnavailable, "Inbox binding requires installed protected authority" unless context
-            usage = "inbox-bind --mapping MAP --assignment ID --attempt ID --event ID --inbox-context ID --mutation ID --expected-generation N"
-            client, params, mutation = protected_attempt_request(context, options, usage)
-            params.merge!("event_id" => require_option(options, :event, usage),
-              "inbox_context_id" => require_option(options, :inbox_context, usage))
-            emit_json(protected_call(client, "bind_inbox", params, mutation))
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-require_relative "attempt/base"
-require "digest"
-
-module Ace
-  module Assign
-    module CLI
-      module Commands
-        # Local files provide bounded bytes; only the existing authority grants admission.
-        module ProtectedSubmission
-          include Attempt::Base
-          private
-
-          def require_option(options, key, usage)
-            value = options[key].to_s.strip
-            raise Ace::Support::Cli::Error, "Missing --#{key}: usage: ace-assign #{usage}" if value.empty?
-            value
-          end
-
-          def submission_request(options, usage)
-            context = protected_context(options)
-            raise AttemptErrors::EvidenceUnavailable, "Submission requires installed protected authority" unless context
-            protected_attempt_request(context, options, usage)
-          end
-
-          def input_bytes(path, limit:, nonempty: true)
-            File.open(path, File::RDONLY | File::NOFOLLOW | File::NONBLOCK) do |file|
-              before = file.stat
-              raise Ace::Support::Cli::Error, "Input must be a bounded regular file" unless before.file? && before.size.between?(nonempty ? 1 : 0, limit)
-              bytes = file.read(limit + 1)
-              after = file.stat
-              selected = File.lstat(path)
-              identity = ->(stat) { [stat.dev, stat.ino, stat.size, stat.mtime, stat.ctime] }
-              unless bytes.bytesize == before.size && identity.call(before) == identity.call(after) &&
-                  identity.call(after) == identity.call(selected) && !selected.symlink?
-                raise Ace::Support::Cli::Error, "Input changed during bounded read"
-              end
-              bytes.freeze
-            end
-          rescue SystemCallError, IOError
-            raise Ace::Support::Cli::Error, "Input file is unavailable"
-          end
-
-          def input_json(bytes)
-            text = bytes.dup.force_encoding(Encoding::UTF_8)
-            raise Ace::Support::Cli::Error, "Input JSON is malformed" unless text.valid_encoding?
-            JSON.parse(text, create_additions: false, max_nesting: 32, allow_duplicate_key: false, allow_comments: false)
-          rescue JSON::ParserError
-            raise Ace::Support::Cli::Error, "Input JSON is malformed"
-          end
-
-          def upload_call(client, operation, params, mutation, parts, purpose)
-            client.call(operation, params, mutation_id: mutation, upload_parts: parts, purpose: purpose, timeout: 30).data
-          rescue SecurityError, Ace::Runtime::RuntimeUnavailableError, SystemCallError, IOError
-            protected_transport_unavailable!
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-
-module Ace
-  module Assign
-    module CLI
-      module Commands
-        class Resume < Ace::Support::Cli::Command
-          include Ace::Support::Cli::Base
-          include AssignmentTarget
-          desc "Recover accepted assignment state without launching another writer"
-          option :assignment, desc: "Assignment ID"
-          option :mapping, desc: "Installed protected launch mapping ID"
-          option :attempt, desc: "Original protected attempt ID"
-          option :dry_run, type: :boolean, default: false, desc: "Inspect recovery without writing observations"
-
-          def call(**options)
-            target = resolve_assignment_target(options)
-            if target.prepared_input
-              raise Ace::Support::Cli::Error, "protected resume only supports --dry-run" unless options[:dry_run]
-              result = build_executor_for_target(target).status
-              descriptor = target.prepared_input.descriptor
-              puts JSON.generate(descriptor.slice("assignment_id", "mapping_id", "attempt_id", "scope", "definition_digest", "selection_sha256").merge(
-                "state" => result.fetch(:state).assignment_state.to_s, "dry_run" => true))
-              return
-            end
-            id = options[:assignment].to_s.strip
-            raise Ace::Support::Cli::Error, "--assignment ID is required" if id.empty?
-
-            puts JSON.generate(Organisms::AttemptCoordinator.new.resume(
-              assignment_id: id, dry_run: options[:dry_run]))
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-# 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: Ace::Assign::Authority::CandidateTransfer::MAX_BYTES)
-            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

@@ -1,61 +0,0 @@
-# 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/models/attempt.rb

@@ -1,178 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../atoms/attempt_state_machine"
-require_relative "attempt_binding"
-
-module Ace
-  module Assign
-    module Models
-      # Mutable derived state of an assignment attempt.
-      #
-      # The binding is immutable; an Attempt carries the derived execution
-      # state: the current state-machine state, the pinned candidate head,
-      # the latest evidence journal commit, accepted receipts (by digest),
-      # recorded effects, and the append-only local event trail for
-      # taskless attempts. `base_head` (binding) and `candidate_head`
-      # (deliverable) are always tracked separately.
-      class Attempt
-        attr_reader :binding, :state, :candidate_head, :journal_commit,
-          :accepted_receipts, :effects, :events, :updated_at
-
-        # @param binding [Models::AttemptBinding] Immutable start-time binding
-        # @param state [String] State-machine state
-        # @param candidate_head [String, nil] Pinned deliverable head
-        # @param journal_commit [String, nil] Latest evidence journal commit SHA
-        # @param accepted_receipts [Array<Hash>] Accepted receipt payloads (digests included)
-        # @param effects [Array<Hash>] Recorded effects with intent/receipt linkage
-        # @param events [Array<Hash>] Local event trail (taskless attempts only)
-        # @param updated_at [Time] Last state change
-        def initialize(binding:, state: "reserved", candidate_head: nil, journal_commit: nil,
-          accepted_receipts: [], effects: [], events: [], updated_at: nil)
-          @binding = binding
-          @state = state.to_s
-          @candidate_head = candidate_head
-          @journal_commit = journal_commit
-          @accepted_receipts = accepted_receipts.dup.freeze
-          @effects = effects.dup.freeze
-          @events = events.dup.freeze
-          @updated_at = updated_at || binding.created_at
-        end
-
-        # @return [String] Immutable attempt ID
-        def attempt_id
-          binding.attempt_id
-        end
-
-        # @return [Boolean] True if no further transitions or effects are allowed
-        def terminal?
-          Atoms::AttemptStateMachine.terminal?(state)
-        end
-
-        # @return [Boolean] True if the attempt awaits reconciliation
-        def uncertain?
-          state == "uncertain"
-        end
-
-        # @return [Boolean] True if the attempt owns an active subtree slot
-        def active?
-          %w[reserved running uncertain].include?(state)
-        end
-
-        # @return [String] "git" or "local_only" recovery mode
-        def recovery_mode
-          binding.recovery_mode
-        end
-
-        # @return [Boolean] True when managed evidence-ref journaling applies
-        def managed?
-          binding.managed?
-        end
-
-        # Effects whose intent was recorded but whose accepted receipt is missing.
-        #
-        # @return [Array<Hash>] Unresolved effect records
-        def unresolved_effects
-          effects.reject { |effect| effect["receipt_digest"] }
-        end
-
-        # Return a new Attempt with the state transitioned.
-        #
-        # @param to [String] Target state (validated against the state machine)
-        # @param at [Time] Transition time
-        # @return [Attempt] New attempt instance
-        # @raise [Ace::Assign::AttemptErrors::InvalidTransition] if illegal
-        def transition(to, at: Time.now.utc)
-          Atoms::AttemptStateMachine.transition!(state, to)
-          with(state: to.to_s, updated_at: at)
-        end
-
-        # Return a new Attempt with updated derived fields. The binding is
-        # never replaced.
-        #
-        # @param attrs [Hash] Fields to override (state, candidate_head,
-        #   journal_commit, accepted_receipts, effects, events, updated_at)
-        # @return [Attempt] New attempt instance
-        def with(**attrs)
-          Attempt.new(
-            binding: binding,
-            state: attrs.fetch(:state, state),
-            candidate_head: attrs.fetch(:candidate_head, candidate_head),
-            journal_commit: attrs.fetch(:journal_commit, journal_commit),
-            accepted_receipts: attrs.fetch(:accepted_receipts, accepted_receipts),
-            effects: attrs.fetch(:effects, effects),
-            events: attrs.fetch(:events, events),
-            updated_at: attrs.fetch(:updated_at, Time.now.utc)
-          )
-        end
-
-        # Convert to a hash for canonical serialization.
-        # @return [Hash] Attempt data with string keys
-        def to_h
-          {
-            "binding" => binding.to_h,
-            "state" => state,
-            "candidate_head" => candidate_head,
-            "journal_commit" => journal_commit,
-            "accepted_receipts" => accepted_receipts,
-            "effects" => effects,
-            "events" => events,
-            "updated_at" => updated_at.iso8601
-          }
-        end
-
-        # JSON projection exposed by public commands. Contains attempt
-        # ID, state, binding facts, references and digests only — never
-        # credentials, receipt bytes, or terminal output.
-        #
-        # @return [Hash] Redacted projection
-        def projection
-          {
-            "attempt_id" => attempt_id,
-            "state" => state,
-            "assignment_id" => binding.assignment_id,
-            "scope" => binding.scope,
-            "project_id" => binding.project_id,
-            "task_id" => binding.task_id,
-            "actor" => binding.actor,
-            "role" => binding.role,
-            "runtime" => binding.runtime,
-            "base_head" => binding.base_head,
-            "candidate_head" => candidate_head,
-            "evidence_git_ref" => binding.evidence_git_ref,
-            "journal_commit" => journal_commit,
-            "recovery_mode" => recovery_mode,
-            "accepted_receipt_digests" => accepted_receipts.map { |receipt| receipt["digest"] },
-            "unresolved_effects" => unresolved_effects.map { |effect| effect["operation"] },
-            "created_at" => binding.created_at.iso8601,
-            "updated_at" => updated_at.iso8601
-          }
-        end
-
-        # Rebuild an attempt from serialized data.
-        #
-        # @param data [Hash] Serialized attempt (string keys)
-        # @return [Attempt] Rebuilt attempt
-        def self.from_h(data)
-          new(
-            binding: AttemptBinding.from_h(data["binding"]),
-            state: data["state"],
-            candidate_head: data["candidate_head"],
-            journal_commit: data["journal_commit"],
-            accepted_receipts: data["accepted_receipts"] || [],
-            effects: data["effects"] || [],
-            events: data["events"] || [],
-            updated_at: parse_time(data["updated_at"])
-          )
-        end
-
-        def self.parse_time(value)
-          return nil if value.nil?
-          return value if value.is_a?(Time)
-          require "time"
-          Time.parse(value)
-        end
-        private_class_method :parse_time
-      end
-    end
-  end
-end