ace-assign 0.70.0 → 0.73.0

data/lib/ace/assign/authority/ordinary_results.rb

@@ -1,196 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "receipt_transfer"
-require_relative "../molecules/canonical_evidence"
-
-module Ace
-  module Assign
-    module Authority
-      # A worker submits an attributable result. This never accepts a terminal
-      # outcome, an independent review, or an external delivery effect.
-      module OrdinaryResults
-        RESULT_OPERATIONS = %w[submit_result result_status result_snapshot].freeze
-        RESULT_TRANSFERS = {
-          "submit_result" => {direction: :upload, purpose: :receipt_artifacts, roles: %i[worker supervisor]},
-          "result_snapshot" => {direction: :download, purpose: :receipt_artifacts, roles: %i[worker supervisor]}
-        }.freeze
-        RESULT_KEYS = %w[assignment_id attempt_id expected_generation pane head receipt_sha256 transfer].freeze
-
-        private
-
-        def validate_result!(request)
-          params = request.fetch("params")
-          if request.fetch("operation") != "submit_result"
-            snapshot = request.fetch("operation") == "result_snapshot"
-            strict!(params, %w[assignment_id attempt_id] + (snapshot ? ["result_id"] : []))
-            token!(params.fetch("result_id")) if snapshot
-            raise ArgumentError, "ordinary result status mutation must be null" unless request.fetch("mutation_id").nil?
-          else
-            strict!(params, RESULT_KEYS)
-            token!(request.fetch("mutation_id"))
-            unless params.fetch("expected_generation").is_a?(Integer) && params.fetch("expected_generation").positive? &&
-                params.fetch("head").is_a?(String) && params.fetch("head").match?(/\A[0-9a-f]{40}\z/) &&
-                params.fetch("receipt_sha256").is_a?(String) && params.fetch("receipt_sha256").match?(/\A[0-9a-f]{64}\z/)
-              raise ArgumentError, "ordinary result selection is invalid"
-            end
-          end
-          %w[assignment_id attempt_id].each { |key| token!(params.fetch(key)) }
-        end
-
-        def ordinary_result(request, peer, role, deadline, transfer)
-          validate_result!(request)
-          params = request.fetch("params")
-          commit = @journal.ref_value
-          registered = registration(params.fetch("assignment_id"), commit: commit)
-          raise AttemptErrors::NotFound, "ordinary work is not registered" unless registered
-          if request.fetch("operation") != "submit_result"
-            events = result_events(params, commit)
-            result = retained_ordinary_result(params, events, commit)
-            if request.fetch("operation") == "result_snapshot"
-              unless result && result.fetch("result_id") == params.fetch("result_id")
-                raise AttemptErrors::NotFound, "ordinary exact result is unavailable"
-              end
-              receipt = result.fetch("receipt")
-              canonical = Molecules::CanonicalEvidence.new(journal: @journal)
-              parts = [JSON.generate(receipt)] + receipt.fetch("artifacts").map { |artifact|
-                canonical.read({"ref" => artifact.fetch("path"), "sha256" => artifact.fetch("sha256")},
-                  **ordinary_result_context(result.fetch("binding")), commit: commit)
-              }
-              authorize!(request, peer, role, deadline)
-              return {data: ordinary_result_projection(result).merge("journal_commit" => commit), transfer_parts: parts, replayed: false}
-            end
-            authorize!(request, peer, role, deadline)
-            return {data: {"assignment_id" => params.fetch("assignment_id"), "attempt_id" => params.fetch("attempt_id"),
-              "journal_commit" => commit, "generation" => @journal.authority_generation(events),
-              "state" => Molecules::CanonicalAttemptState.derive(events), "submitted_result" => result && ordinary_result_projection(result)}, replayed: false}
-          end
-          unless %i[worker supervisor].include?(role)
-            raise AttemptErrors::UnauthorizedIdentity, "ordinary result requires its original worker"
-          end
-          authorize_start_replay!(request, peer, role, deadline)
-          admitted = ReceiptTransfer.decode(input: transfer, receipt_sha256: params.fetch("receipt_sha256"),
-            artifact_field: "artifacts", reference_key: "path")
-          digest = Atoms::EvidenceDigest.digest({"params" => params, "project_id" => @project, "peer_uid" => peer.fetch("uid")})
-          keys = [@exclusion.task_key(registered.fetch("task_id")), @exclusion.assignment_key(params.fetch("assignment_id"))]
-          @exclusion.with_shared_multi(keys, deadline: deadline) do
-            @journal.mutate(assignment_id: params.fetch("assignment_id"), attempt_id: params.fetch("attempt_id"),
-              mutation_id: request.fetch("mutation_id"), operation: "submit_result", parameters_digest: digest,
-              expected_generation: params.fetch("expected_generation"), with_replay: true, deadline: deadline,
-              replay_authorizer: -> { authorize_start_replay!(request, peer, role, deadline) }) do |events, prefix, generation|
-              authorize_start_replay!(request, peer, role, deadline)
-              unless Molecules::CanonicalAttemptState.derive(events) == "running"
-                raise AttemptErrors::Conflict, "ordinary result requires the original running attempt"
-              end
-              raise AttemptErrors::Conflict, "ordinary attempt already submitted its result" if retained_ordinary_result(params, events, prefix)
-              observed = @admission.execution!(peer: peer, pane: params.fetch("pane"), head: params.fetch("head"), deadline: deadline)
-              start_replay_owner!(params, observed.fetch(:identity))
-              ordinary_result_plan(params, peer, admitted, observed, events, prefix, generation + 1)
-            end
-          end
-        end
-
-        def result_events(params, commit)
-          events = @journal.read_events(params.fetch("assignment_id"), commit: commit)
-            .select { |event| event.fetch("attempt_id") == params.fetch("attempt_id") }
-          unless Models::EvidenceEvent.chain_valid?(events) && events.one? { |event| event["type"] == "process_start" }
-            raise AttemptErrors::EvidenceUnavailable, "ordinary result attempt evidence is unavailable"
-          end
-          events
-        end
-
-        def ordinary_result_plan(params, peer, admitted, observed, events, commit, generation)
-          original = admitted.fetch(:receipt)
-          original_receipt = Models::ExecutionReceipt.from_h(original)
-          unless original_receipt.digest == Atoms::EvidenceDigest.digest(original_receipt.digest_payload)
-            raise AttemptErrors::ReceiptRejected, "ordinary original result digest differs"
-          end
-          identity = observed.fetch(:identity)
-          expected_producer = {"actor" => identity.actor, "role" => identity.role, "runtime" => identity.runtime}
-          validate_ordinary_result_receipt!(original, expected_producer)
-          id = SecureRandom.hex(16)
-          binding = params.slice("assignment_id", "attempt_id", "head").merge("authority" => "ordinary", "project_id" => @project,
-            "result_id" => id, "worker_uid" => peer.fetch("uid"), "producer" => expected_producer,
-            "runtime_binding" => identity.runtime_binding, "checkout" => observed.fetch(:checkout),
-            "generation" => generation, "uploaded_receipt_sha256" => admitted.fetch(:receipt_sha256),
-            "original_receipt_digest" => original_receipt.digest)
-          canonical = Molecules::CanonicalEvidence.new(journal: @journal)
-          plan = admitted.fetch(:artifacts).empty? ? {events: [], blobs: {}, references: []} :
-            canonical.import_plan(**ordinary_result_context(binding), artifacts: admitted.fetch(:artifacts),
-              admitted_after_event_digest: events.last.fetch("digest"))
-          receipt = original.except("digest", "recorded_at").merge("artifacts" => plan.fetch(:references).map { |reference|
-            {"path" => reference.fetch("ref"), "sha256" => reference.fetch("sha256")}
-          })
-          pending = @journal.send(:chain_mutation_events, params.fetch("attempt_id"), events.last.fetch("digest"), plan.fetch(:events))
-          reader = ->(_data, artifact) { canonical.read_pending({"ref" => artifact.fetch("path"), "sha256" => artifact.fetch("sha256")},
-            **ordinary_result_context(binding), current_events: events, pending_events: pending, blobs: plan.fetch(:blobs), commit: commit) }
-          verified = verify_ordinary_result_receipt(params, receipt, binding, commit, reader)
-          if JSON.generate(verified.to_h).bytesize > 16_384
-            raise AttemptErrors::ReceiptRejected, "canonical ordinary receipt exceeds its transfer limit"
-          end
-          payload = {"authority" => "ordinary", "result_id" => id, "binding" => binding, "receipt" => verified.to_h}
-          plan.merge(events: plan.fetch(:events) + [{type: "result_submitted", payload: payload}],
-            data: ordinary_result_projection(payload))
-        end
-
-        def ordinary_result_projection(payload)
-          payload.slice("result_id").merge(payload.fetch("binding").slice("head", "generation"),
-            "receipt_digest" => payload.fetch("receipt").fetch("digest"), "verdict" => payload.fetch("receipt").fetch("verdict"),
-            "state" => "running", "authority" => "ordinary")
-        end
-
-        def ordinary_result_context(binding)
-          {kind: "result", project_id: @project, assignment_id: binding.fetch("assignment_id"), attempt_id: binding.fetch("attempt_id"),
-            peer_uid: binding.fetch("worker_uid"), binding: binding, request_id_or_event_id: binding.fetch("result_id"), generation: binding.fetch("generation")}
-        end
-
-        def validate_ordinary_result_receipt!(receipt, producer)
-          unless receipt["producer"] == producer && (receipt.keys - Models::ExecutionReceipt.from_h(receipt).to_h.keys).empty? &&
-              !receipt["campaign"] && !receipt["review"] && receipt["operation"] != "review" &&
-              !Molecules::ReceiptVerifier::EXTERNAL_EFFECT_OPERATIONS.include?(receipt["operation"])
-            raise AttemptErrors::ReceiptRejected, "ordinary result producer or operation requires another evidence owner"
-          end
-        end
-
-        def verify_ordinary_result_receipt(params, receipt, binding, commit, reader)
-          validate_ordinary_result_receipt!(receipt, binding.fetch("producer"))
-          attempt = @journal.derived_attempts(params.fetch("assignment_id"), commit: commit).find { |item| item.attempt_id == params.fetch("attempt_id") }
-          raise AttemptErrors::EvidenceUnavailable, "ordinary result attempt is unavailable" unless attempt
-          Array(receipt["artifacts"]).each { |artifact| reader.call(receipt, artifact) }
-          Molecules::ReceiptVerifier.new(artifact_reader: reader).verify_result!(receipt,
-            attempt: attempt, live_head: binding.fetch("head"), repo_root: @journal.repo_root)
-        end
-
-        def retained_ordinary_result(params, events, commit)
-          raise AttemptErrors::EvidenceUnavailable, "ordinary result chain is corrupt" unless Models::EvidenceEvent.chain_valid?(events)
-          records = events.select { |event| event["type"] == "result_submitted" }
-          replies = events.select { |event| event["type"] == "authority_mutation" && event.dig("payload", "operation") == "submit_result" }
-          return nil if records.empty? && replies.empty?
-          unless records.one? && replies.one?
-            raise AttemptErrors::EvidenceUnavailable, "ordinary result provenance is missing or duplicated"
-          end
-          payload = records.first.fetch("payload")
-          binding = payload.fetch("binding")
-          start = events.find { |event| event["type"] == "process_start" }.fetch("payload")
-          unless payload.keys.sort == %w[authority binding receipt result_id] && payload["authority"] == "ordinary" &&
-              payload["result_id"].is_a?(String) && payload["result_id"].match?(/\A[0-9a-f]{32}\z/) &&
-              binding.keys.sort == %w[assignment_id attempt_id authority checkout generation head original_receipt_digest producer project_id result_id runtime_binding uploaded_receipt_sha256 worker_uid] &&
-              binding["authority"] == "ordinary" && binding["result_id"] == payload["result_id"] &&
-              binding["head"] == binding.dig("checkout", "head") &&
-              binding.values_at("project_id", "assignment_id", "attempt_id", "runtime_binding") ==
-              [@project, params.fetch("assignment_id"), params.fetch("attempt_id"), start.fetch("runtime_binding")] &&
-              binding.fetch("producer") == start.slice("actor", "role", "runtime") &&
-              binding.fetch("worker_uid") == start.dig("runtime_binding", "process_identity", "uid") &&
-              payload.fetch("receipt").fetch("producer") == binding.fetch("producer") &&
-              replies.first.dig("payload", "data").slice(*ordinary_result_projection(payload).keys) == ordinary_result_projection(payload)
-            raise AttemptErrors::EvidenceUnavailable, "ordinary result owner differs"
-          end
-          canonical = Molecules::CanonicalEvidence.new(journal: @journal)
-          reader = ->(_data, artifact) { canonical.read({"ref" => artifact.fetch("path"), "sha256" => artifact.fetch("sha256")},
-            **ordinary_result_context(binding), commit: commit) }
-          verify_ordinary_result_receipt(params, payload.fetch("receipt"), binding, commit, reader)
-          payload
-        end
-      end
-    end
-  end
-end

data/lib/ace/assign/authority/ordinary_server.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "socket_server"
-
-module Ace
-  module Assign
-    module Authority
-      # Explicit ordinary admission over Assign's existing wire/transfer owner.
-      # The Lab composition supplies a trusted installed admission object and
-      # closed handlers. No protected Deployment or kernel adapter is replaced.
-      class OrdinaryServer < SocketServer
-        def initialize(admission:, lifecycle:, services: [])
-          @admission = admission
-          super(service: admission.service, lifecycle: lifecycle, services: services)
-        end
-
-        private
-
-        def verify_listener!
-          @admission.verify_listener!
-        end
-
-        def authorize_transfer!(request:, peer:, role:, deadline:)
-          @lifecycle.authorize_transfer!(request: request, peer: peer, role: role, deadline: deadline)
-        end
-
-        def dispatch_lifecycle(request:, peer:, role:, deadline:, transfer: nil)
-          @lifecycle.dispatch(request: request, peer: peer, role: role, deadline: deadline, transfer: transfer)
-        end
-
-        def receive(socket)
-          deadline = wire.deadline(30)
-          peer = @admission.peer(socket, deadline: deadline)
-          ingress = Ace::Runtime::Molecules::ProtectedSocket::Ingress.new(socket)
-          frame = wire.read(ingress, deadline: [deadline, wire.deadline(5)].min, limit: 16_384, with_size: true)
-          request = frame.fetch(:data)
-          unless request.is_a?(Hash) && request.keys.sort == %w[mutation_id operation params project_id version] &&
-              request["version"].is_a?(Integer) && request["version"] == 1 &&
-              request["operation"].is_a?(String) && request["params"].is_a?(Hash)
-            raise ArgumentError, "invalid ordinary authority envelope"
-          end
-          role = @admission.authorize!(request: request, peer: peer, deadline: deadline)
-          binding = @lifecycle.transfer_binding(request)
-          bodyless_read!(ingress, deadline) unless binding && binding.fetch(:direction) == :upload
-          # Both binary bodies and EOF use ancillary-rejecting reads. Replies
-          # use the original duplex socket through the wrapper below.
-          dispatch_request(Duplex.new(socket, ingress), request, peer, role, deadline, frame_bytes: frame.fetch(:bytesize))
-        rescue ArgumentError, KeyError, AttemptErrors::MalformedTransfer
-          refusal(socket, "invalid_input")
-        rescue AttemptErrors::UnauthorizedIdentity, SecurityError
-          refusal(socket, "unauthorized")
-        rescue AttemptErrors::Conflict
-          refusal(socket, "conflict")
-        rescue AttemptErrors::NotFound
-          refusal(socket, "missing")
-        rescue AttemptErrors::BoundedResultUnavailable
-          refusal(socket, "bounded_result")
-        rescue StandardError
-          refusal(socket, "evidence_unavailable")
-        ensure
-          socket.close unless socket.closed?
-          @mutex.synchronize { @connections.delete(socket) }
-        end
-
-        class Duplex
-          def initialize(socket, ingress) = (@socket, @ingress = socket, ingress)
-          def to_io = @socket
-          def read_nonblock(*args, **options) = @ingress.read_nonblock(*args, **options)
-          def write_nonblock(*args, **options) = @socket.write_nonblock(*args, **options)
-        end
-        private_constant :Duplex
-      end
-    end
-  end
-end

data/lib/ace/assign/authority/original_inbox_selection.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module Ace
-  module Assign
-    module Authority
-      # Original descriptor selection shared by canonical Inbox consumers.
-      # The held historical manifest/key owner supplies the exact artifact.
-      class OriginalInboxSelection
-        def initialize(history:, authority_id:)
-          @history, @authority_id = history, authority_id
-        end
-
-        def load!(events:, params:, map:, journal:, commit:)
-          provisioning = events.select { |event| event["type"] == "scope_provisioning" }
-          reservations = events.select { |event| event["type"] == "authority_mutation" && event.dig("payload", "operation") == "reserve_attempt" }
-          unless provisioning.one? && reservations.one?
-            raise AttemptErrors::EvidenceUnavailable, "context completion original selection is ambiguous"
-          end
-          identity = provisioning.first.fetch("payload")
-          reserved = reservations.first.fetch("payload").fetch("data")
-          original = @history.descriptor!(sha256: identity.fetch("descriptor_sha256"))
-          selected = original.mapping(params.fetch("mapping_id"))
-          unless identity.keys.sort == %w[deployment_digest descriptor_sha256 reservation_generation slot_id] &&
-              reserved.values_at("project_id", "assignment_id", "attempt_id", "mapping_id") ==
-                [map.fetch("project_id"), params.fetch("assignment_id"), params.fetch("attempt_id"), params.fetch("mapping_id")] &&
-              identity.fetch("reservation_generation") == reserved.fetch("reservation_generation") &&
-              identity.fetch("deployment_digest") == original.mapping_digest(params.fetch("mapping_id")) &&
-              selected.fetch("project_id") == map.fetch("project_id") && selected.fetch("authority_id") == @authority_id &&
-              identity.fetch("slot_id") == selected.fetch("execution_scope").fetch("slot_id") &&
-              original.project(selected.fetch("project_id")).values_at("journal_repository", "evidence_git_ref", "evidence_checkout_root") ==
-                [journal.repo_root, journal.ref, journal.checkout_root]
-            raise AttemptErrors::EvidenceUnavailable, "context completion original association differs"
-          end
-          journal.event_commit!(assignment_id: params.fetch("assignment_id"), event_digest: provisioning.first.fetch("digest"), commit: commit)
-          [original, selected]
-        end
-
-      end
-    end
-  end
-end

data/lib/ace/assign/authority/posix_acl.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-require "fiddle"
-
-module Ace
-  module Assign
-    module Authority
-      # Linux POSIX access ACL evaluation for a fixed unprivileged principal.
-      # No credential switching; unsupported or unreadable policy refuses admission.
-      class PosixAcl
-        def entries(path, attribute: "system.posix_acl_access")
-          unless %w[system.posix_acl_access system.posix_acl_default].include?(attribute)
-            raise ArgumentError, "unsupported POSIX ACL attribute"
-          end
-          raise Ace::Runtime::RuntimeUnavailableError, "receiver ACL inspection requires Linux" unless RUBY_PLATFORM.include?("linux")
-          function = Fiddle::Function.new(Fiddle::Handle::DEFAULT["lgetxattr"],
-            [Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP, Fiddle::TYPE_SIZE_T], Fiddle::TYPE_SSIZE_T)
-          buffer = Fiddle::Pointer.malloc(8192, Fiddle::RUBY_FREE)
-          count = function.call(path, attribute, buffer, 8192)
-          return nil if count == -1 && Fiddle.last_error == Errno::ENODATA::Errno
-          raise Ace::Runtime::RuntimeUnavailableError, "receiver access ACL is unreadable" if count < 4 || (count - 4) % 8 != 0
-          bytes = buffer[0, count]
-          raise Ace::Runtime::RuntimeUnavailableError, "unknown receiver ACL version" unless bytes.unpack1("L<") == 2
-          rows = bytes.byteslice(4..).unpack("S<S<L<" * ((count - 4) / 8)).each_slice(3).to_a
-          validate!(rows)
-          rows
-        rescue Fiddle::DLError
-          raise Ace::Runtime::RuntimeUnavailableError, "receiver ACL inspection is unavailable"
-        end
-
-        def searchable?(path, stat:, uid:, groups:)
-          rows = entries(path)
-          unless rows
-            shift = uid == stat.uid ? 6 : (groups.include?(stat.gid) ? 3 : 0)
-            return ((stat.mode >> shift) & 1) == 1
-          end
-          return (rows.find { |tag, _perm, _id| tag == 1 }[1] & 1) == 1 if uid == stat.uid
-          mask = rows.find { |tag, _perm, _id| tag == 16 }&.at(1) || 7
-          named = rows.find { |tag, _perm, id| tag == 2 && id == uid }
-          return (named[1] & mask & 1) == 1 if named
-          matched = rows.select { |tag, _perm, id| (tag == 4 && groups.include?(stat.gid)) || (tag == 8 && groups.include?(id)) }
-          return matched.any? { |_tag, perm, _id| (perm & mask & 1) == 1 } unless matched.empty?
-          (rows.find { |tag, _perm, _id| tag == 32 }[1] & 1) == 1
-        end
-
-        private
-
-        def validate!(rows)
-          valid = rows.all? { |tag, perm, id| [1, 2, 4, 8, 16, 32].include?(tag) && (0..7).cover?(perm) &&
-            ([2, 8].include?(tag) ? id != 0xffffffff : id == 0xffffffff) }
-          valid &&= [1, 4, 32].all? { |tag| rows.count { |row| row[0] == tag } == 1 }
-          valid &&= rows.count { |row| row[0] == 16 } <= 1
-          valid &&= [2, 8].all? { |tag| ids = rows.select { |row| row[0] == tag }.map(&:last); ids.uniq == ids }
-          valid &&= !rows.any? { |row| [2, 8].include?(row[0]) } || rows.count { |row| row[0] == 16 } == 1
-          raise Ace::Runtime::RuntimeUnavailableError, "invalid receiver access ACL" unless valid
-        end
-      end
-    end
-  end
-end

data/lib/ace/assign/authority/prepared_input.rb

@@ -1,130 +0,0 @@
-# frozen_string_literal: true
-
-require "shellwords"
-require_relative "client"
-require_relative "prepared_work"
-
-module Ace
-  module Assign
-    module Authority
-      # One authenticated original fetch and one immutable verified work graph.
-      # Caller identifiers select; the maintained Client/Endcap authenticates.
-      class PreparedInput
-        attr_reader :descriptor, :work, :working_directory
-
-        def self.fetch(client:, assignment_id:, attempt_id:)
-          reply = client.call("evidence_fetch", {"assignment_id" => assignment_id, "attempt_id" => attempt_id,
-            "kind" => "prepared_work", "purpose_id" => "original_prepared_work", "artifact_id" => "prepared_bundle"},
-            download: true, purpose: :candidate, timeout: 30)
-          new(reply: reply, candidate_loader: -> {
-            client.call("evidence_fetch", {"assignment_id" => assignment_id, "attempt_id" => attempt_id,
-              "kind" => "campaign_candidate", "purpose_id" => "original_campaign_candidate", "artifact_id" => "candidate_bundle"},
-              download: true, purpose: :candidate, timeout: 30)
-          })
-        end
-
-        def initialize(reply:, candidate_reply: nil, candidate_loader: nil)
-          @descriptor = reply.data.fetch("descriptor")
-          Molecules::LifecycleExclusion.workspace_reader(projection: descriptor.fetch("workspace_exclusion"))
-          unless descriptor.dig("workspace_exclusion", "root_resource", "view_path") ==
-              "/run/ace/lifecycle-exclusion/#{descriptor.fetch('mapping_id')}"
-            raise AttemptErrors::EvidenceUnavailable, "prepared_input_unavailable: original lifecycle mapping differs"
-          end
-          unless reply.parts.is_a?(Array) && reply.parts.one?
-            raise AttemptErrors::EvidenceUnavailable, "prepared_input_unavailable: one original bundle required"
-          end
-          root = PrivateDirectory.verify!(descriptor.fetch("original_worker_scratch_root"))
-          @work = PreparedWork.admit(bytes: reply.parts.first, head: descriptor.fetch("prepared_head"),
-            tree: descriptor.fetch("prepared_tree"), sha256: descriptor.fetch("sha256"), size: descriptor.fetch("bytes"), root: root)
-          expected = work.reference(head: descriptor.fetch("prepared_head"), tree: descriptor.fetch("prepared_tree"))
-          definition = work.definition_bytes(head: descriptor.fetch("prepared_head"), tree: descriptor.fetch("prepared_tree"))
-          unless expected == descriptor.slice(*expected.keys) &&
-              descriptor.values_at("assignment_id", "project_id") == work.manifest.values_at("assignment_id", "project_id") &&
-              Digest::SHA256.hexdigest(definition) == descriptor.fetch("definition_digest")
-            raise AttemptErrors::EvidenceUnavailable, "prepared_input_mismatch: original graph association"
-          end
-          execution = work.definition["campaign_execution"]
-          if execution
-            candidate_reply ||= candidate_loader&.call
-            candidate = candidate_reply&.data&.fetch("descriptor")
-            unless candidate.is_a?(Hash) && candidate.keys.sort == %w[head tree bytes sha256 candidate_generation campaign_execution mapping_id assignment_id attempt_id project_id original_worker_identity original_worker_scratch_root original_binding_digest].sort &&
-                candidate.slice("mapping_id", "assignment_id", "attempt_id", "project_id", "original_worker_identity", "original_worker_scratch_root", "original_binding_digest") ==
-                  descriptor.slice("mapping_id", "assignment_id", "attempt_id", "project_id", "original_worker_identity", "original_worker_scratch_root", "original_binding_digest") &&
-                candidate.fetch("campaign_execution") == execution && candidate.fetch("head") == execution.fetch("head") &&
-                candidate.fetch("candidate_generation") == execution.fetch("parent_candidate_generation") &&
-                candidate_reply.parts.is_a?(Array) && candidate_reply.parts.one?
-              raise AttemptErrors::EvidenceUnavailable, "campaign original candidate input differs"
-            end
-            materialized = CandidateTransfer.new(root: root).materialize_repository(bytes: candidate_reply.parts.first,
-              sha256: candidate.fetch("sha256"), size: candidate.fetch("bytes"), head: candidate.fetch("head"),
-              tree: candidate.fetch("tree"), root: root)
-            @working_directory = materialized.fetch("directory").freeze
-          elsif candidate_reply
-            raise AttemptErrors::EvidenceUnavailable, "ordinary prepared input forbids a campaign candidate"
-          end
-          @descriptor = JSON.parse(JSON.generate(descriptor))
-          pending = [@descriptor]
-          until pending.empty?
-            value = pending.pop
-            pending.concat(value.values) if value.is_a?(Hash)
-            pending.concat(value) if value.is_a?(Array)
-            value.freeze
-          end
-          freeze
-        end
-
-        def render(text)
-          values = descriptor.slice("mapping_id", "assignment_id", "scope", "attempt_id")
-          rendered = +""
-          cursor = 0
-          # Only an opening delimiter introduces a token. Closing braces in
-          # literal JSON are preserved; inserted selector values are not parsed.
-          while (opening = text.index("{{", cursor))
-            rendered << text[cursor...opening]
-            closing = text.index("}}", opening + 2)
-            unless closing
-              raise AttemptErrors::EvidenceUnavailable, "prepared_input_invalid: unresolved instruction token"
-            end
-            token = text[(opening + 2)...closing]
-            if token.include?("{") || token.include?("}")
-              raise AttemptErrors::EvidenceUnavailable, "prepared_input_invalid: unresolved instruction token"
-            end
-            field = token.delete_prefix("admitted.")
-            unless token == "admitted." + field && values.key?(field)
-              raise AttemptErrors::EvidenceUnavailable, "prepared_input_invalid: unknown instruction token"
-            end
-            rendered << Shellwords.escape(values.fetch(field))
-            cursor = closing + 2
-          end
-          rendered << text[cursor..]
-          rendered.freeze
-        end
-
-        def drive_prompt
-          target = Shellwords.escape(descriptor.fetch("assignment_id") + "@" + descriptor.fetch("scope"))
-          selectors = "--assignment #{target} --mapping #{Shellwords.escape(descriptor.fetch('mapping_id'))} --attempt #{Shellwords.escape(descriptor.fetch('attempt_id'))}"
-          instructions = ["Drive the authenticated captured assignment subtree. Use ace-assign status #{selectors}, step #{selectors}, start #{selectors}, finish #{selectors} --message REPORT, and fail #{selectors} --message REASON. Do not fork-run, add, retry, renumber, or expand another graph."]
-          if (execution = work.definition["campaign_execution"])
-            instructions << "This is a registered campaign #{execution.fetch('phase')} child. The provider working directory is the private authenticated parent candidate repository at #{Shellwords.escape(execution.fetch('head'))}, with original base #{Shellwords.escape(execution.fetch('base'))}. Do not edit or advance that candidate. Execute the captured #{Shellwords.escape(execution.fetch('operation'))} phase and retain its actual #{Shellwords.escape(execution.fetch('check_name'))} check and report artifacts. Submit an ordinary campaign-free result (campaign null), operation #{Shellwords.escape(execution.fetch('operation'))}, exact original head/base, and actual check outcome. The existing independent reviewer must validate those same artifact bytes; an approval child must retain the exact canonical independent review actor/verdict. No session metadata or completed queue step counts as a settled R1 campaign round."
-          end
-          original = "--mapping #{Shellwords.escape(descriptor.fetch('mapping_id'))} --assignment #{Shellwords.escape(descriptor.fetch('assignment_id'))} --attempt #{Shellwords.escape(descriptor.fetch('attempt_id'))}"
-          instructions << "Before the original worker exits, explicitly submit its tested candidate and real execution result through the protected authority. Queue completion is not candidate/result acceptance. Read ace-assign authority status #{original}; persist its authority_generation with the complete next command arguments and ordered byte inputs. For each NEW operation use a new explicit mutation and a newly selected generation; for exact retries preserve the original generation, mutation and bytes."
-          instructions << "Submit one prepared Git bundle: ace-assign submit-candidate #{original} --head HEAD --candidate-generation CURRENT_CANDIDATE --expected-generation G --mutation CANDIDATE_MUTATION --bundle FILE. Select CURRENT_CANDIDATE from status result_candidate_generation, using 0 when null. Persist the returned candidate_generation and head as REVIEWED_CANDIDATE and HEAD; never derive the next counter by arithmetic or from queue completion."
-          instructions << "Have an independent installed reviewer run ace-overseer review --project #{Shellwords.escape(descriptor.fetch('project_id'))} --agent #{Shellwords.escape(descriptor.fetch('mapping_id'))} --assignment #{Shellwords.escape(descriptor.fetch('assignment_id'))} --attempt #{Shellwords.escape(descriptor.fetch('attempt_id'))} --head HEAD --candidate-generation REVIEWED_CANDIDATE --expected-generation G --mutation REVIEW_REQUEST --accept-mutation REVIEW_ACCEPT. Do not impersonate that principal. The review consumer owns actual candidate export, independent checks and canonical acceptance. After review, read authority status again before the first result submission."
-          instructions << "Produce the real receipt with Ace::Assign::Models::ExecutionReceipt.new/to_h: original assignment/attempt/project and scope #{Shellwords.escape(descriptor.fetch('scope'))}, exact tested candidate head, installed worker actor/role worker/runtime herdr, actual operation/verdict/executed checks and ordered artifact path/SHA256 pairs. No invented successful check or queue-to-receipt conversion. Submit JSON bytes and matching ordered artifact files with ace-assign submit-result #{original} --head HEAD --candidate-generation REVIEWED_CANDIDATE --expected-generation G --mutation RESULT_MUTATION --receipt FILE --artifact FILE ... . Failed empty artifacts use no --artifact; succeeded requires evidence. Supervisor finish is separate and revalidates result, independent review and no-writer/settlement proof."
-          instructions << "For an authorized merge step captured INSIDE this subtree, use the protected delivery rule in wfi://assign/drive. Never execute an outer preset step or expand this graph. Retain the exact approved candidate, structured input bytes, authorization and request ID before the first request; select authority_generation for that new request only."
-          service = "--project #{Shellwords.escape(descriptor.fetch('project_id'))} #{original} --scope #{Shellwords.escape(descriptor.fetch('scope'))} --candidate-head HEAD --candidate-generation REVIEWED_CANDIDATE"
-          instructions << "Request the uniquely installed authorized merge receiver: ace-lab service request #{service} --service SERVICE --operation merge --authorization AUTHORIZATION --request-id REQUEST --expected-generation G --input INPUT_FILE. Credentials alone are not authorization. Persist the returned original input_digest and target with all request arguments. Lost/uncertain replies never permit another effect or refreshed-generation retry."
-          instructions << "Inspect the same request: ace-lab service status #{service} --request REQUEST --input-digest INPUT_DIGEST --target TARGET. Only canonical succeeded evidence permits ace-assign delivery #{original} --scope #{Shellwords.escape(descriptor.fetch('scope'))} --operation merge --service-request REQUEST --candidate-head HEAD --candidate-generation REVIEWED_CANDIDATE --input-digest INPUT_DIGEST --target TARGET. This consumption verifies the imported receipt and never executes merge. Refusal, unavailable or uncertain leaves the active delivery step unfinished; report its exact blocker. Finish the queue step only after succeeded canonical delivery."
-          work.manifest.fetch("context").each do |entry|
-            instructions << render(work.files.fetch(entry.fetch("text").fetch("filename")))
-          end
-          work.manifest.fetch("steps").each do |entry|
-            instructions << "Step #{entry.fetch('number')}:\n" + render(work.parse_queue_step!(work.files.fetch("steps/" + entry.fetch("filename"))).fetch(:body))
-          end
-          instructions.join("\n\n").freeze
-        end
-      end
-    end
-  end
-end