ace-assign 0.64.0 → 0.66.1

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

@@ -4,17 +4,22 @@ require "json"
 require "securerandom"
 require "ace/herdr/molecules/protected_native_control"
 require_relative "client"
+require_relative "candidate_transfer"
+require_relative "launch_control_channel"
 
 module Ace
   module Assign
     module Authority
       class LaunchDriver
+        LAUNCH_DEADLINE = 30
         def initialize(mapping_id:, deployment: Deployment.load,
-          kernel: Ace::Runtime::Molecules::ProtectedLinux.new, client: nil, native: nil)
+          kernel: Ace::Runtime::Molecules::ProtectedLinux.new, client: nil, native: nil,
+          clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) })
           @mapping_id, @deployment, @kernel = mapping_id, deployment, kernel
           @map = deployment.mapping(mapping_id)
           @client = client || Client.new(mapping_id: mapping_id, deployment: deployment, kernel: kernel)
           @native = native
+          @clock = clock
         end
 
         def preflight
@@ -22,40 +27,62 @@ module Ace
           @client.call("launch_preflight", {}).data
         end
 
-        def launch(assignment_id:, definition_bytes:, scope:, base_head:, mutation_id: SecureRandom.hex(16))
-          preflight
-          registration = @client.call("registration_status", {"assignment_id" => assignment_id}).data
+        def launch(assignment_id:, definition_bytes:, prepared_bundle:, scope:, base_head:, mutation_id: SecureRandom.hex(16))
+          state = nil
+          deadline = @clock.call + LAUNCH_DEADLINE
+          @deployment.verify!(@mapping_id, kernel: @kernel)
+          launch_call(deadline, "launch_preflight", {})
+          registration = launch_call(deadline, "registration_status", {"assignment_id" => assignment_id}).data
           digest = Digest::SHA256.hexdigest(definition_bytes)
+          definition = JSON.parse(definition_bytes)
+          prepared = definition.fetch("prepared_work")
+          unless definition["session_id"] == assignment_id && prepared["scope"] == scope &&
+              prepared_bundle.is_a?(String) && prepared_bundle.bytesize.between?(1, CandidateTransfer::MAX_BYTES)
+            raise ArgumentError, "prepared launch selection or bundle is invalid"
+          end
+          bundle_sha = Digest::SHA256.hexdigest(prepared_bundle)
           registered = if registration["definition_digest"] == digest
+            unless registration.values_at("prepared_bundle_bytes", "prepared_bundle_sha256") == [prepared_bundle.bytesize, bundle_sha]
+              raise AttemptErrors::Conflict, "original registration prepared bundle differs"
+            end
             registration
           else
-            @client.call("register_assignment", {"assignment_id" => assignment_id,
-              "definition_bytes" => definition_bytes, "definition_digest" => digest,
-              "expected_generation" => registration.fetch("generation", 0)}, mutation_id: "#{mutation_id}-register").data
+            launch_call(deadline, "register_assignment", {"assignment_id" => assignment_id,
+              "definition_digest" => digest, "prepared_head" => prepared.fetch("prepared_head"), "prepared_tree" => prepared.fetch("prepared_tree"),
+              "manifest_sha256" => prepared.fetch("manifest_sha256"), "expected_generation" => registration.fetch("generation", 0)},
+              mutation_id: "#{mutation_id}-register", upload_parts: [prepared_bundle], purpose: :candidate).data
           end
-          reserved = @client.call("reserve_attempt", {"assignment_id" => assignment_id, "scope" => scope,
+          reserved = launch_call(deadline, "reserve_attempt", {"assignment_id" => assignment_id, "scope" => scope,
             "worker_uid" => @map.fetch("worker_uid"), "runtime" => "herdr", "base_head" => base_head,
             "launcher_process_binding" => @kernel.capture(Process.pid),
-            "expected_generation" => registered.fetch("definition_generation")}, mutation_id: "#{mutation_id}-reserve")
+            "expected_generation" => registered.fetch("definition_generation")}, mutation_id: "#{mutation_id}-reserve") { |reply| state = reply.data }
           # Only this actual CAS winner may create. A cached canonical reply is
           # evidence of ownership, never evidence that native creation is fresh.
           return reserved.data.merge("required_action" => "inspect_retained_reservation_no_creation_permission") if reserved.replayed
           state = reserved.data
-          inspected = @client.call("inspect_launch", state.slice("assignment_id", "attempt_id")).data
+          inspected = launch_call(deadline, "inspect_launch", state.slice("assignment_id", "attempt_id")).data
           state = inspected
           origin = inspected.fetch("native_binding")
-          return close_before_native_release(state, mutation_id) unless origin
+          return close_before_native_release(state, mutation_id, deadline: deadline) unless origin
           fixed = JSON.parse(JSON.generate(@map))
           fixed.fetch("native").merge!(origin.slice("server_identity", "socket_identity", "workspace_id"))
           @native ||= Ace::Herdr::Molecules::ProtectedNativeControl.new(mapping: fixed, kernel: @kernel)
+          launch_remaining!(deadline)
           binding = @native.create(mapping_id: @mapping_id, ticket: state.fetch("launch_ticket"))
           child_handle = @kernel.pin(binding.fetch("process_identity"))
-          recorded = @client.call("record_launch", lifecycle_params(state, binding), mutation_id: "#{mutation_id}-record").data
-          bound = @client.call("bind_process", lifecycle_params(recorded, binding), mutation_id: "#{mutation_id}-bind").data
+          guarded = @native.guarded_binding!(binding)
+          unless guarded.reject { |key, _| key == "guarded_origin" } == binding
+            raise AttemptErrors::EvidenceUnavailable, "original native capture changed launch binding"
+          end
+          launch_remaining!(deadline)
+          recorded = launch_call(deadline, "record_launch", lifecycle_params(state, binding).merge("guarded_origin" => guarded.fetch("guarded_origin")), mutation_id: "#{mutation_id}-record").data
+          bound = launch_call(deadline, "bind_process", lifecycle_params(recorded, binding), mutation_id: "#{mutation_id}-bind").data
           # Exact original child is reobserved after canonical bind, before release.
           @native.observe(binding.fetch("native_origin").merge("process_binding" => binding))
           @kernel.live!(binding.fetch("process_identity"))
-          issued = @client.call("release_launch", lifecycle_params(bound, binding), mutation_id: "#{mutation_id}-release").data
+          issued = launch_call(deadline, "release_launch", lifecycle_params(bound, binding), mutation_id: "#{mutation_id}-release").data
+          @issued_state = issued
+          @steering_binding = binding.merge("guarded_origin" => recorded.fetch("guarded_origin"))
           issued
         rescue StandardError
           # Response loss or partial creation never retries native creation.
@@ -68,6 +95,47 @@ module Ace
           child_handle&.close
         end
 
+        # The same original launcher remains foreground. A transient channel
+        # failure reconnects this process and never repeats native issuance.
+        def serve_control!(state:)
+          unless state.equal?(@issued_state) && state["phase"] == "issued" && @steering_binding
+            raise AttemptErrors::EvidenceUnavailable, "Only the fresh original launcher may retain control"
+          end
+          @seen_prompt_intents ||= {}
+          @prompt_issuance_refs ||= {}
+          @reported_prompt_completions ||= {}
+          announced = false
+          until @control_cancelled
+            begin
+              break if announced && authenticated_control_release?(state)
+              report_retained_prompt_completions!(state)
+              report_retained_input_inhibition!(state)
+              @client.with_launch_control(state: state) do |socket, codec, ready|
+                if @control_original_binding_digest && ready.fetch("original_binding_digest") != @control_original_binding_digest
+                  raise AttemptErrors::EvidenceUnavailable, "Original launcher control binding changed"
+                end
+                @control_original_binding_digest ||= ready.fetch("original_binding_digest")
+                unless announced
+                  yield({"version" => 1, "type" => "launch_ready", "mapping_id" => @mapping_id,
+                    "assignment_id" => state.fetch("assignment_id"), "attempt_id" => state.fetch("attempt_id"),
+                    "generation" => ready.fetch("generation"), "journal_commit" => ready.fetch("journal_commit"),
+                    "original_binding_digest" => ready.fetch("original_binding_digest")})
+                  announced = true
+                end
+                original_prompt_loop(socket, codec, state, ready)
+              end
+            rescue Ace::Runtime::RuntimeUnavailableError, AttemptErrors::EvidenceUnavailable, AttemptErrors::UnauthorizedIdentity, IOError, SystemCallError
+              # Endpoint refusal also cannot authenticate terminal release.
+              # EOF does not prove the actor drained or justify a second send.
+              sleep(0.25) unless @control_cancelled
+            end
+          end
+        end
+
+        def request_control_cancel
+          @control_cancelled = true
+        end
+
         def terminate(state:, binding:, evidence:, mutation_id: SecureRandom.hex(16))
           observed = state["termination_observation"]
           unless observed.is_a?(Hash) && observed["status"] == "exited" && observed["process_identity"] == binding["process_identity"]
@@ -83,23 +151,234 @@ module Ace
         end
 
         private
-        def close_before_native_release(state, mutation_id)
+
+        # Client preparation precedes its transport deadline. Recheck the one
+        # original budget after each reply and before subsequent native effects.
+        def launch_call(deadline, operation, params, **options)
+          remaining = launch_remaining!(deadline)
+          result = @client.call(operation, params, **options, timeout: remaining)
+          yield result if block_given?
+          launch_remaining!(deadline)
+          result
+        end
+
+        def launch_remaining!(deadline)
+          remaining = deadline - @clock.call
+          unless remaining.positive?
+            raise Ace::Runtime::RuntimeUnavailableError, "original launch deadline expired"
+          end
+          remaining
+        end
+
+        # Status is queried before reopening a private stream: synchronous
+        # canonical reads cannot consume the original channel's heartbeat wait.
+        def authenticated_control_release?(state)
+          params = state.slice("assignment_id", "attempt_id")
+          composition = @deployment.authority(@map.fetch("authority_id")).fetch("composition")
+          params["result_candidate_generation"] = nil if composition == "services"
+          data = @client.call("attempt_status", params, mutation_id: nil, timeout: 30).data
+          unless data.is_a?(Hash) && data.values_at("mapping_id", "assignment_id", "attempt_id") ==
+              [@mapping_id, state.fetch("assignment_id"), state.fetch("attempt_id")] &&
+              data["original_binding_digest"] == @control_original_binding_digest &&
+              data["process_binding"] == @steering_binding.reject { |key, _| key == "guarded_origin" } &&
+              data["launcher_identity"] == state.fetch("launcher_identity") &&
+              data["state"].is_a?(String) && %w[reserved running uncertain succeeded failed stopped].include?(data["state"]) &&
+              data["generation"].is_a?(Integer) && data["generation"] >= 0 &&
+              data["journal_commit"].is_a?(String) && data["journal_commit"].match?(/\A(?:[0-9a-f]{40}|[0-9a-f]{64})\z/)
+            raise AttemptErrors::EvidenceUnavailable, "Original launcher canonical status differs"
+          end
+          terminal = data.fetch("terminal_event_id")
+          release = data.fetch("reservation_release_event_id")
+          unless [terminal, release].all? { |value| value.nil? || value.is_a?(String) && value.match?(/\A[0-9a-f]{64}\z/) } &&
+              (release.nil? || !terminal.nil? && %w[succeeded failed stopped].include?(data.fetch("state")))
+            raise AttemptErrors::EvidenceUnavailable, "Original launcher terminal release metadata differs"
+          end
+          %w[succeeded failed stopped].include?(data.fetch("state")) && !terminal.nil? && !release.nil?
+        rescue KeyError, TypeError, NoMethodError
+          raise AttemptErrors::EvidenceUnavailable, "Original launcher canonical status is malformed"
+        end
+
+        def report_retained_prompt_completions!(state)
+          @seen_prompt_intents.each do |id, evidence|
+            next if @reported_prompt_completions[id]
+            next unless %w[submitted not_issued].include?(evidence["outcome"])
+            reference = @prompt_issuance_refs.fetch(id)
+            accepted = @client.call("launch_prompt_completion", state.slice("assignment_id", "attempt_id").merge(reference).merge(
+              "guarded_evidence" => evidence), mutation_id: nil, timeout: 30).data
+            unless accepted.keys.sort == %w[intent_event_id journal_commit outcome] && accepted["intent_event_id"] == id && accepted["outcome"] == evidence.fetch("outcome") &&
+                accepted["journal_commit"].is_a?(String) && accepted["journal_commit"].match?(/\A(?:[0-9a-f]{40}|[0-9a-f]{64})\z/)
+              raise AttemptErrors::EvidenceUnavailable, "Retained native completion acknowledgement differs"
+            end
+            @reported_prompt_completions[id] = accepted.fetch("journal_commit")
+          end
+        end
+        def original_prompt_loop(socket, codec, state, ready)
+          wire = Ace::Runtime::Molecules::ProtectedSocket
+          until @control_cancelled
+            deadline = wire.deadline(30)
+            frame = wire.read(socket, deadline: deadline, limit: 16_384)
+            if frame.is_a?(Hash) && frame.keys.sort == %w[nonce type version] && frame["type"] == "launch_control_idle" &&
+                frame["version"].is_a?(Integer) && frame["version"] == 1 && frame["nonce"].is_a?(String) && frame["nonce"].match?(/\A[0-9a-f]{32}\z/)
+              wire.write(socket, frame.merge("type" => "launch_control_idle_ack"), deadline: deadline, limit: 16_384)
+              next
+            end
+            if frame.is_a?(Hash) && frame["type"] == "launch_input_inhibit"
+              original_input_inhibit!(socket, state, ready, frame, deadline)
+              next
+            end
+            raise AttemptErrors::EvidenceUnavailable, "Original launcher input is inhibited" if @input_inhibited
+            if frame.is_a?(Hash) && frame["type"] == "launch_review_delegate"
+              original_review_delegate!(socket, state, ready, frame, deadline)
+              next
+            end
+            LaunchControlChannel.validate_prompt!(frame)
+            unless frame["attempt_id"] == state.fetch("attempt_id") && frame["original_binding_digest"] == ready.fetch("original_binding_digest")
+              raise AttemptErrors::EvidenceUnavailable, "Private prompt does not join original launcher"
+            end
+            evidence = codec.receive_launch_prompt(socket, descriptor: frame.fetch("text_descriptor"),
+              transfer_id: frame.fetch("transfer_id"), deadline: deadline) do |input|
+              expected = @client.call("launch_prompt_intent", state.slice("assignment_id", "attempt_id").merge(
+                frame.slice("mutation_id", "intent_event_id", "journal_commit")), mutation_id: nil).data
+              binding = expected.fetch("binding")
+              Ace::Herdr::Molecules::GuardedNativeOrigin.verify!(expected.fetch("origin"),
+                terminal_id: @steering_binding.fetch("terminal_id"), child: @steering_binding.fetch("process_identity"))
+              unless expected["intent_event_id"] == frame["intent_event_id"] && expected["origin"] == @steering_binding.fetch("guarded_origin") &&
+                  binding.is_a?(Hash) && binding["text_bytes"].is_a?(Integer) &&
+                  binding.values_at("mapping_id", "assignment_id", "attempt_id", "mutation_id") ==
+                    [@mapping_id, state.fetch("assignment_id"), state.fetch("attempt_id"), frame.fetch("mutation_id")] &&
+                  binding["original_binding_digest"] == frame["original_binding_digest"] && binding["text_bytes"] == input.bytes.bytesize &&
+                  binding["text_sha256"] == Digest::SHA256.hexdigest(input.bytes)
+                raise AttemptErrors::EvidenceUnavailable, "Private prompt immutable intent differs"
+              end
+              id = frame.fetch("intent_event_id")
+              @prompt_issuance_refs[id] = frame.slice("mutation_id", "intent_event_id", "original_binding_digest")
+              if @seen_prompt_intents.key?(id)
+                @seen_prompt_intents.fetch(id)
+              else
+                @seen_prompt_intents[id] = {"outcome" => "uncertain", "origin" => @steering_binding.fetch("guarded_origin")}
+                @native.prompt_preflight!(@steering_binding)
+                @seen_prompt_intents[id] = @native.prompt(binding: @steering_binding, text: input.bytes)
+              end
+            end
+            result = frame.slice("mutation_id", "intent_event_id", "original_binding_digest").merge("version" => 1,
+              "type" => "prompt_dispatch_outcome", "guarded_evidence" => evidence)
+            wire.write(socket, result, deadline: deadline, limit: 16_384)
+            recorded = wire.read(socket, deadline: deadline, limit: 16_384)
+            LaunchControlChannel.validate_recorded!(recorded, frame, evidence)
+            @reported_prompt_completions[frame.fetch("intent_event_id")] = recorded.fetch("journal_commit") if %w[submitted not_issued].include?(evidence.fetch("outcome"))
+          end
+        end
+
+        def original_review_delegate!(socket, state, ready, frame, deadline)
+          LaunchControlChannel.validate_review!(frame)
+          unless frame["attempt_id"] == state.fetch("attempt_id") &&
+              frame["original_binding_digest"] == ready.fetch("original_binding_digest")
+            raise AttemptErrors::EvidenceUnavailable, "Review request belongs to another original launcher"
+          end
+          selectors = state.slice("assignment_id", "attempt_id").merge(
+            frame.slice("mutation_id", "request_event_id", "journal_commit", "original_binding_digest"))
+          intent = @client.call("launch_review_intent", selectors, mutation_id: nil,
+            timeout: review_exchange_remaining!(deadline)).data
+          params = validate_review_intent!(intent, state, frame)
+          accepted = @client.call("assign_review", params, mutation_id: "review-delegate.#{frame.fetch('request_event_id')}",
+            timeout: review_exchange_remaining!(deadline)).data
+          unless accepted.is_a?(Hash) &&
+              %w[candidate_generation reviewer_uid].all? { |key| accepted[key].is_a?(Integer) } &&
+              %w[head candidate_generation reviewer_uid reviewer_process_binding].all? { |key| accepted[key] == params.fetch(key) } &&
+              accepted["generation"].is_a?(Integer) && accepted["generation"] == params.fetch("expected_generation") + 1 &&
+              accepted["review_id"].is_a?(String) && accepted["review_id"].match?(/\A[0-9a-f]{32}\z/)
+            raise AttemptErrors::EvidenceUnavailable, "Original review assignment reply differs"
+          end
+          identity = accepted.fetch("reviewer_process_binding")
+          boot = params.fetch("reviewer_process_binding").fetch("started_at").split(":", -1)[1]
+          Molecules::ExecutionScopeLineage.validate_process_identity!(identity, boot_id: boot)
+          result = frame.slice("mutation_id", "request_event_id", "original_binding_digest").merge(
+            accepted.slice("assignment_event_id", "journal_commit"), "version" => 1, "type" => "launch_review_assigned")
+          LaunchControlChannel.validate_review_assigned!(result, frame)
+          Ace::Runtime::Molecules::ProtectedSocket.write(socket, result, deadline: deadline, limit: 16_384)
+        end
+
+        def validate_review_intent!(intent, state, frame)
+          fields = %w[assignment_params original_binding_digest request_event_id]
+          params = intent.is_a?(Hash) && intent["assignment_params"]
+          unless intent.is_a?(Hash) && intent.keys.sort == fields &&
+              %w[request_event_id original_binding_digest].all? { |key| intent[key] == frame.fetch(key) } &&
+              params.is_a?(Hash) && params.keys.sort == %w[assignment_id attempt_id candidate_generation expected_generation head mapping_id reviewer_process_binding reviewer_uid] &&
+              params.values_at("mapping_id", "assignment_id", "attempt_id") == [@mapping_id, state.fetch("assignment_id"), state.fetch("attempt_id")] &&
+              params["head"].is_a?(String) && params["head"].match?(/\A(?:[0-9a-f]{40}|[0-9a-f]{64})\z/) &&
+              %w[candidate_generation expected_generation reviewer_uid].all? { |key| params[key].is_a?(Integer) && params[key].positive? } &&
+              params["reviewer_uid"] != @map.fetch("worker_uid") &&
+              params["reviewer_process_binding"].is_a?(Hash) && params["reviewer_process_binding"]["uid"] == params["reviewer_uid"]
+            raise AttemptErrors::EvidenceUnavailable, "Canonical review intent differs"
+          end
+          identity = params.fetch("reviewer_process_binding")
+          boot = identity["started_at"].is_a?(String) && identity["started_at"].split(":", -1)[1]
+          Molecules::ExecutionScopeLineage.validate_process_identity!(identity, boot_id: boot)
+          params
+        end
+
+        def review_exchange_remaining!(deadline)
+          remaining = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          raise AttemptErrors::EvidenceUnavailable, "Original review exchange deadline expired" unless remaining.positive?
+          [remaining, 30].min
+        end
+
+        def original_input_inhibit!(socket, state, ready, frame, deadline)
+          LaunchControlChannel.validate_inhibit!(frame)
+          unless frame["attempt_id"] == state.fetch("attempt_id") && frame["original_binding_digest"] == ready.fetch("original_binding_digest")
+            raise AttemptErrors::EvidenceUnavailable, "Input inhibition does not join original launcher"
+          end
+          selectors = frame.slice("original_binding_digest", "seal_event_id", "journal_commit")
+          selected = @client.call("launch_input_inhibit_selection", state.slice("assignment_id", "attempt_id").merge(selectors), mutation_id: nil).data
+          unless selected == frame.slice("attempt_id", "original_binding_digest", "seal_event_id", "journal_commit")
+            raise AttemptErrors::EvidenceUnavailable, "Input inhibition original seal selection differs"
+          end
+          @input_inhibited = true
+          @input_inhibition_refs = frame.slice("original_binding_digest", "seal_event_id")
+          evidence = @retained_input_inhibition || @native.inhibit_input(binding: @steering_binding)
+          if evidence.is_a?(Hash) && evidence["outcome"] == "inhibited"
+            @retained_input_inhibition = evidence
+          end
+          wire = Ace::Runtime::Molecules::ProtectedSocket
+          result = @input_inhibition_refs.merge("version" => 1, "type" => "launch_input_inhibit_outcome", "guarded_evidence" => evidence)
+          wire.write(socket, result, deadline: deadline, limit: 16_384)
+          recorded = wire.read(socket, deadline: deadline, limit: 16_384)
+          LaunchControlChannel.validate_inhibit_recorded!(recorded, frame)
+          unless @retained_input_inhibition
+            raise AttemptErrors::EvidenceUnavailable, "Unconfirmed drain cannot receive positive canonical acknowledgement"
+          end
+          @reported_input_inhibition = recorded.fetch("journal_commit")
+        end
+
+        def report_retained_input_inhibition!(state)
+          return unless @retained_input_inhibition && !@reported_input_inhibition
+          accepted = @client.call("launch_input_inhibit_completion", state.slice("assignment_id", "attempt_id").merge(@input_inhibition_refs).merge(
+            "guarded_evidence" => @retained_input_inhibition), mutation_id: nil, timeout: 30).data
+          frame = @input_inhibition_refs.merge("version" => 1, "type" => "launch_input_inhibit")
+          unless accepted.is_a?(Hash) && accepted.keys.sort == %w[journal_commit original_binding_digest seal_event_id]
+            raise AttemptErrors::EvidenceUnavailable, "Retained input inhibition acknowledgement differs"
+          end
+          LaunchControlChannel.validate_inhibit_recorded!(accepted.merge("version" => 1, "type" => "launch_input_inhibit_recorded"), frame)
+          @reported_input_inhibition = accepted.fetch("journal_commit")
+        end
+
+        def close_before_native_release(state, mutation_id, deadline:)
           unless state["scope_binding_event_id"]
             return state.merge("required_action" => "inspect_exact_scope")
           end
           selectors = state.slice("assignment_id", "attempt_id")
-          sealed = @client.call("close_execution_scope", selectors.merge("expected_generation" => state.fetch("generation")),
+          sealed = launch_call(deadline, "close_execution_scope", selectors.merge("expected_generation" => state.fetch("generation")),
             mutation_id: "#{mutation_id}-scope-seal").data
-          closed = @client.call("close_execution_scope", selectors.merge("expected_generation" => sealed.fetch("generation")),
+          closed = launch_call(deadline, "close_execution_scope", selectors.merge("expected_generation" => sealed.fetch("generation")),
             mutation_id: "#{mutation_id}-scope-proof").data
           unless closed["state"] == "closed_no_writers"
             return state.merge("required_action" => "inspect_exact_scope")
           end
-          inspected = @client.call("inspect_launch", selectors).data
+          inspected = launch_call(deadline, "inspect_launch", selectors).data
           failure = inspected.fetch("scope_failure_evidence")
           raise AttemptErrors::EvidenceUnavailable, "canonical scope failure selectors unavailable" unless failure
           bytes = JSON.generate(failure)
-          @client.call("abort_launch", selectors.merge("launch_ticket" => state.fetch("launch_ticket"),
+          launch_call(deadline, "abort_launch", selectors.merge("launch_ticket" => state.fetch("launch_ticket"),
             "expected_generation" => inspected.fetch("generation"), "failure_evidence" => bytes,
             "failure_digest" => Digest::SHA256.hexdigest(bytes)), mutation_id: "#{mutation_id}-scope-abort").data
         end

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

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Ace
+  module Assign
+    module Authority
+      class LaunchLifecycle
+        def launch_input_inhibit_selection!(request:, peer:, role:)
+          params = request.fetch("params")
+          strict!(params, %w[mapping_id assignment_id attempt_id original_binding_digest seal_event_id journal_commit])
+          raise ArgumentError, "Input inhibition selection requires null mutation ID" unless request.fetch("mutation_id").nil?
+          map = steering_principal!(params, peer, role)
+          raise AttemptErrors::UnauthorizedIdentity, "Input inhibition selection requires original launcher" unless role == :launcher
+          LaunchControlChannel.validate_inhibit!(params.slice("attempt_id", "original_binding_digest", "seal_event_id", "journal_commit").merge(
+            "version" => 1, "type" => "launch_input_inhibit"))
+          journal = journal_for(map)
+          commit = params.fetch("journal_commit")
+          journal.verify_canonical_prefix!(commit: commit)
+          events = journal.read_events(params.fetch("assignment_id"), commit: commit).select { |event| event["attempt_id"] == params.fetch("attempt_id") }
+          authenticate_input_inhibition!(events, params, map, peer: peer)
+          {data: params.slice("attempt_id", "original_binding_digest", "seal_event_id", "journal_commit"), replayed: false}
+        end
+
+        def launch_input_inhibit_completion!(request:, peer:, role:)
+          params = request.fetch("params")
+          strict!(params, %w[mapping_id assignment_id attempt_id original_binding_digest seal_event_id guarded_evidence])
+          raise ArgumentError, "Input inhibition completion requires null mutation ID" unless request.fetch("mutation_id").nil?
+          map = steering_principal!(params, peer, role)
+          raise AttemptErrors::UnauthorizedIdentity, "Input inhibition completion requires original launcher" unless role == :launcher
+          {data: record_original_input_inhibition!(params, map, params.fetch("guarded_evidence"), peer: peer), replayed: false}
+        end
+
+        private
+
+        def request_original_input_inhibition!(params, map, journal)
+          selected = with_containment_exclusion(params, map, journal) do
+            @mutex.synchronize do
+              commit = journal.ref_value
+              events = journal.read_events(params.fetch("assignment_id"), commit: commit).select { |event| event["attempt_id"] == params.fetch("attempt_id") }
+              next true if accepted_input_inhibition?(events, journal, commit)
+              state = origin(events, **params.slice("assignment_id", "attempt_id", "mapping_id").transform_keys(&:to_sym))
+              # Before native release there is no admitted outside-unit input
+              # owner. Its existing native issuer/guarded abort gates remain.
+              next true unless issued_input_actor?(events)
+              original = original_prompt_record!(events, state, params: params)
+              lineage = Molecules::ExecutionScopeLineage.new(events: events, project_id: map.fetch("project_id"),
+                assignment_id: params.fetch("assignment_id"), attempt_id: params.fetch("attempt_id"), mapping_id: params.fetch("mapping_id"))
+              raise AttemptErrors::EvidenceUnavailable, "Original scope is not sealed" unless lineage.seal_event
+              channel = @control_channels[steering_key(params, map)]
+              next false unless channel && !channel.closed?
+              frame = {"version" => 1, "type" => "launch_input_inhibit", "attempt_id" => params.fetch("attempt_id"),
+                "original_binding_digest" => original.fetch("binding_digest"), "seal_event_id" => lineage.seal_event.fetch("digest"), "journal_commit" => commit}
+              [channel, frame]
+            end
+          end
+          return selected if selected == true || selected == false
+          channel, frame = selected
+          channel.inhibit_input(frame: frame, deadline: wire.deadline(30))
+          true
+        rescue AttemptErrors::EvidenceUnavailable, Ace::Runtime::RuntimeUnavailableError, IOError, SystemCallError
+          false
+        end
+
+        def record_original_input_inhibition!(params, map, evidence, peer: nil)
+          journal = journal_for(map)
+          with_containment_exclusion(params, map, journal) do
+            @mutex.synchronize do
+              commit = journal.ref_value
+              current = journal.read_events(params.fetch("assignment_id"), commit: commit).select { |event| event["attempt_id"] == params.fetch("attempt_id") }
+              @kernel.live!(peer) if peer
+              original = authenticate_input_inhibition!(current, params, map, peer: peer)
+              journal.verify_input_drained_evidence!(evidence, original.fetch("origin"))
+              selection = params.slice("mapping_id", "assignment_id", "attempt_id", "original_binding_digest", "seal_event_id").merge("project_id" => map.fetch("project_id"))
+              journal.observe_input_inhibition(selection: selection, evidence: evidence) do |events, _old, _generation|
+                @kernel.live!(peer) if peer
+                authenticate_input_inhibition!(events, params, map, peer: peer)
+              end.fetch(:data).slice("original_binding_digest", "seal_event_id", "journal_commit")
+            end
+          end
+        end
+
+        def accepted_input_inhibition?(events, journal, commit)
+          proofs = events.select { |event| event["type"] == "input_inhibited" }
+          return false if proofs.empty?
+          raise AttemptErrors::EvidenceUnavailable, "Original input inhibition proof is ambiguous" unless proofs.length == 1
+          proof = proofs.first
+          payload = proof.fetch("payload")
+          unless payload.is_a?(Hash) && payload.keys.sort == (Molecules::JournalInputInhibition::INPUT_INHIBITION_FIELDS + ["guarded_evidence"]).sort
+            raise AttemptErrors::EvidenceUnavailable, "Original input inhibition proof fields are malformed"
+          end
+          id = "input-inhibit.#{payload.fetch('seal_event_id')}"
+          digest = Digest::SHA256.hexdigest(JSON.generate(journal.send(:canonical_prompt_value, payload)))
+          journal.send(:verify_input_inhibition!, payload, mutation_id: id, digest: digest,
+            assignment_id: payload.fetch("assignment_id"), attempt_id: payload.fetch("attempt_id"), commit: commit)
+          accepted = events.find { |event| event["type"] == "authority_mutation" && event["previous_digest"] == proof.fetch("digest") &&
+            event.dig("payload", "operation") == "input_inhibition_observation" && event.dig("payload", "mutation_id") == id }
+          expected = payload.slice("original_binding_digest", "seal_event_id")
+          data = accepted&.dig("payload", "data")
+          unless accepted && accepted.dig("payload", "parameters_digest") == digest &&
+              data.is_a?(Hash) && data.reject { |key, _| key == "generation" } == expected
+            raise AttemptErrors::EvidenceUnavailable, "Original input inhibition acceptance differs"
+          end
+          true
+        rescue KeyError, TypeError, ArgumentError
+          raise AttemptErrors::EvidenceUnavailable, "Original input inhibition proof is malformed"
+        end
+
+        def authenticate_input_inhibition!(events, params, map, peer: nil)
+          state = origin(events, **params.slice("assignment_id", "attempt_id", "mapping_id").transform_keys(&:to_sym))
+          if peer && !@kernel.same?(state.fetch("launcher_identity"), peer)
+            raise AttemptErrors::UnauthorizedIdentity, "Input inhibition belongs to another launcher incarnation"
+          end
+          original = original_prompt_record!(events, state, params: params)
+          lineage = Molecules::ExecutionScopeLineage.new(events: events, project_id: map.fetch("project_id"),
+            assignment_id: params.fetch("assignment_id"), attempt_id: params.fetch("attempt_id"), mapping_id: params.fetch("mapping_id"))
+          seal = lineage.seal_event
+          acceptance = seal && events.find { |event| event["type"] == "authority_mutation" && event["previous_digest"] == seal.fetch("digest") &&
+            %w[close_execution_scope stop_attempt].include?(event.dig("payload", "operation")) }
+          unless original.fetch("binding_digest") == params.fetch("original_binding_digest") && seal && acceptance &&
+              seal.fetch("digest") == params.fetch("seal_event_id")
+            raise AttemptErrors::EvidenceUnavailable, "Input inhibition does not join accepted original seal"
+          end
+          if events.any? { |event| event["type"] == "authority_mutation" && event.dig("payload", "operation") == "scope_reservation_release" }
+            raise AttemptErrors::EvidenceUnavailable, "Released scope cannot request original input inhibition"
+          end
+          original
+        rescue KeyError, TypeError, ArgumentError
+          raise AttemptErrors::EvidenceUnavailable, "Original input inhibition lineage is malformed"
+        end
+      end
+    end
+  end
+end