ace-assign 0.58.0 → 0.61.0

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "digest"
+require "json"
 
 module Ace
   module Assign
@@ -55,12 +56,21 @@ module Ace
           verify_artifacts(data, repo_root) if data["verdict"] == "succeeded"
           verify_checks(data)
           verify_review(data)
+          verify_campaign(data, repo_root: repo_root, live_head: live_head)
 
           receipt = Models::ExecutionReceipt.from_h(data.merge("recorded_at" => Time.now.utc))
           verify_digest(receipt)
 
           receipt
         end
+        # Recheck the source artifacts/checks of an already accepted receipt.
+        def verify_accepted_evidence!(data, live_head:, repo_root:)
+          verify_head(data, live_head)
+          verify_artifacts(data, repo_root)
+          verify_checks(data)
+          verify_review(data)
+        end
+
         # @param operation [String] Receipt operation
         # @return [Boolean] True when the operation acts outside the repository
         def external_effect?(operation)
@@ -196,6 +206,41 @@ module Ace
           end
         end
 
+        # Consume ace-review's single campaign authority through the existing
+        # receipt boundary; a worker-supplied local result grants no authority.
+        def verify_campaign(data, repo_root:, live_head:)
+          campaign = data["campaign"]
+          return unless campaign
+          reject_unless(campaign.is_a?(Hash), "campaign must be an object")
+          reject("campaign result requires a succeeded review receipt") unless
+            data["operation"] == REVIEW_OPERATION && data["verdict"] == "succeeded"
+          reference = campaign["result"]
+          reject_unless(reference.is_a?(Hash), "campaign requires a result artifact reference")
+          unless Array(data["artifacts"]).include?(reference)
+            reject("campaign result must be included in verified receipt artifacts")
+          end
+          resolved = safe_resolve(repo_root, reference["path"].to_s)
+          reject("campaign result path escapes repository or is missing") unless resolved
+          result = JSON.parse(File.read(resolved))
+          reject_unless(result.is_a?(Hash), "campaign result must be an object")
+          require "ace/review"
+          current = Ace::Review::Organisms::CampaignManager.new(repo_root: repo_root).status(campaign["id"])
+          unless result["campaign_id"] == campaign["id"] && result["accepted"] == true &&
+              result["dry_run"] == false && current["accepted"] == true &&
+              result["result_identity"] == current["result_identity"] &&
+              result.dig("evidence", "current_head") == live_head && current.dig("evidence", "current_head") == live_head
+            reject("campaign result is stale, incomplete, blocked or does not match live authority")
+          end
+          approval = current["rounds"].last["approval"]
+          unless approval["producer"] == data.dig("producer", "actor") &&
+              approval["reviewer"] == data.dig("review", "reviewer", "actor") &&
+              approval["head"] == data["head"]
+            reject("campaign producer/reviewer attribution does not match independently validated receipt")
+          end
+        rescue JSON::ParserError, ArgumentError, TypeError, KeyError => e
+          reject("invalid campaign result: #{e.message}")
+        end
+
         # Resolve a project-relative artifact path to its real location,
         # rejecting traversal and symlink escapes (an in-repo symlink must
         # not smuggle in an external file); returns nil when the path leaves

data/lib/ace/assign/organisms/assignment_executor.rb

@@ -114,7 +114,9 @@ module Ace
             updated_at: assignment.updated_at,
             source_config: archived_path,
             cache_dir: assignment.cache_dir,
-            parent: assignment.parent
+            parent: assignment.parent,
+            task_id: assignment.task_id,
+            project_id: assignment.project_id
           )
           assignment_manager.update(assignment)
 

data/lib/ace/assign/organisms/attempt_coordinator.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
+require "digest"
 require "json"
 require "open3"
+require "pathname"
 
 module Ace
   module Assign
@@ -21,22 +23,282 @@ module Ace
       # to the candidate revision invalidates prior candidate authorization;
       # `journal_commit` is tracked separately from both.
       class AttemptCoordinator
+        SERVICE_RECEIPT_FIELDS = %w[assignment_id attempt_id candidate_head evidence executor_uid
+          input_digest operation outcome project_id request_id target transport].freeze
+        SERVICE_BINDING_FIELDS = %w[request_id assignment_id attempt_id project_id operation
+          input_digest target candidate_head executor_uid transport].freeze
         # @param cache_base [String, nil] Assignment cache base
         # @param repo_root [String, nil] Candidate repository root (default: project root)
         # @param journal [Molecules::EvidenceJournal, nil] Evidence journal (default built per repo)
         # @param identity_resolver [Molecules::ExecutionIdentityResolver, nil] Trust boundary
         # @param verifier [Molecules::ReceiptVerifier, nil] Receipt verifier
-        def initialize(cache_base: nil, repo_root: nil, journal: nil, identity_resolver: nil, verifier: nil)
+        def initialize(cache_base: nil, repo_root: nil, journal: nil, identity_resolver: nil, verifier: nil,
+          lifecycle_exclusion: nil)
           @manager = Molecules::AssignmentManager.new(cache_base: cache_base)
           @store = @manager.attempt_store
           @repo_root = repo_root || Ace::Support::Fs::Molecules::ProjectRootFinder.find_or_current
           @journal = journal
           @identity_resolver = identity_resolver || Molecules::ExecutionIdentityResolver.new
           @verifier = verifier || Molecules::ReceiptVerifier.new(identity_resolver: @identity_resolver)
+          @lifecycle_exclusion = lifecycle_exclusion
         end
 
         attr_reader :store
 
+        # Claim an external service effect before dispatch. Only a managed,
+        # active attempt for the exact project and candidate may own it. The
+        # guard re-runs inside the journal lock per CAS attempt, so a
+        # terminal event landing between validation and commit still blocks
+        # the claim.
+        def claim_service_request(binding)
+          attempt = service_attempt(binding)
+          head = candidate_head!
+          valid_head = binding["candidate_head"] == head && [nil, head].include?(attempt.candidate_head)
+          unless valid_head
+            raise AttemptErrors::ReceiptRejected, "Service request candidate head is stale"
+          end
+          require_review_evidence(attempt, head) if @verifier.external_effect?(binding["operation"])
+          # Dispatching claims record uncertain directly: the effect may
+          # happen as soon as the claim lands, and a crash before the
+          # executor response must leave uncertainty, not a stranded
+          # accepted state that a retry would return without dispatching.
+          journal_for.claim_service_request(binding, state: "uncertain", guard: -> { claim_guard(binding) })
+        end
+
+        # Rechecked against the authoritative ref for every locked claim
+        # attempt: the attempt must still be journal-active and the exact
+        # authorization must still be unconsumed.
+        def claim_guard(binding)
+          derived = journal_for.derived_attempts(binding.fetch("assignment_id"))
+            .find { |candidate| candidate.attempt_id == binding.fetch("attempt_id") }
+          unless derived&.active?
+            raise AttemptErrors::ReceiptRejected, "Attempt is no longer active in the authoritative journal"
+          end
+          journal_for.authorization_conflict(binding)
+        end
+
+        def service_attempt(binding)
+          attempt = authoritative_attempt(binding)
+          raise AttemptErrors::NotFound, "Attempt not found" unless attempt
+          unless attempt.managed? && attempt.active? &&
+              attempt.binding.assignment_id == binding["assignment_id"] &&
+              attempt.binding.project_id == binding["project_id"]
+            raise AttemptErrors::ReceiptRejected, "Service request does not match an active managed attempt"
+          end
+          attempt
+        end
+
+        # The authoritative journal wins for managed assignments, and a
+        # managed service claim REQUIRES the journal-derived attempt: a lost
+        # or unavailable evidence ref fails closed instead of trusting a
+        # local cache record that the journal cannot corroborate.
+        def authoritative_attempt(binding)
+          assignment_id = binding.fetch("assignment_id")
+          assignment = @manager.load(assignment_id)
+          if assignment&.managed?
+            journal_for.derived_attempts(assignment_id)
+              .find { |candidate| candidate.attempt_id == binding.fetch("attempt_id") }
+          else
+            @store.find(binding.fetch("attempt_id")) ||
+              recover_managed_attempt(assignment_id, binding.fetch("attempt_id"))
+          end
+        end
+
+        def reject_service_request(binding, reason:)
+          service_attempt(binding)
+          journal_for.reject_service_request(binding, reason: reason)
+        end
+
+        def service_request_status(request_id)
+          journal_for.service_request(request_id)
+        end
+
+        def transition_service_request(request_id, state:, receipt: nil)
+          if %w[succeeded failed].include?(state)
+            request = journal_for.service_request(request_id)
+            raise AttemptErrors::NotFound, "Service request #{request_id} not found" unless request
+            validate_service_receipt!(request, state, receipt)
+          elsif receipt
+            raise AttemptErrors::ReceiptRejected, "Non-terminal service transition cannot carry a receipt"
+          end
+          journal_for.transition_service_request(request_id, state: state, receipt: receipt, validated: true)
+        end
+
+        # Settle a failed effect as "no effect occurred". The settlement is
+        # evidence-validated like a terminal receipt — the executor must
+        # attest this request with outcome:failed and attributable evidence
+        # — and the original failure event stays in the journal history.
+        def reconcile_service_failure(request_id, receipt:)
+          request = journal_for.service_request(request_id)
+          raise AttemptErrors::NotFound, "Service request #{request_id} not found" unless request
+          unless %w[failed rejected uncertain].include?(request["state"]) &&
+              (request["state"] != "rejected" || request["consumed"] != false)
+            raise AttemptErrors::InvalidState,
+              "Only dispatched (failed, uncertain, or rejected) service requests can be reconciled"
+          end
+          settle_no_effect(request_id, request, receipt)
+        end
+
+        # Settle an uncertain claim whose handler was never invoked (a
+        # pre-dispatch refusal observed by the trusted local service). Same
+        # evidence rules as a failure settlement: a distinct, executor-owned
+        # no-effect attestation bound to this request.
+        def reconcile_service_no_effect(request_id, receipt:)
+          request = journal_for.service_request(request_id)
+          raise AttemptErrors::NotFound, "Service request #{request_id} not found" unless request
+          unless request["state"] == "uncertain"
+            raise AttemptErrors::InvalidState, "Only uncertain service requests can settle as no-effect"
+          end
+          settle_no_effect(request_id, request, receipt)
+        end
+
+        def settle_no_effect(request_id, request, receipt)
+          # The settlement must be a distinct, later executor attestation:
+          # replaying the already-recorded failure receipt proves nothing
+          # about whether the effect took place.
+          if request["receipt"] && Atoms::EvidenceDigest.digest(receipt) ==
+              Atoms::EvidenceDigest.digest(request["receipt"])
+            raise AttemptErrors::ReceiptRejected,
+              "Service failure settlement requires a new attestation, not the recorded receipt"
+          end
+          validate_service_receipt!(request, "failed", receipt, require_no_effect: true)
+          journal_for.transition_service_request(request_id, state: "failed-settled",
+            receipt: receipt, validated: true)
+        end
+
+        def validate_service_receipt!(request, state, receipt, require_no_effect: false)
+          unless receipt.is_a?(Hash) && receipt.keys.sort == SERVICE_RECEIPT_FIELDS.sort
+            raise AttemptErrors::ReceiptRejected, "Service receipt has invalid fields"
+          end
+          SERVICE_BINDING_FIELDS.each do |key|
+            unless receipt[key] == request[key]
+              raise AttemptErrors::ReceiptRejected, "Service receipt does not match #{key}"
+            end
+          end
+          unless receipt["outcome"] == state && receipt["executor_uid"].is_a?(Integer) &&
+              receipt["executor_uid"] >= 0 && valid_service_evidence?(receipt["evidence"])
+            raise AttemptErrors::ReceiptRejected, "Service receipt has invalid executor or evidence"
+          end
+          unless receipt["executor_uid"] == request["executor_uid"]
+            raise AttemptErrors::ReceiptRejected, "Service receipt executor does not match the claimed executor"
+          end
+          # Local transport runs the executor in the submitting process, so
+          # the submitter must be the configured executor identity itself.
+          if request["transport"] == "local" && Process.uid != request["executor_uid"]
+            raise AttemptErrors::ReceiptRejected, "Service receipt submitter is not the configured executor"
+          end
+          verify_service_evidence!(receipt["evidence"], request, state, require_no_effect: require_no_effect)
+        end
+
+        def valid_service_evidence?(evidence)
+          evidence.is_a?(Array) && !evidence.empty? && evidence.all? do |item|
+            item.is_a?(Hash) && item.keys.sort == %w[ref sha256] &&
+              item["ref"].is_a?(String) && item["ref"].match?(/\A[a-zA-Z0-9_.:\/-]{1,256}\z/) &&
+              item["sha256"].is_a?(String) && item["sha256"].match?(/\A[0-9a-f]{64}\z/)
+          end
+        end
+
+        # Evidence must live inside the candidate repository (symlinks
+        # resolved), be owned by — and not writable by anyone but — the
+        # claimed executor identity, postdate the claim, and carry a
+        # structured attestation naming the claimed request, input digest,
+        # and attested outcome. All checks read one open handle, so a swap
+        # on a caller-writable path cannot mix files between checks.
+        def verify_service_evidence!(evidence, request, state, require_no_effect: false)
+          repo_root = File.realpath(@repo_root)
+          claimed_at = parse_claimed_at(request)
+          evidence.each do |item|
+            ref = item["ref"]
+            unless Pathname.new(ref).relative?
+              raise AttemptErrors::ReceiptRejected, "Service receipt evidence must be repository-relative: #{ref}"
+            end
+            path = File.expand_path(ref, repo_root)
+            unless path.start_with?(repo_root + File::SEPARATOR)
+              raise AttemptErrors::ReceiptRejected, "Service receipt evidence must live inside the repository: #{ref}"
+            end
+            begin
+              file = File.open(path, "rb")
+            rescue Errno::ENOENT
+              raise AttemptErrors::ReceiptRejected, "Service receipt evidence is unavailable: #{ref}"
+            end
+            begin
+              real = File.realpath(path)
+              unless real.start_with?(repo_root + File::SEPARATOR)
+                raise AttemptErrors::ReceiptRejected, "Service receipt evidence must live inside the repository: #{ref}"
+              end
+              stat = file.stat
+              # The open handle must still be the file at the validated
+              # location: a swap between resolution and open fails here.
+              opened = File.stat(real)
+              unless opened.dev == stat.dev && opened.ino == stat.ino
+                raise AttemptErrors::ReceiptRejected, "Service receipt evidence changed during verification: #{ref}"
+              end
+              unless stat.uid == request["executor_uid"] && (stat.mode & 0o022).zero?
+                raise AttemptErrors::ReceiptRejected, "Service receipt evidence is not executor-owned: #{ref}"
+              end
+              unless claimed_at.nil? || stat.mtime >= claimed_at
+                raise AttemptErrors::ReceiptRejected, "Service receipt evidence predates the claim: #{ref}"
+              end
+              failed_at = parse_failed_at(request)
+              unless failed_at.nil? || stat.mtime >= failed_at
+                raise AttemptErrors::ReceiptRejected, "Service receipt evidence predates the failure: #{ref}"
+              end
+              content = file.read
+              unless attestation_line(content, request, state, require_no_effect: require_no_effect)
+                raise AttemptErrors::ReceiptRejected,
+                  "Service receipt evidence does not bind the claimed request: #{ref}"
+              end
+              unless Digest::SHA256.hexdigest(content) == item["sha256"]
+                raise AttemptErrors::ReceiptRejected, "Service receipt evidence digest mismatch: #{ref}"
+              end
+            ensure
+              file.close
+            end
+          end
+        end
+
+        # The evidence artifact must carry a structured attestation line
+        # naming the claimed request, input digest, and attested outcome
+        # exactly: an unrelated executor-owned file cannot attest this
+        # effect, prose cannot substitute for the attested outcome, and its
+        # result cannot be recorded under another terminal state.
+        def attestation_line(content, request, state, require_no_effect: false)
+          attestation = /^ace-service-attestation request:#{Regexp.escape(request.fetch("request_id"))} \
+input:#{Regexp.escape(request.fetch("input_digest"))} outcome:(\S+)( no-effect:(\S+))?$/
+          line = content.scan(attestation).first
+          return false unless line
+          return false if require_no_effect && line[2] != "true"
+          %w[succeeded failed].include?(state) ? line.first == state : true
+        end
+
+        def parse_claimed_at(request)
+          return nil if request["claimed_at"].nil?
+          Time.iso8601(request["claimed_at"])
+        rescue ArgumentError
+          raise AttemptErrors::ReceiptRejected, "Service request has an invalid claim timestamp"
+        end
+
+        def parse_failed_at(request)
+          return nil if request["failed_at"].nil?
+          Time.iso8601(request["failed_at"])
+        rescue ArgumentError
+          raise AttemptErrors::ReceiptRejected, "Service request has an invalid failure timestamp"
+        end
+
+        # Read-only eligibility check for dry-run: applies the same review
+        # evidence and candidate-head requirements as the claim without
+        # reserving anything.
+        def request_eligible!(binding)
+          attempt = service_attempt(binding)
+          head = candidate_head!
+          valid_head = binding["candidate_head"] == head && [nil, head].include?(attempt.candidate_head)
+          unless valid_head
+            raise AttemptErrors::ReceiptRejected, "Service request candidate head is stale"
+          end
+          require_review_evidence(attempt, head) if @verifier.external_effect?(binding["operation"])
+          true
+        end
+
         # Start a scoped attempt for an assignment.
         #
         # A repeated identical start returns the existing active attempt; a
@@ -62,49 +324,61 @@ module Ace
           identity ||= @identity_resolver.resolve
           base_head = candidate_head!
 
-          @store.with_lock(assignment_id) do
-            journal_actives = assignment.managed? ? active_journal_attempts(assignment) : []
-
-            existing = @store.active(assignment_id, scope) ||
-              journal_actives.find { |attempt| Atoms::AssignmentScope.equal?(attempt.binding.scope, scope) }
-            if existing
-              if existing.binding.project_id == project && existing.binding.task_id == assignment.task_id &&
-                  existing.binding.actor == identity.actor && existing.binding.role == identity.role
-                return existing
+          # Serialize writer registration against prune: prune holds the
+          # exclusive exclusion from its final evidence reads through removal.
+          # A worktree-backed task identity shares the same protocol (task
+          # key first, then assignment key — the one consistent global
+          # order), so a worktree prune and an attempt start cannot interleave.
+          start_keys = []
+          unless assignment.task_id.to_s.strip.empty?
+            start_keys << lifecycle_exclusion.task_key(assignment.task_id)
+          end
+          start_keys << lifecycle_exclusion.assignment_key(assignment_id)
+          lifecycle_exclusion.with_shared_multi(start_keys) do
+            @store.with_lock(assignment_id) do
+              journal_actives = assignment.managed? ? active_journal_attempts(assignment) : []
+
+              existing = @store.active(assignment_id, scope) ||
+                journal_actives.find { |attempt| Atoms::AssignmentScope.equal?(attempt.binding.scope, scope) }
+              if existing
+                if existing.binding.project_id == project && existing.binding.task_id == assignment.task_id &&
+                    existing.binding.actor == identity.actor && existing.binding.role == identity.role
+                  return existing
+                end
+
+                raise AttemptErrors::Conflict,
+                  "Active attempt #{existing.attempt_id} already owns #{assignment_id}@#{scope} " \
+                  "(project #{existing.binding.project_id}); refusing to launch a second writer"
               end
 
-              raise AttemptErrors::Conflict,
-                "Active attempt #{existing.attempt_id} already owns #{assignment_id}@#{scope} " \
-                "(project #{existing.binding.project_id}); refusing to launch a second writer"
-            end
+              active_scopes = @store.list(assignment_id).select(&:active?).map(&:binding)
+              active_scopes.concat(journal_actives.map(&:binding))
+              blocker = active_scopes.find { |binding| scopes_overlap?(binding.scope, scope) }
+              if blocker
+                raise AttemptErrors::Conflict,
+                  "Active attempt scope #{blocker.scope} overlaps requested scope #{scope} on #{assignment_id}; " \
+                  "refusing overlapping writers"
+              end
 
-            active_scopes = @store.list(assignment_id).select(&:active?).map(&:binding)
-            active_scopes.concat(journal_actives.map(&:binding))
-            blocker = active_scopes.find { |binding| scopes_overlap?(binding.scope, scope) }
-            if blocker
-              raise AttemptErrors::Conflict,
-                "Active attempt scope #{blocker.scope} overlaps requested scope #{scope} on #{assignment_id}; " \
-                "refusing overlapping writers"
-            end
+              attempt_id = unique_attempt_id(assignment_id, journal_actives.map(&:attempt_id))
+              events = start_events(assignment_id, assignment, scope, project, identity, base_head, attempt_id)
+              attempt = reserve(assignment, scope, project, identity, base_head, attempt_id)
+              if attempt.managed?
+                commit = journal_for.append(
+                  assignment_id: assignment_id,
+                  attempt_id: attempt.attempt_id,
+                  events: events
+                )
+                attempt = attempt.with(journal_commit: commit)
+                attempt = yield_lost_ownership_race(attempt, assignment_id, scope)
+              else
+                attempt = attempt.with(events: events)
+              end
 
-            attempt_id = unique_attempt_id(assignment_id, journal_actives.map(&:attempt_id))
-            events = start_events(assignment_id, assignment, scope, project, identity, base_head, attempt_id)
-            attempt = reserve(assignment, scope, project, identity, base_head, attempt_id)
-            if attempt.managed?
-              commit = journal_for.append(
-                assignment_id: assignment_id,
-                attempt_id: attempt.attempt_id,
-                events: events
-              )
-              attempt = attempt.with(journal_commit: commit)
-              attempt = yield_lost_ownership_race(attempt, assignment_id, scope)
-            else
-              attempt = attempt.with(events: events)
+              @store.save(attempt)
+              @store.claim(assignment_id, scope, attempt)
+              attempt
             end
-
-            @store.save(attempt)
-            @store.claim(assignment_id, scope, attempt)
-            attempt
           end
         end
 
@@ -165,6 +439,61 @@ module Ace
           attempt.projection
         end
 
+        # Read accepted check evidence without transitions, locks, cache writes
+        # or audit checkout creation. Managed history comes from the Git ref.
+        def evidence(attempt_id:, receipt_digest:, kind: "check", check_name: "tests", historical_head: nil)
+          unless %w[check review-collection review-approval].include?(kind) && check_name.is_a?(String) && !check_name.strip.empty?
+            raise AttemptErrors::ReceiptRejected, "Invalid evidence kind or check name"
+          end
+          if !historical_head.nil? && (!%w[review-collection review-approval].include?(kind) || !historical_head.is_a?(String) ||
+              !historical_head.match?(/\A[0-9a-f]{40,64}\z/))
+            raise AttemptErrors::ReceiptRejected, "Historical evidence requires review collection/approval and an exact recorded head"
+          end
+          unless attempt_id.to_s.match?(/\A[a-zA-Z0-9][a-zA-Z0-9_.-]{0,127}\z/) &&
+              receipt_digest.to_s.match?(/\A[0-9a-f]{64}\z/)
+            raise AttemptErrors::ReceiptRejected, "Invalid attempt ID or receipt digest"
+          end
+          attempt = @store.find(attempt_id) || recover_managed_attempt(nil, attempt_id)
+          raise AttemptErrors::NotFound, "Attempt #{attempt_id} not found" unless attempt
+          raise AttemptErrors::ReceiptRejected, "Execution evidence requires managed immutable journal history" unless attempt.managed?
+          attempt = recover_managed_attempt(attempt.binding.assignment_id, attempt_id)
+          raise AttemptErrors::ReceiptRejected, "No succeeded accepted attempt" unless attempt&.state == "succeeded"
+          accepted = journal_for.accepted_receipts(attempt.binding.assignment_id)
+          data = accepted.find { |r| r["attempt_id"] == attempt_id && r["digest"] == receipt_digest }
+          raise AttemptErrors::ReceiptRejected, "Receipt was not accepted by coordinator" unless data
+          if kind == "check" && (%w[review review-collect].include?(data["operation"]) || @verifier.external_effect?(data["operation"]))
+            raise AttemptErrors::ReceiptRejected, "Review or external-effect operations cannot be check evidence"
+          end
+          expected_operation = case kind
+          when "review-collection" then "review-collect"
+          when "review-approval" then "review"
+          else (check_name == "tests") ? "test" : check_name
+          end
+          unless data["campaign"].nil? && data["operation"] == expected_operation
+            raise AttemptErrors::ReceiptRejected, "Accepted receipt operation does not prove #{kind}: #{expected_operation}"
+          end
+          required_check = (kind == "review-collection") ? "review-execution" : check_name
+          has_required_check = Array(data["checks"]).any? { |check| check["name"] == required_check && check["verdict"] == "passed" }
+          unless kind == "review-approval" || has_required_check
+            raise AttemptErrors::ReceiptRejected, "Accepted receipt does not prove the required check #{required_check}"
+          end
+          receipt = Models::ExecutionReceipt.from_h(data)
+          unless receipt.digest == Atoms::EvidenceDigest.digest(receipt.digest_payload)
+            raise AttemptErrors::ReceiptRejected, "Accepted receipt digest is corrupt"
+          end
+          evidence_head = historical_head || candidate_head!
+          unless data["verdict"] == "succeeded" && data["head"] == evidence_head && attempt.candidate_head == evidence_head
+            raise AttemptErrors::ReceiptRejected, "Accepted execution evidence is stale or unsuccessful"
+          end
+          @verifier.verify_accepted_evidence!(data, live_head: evidence_head, repo_root: @repo_root)
+          {"attempt_id" => attempt_id, "receipt_digest" => receipt_digest, "head" => evidence_head, "kind" => kind,
+           "historical" => !historical_head.nil?,
+           "operation" => data["operation"], "checks" => data["checks"], "producer" => data["producer"], "review" => data["review"],
+           "artifacts" => data["artifacts"], "assignment_id" => data["assignment_id"],
+           "project_id" => data["project_id"], "scope" => data["scope"],
+           "evidence_git_ref" => attempt.binding.evidence_git_ref, "journal_commit" => attempt.journal_commit}
+        end
+
         # Reconcile an interrupted attempt.
         #
         # Running attempts are classified conservatively (stopped before
@@ -251,7 +580,7 @@ module Ace
             return nil if assignment && !assignment.managed?
 
             return journal_for.derived_attempts(assignment_id)
-              .find { |candidate| candidate.attempt_id == attempt_id }
+                .find { |candidate| candidate.attempt_id == attempt_id }
           end
 
           journal_for.assignment_ids.each do |journal_assignment_id|
@@ -339,7 +668,7 @@ module Ace
           recorded = reconciler.recorded_runtime(attempt)
           unless data.dig("producer", "runtime") == recorded
             raise AttemptErrors::ReceiptRejected,
-              "Receipt runtime #{data.dig('producer', 'runtime').inspect} does not match the recorded " \
+              "Receipt runtime #{data.dig("producer", "runtime").inspect} does not match the recorded " \
               "execution boundary #{recorded.inspect}"
           end
 
@@ -381,7 +710,8 @@ module Ace
           @reconciler ||= Molecules::AttemptReconciler.new(journal: journal_for, verifier: @verifier)
         end
 
-        def reserve(assignment, scope, project, identity, base_head, attempt_id)          binding = Models::AttemptBinding.new(
+        def reserve(assignment, scope, project, identity, base_head, attempt_id)
+          binding = Models::AttemptBinding.new(
             attempt_id: attempt_id,
             assignment_id: assignment.id,
             scope: scope,
@@ -531,6 +861,12 @@ module Ace
           @journal
         end
 
+        # Prune/writer exclusion shared with overseer prune (durable, outside
+        # every deletion target).
+        def lifecycle_exclusion
+          @lifecycle_exclusion ||= Molecules::LifecycleExclusion.new(repo_root: @repo_root)
+        end
+
         def candidate_head!
           out, status = Open3.capture2("git", "rev-parse", "HEAD", chdir: @repo_root, stdin_data: "")
           head = out.to_s.strip

data/lib/ace/assign/version.rb

@@ -2,6 +2,6 @@
 
 module Ace
   module Assign
-    VERSION = "0.58.0"
+    VERSION = "0.61.0"
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ace-assign
 version: !ruby/object:Gem::Version
-  version: 0.58.0
+  version: 0.61.0
 platform: ruby
 authors:
 - Michal Czyz
 bindir: exe
 cert_chain: []
-date: 2026-09-29 00:00:00.000000000 Z
+date: 2026-10-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ace-support-cli
@@ -107,6 +107,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.39'
+- !ruby/object:Gem::Dependency
+  name: ace-review
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.57'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.57'
 - !ruby/object:Gem::Dependency
   name: ace-task
   requirement: !ruby/object:Gem::Requirement
@@ -127,14 +141,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.17'
+        version: '0.18'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.17'
+        version: '0.18'
 - !ruby/object:Gem::Dependency
   name: ace-support-test-helpers
   requirement: !ruby/object:Gem::Requirement
@@ -294,6 +308,7 @@ files:
 - lib/ace/assign/cli/commands/add.rb
 - lib/ace/assign/cli/commands/assignment_target.rb
 - lib/ace/assign/cli/commands/attempt/base.rb
+- lib/ace/assign/cli/commands/attempt/evidence.rb
 - lib/ace/assign/cli/commands/attempt/finish.rb
 - lib/ace/assign/cli/commands/attempt/reconcile.rb
 - lib/ace/assign/cli/commands/attempt/start.rb
@@ -325,6 +340,7 @@ files:
 - lib/ace/assign/molecules/evidence_journal.rb
 - lib/ace/assign/molecules/execution_identity_resolver.rb
 - lib/ace/assign/molecules/fork_session_launcher.rb
+- lib/ace/assign/molecules/lifecycle_exclusion.rb
 - lib/ace/assign/molecules/preset_inferrer.rb
 - lib/ace/assign/molecules/queue_scanner.rb
 - lib/ace/assign/molecules/receipt_verifier.rb