ace-assign 0.64.0 → 0.66.1

data/lib/ace/assign/cli/commands/attempt/base.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "json"
+require_relative "../../../authority/protected_assignment_context"
 
 module Ace
   module Assign
@@ -13,6 +14,54 @@ module Ace
           module Base
             private
 
+            def protected_context(options)
+              keys = %i[mapping assignment result head candidate_generation mutation expected_generation inbox_context registration signature]
+              keys.each do |key|
+                if options.key?(key) && options[key].to_s.strip.empty?
+                  raise Ace::Support::Cli::Error, "Empty protected --#{key.to_s.tr('_', '-')} selector"
+                end
+              end
+              context = @protected_assignment_context ||= Ace::Assign::Authority::ProtectedAssignmentContext.load
+              selected = keys.any? do |key|
+                options.key?(key)
+              end
+              context if context.protected_participant? || selected || context.mapping_hint?
+            rescue SecurityError, Ace::Runtime::RuntimeUnavailableError
+              protected_transport_unavailable!
+            end
+
+            def protected_attempt_request(context, options, usage)
+              params = {"assignment_id" => require_option(options, :assignment, usage),
+                "attempt_id" => require_option(options, :attempt, usage),
+                "expected_generation" => integer_option(options, :expected_generation, usage)}
+              context.verify_attempt_hints!(assignment_id: params.fetch("assignment_id"), attempt_id: params.fetch("attempt_id"))
+              [context.client(options: options), params, require_option(options, :mutation, usage)]
+            rescue SecurityError, Ace::Runtime::RuntimeUnavailableError
+              protected_transport_unavailable!
+            end
+
+            def protected_call(client, operation, params, mutation)
+              client.call(operation, params, mutation_id: mutation, timeout: 30).data
+            rescue SecurityError, Ace::Runtime::RuntimeUnavailableError
+              protected_transport_unavailable!
+            end
+
+            def protected_transport_unavailable!
+              raise AttemptErrors::EvidenceUnavailable, "Protected authority outcome unavailable; retain original selectors and mutation for reconciliation"
+            end
+
+            def integer_option(options, key, usage, positive: false)
+              value = options[key]
+              unless value.is_a?(Integer) || (value.is_a?(String) && value.match?(/\A(?:0|[1-9][0-9]*)\z/))
+                raise Ace::Support::Cli::Error, "--#{key.to_s.tr('_', '-')} requires an exact integer: #{usage}"
+              end
+              number = value.is_a?(Integer) ? value : Integer(value, 10)
+              unless positive ? number.positive? : number >= 0
+                raise Ace::Support::Cli::Error, "--#{key.to_s.tr('_', '-')} is out of range"
+              end
+              number
+            end
+
             def build_coordinator
               Organisms::AttemptCoordinator.new
             end

data/lib/ace/assign/cli/commands/attempt/finish.rb

@@ -8,18 +8,34 @@ module Ace
     module CLI
       module Commands
         module Attempt
-          # Accept a structured execution receipt and record the outcome.
-          # Terminal and uncertain attempts refuse new receipts.
+          # Protected completion selects an already submitted canonical result.
+          # Ordinary local completion accepts its structured receipt file.
           class Finish < Ace::Support::Cli::Command
             include Ace::Support::Cli::Base
             include Attempt::Base
 
-            desc "Finish an attempt with a structured execution receipt"
+            desc "Finish a protected canonical result or an ordinary local receipt"
 
             option :attempt, desc: "Attempt ID"
-            option :receipt, desc: "Path to the receipt JSON file"
+            option :mapping, desc: "Exact installed protected mapping ID"
+            option :assignment, desc: "Exact protected assignment ID"
+            option :mutation, desc: "Stable original authority mutation ID"
+            option :expected_generation, desc: "Original authority mutation generation"
+            option :receipt, desc: "Path to the ordinary local receipt JSON file"
+            option :result, desc: "Already submitted canonical protected result ID"
+            option :head, desc: "Exact canonical candidate head"
+            option :candidate_generation, desc: "Original canonical candidate generation"
 
             def call(**options)
+              if (context = protected_context(options))
+                raise Ace::Support::Cli::Error, "Protected finish forbids --receipt" unless options[:receipt].to_s.empty?
+                usage = "finish --mapping MAP --assignment ID --attempt ID --result ID --head SHA --candidate-generation N --mutation ID --expected-generation N"
+                client, params, mutation = protected_attempt_request(context, options, usage)
+                params.merge!("result_id" => require_option(options, :result, usage), "head" => require_option(options, :head, usage),
+                  "candidate_generation" => integer_option(options, :candidate_generation, usage, positive: true))
+                emit_json(protected_call(client, "finish", params, mutation))
+                return
+              end
               attempt_id = require_option(options, :attempt, "finish --attempt ID --receipt FILE")
               receipt = require_option(options, :receipt, "finish --attempt ID --receipt FILE")
 

data/lib/ace/assign/cli/commands/attempt/reconcile.rb

@@ -17,9 +17,20 @@ module Ace
             desc "Reconcile an interrupted or uncertain attempt"
 
             option :attempt, desc: "Attempt ID"
+            option :mapping, desc: "Exact installed protected mapping ID"
+            option :assignment, desc: "Exact protected assignment ID"
+            option :mutation, desc: "Stable original authority mutation ID"
+            option :expected_generation, desc: "Original authority mutation generation"
             option :receipt, desc: "Path to the receipt JSON file (required to resolve uncertainty)"
 
             def call(**options)
+              if (context = protected_context(options))
+                raise Ace::Support::Cli::Error, "Protected recovery forbids --receipt" unless options[:receipt].to_s.empty?
+                usage = "reconcile --mapping MAP --assignment ID --attempt ID --mutation ID --expected-generation N"
+                client, params, mutation = protected_attempt_request(context, options, usage)
+                emit_json(protected_call(client, "recover", params, mutation))
+                return
+              end
               attempt_id = require_option(options, :attempt, "reconcile --attempt ID [--receipt FILE]")
               receipt = options[:receipt].to_s.strip
 

data/lib/ace/assign/cli/commands/authority/inbox_context_principal.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+require_relative "../../../authority/prepared_task_context"
+
+module Ace
+  module Assign
+    module CLI
+      module Commands
+        module Authority
+          class InboxContextPrincipal < Ace::Support::Cli::Command
+            desc "Classify the actual caller through every retained protected owner"
+
+            def call(**options)
+              raise ArgumentError, "fixed inbox context options differ" unless options.empty?
+              consumer = Ace::Assign::Authority::PreparedTaskContext.new(context: @protected_assignment_context)
+              $stdout.write(consumer.inbox_principal())
+              0
+            rescue ArgumentError, Ace::Runtime::Error, Ace::Assign::Error => error
+              raise Ace::Support::Cli::Error, error.message
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/assign/cli/commands/authority/inbox_context_selection.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+require_relative "../../../authority/prepared_task_context"
+
+module Ace
+  module Assign
+    module CLI
+      module Commands
+        module Authority
+          class InboxContextSelection < Ace::Support::Cli::Command
+            desc "Read the fixed installed inbox context selection"
+            option :project, required: true, desc: "Installed project ID"
+            option :mapping, required: true, desc: "Installed mapping ID"
+            option :inbox_context, required: true, desc: "Installed inbox context ID"
+
+            def call(**options)
+              raise ArgumentError, "fixed inbox context options differ" unless options.keys.sort == %i[inbox_context mapping project]
+              consumer = Ace::Assign::Authority::PreparedTaskContext.new(context: @protected_assignment_context)
+              $stdout.write(consumer.inbox_selection(**options))
+              0
+            rescue ArgumentError, Ace::Runtime::Error, Ace::Assign::Error => error
+              raise Ace::Support::Cli::Error, error.message
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/assign/cli/commands/authority/launch.rb

@@ -7,10 +7,13 @@ module Ace
       module Commands
         module Authority
           class Launch < Ace::Support::Cli::Command
-            desc "Launch one mapped native worker through the protected gate"
+            desc "Launch one mapped worker and retain its original foreground control channel"
+            READY_FIELDS = %w[assignment_id attempt_id generation journal_commit mapping_id original_binding_digest type version].freeze
+            READY_LIMIT = 16_384
             option :mapping, required: true, desc: "Installed launch mapping ID"
             option :assignment, desc: "Managed assignment ID"
-            option :definition, desc: "Current managed assignment definition JSON file"
+            option :definition, desc: "Retained final prepared assignment definition JSON file"
+            option :prepared_bundle, desc: "Retained original prepared input Git bundle"
             option :step, desc: "Assignment subtree scope"
             option :base_head, desc: "Exact base commit SHA"
             option :mutation, desc: "Stable invocation ID for safe replay"
@@ -20,20 +23,69 @@ module Ace
               result = if options[:dry_run]
                 driver.preflight
               else
-                %i[assignment definition step base_head].each do |key|
+                %i[assignment definition prepared_bundle step base_head].each do |key|
                   raise ArgumentError, "Missing --#{key.to_s.tr('_', '-')}" unless options[key].is_a?(String) && !options[key].empty?
                 end
-                raise ArgumentError, "assignment definition is oversized" if File.size(options[:definition]) > 32_768
-                args = {assignment_id: options[:assignment], definition_bytes: File.read(options[:definition]),
+                definition = retained_input(options[:definition], 32_768).force_encoding(Encoding::UTF_8)
+                raise ArgumentError, "assignment definition is not UTF-8" unless definition.valid_encoding?
+                bundle = retained_input(options[:prepared_bundle], Ace::Assign::Authority::CandidateTransfer::MAX_BYTES)
+                args = {prepared_bundle: bundle, assignment_id: options[:assignment], definition_bytes: definition,
                   scope: options[:step], base_head: options[:base_head]}
                 args[:mutation_id] = options[:mutation] if options[:mutation]
                 driver.launch(**args)
               end
-              puts JSON.generate(result)
+              if !options[:dry_run] && result["phase"] == "issued"
+                retaining_control = true
+                announced = false
+                driver.serve_control!(state: result) do |ready|
+                  raise ArgumentError, "original launch readiness was already announced" if announced
+                  line = readiness_line(ready, result, options)
+                  $stdout.write(line)
+                  $stdout.flush
+                  announced = true
+                end
+                raise ArgumentError, "original control ended before authenticated readiness" unless announced
+              else
+                puts JSON.generate(result)
+              end
             rescue ArgumentError, SystemCallError, Ace::Runtime::Error, Ace::Assign::Error => error
               raise Ace::Support::Cli::Error, error.message
+            ensure
+              # Local foreground-loop cancellation is not a stopped/settled proof.
+              driver.request_control_cancel if retaining_control
             end
             private
+            def retained_input(path, limit)
+              File.open(path, File::RDONLY | File::NOFOLLOW | File::NONBLOCK) do |file|
+                before = file.stat
+                unless before.file? && before.size.between?(1, limit)
+                  raise ArgumentError, "retained launch input is not a bounded regular file"
+                end
+                bytes = (file.read(limit + 1) || "").b
+                after = file.stat
+                identity = ->(stat) { [stat.dev, stat.ino, stat.size, stat.mtime, stat.ctime] }
+                unless bytes.bytesize == before.size && bytes.bytesize <= limit && identity.call(before) == identity.call(after)
+                  raise ArgumentError, "retained launch input changed while reading"
+                end
+                bytes
+              end
+            end
+
+            def readiness_line(ready, result, options)
+              unless ready.is_a?(Hash) && ready.keys.all? { |key| key.is_a?(String) } && ready.keys.sort == READY_FIELDS &&
+                  ready["version"].is_a?(Integer) && ready["version"] == 1 && ready["type"] == "launch_ready" &&
+                  ready.values_at("mapping_id", "assignment_id", "attempt_id") ==
+                    [options.fetch(:mapping), options.fetch(:assignment), result.fetch("attempt_id")] &&
+                  ready["generation"].is_a?(Integer) && ready["generation"].positive? &&
+                  ready["journal_commit"].is_a?(String) && ready["journal_commit"].match?(/\A(?:[0-9a-f]{40}|[0-9a-f]{64})\z/) &&
+                  ready["original_binding_digest"].is_a?(String) && ready["original_binding_digest"].match?(/\A[0-9a-f]{64}\z/)
+                raise ArgumentError, "original launch readiness is malformed or mismatched"
+              end
+              line = JSON.generate(ready) + "\n"
+              raise ArgumentError, "original launch readiness is oversized" if line.bytesize > READY_LIMIT
+              line
+            end
+
             def build_driver(mapping)
               Ace::Assign::Authority::LaunchDriver.new(mapping_id: mapping)
             end

data/lib/ace/assign/cli/commands/authority/serve.rb

@@ -12,7 +12,8 @@ module Ace
             option :authority, required: true, desc: "Installed authority ID"
             def call(**options)
               deployment = Ace::Assign::Authority::Deployment.load
-              launch = Ace::Assign::Authority::LaunchLifecycle.new(deployment: deployment)
+              history = Ace::Assign::Authority::DeploymentHistory.load
+              launch = Ace::Assign::Authority::LaunchLifecycle.new(deployment: deployment, deployment_history: history)
               router = Ace::Assign::Authority::Router.new(launch: launch)
               server = Ace::Assign::Authority::Server.new(authority_id: options.fetch(:authority), deployment: deployment, lifecycle: router)
               signals = %w[INT TERM].to_h { |signal| [signal, Signal.trap(signal) { server.request_stop }] }

data/lib/ace/assign/cli/commands/authority/status.rb

@@ -13,7 +13,7 @@ module Ace
             option :attempt, required: true, desc: "Attempt ID"
             def call(**options)
               reply = Ace::Assign::Authority::Client.new(mapping_id: options.fetch(:mapping)).call("attempt_status",
-                {"assignment_id" => options.fetch(:assignment), "attempt_id" => options.fetch(:attempt)})
+                {"assignment_id" => options.fetch(:assignment), "attempt_id" => options.fetch(:attempt), "result_candidate_generation" => nil})
               puts JSON.generate(reply.data)
             rescue ArgumentError, Ace::Runtime::Error, Ace::Assign::Error => error
               raise Ace::Support::Cli::Error, error.message

data/lib/ace/assign/cli/commands/authority/task_context.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+require_relative "../../../authority/prepared_task_context"
+
+module Ace
+  module Assign
+    module CLI
+      module Commands
+        module Authority
+          class TaskContext < Ace::Support::Cli::Command
+            desc "Return the captured original task context through the fixed selected entry"
+            option :mapping, required: true, desc: "Installed original mapping ID"
+            option :assignment, required: true, desc: "Original assignment ID@SCOPE"
+            option :attempt, required: true, desc: "Original protected attempt ID"
+            option :task, required: true, desc: "Captured canonical task ID"
+
+            def call(**options)
+              unless options.keys.sort == %i[assignment attempt mapping task]
+                raise ArgumentError, "fixed task-context accepts only its four selectors"
+              end
+              consumer = Ace::Assign::Authority::PreparedTaskContext.new(context: @protected_assignment_context)
+              $stdout.write(consumer.call(**options))
+              0
+            rescue ArgumentError, Ace::Runtime::Error, Ace::Assign::Error => error
+              raise Ace::Support::Cli::Error, error.message
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/assign/cli/commands/authority/task_context_principal.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+require_relative "../../../authority/prepared_task_context"
+
+module Ace
+  module Assign
+    module CLI
+      module Commands
+        module Authority
+          class TaskContextPrincipal < Ace::Support::Cli::Command
+            desc "Classify this actual caller through the installed and retained protected owners"
+
+            def call(**options)
+              raise ArgumentError, "fixed task-context-principal accepts no options" unless options.empty?
+              consumer = Ace::Assign::Authority::PreparedTaskContext.new(context: @protected_assignment_context)
+              $stdout.write(consumer.principal)
+              0
+            rescue ArgumentError, Ace::Runtime::Error, Ace::Assign::Error => error
+              raise Ace::Support::Cli::Error, error.message
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/assign/cli/commands/authority/task_context_selection.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+require_relative "../../../authority/prepared_task_context"
+
+module Ace
+  module Assign
+    module CLI
+      module Commands
+        module Authority
+          class TaskContextSelection < Ace::Support::Cli::Command
+            desc "Return the authenticated original task-context entry without captured text"
+            option :mapping, required: true, desc: "Installed original mapping ID"
+            option :assignment, required: true, desc: "Original assignment ID@SCOPE"
+            option :attempt, required: true, desc: "Original protected attempt ID"
+
+            def call(**options)
+              unless options.keys.sort == %i[assignment attempt mapping]
+                raise ArgumentError, "fixed task-context-selection accepts only its three selectors"
+              end
+              consumer = Ace::Assign::Authority::PreparedTaskContext.new(context: @protected_assignment_context)
+              $stdout.write(consumer.selection(**options))
+              0
+            rescue ArgumentError, Ace::Runtime::Error, Ace::Assign::Error => error
+              raise Ace::Support::Cli::Error, error.message
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/assign/cli/commands/authority/worker.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+require_relative "../../../authority/prepared_worker"
+
+module Ace
+  module Assign
+    module CLI
+      module Commands
+        module Authority
+          class Worker < Ace::Support::Cli::Command
+            desc "Consume the original authenticated prepared subtree as its fixed worker"
+
+            def call(**options)
+              raise ArgumentError, "fixed worker accepts no options" unless options.empty?
+              Ace::Assign::Authority::PreparedWorker.new.run
+            rescue ArgumentError, Ace::Runtime::Error, Ace::Assign::Error => error
+              raise Ace::Support::Cli::Error, error.message
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+require_relative "protected_submission"
+
+module Ace
+  module Assign
+    module CLI
+      module Commands
+        class CampaignExportResult < Ace::Support::Cli::Command
+          include Ace::Support::Cli::Base
+          include ProtectedSubmission
+          desc "Download a verified accepted campaign result through its original authority"
+          option :mapping, desc: "Original installed parent mapping"
+          option :assignment, desc: "Original parent assignment"
+          option :attempt, desc: "Original parent attempt"
+          option :head, desc: "Exact parent candidate head"
+          option :candidate_generation, desc: "Exact parent candidate counter"
+          option :output, desc: "Result byte file (created once, exact retries allowed)"
+
+          def call(**options)
+            usage = "campaign-export-result with original parent selectors and --output FILE"
+            context = protected_context(options)
+            raise AttemptErrors::EvidenceUnavailable, "Campaign export requires installed authority" unless context
+            params = {"assignment_id" => require_option(options, :assignment, usage),
+              "attempt_id" => require_option(options, :attempt, usage), "head" => require_option(options, :head, usage),
+              "candidate_generation" => integer_option(options, :candidate_generation, usage, positive: true)}
+            raise Ace::Support::Cli::Error, "Campaign head must be an exact SHA-1" unless params["head"].match?(/\A[0-9a-f]{40}\z/)
+            context.verify_attempt_hints!(assignment_id: params.fetch("assignment_id"), attempt_id: params.fetch("attempt_id"))
+            path = require_option(options, :output, usage)
+            reply = context.client(options: options).call("campaign_export_result", params, download: true, purpose: :artifacts, timeout: 30)
+            bytes = reply.parts&.first
+            unless reply.parts&.size == 1 && bytes.is_a?(String) && bytes.bytesize <= 64 * 1024 &&
+                reply.data.values_at("head", "candidate_generation", "bytes", "sha256") ==
+                  [params.fetch("head"), params.fetch("candidate_generation"), bytes.bytesize, Digest::SHA256.hexdigest(bytes)]
+              raise AttemptErrors::EvidenceUnavailable, "Campaign result download differs"
+            end
+            begin
+              File.open(path, File::WRONLY | File::CREAT | File::EXCL | File::NOFOLLOW, 0o600) do |file|
+                file.write(bytes)
+                file.flush
+                file.fsync
+              end
+            rescue Errno::EEXIST
+              raise Ace::Support::Cli::Error, "Existing campaign result file differs" unless input_bytes(path, limit: 64 * 1024) == bytes
+            end
+            emit_json(reply.data.except("transfer").merge("path" => path))
+          rescue SecurityError, Ace::Runtime::RuntimeUnavailableError
+            protected_transport_unavailable!
+          rescue SystemCallError, IOError
+            raise Ace::Support::Cli::Error, "Campaign result file or transport is unavailable"
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -8,6 +8,7 @@ module Ace
         # Create a new workflow assignment from YAML or preset-backed task refs
         class Create < Ace::Support::Cli::Command
           include Ace::Support::Cli::Base
+          include AssignmentTarget
 
           desc "Create a new workflow assignment"
 
@@ -20,6 +21,7 @@ module Ace
           option :debug, aliases: ["-d"], type: :boolean, default: false, desc: "Show debug output"
 
           def call(yaml: nil, task: nil, preset: nil, **options)
+            refuse_protected_graph_mutation!(options)
             validate_modes!(yaml, task, preset)
             raise Ace::Support::Cli::Error, "--delivery-parameters requires --task" if yaml && options[:delivery_parameters]
 

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

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

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

@@ -12,6 +12,8 @@ module Ace
           desc "Mark current step as failed"
 
           option :message, aliases: ["-m"], required: true, desc: "Error message"
+          option :mapping, desc: "Installed protected launch mapping ID"
+          option :attempt, desc: "Original protected attempt ID"
           option :assignment, desc: "Target specific assignment ID"
           option :quiet, aliases: ["-q"], type: :boolean, default: false, desc: "Suppress non-essential output"
           option :debug, aliases: ["-d"], type: :boolean, default: false, desc: "Show debug output"
@@ -28,6 +30,10 @@ module Ace
               puts "Step #{failed.number} (#{failed.name}) marked as failed"
               puts "Updated: #{File.basename(failed.file_path)}"
               puts "Error: #{message}"
+              if target.prepared_input
+                puts "Further work requires a reviewed new prepared version and attempt."
+                return
+              end
               puts
               puts "Options:"
               puts "- ace-assign add \"fix-step\" to add a fix step"