ace-lab 0.9.0 → 0.13.0

data/lib/ace/lab/organisms/protected_service_publication.rb

@@ -1,268 +0,0 @@
-# frozen_string_literal: true
-require "securerandom"
-require "rubygems/package"
-require "ace/hitl/providers/lab"
-require_relative "../molecules/protected_publication_publisher"
-
-module Ace
-  module Lab
-    module Organisms
-      class ProtectedServiceReceiver
-        # One invocation is retained by the existing receiver worker, not a
-        # second effect queue. Only canonical continuation can authorize a push.
-        def begin_publication!(admitted:, materialized:, deadline:)
-          raise SecurityError, "publication receiver already owns an invocation" if @publication
-          @publication_hitl ||= Ace::Hitl::Providers::Lab.boundary_client(
-            socket_path: Ace::Hitl::Providers::Lab::DEFAULT_SOCKET_PATH,
-            policy: Ace::Hitl::Providers::Lab.grants_policy(grants_path: Ace::Hitl::Providers::Lab::DEFAULT_GRANTS_PATH))
-          params = admitted.fetch(:params)
-          started = admitted.fetch(:started)
-          unless started.fetch("executor_process_binding") == @kernel.capture(Process.pid)
-            raise SecurityError, "publication original receiver differs"
-          end
-          @publication = admitted.merge(materialized: materialized, handles: [], challenge: nil,
-            ask_id: nil, disposition: "dispatch_started")
-          hold_publication_artifact!(@publication)
-          verified = publication_registry!(@publication, deadline)
-          return complete_publication!(@publication, verified, deadline) if %w[succeeded failed].include?(verified.fetch("classification"))
-          unless verified.fetch("classification") == "absent"
-            @publication[:disposition] = "uncertain"
-            return publication_status("uncertain", verified.fetch("code"))
-          end
-          publication_push!(@publication, nil, deadline)
-        rescue StandardError, SecurityError
-          publication_status("uncertain", "publication_admission_unavailable")
-        end
-
-        def tick_publication!(request_id:, deadline:)
-          entry = @publication
-          return {"request_id" => request_id, "state" => "publication-blocked", "code" => "original-executor-unavailable"} unless entry && entry.dig(:params, "request_id") == request_id
-          check_publication!(entry)
-          status = publication_call!(entry, "service_status", {}, deadline).data
-          if %w[succeeded failed].include?(status["state"])
-            close_publication!(entry)
-            return projection(status)
-          end
-          if entry[:disposition] == "uncertain"
-            verified = publication_registry!(entry, deadline)
-            return complete_publication!(entry, verified, deadline) if verified["classification"] == "succeeded"
-            return publication_status("uncertain", "publication_outcome_unconfirmed")
-          end
-          unless status["dispatch_phase"] == "otp_pending" && status["publication_challenge_digest"] == entry.fetch(:challenge).fetch("publication_challenge_digest")
-            return publication_status("uncertain", "publication_challenge_changed")
-          end
-          publication_ask!(entry, deadline) unless entry[:ask_created]
-          ask = @publication_hitl.read(entry.fetch(:ask_id), deadline: deadline)
-          check_publication_ask!(entry, ask)
-          if %w[cancelled consumed].include?(ask["state"])
-            entry[:ask_id] = nil
-            entry[:ask_created] = false
-            entry[:ask_otp] = nil
-            return publication_status("publication-pending", "otp-answer-unavailable")
-          end
-          if ask.fetch("otp").fetch("expires_at") <= Time.now.to_i
-            @publication_hitl.cancel(entry.fetch(:ask_id), reason: "otp-answer-expired", deadline: deadline)
-            return publication_status("publication-pending", "otp-answer-expired")
-          end
-          return publication_status("publication-pending", "otp-answer-pending") unless ask["state"] == "answer-delivered"
-          return publication_status("publication-pending", "otp-tick-budget") if publication_remaining!(deadline) < 1.5
-          answer = @publication_hitl.consume(entry.fetch(:ask_id), timeout: 1, operation: "publish", deadline: deadline)
-          otp = answer["answer"]
-          unless otp.is_a?(String) && otp.match?(/\A[0-9]{6}\z/) && ask.fetch("otp").fetch("expires_at") > Time.now.to_i
-            return publication_status("publication-pending", "otp-answer-unavailable")
-          end
-          check_publication!(entry)
-          return publication_status("publication-pending", "otp-tick-budget") if publication_remaining!(deadline) < 1
-          status = publication_call!(entry, "service_status", {}, deadline).data
-          return publication_status("publication-pending", "otp-answer-expired") unless ask.fetch("otp").fetch("expires_at") > Time.now.to_i
-          entry[:disposition] = "uncertain" # A lost issuing reply is never retried.
-          issued = publication_call!(entry, "publication_continue", {
-            "expected_generation" => status.fetch("generation"), "input_digest" => entry.fetch(:params).fetch("input_digest"),
-            "challenge_digest" => entry.fetch(:challenge).fetch("publication_challenge_digest")}, deadline,
-            mutation_id: Digest::SHA256.hexdigest("publication-continue:#{entry.fetch(:challenge).fetch('publication_challenge_digest')}")).data
-          return publication_status("uncertain", "publication_issuing_unconfirmed") unless issued["invocation"] == "permitted" && issued["dispatch_phase"] == "issuing"
-          entry[:started] = issued
-          publication_push!(entry, otp, deadline)
-        rescue StandardError, SecurityError
-          publication_status("uncertain", "publication_tick_unavailable")
-        ensure
-          otp&.clear if otp.is_a?(String) && !otp.frozen?
-          answer&.delete("answer")
-        end
-
-        def publication_active?
-          !@publication.nil?
-        end
-
-        # Called only after the existing worker has stopped its bounded tick.
-        # Durable uncertain state and candidate bytes remain for read-only recovery.
-        def release_publication_lifetime!
-          @publication&.fetch(:handles)&.each { |_path, handle, _identity| handle.close unless handle.closed? }
-          @publication = nil
-        end
-
-        private
-
-        def hold_publication_artifact!(entry)
-          root = entry.fetch(:materialized).fetch("directory")
-          publication = entry.fetch(:envelope).fetch("input").fetch("publication")
-          components = publication.fetch("artifact_relative_path").split("/")
-          paths = [root]
-          components.each { |component| paths << File.join(paths.last, component) }
-          paths.each_with_index do |path, index|
-            handle = File.open(path, File::RDONLY | File::NOFOLLOW | File::NONBLOCK)
-            stat = handle.stat
-            valid = index == paths.size - 1 ? stat.file? && stat.size.between?(1, 64 * 1024 * 1024) : stat.directory?
-            unless valid && stat.uid == Process.uid && (stat.mode & 0o022).zero?
-              handle.close
-              raise SecurityError, "publication staging protection differs"
-            end
-            entry.fetch(:handles) << [path, handle, publication_identity(stat)]
-          end
-          entry[:artifact] = paths.last
-          spec = Gem::Package.new(paths.last).spec
-          unless spec.name == publication.fetch("gem_name") && spec.version.to_s == publication.fetch("version")
-            raise SecurityError, "publication artifact metadata differs"
-          end
-          entry[:platform] = spec.platform.to_s
-          check_publication!(entry)
-        end
-
-        def check_publication!(entry)
-          @kernel.live!(entry.fetch(:started).fetch("executor_process_binding"))
-          raise SecurityError, "publication receiver birth differs" unless @kernel.capture(Process.pid) == entry.fetch(:started).fetch("executor_process_binding")
-          entry.fetch(:handles).each do |path, handle, expected|
-            unless publication_identity(handle.stat) == expected && publication_identity(File.lstat(path)) == expected
-              raise SecurityError, "publication held staging changed"
-            end
-          end
-          artifact = entry.fetch(:handles).last.fetch(1)
-          artifact.rewind
-          digest = Digest::SHA256.new
-          while (chunk = artifact.read(65_536))
-            digest.update(chunk)
-          end
-          unless digest.hexdigest == entry.fetch(:envelope).fetch("input").fetch("target").fetch("artifact_digest")
-            raise SecurityError, "publication artifact bytes differ"
-          end
-        end
-
-        def publication_identity(stat)
-          stat.directory? ? [stat.dev, stat.ino, stat.uid, stat.gid, stat.mode] :
-            [stat.dev, stat.ino, stat.uid, stat.gid, stat.mode, stat.size, stat.mtime, stat.ctime]
-        end
-
-        def publication_registry!(entry, deadline)
-          check_publication!(entry)
-          @publication_publisher.verify!(publication: entry.fetch(:envelope).fetch("input").fetch("publication"),
-            artifact_digest: entry.fetch(:params).fetch("target").fetch("artifact_digest"), platform: entry.fetch(:platform), deadline: deadline)
-        end
-
-        def publication_push!(entry, otp, deadline)
-          check_publication!(entry)
-          entry[:disposition] = "uncertain"
-          result = @publication_publisher.push!(operation: entry.fetch(:operation),
-            publication: entry.fetch(:envelope).fetch("input").fetch("publication"), artifact: entry.fetch(:artifact),
-            artifact_digest: entry.fetch(:params).fetch("target").fetch("artifact_digest"), otp: otp, deadline: deadline)
-          check_publication!(entry)
-          verified = publication_registry!(entry, deadline)
-          return complete_publication!(entry, verified, deadline) if %w[succeeded failed].include?(verified["classification"])
-          if %w[otp-required otp-rejected otp-expired].include?(result["classification"]) && verified["classification"] == "absent"
-            return retain_publication_challenge!(entry, result, deadline)
-          end
-          return complete_publication!(entry, result, deadline) if result["classification"] == "failed" && verified["classification"] == "absent"
-          publication_status("uncertain", "publication_outcome_unconfirmed")
-        end
-
-        def retain_publication_challenge!(entry, result, deadline)
-          input = entry.fetch(:envelope).fetch("input")
-          params = entry.fetch(:params)
-          previous = entry[:challenge]&.fetch("publication_challenge_digest")
-          need = params.slice("request_id", "input_digest", "candidate_generation", "head").merge(
-            "schema" => "ace.publication-otp-need/v1", "classification" => result.fetch("classification"),
-            "claim_binding" => entry.fetch(:claim).fetch("claim_binding"),
-            "registry" => input.fetch("publication").fetch("registry"), "gem_name" => input.fetch("publication").fetch("gem_name"),
-            "version" => input.fetch("publication").fetch("version"), "artifact_digest" => input.fetch("target").fetch("artifact_digest"),
-            "dispatch_event_digest" => entry.fetch(:dispatch_event_digest), "previous_challenge_digest" => previous)
-          bytes = JSON.generate(need)
-          status = publication_call!(entry, "service_status", {}, deadline).data
-          entry[:challenge] = publication_call!(entry, "publication_challenge", {
-            "input_digest" => params.fetch("input_digest"), "expected_generation" => status.fetch("generation"),
-            "receipt_sha256" => Digest::SHA256.hexdigest(bytes)}, deadline,
-            mutation_id: Digest::SHA256.hexdigest("publication-challenge:#{Digest::SHA256.hexdigest(bytes)}"),
-            upload_parts: [bytes], purpose: :receipt_artifacts).data
-          entry[:disposition] = "otp_pending"
-          entry[:ask_id] = nil
-          entry[:ask_created] = false
-          entry[:ask_otp] = nil
-          publication_ask!(entry, deadline)
-          publication_status("publication-pending", result.fetch("classification"))
-        end
-
-        def publication_ask!(entry, deadline)
-          entry[:ask_id] ||= "publication-#{SecureRandom.hex(12)}"
-          binding = entry.fetch(:params).slice("assignment_id", "attempt_id", "request_id", "input_digest", "candidate_generation", "head").merge(
-            "schema" => "ace.hitl-publication-binding/v1", "mapping_id" => @mapping_id,
-            "claim_binding" => entry.fetch(:claim).fetch("claim_binding"),
-            "challenge_digest" => entry.fetch(:challenge).fetch("publication_challenge_digest"))
-          entry[:ask_binding] = immutable(binding)
-          entry[:ask_otp] ||= immutable({"operation" => "publish", "input_digest" => binding.fetch("input_digest"),
-            "result_ref" => entry.fetch(:challenge).fetch("publication_challenge_ref").fetch("ref"), "expires_at" => Time.now.to_i + 900})
-          @publication_hitl.create(id: entry.fetch(:ask_id), assignment: binding.fetch("assignment_id"), attempt: binding.fetch("attempt_id"),
-            project: @map.fetch("project_id"), harness: "lab-admin", plan: "Scoped RubyGems publication", kind: "otp",
-            question: "Provide the RubyGems OTP for this authorized artifact publication.", ace_hitl_id: entry.fetch(:ask_id),
-            publication_binding: binding, otp: entry.fetch(:ask_otp), deadline: deadline)
-          entry[:ask_created] = true
-        end
-
-        def check_publication_ask!(entry, ask)
-          unless ask["id"] == entry.fetch(:ask_id) && ask["publication_binding"] == entry.fetch(:ask_binding) &&
-              ask["publication_requester_peer"] == entry.fetch(:started).fetch("executor_process_binding") &&
-              ask.dig("otp", "input_digest") == entry.fetch(:params).fetch("input_digest") &&
-              ask.dig("otp", "result_ref") == entry.fetch(:challenge).fetch("publication_challenge_ref").fetch("ref")
-            raise SecurityError, "publication HITL retained request differs"
-          end
-        end
-
-        def publication_call!(entry, operation, extra, deadline, **options)
-          params = entry.fetch(:params).slice("assignment_id", "attempt_id", "candidate_generation", "head", "request_id")
-          params["claim_binding"] = entry.fetch(:claim).fetch("claim_binding") unless operation == "service_status"
-          @client.call(operation, params.merge(extra), timeout: publication_remaining!(deadline), **options)
-        end
-
-        def complete_publication!(entry, result, deadline)
-          check_publication!(entry)
-          input = entry.fetch(:envelope).fetch("input")
-          evidence = JSON.generate(input.merge("schema" => "ace.publication-result/v1", "classification" => result.fetch("classification"),
-            "code" => result.fetch("code"), "request_id" => entry.fetch(:params).fetch("request_id"),
-            "input_digest" => entry.fetch(:params).fetch("input_digest"), "claim_binding" => entry.fetch(:claim).fetch("claim_binding")))
-          receipt = entry.fetch(:envelope).fetch("request").slice(*Ace::Assign::Molecules::EvidenceJournal::TERMINAL_BINDING_FIELDS).merge(
-            "outcome" => result.fetch("classification") == "succeeded" ? "succeeded" : "failed",
-            "evidence" => [{"ref" => "publication-result", "sha256" => Digest::SHA256.hexdigest(evidence)}])
-          bytes = JSON.generate(receipt)
-          completed = publication_call!(entry, "complete_service", {"receipt_sha256" => Digest::SHA256.hexdigest(bytes)}, deadline,
-            mutation_id: Digest::SHA256.hexdigest("publication-complete:#{entry.fetch(:mutation_id)}"), upload_parts: [bytes, evidence], purpose: :receipt_artifacts).data
-          return publication_status("uncertain", "publication_completion_unconfirmed") unless %w[succeeded failed].include?(completed["state"])
-          close_publication!(entry)
-          projection(completed)
-        end
-
-        def close_publication!(entry)
-          entry.fetch(:handles).each { |_path, handle, _identity| handle.close }
-          cleanup_staging(entry.fetch(:materialized).fetch("directory"), entry.fetch(:staging_identity))
-          @publication = nil
-        end
-
-        def publication_remaining!(deadline)
-          remaining = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          raise IOError, "publication tick deadline expired" unless remaining.positive?
-          remaining
-        end
-
-        def publication_status(state, code)
-          {"request_id" => @publication&.dig(:params, "request_id"), "state" => state, "code" => code}.freeze
-        end
-      end
-    end
-  end
-end

data/lib/ace/lab/organisms/protected_service_receiver.rb

@@ -1,267 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-require "digest"
-require "fileutils"
-require "ace/assign/authority/client"
-require "ace/assign/authority/candidate_transfer"
-require "ace/assign/authority/evidence_transfer"
-require_relative "../molecules/protected_service_handler"
-require_relative "../molecules/protected_service_policy"
-require_relative "../atoms/protected_workspace_prune_preview"
-require_relative "protected_service_publication"
-
-module Ace
-  module Lab
-    module Organisms
-      # Fixed executor-side orchestration. All durable permission and outcome
-      # state remains in the existing authority journal. Transport supplies
-      # the kernel peer; submitted actor strings are never accepted.
-      class ProtectedServiceReceiver
-        SUBMISSION = %w[assignment_id attempt_id expected_generation candidate_generation head request_id
-          operation input_digest target authorization].freeze
-
-        def initialize(mapping_id:, service_id:, deployment: Ace::Assign::Authority::Deployment.load,
-          kernel: Ace::Runtime::Molecules::ProtectedLinux.new, client: nil,
-          handler: Molecules::ProtectedServiceHandler.new, cleanup_owner: nil, publication_publisher: nil, publication_hitl: nil)
-          @mapping_id, @service_id, @deployment, @kernel, @handler = mapping_id, service_id, deployment, kernel, handler
-          @cleanup_owner = cleanup_owner
-          @publication_publisher = publication_publisher || Molecules::ProtectedPublicationPublisher.new
-          @publication_hitl = publication_hitl
-          @map = deployment.mapping(mapping_id)
-          deployment.verify_composition!(@map.fetch("authority_id"), composition: "services")
-          @project = deployment.project(@map.fetch("project_id"))
-          @receiver = @project.fetch("service_receivers").fetch(service_id)
-          @client = client || Ace::Assign::Authority::Client.new(mapping_id: mapping_id, deployment: deployment, kernel: kernel)
-          @inputs = Molecules::ProtectedServicePolicy.new(proposal_resolver: ->(*) { raise SecurityError, "proposal decisions belong to authority" })
-        end
-
-        def preview_workspace_prune(intent:, peer:, deadline:)
-          raise SecurityError, "fixed cleanup preview composition unavailable" unless @cleanup_owner
-          intent = Atoms::ProtectedWorkspacePrunePreview.intent!(JSON.parse(JSON.generate(intent)))
-          maintenance = intent.fetch("maintenance")
-          unless maintenance.fetch("mapping_id") == @mapping_id && maintenance.fetch("project_id") == @map.fetch("project_id") &&
-              peer.values_at("uid", "gid", "groups") == @map.values_at("worker_uid", "worker_gid", "worker_groups")
-            raise SecurityError, "cleanup preview worker or installed scope differs"
-          end
-          @kernel.live!(peer)
-          me = @kernel.capture(Process.pid)
-          credentials = @project.fetch("peer_credentials").fetch(@receiver.fetch("executor_uid").to_s)
-          unless me.values_at("uid", "gid", "groups") == [@receiver.fetch("executor_uid"), credentials.fetch("gid"), credentials.fetch("groups")]
-            raise SecurityError, "cleanup preview receiver principal differs"
-          end
-          remaining = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          raise Ace::Runtime::RuntimeUnavailableError, "cleanup preview deadline expired" unless remaining.positive?
-          selected = @client.call("workspace_prune_preview_context", maintenance.except("project_id", "mapping_id").merge(
-            "service_id" => @service_id, "worker_process_binding" => peer), timeout: remaining).data
-          selected = Atoms::ProtectedWorkspacePrunePreview.context!(selected)
-          result = @cleanup_owner.preview!(intent: intent, maintenance_context: selected, deadline: deadline)
-          Atoms::ProtectedWorkspacePrunePreview.result!(result, intent: intent, context: selected)
-        end
-
-        def execute(submission:, peer:, input_bytes:, mutation_id:, on_claim: nil, claim_timeout: nil)
-          contacted = false
-          request_id = nil
-          unless submission.is_a?(Hash) && submission.keys.sort == SUBMISSION.sort &&
-              peer.fetch("uid") == @map.fetch("worker_uid") && peer["gid"] == @map.fetch("worker_gid") &&
-              peer["groups"] == @map.fetch("worker_groups")
-            raise SecurityError, "receiver submission or peer differs"
-          end
-          params = immutable(submission.merge("service_id" => @service_id, "worker_process_binding" => peer))
-          id = params.fetch("request_id")
-          unless id.is_a?(String) && id.match?(Ace::Assign::Molecules::JournalMutation::ID)
-            raise ArgumentError, "receiver request identity is invalid"
-          end
-          request_id = id
-          peer = params.fetch("worker_process_binding")
-          @kernel.live!(peer)
-          me = @kernel.capture(Process.pid)
-          credentials = @project.fetch("peer_credentials").fetch(@receiver.fetch("executor_uid").to_s)
-          unless me["uid"] == @receiver["executor_uid"] && me["gid"] == credentials["gid"] && me["groups"] == credentials["groups"]
-            raise SecurityError, "receiver principal differs"
-          end
-          unless input_bytes.is_a?(String) && mutation_id.is_a?(String) && mutation_id.match?(Ace::Assign::Molecules::JournalMutation::ID)
-            raise ArgumentError, "receiver input or mutation identity is invalid"
-          end
-          if claim_timeout && (!claim_timeout.is_a?(Numeric) || !claim_timeout.finite? ||
-              !claim_timeout.positive? || claim_timeout > 5)
-            raise ArgumentError, "receiver claim deadline is invalid"
-          end
-          bytes = input_bytes.dup.freeze
-          mutation_id = mutation_id.dup.freeze
-          input = @inputs.input_binding(bytes, expected_digest: params.fetch("input_digest"),
-            expected_target: params.fetch("target"), operation: params.fetch("operation"))
-          cleanup = params.fetch("operation") == "prune-preserved-workspace"
-          raise SecurityError, "fixed cleanup owner composition is unavailable" if cleanup && !@cleanup_owner
-          contacted = true
-          claim_options = {mutation_id: mutation_id, upload_parts: [bytes], purpose: :service_input}
-          claim_options[:timeout] = claim_timeout if claim_timeout
-          claim = @client.call("request_service", params, **claim_options)
-          notify_claim(on_claim, claim, request_id) if on_claim
-          unless !claim.replayed && claim.data["claim"] == "created"
-            return projection(claim.data)
-          end
-          original_cleanup_owner = @cleanup_owner.identity! if cleanup
-          binding = params.slice("assignment_id", "attempt_id", "candidate_generation", "head", "request_id")
-          exported = @client.call("export_candidate", binding.except("request_id").merge("purpose_id" => params.fetch("request_id")),
-            download: true, purpose: :candidate, timeout: 30)
-          unless exported.parts.is_a?(Array) && exported.parts.length == 1
-            raise SecurityError, "candidate export is incomplete"
-          end
-          materialized = Ace::Assign::Authority::CandidateTransfer.new(root: @receiver.fetch("staging_root")).materialize(
-            bytes: exported.parts.first, sha256: exported.data.fetch("sha256"), size: exported.data.fetch("bytes"),
-            head: binding.fetch("head"), tree: exported.data.fetch("tree"), root: @receiver.fetch("staging_root"))
-          staging_identity = File.lstat(materialized.fetch("directory"))
-          begin_params = binding.merge("claim_binding" => claim.data.fetch("claim_binding"), "expected_generation" => claim.data.fetch("generation"))
-          started = @client.call("begin_dispatch", begin_params, mutation_id: Digest::SHA256.hexdigest("begin:#{mutation_id}"), upload_parts: [bytes], purpose: :service_input)
-          return projection(started.data) unless !started.replayed && started.data["invocation"] == "permitted"
-          if cleanup && Ace::Assign::Atoms::EvidenceDigest.digest(original_cleanup_owner) !=
-              Ace::Assign::Atoms::EvidenceDigest.digest(started.data.fetch("operation_owner_binding"))
-            raise SecurityError, "original cleanup admission owner differs"
-          end
-
-          document = Molecules::GrantResolver.trusted_document(Ace::Lab.authorization_path)
-          operation = Molecules::ServicePolicy.new(document).operation!(params.fetch("operation"),
-            project: @map.fetch("project_id"), service_id: @service_id)
-          authorization = @client.call("service_authorization", binding.merge("claim_binding" => claim.data.fetch("claim_binding"),
-            "input_digest" => params.fetch("input_digest")), upload_parts: [bytes], purpose: :service_input)
-          expected = binding.slice("head", "candidate_generation", "request_id").merge("claim_binding" => claim.data.fetch("claim_binding"),
-            "policy_digest" => claim.data.fetch("policy_digest"), "operation_digest" => Ace::Assign::Atoms::EvidenceDigest.digest(operation))
-          unless !authorization.replayed && authorization.data == expected
-            raise SecurityError, "current authority authorization differs"
-          end
-          # This successful fresh authority read is the admission point. A
-          # later veto cannot retroactively undo it; no read creates permission.
-          reloaded = Molecules::ServicePolicy.new(Molecules::GrantResolver.trusted_document(Ace::Lab.authorization_path)).operation!(
-            params.fetch("operation"), project: @map.fetch("project_id"), service_id: @service_id)
-          unless Ace::Assign::Atoms::EvidenceDigest.digest(reloaded) == expected.fetch("operation_digest")
-            raise SecurityError, "local operation changed after admission"
-          end
-          canonical = params.slice(*Ace::Assign::Molecules::EvidenceJournal::TERMINAL_BINDING_FIELDS, "authorization", "service_id").merge(
-            "project_id" => @map.fetch("project_id"), "candidate_head" => binding.fetch("head"),
-            "caller_uid" => peer.fetch("uid"), "executor_uid" => @receiver.fetch("executor_uid"), "transport" => "unix")
-          envelope = immutable("version" => 1, "request" => canonical, "input" => input.fetch(:input), "execution" => {
-            "executor_uid" => @receiver.fetch("executor_uid"), "authority_id" => @map.fetch("authority_id"),
-            "claim_binding" => claim.data.fetch("claim_binding"), "candidate_generation" => binding.fetch("candidate_generation"),
-            "head" => binding.fetch("head"), "staging_id" => File.basename(materialized.fetch("directory"))})
-          if params.fetch("operation") == "publish"
-            return begin_publication!(admitted: {params: params, claim: claim.data, started: started.data,
-              dispatch_event_digest: started.data.fetch("dispatch_event_digest"), operation: immutable(operation), envelope: envelope,
-              staging_identity: staging_identity, mutation_id: mutation_id}, materialized: materialized,
-              deadline: Process.clock_gettime(Process::CLOCK_MONOTONIC) + 30)
-          end
-          if cleanup
-            artifacts = cleanup_result_evidence!(params, input.fetch(:input), claim.data, started.data)
-            response = {"outcome" => "succeeded", "evidence" => artifacts.each_with_index.map do |artifact, index|
-              {"ref" => "cleanup-#{index}", "sha256" => Digest::SHA256.hexdigest(artifact)}
-            end}
-          else
-            response = @handler.execute(operation: immutable(operation), envelope: envelope, candidate_root: materialized.fetch("directory"))
-            return uncertain(params.fetch("request_id")) unless response
-            artifacts = Ace::Assign::Authority::EvidenceTransfer.read_staged(root: materialized.fetch("directory"), evidence: response.fetch("evidence"))
-          end
-          receipt = canonical.slice(*Ace::Assign::Molecules::EvidenceJournal::TERMINAL_BINDING_FIELDS).merge(
-            "outcome" => response.fetch("outcome"), "evidence" => response.fetch("evidence"))
-          receipt_bytes = JSON.generate(receipt)
-          completion = @client.call("complete_service", binding.merge("claim_binding" => claim.data.fetch("claim_binding"),
-            "receipt_sha256" => Digest::SHA256.hexdigest(receipt_bytes)),
-            mutation_id: Digest::SHA256.hexdigest("complete:#{mutation_id}"), upload_parts: [receipt_bytes] + artifacts, purpose: :receipt_artifacts)
-          unless completion.data["request_id"] == request_id && %w[succeeded failed].include?(completion.data["state"])
-            return uncertain(request_id)
-          end
-          cleanup_staging(materialized.fetch("directory"), staging_identity)
-          projection(completion.data)
-        rescue Ace::Assign::Error, Ace::Runtime::RuntimeUnavailableError, Ace::Lab::InvalidConfigurationError,
-          SecurityError, ArgumentError, KeyError, SystemCallError, Timeout::Error
-          contacted ? uncertain(request_id) : {"request_id" => request_id, "state" => "refused", "code" => "invalid_receiver_admission"}
-        end
-
-        private
-
-        def cleanup_result_evidence!(params, input, claim, started)
-          owner = started.fetch("operation_owner_binding")
-          result = @cleanup_owner.execute!(request: {
-            "request_id" => params.fetch("request_id"), "input_digest" => params.fetch("input_digest"),
-            "claim_binding" => claim.fetch("claim_binding"), "request_event_digest" => claim.fetch("request_event_digest"),
-            "dispatch_event_digest" => started.fetch("dispatch_event_digest"), "input" => input
-          }, operation_owner_binding: owner)
-          selection = {"schema" => "ace.protected-workspace-prune-root-selection/v1",
-            "request_id" => params.fetch("request_id"), "input_digest" => params.fetch("input_digest"),
-            "operation_owner_binding_digest" => Ace::Assign::Atoms::EvidenceDigest.digest(owner),
-            "receipt_ref" => result.fetch(:receipt_ref)}
-          [result.fetch(:bytes), JSON.generate(selection)]
-        end
-
-        # A source-owned listener callback, never a wire-selected handler. Its
-        # reply exposes accepted canonical identity before long work. Transport
-        # loss in the callback is handled by that listener; it cannot resend.
-        def notify_claim(callback, claim, request_id)
-          data = claim.data
-          unless data.is_a?(Hash) && data["request_id"] == request_id &&
-              data["generation"].is_a?(Integer) && data["generation"].positive? &&
-              data["journal_commit"].is_a?(String) && data["journal_commit"].match?(/\A(?:[0-9a-f]{40}|[0-9a-f]{64})\z/) &&
-              [true, false].include?(claim.replayed)
-            raise SecurityError, "canonical service acceptance identity is unavailable"
-          end
-          callback.call(immutable(data.slice("request_id", "generation", "journal_commit", "state", "claim")
-            .merge("replayed" => claim.replayed)))
-        end
-
-        def cleanup_staging(directory, identity, prefix: "candidate-")
-          quarantine = nil
-          root = File.expand_path(@receiver.fetch("staging_root"))
-          Ace::Assign::Authority::PrivateDirectory.verify!(root)
-          current = File.lstat(directory)
-          return unless File.dirname(directory) == root && File.basename(directory).start_with?(prefix) &&
-            current.directory? && current.uid == Process.uid && current.dev == identity.dev && current.ino == identity.ino
-          # Capture the pathname atomically before checking the object we will
-          # delete. A concurrent replacement at the original name must survive.
-          quarantine = Dir.mktmpdir(".receiver-cleanup-", root)
-          File.chmod(0o700, quarantine)
-          captured = File.join(quarantine, "candidate")
-          File.rename(directory, captured)
-          moved = File.lstat(captured)
-          return unless moved.directory? && moved.uid == Process.uid &&
-            moved.dev == identity.dev && moved.ino == identity.ino
-          FileUtils.remove_entry_secure(captured)
-        rescue Ace::Assign::Error, SystemCallError
-          # A cleanup failure cannot change already-confirmed canonical truth.
-          # Never fall back to cleaning the staging root or another directory.
-          nil
-        ensure
-          if quarantine
-            begin
-              # Never recursively remove a mismatched captured object.
-              Dir.rmdir(quarantine)
-            rescue SystemCallError
-              nil
-            end
-          end
-        end
-
-        def projection(data)
-          data.slice("request_id", "state", "dispatch_phase", "claim", "generation", "journal_commit").tap do |result|
-            result.merge!(data.slice("receipt", "completion_digest")) if data["operation"] == "publish"
-          end
-        end
-
-        def uncertain(id)
-          {"request_id" => id, "state" => "uncertain", "required_action" => "inspect_canonical_service_status_and_record_exact_outcome"}
-        end
-
-        def immutable(value)
-          copy = JSON.parse(JSON.generate(value))
-          freeze_value(copy)
-        end
-
-        def freeze_value(value)
-          value.each_value { |child| freeze_value(child) } if value.is_a?(Hash)
-          value.each { |child| freeze_value(child) } if value.is_a?(Array)
-          value.freeze
-        end
-      end
-    end
-  end
-end
-
-require_relative "protected_service_recovery"