ace-assign 0.64.0 → 0.66.0

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

@@ -5,9 +5,15 @@ require "securerandom"
 require "time"
 require "fileutils"
 require "open3"
+require "ace/herdr/molecules/guarded_native_origin"
+require_relative "launch_control_channel"
 require_relative "deployment"
+require_relative "deployment_history"
 require_relative "../molecules/execution_scope_lineage"
+require_relative "../molecules/original_launch_binding"
+require_relative "../molecules/canonical_attempt_state"
 require_relative "execution_scope_observation"
+require_relative "prepared_work"
 
 module Ace
   module Assign
@@ -16,24 +22,34 @@ module Ace
       # Process handles/streams are observations, never a replacement ledger.
       class LaunchLifecycle
         MUTATIONS = {
-          "register_assignment" => %w[mapping_id assignment_id definition_bytes definition_digest expected_generation],
+          "register_assignment" => %w[mapping_id assignment_id definition_digest prepared_head prepared_tree manifest_sha256 expected_generation transfer],
           "reserve_attempt" => %w[mapping_id assignment_id scope worker_uid runtime base_head launcher_process_binding expected_generation],
-          "record_launch" => %w[mapping_id assignment_id attempt_id launch_ticket process_binding expected_generation],
+          "record_launch" => %w[mapping_id assignment_id attempt_id launch_ticket process_binding guarded_origin expected_generation],
           "bind_process" => %w[mapping_id assignment_id attempt_id launch_ticket process_binding expected_generation],
           "release_launch" => %w[mapping_id assignment_id attempt_id launch_ticket process_binding expected_generation],
           "abort_launch" => %w[mapping_id assignment_id attempt_id launch_ticket failure_evidence failure_digest expected_generation]
         }.freeze
-        OPERATIONS = (MUTATIONS.keys + %w[launch_preflight registration_status attempt_status inspect_launch observe_execution_scope close_execution_scope]).freeze
+        TRANSFER_OPERATIONS = {"register_assignment" => {direction: :upload, purpose: :candidate, roles: [:launcher]}, "prompt_attempt" => {direction: :upload, purpose: :prompt_text, roles: %i[launcher supervisor]}}.freeze
+        OPERATIONS = (MUTATIONS.keys + %w[assignment_inventory stop_attempt prompt_attempt prompt_status launch_review_intent launch_input_inhibit_selection launch_input_inhibit_completion launch_prompt_intent launch_prompt_completion launch_preflight registration_status attempt_status inspect_launch observe_execution_scope close_execution_scope]).freeze
         TERMINAL = %w[succeeded failed stopped].freeze
 
-        attr_reader :mutex, :journals, :exclusions
-        def initialize(deployment:, kernel: Ace::Runtime::Molecules::ProtectedLinux.new, journals: nil, mutex: Mutex.new, exclusions: {}, scope_observer_factory: nil)
+        attr_reader :mutex, :journals, :deployment, :deployment_history
+        def initialize(deployment:, kernel: Ace::Runtime::Molecules::ProtectedLinux.new, journals: nil, mutex: Mutex.new, scope_observer_factory: nil, deployment_history: nil, control_exclusion_factory: nil)
           @deployment, @kernel = deployment, kernel
+          if deployment_history && (!deployment_history.is_a?(DeploymentHistory) ||
+              !deployment_history.selects?(deployment))
+            raise ArgumentError, "protected history transaction does not select installed descriptor"
+          end
+          @deployment_history = deployment_history
           @journals = journals || {}
-          @exclusions = exclusions
+          @control_exclusion_factory = control_exclusion_factory || ->(**options) {
+            Molecules::LifecycleExclusion.control_exclusion(**options)
+          }
           @mutex = mutex
           @observations = {}
           @streams = {}
+          @native_issuers = {}
+          @control_channels = {}
           @slot_exclusions = {}
           @scope_observers = {}
           @scope_observer_factory = scope_observer_factory || ->(mapping_id) {
@@ -56,8 +72,17 @@ module Ace
             mapping_id: params.fetch("mapping_id")).require_launch_bound!
         end
 
-        def dispatch(request:, peer:, role:)
+        def dispatch(request:, peer:, role:, transfer: nil)
           operation, params = request.values_at("operation", "params")
+          return assignment_inventory!(request: request, peer: peer, role: role) if operation == "assignment_inventory"
+          return stop_attempt!(request: request, peer: peer, role: role) if operation == "stop_attempt"
+          return prompt_attempt!(request: request, peer: peer, role: role, transfer: transfer) if operation == "prompt_attempt"
+          return prompt_status!(request: request, peer: peer, role: role) if operation == "prompt_status"
+          return launch_input_inhibit_selection!(request: request, peer: peer, role: role) if operation == "launch_input_inhibit_selection"
+          return launch_input_inhibit_completion!(request: request, peer: peer, role: role) if operation == "launch_input_inhibit_completion"
+          return launch_review_intent!(request: request, peer: peer, role: role) if operation == "launch_review_intent"
+          return launch_prompt_intent!(request: request, peer: peer, role: role) if operation == "launch_prompt_intent"
+          return launch_prompt_completion!(request: request, peer: peer, role: role) if operation == "launch_prompt_completion"
           if operation == "observe_execution_scope"
             raise ArgumentError, "scope observation mutation ID must be null" unless request.fetch("mutation_id").nil?
             return {data: observe_execution_scope!(params: params, peer: peer, role: role), replayed: false}
@@ -112,7 +137,15 @@ module Ace
           @kernel.live!(peer)
           journal = journal_for(map)
           digest = Digest::SHA256.hexdigest(JSON.generate(canonical(params)))
-          with_exclusion(params, map, journal) do
+          prepared = if operation == "register_assignment"
+            authorize_transfer!(request: request, peer: peer, role: role)
+            admitted = admit_prepared_registration!(params, map, transfer)
+            digest = Digest::SHA256.hexdigest(JSON.generate(canonical(params.merge("task_context_entry" => admitted.fetch(:task_context_entry)))))
+            params = params.merge("definition_bytes" => admitted.fetch(:definition_bytes))
+            admitted
+          end
+          native_start = nil
+          outcome = with_exclusion(params, map, journal) do |control_context|
           if operation == "reserve_attempt"
             existing = @mutex.synchronize { journal.mutation_result(request.fetch("mutation_id")) }
             unless existing
@@ -141,18 +174,22 @@ module Ace
             begin
               fresh = false
               released = false
-              result = journal.mutate(assignment_id: params.fetch("assignment_id"), attempt_id: attempt_id,
+              result = with_parent_campaign_registration(params, control_context, replay: !replay.nil?) do |campaign_guard|
+              journal.mutate(assignment_id: params.fetch("assignment_id"), attempt_id: attempt_id,
                 mutation_id: request.fetch("mutation_id"), operation: operation, parameters_digest: digest,
                 expected_generation: operation == "reserve_attempt" ? 0 : (params.fetch("expected_generation") || 0), with_replay: true) do |events, commit, generation|
                 fresh = true
+                recheck_control_registration!(control_context, params, map, journal, commit: commit)
+                campaign_guard&.call(journal, commit)
                 plan = case operation
-                when "register_assignment" then register(params, map, journal, commit, generation)
+                when "register_assignment" then register(params, map, journal, commit, generation, prepared: prepared,
+                  lifecycle_control: control_context.fetch(:selection))
                 when "reserve_attempt" then reserve(params, map, journal, commit, generation, peer, attempt_id)
                 when "record_launch" then record(params, map, events, peer)
                 when "bind_process" then bind(params, map, events, peer)
                 when "release_launch"
                   released = true
-                  release(params, map, events, peer)
+                  release(params, map, events, peer, journal: journal, commit: commit)
                 when "abort_launch" then abort(params, map, events, peer, supervisor: role == :supervisor, journal: journal, commit: commit)
                 end
                 bounded_reply!(plan.fetch(:data), generation + 1)
@@ -162,6 +199,7 @@ module Ace
                 reservation_handle ||= @kernel.pin(peer) if operation == "reserve_attempt"
                 plan
               end
+              end
               fresh = !result.fetch(:replayed)
               result = result.fetch(:data)
               if fresh && operation == "reserve_attempt"
@@ -173,7 +211,8 @@ module Ace
                 stream = @streams.fetch(result.fetch("attempt_id"))
                 permission = {"operation" => "release", "launch_ticket" => result.fetch("launch_ticket"),
                   "attempt_id" => result.fetch("attempt_id"), "assignment_id" => result.fetch("assignment_id"),
-                  "generation" => result.fetch("generation"), "journal_commit" => result.fetch("journal_commit")}
+                  "generation" => result.fetch("generation"), "journal_commit" => result.fetch("journal_commit"),
+                  "prepared_input" => result.fetch("prepared_input")}
                 begin
                   wire.write(stream.fetch(:socket), permission, deadline: wire.deadline(1))
                 rescue StandardError
@@ -198,7 +237,8 @@ module Ace
                 "mutation_id" => "scope-admission-#{Digest::SHA256.hexdigest(response.dig(:data, 'attempt_id'))[0, 48]}",
                 "expected_generation" => parent.dig(:data, "generation"))
               digest = Digest::SHA256.hexdigest(JSON.generate(canonical(admission.reject { |key, _| key == "mutation_id" })))
-              admit_native_service_held!(admission, map, journal, peer, role, digest)
+              admitted = admit_native_service_held!(admission, map, journal, peer, role, digest)
+              native_start = [admission, admitted] unless admitted.fetch(:replayed)
             rescue Ace::Runtime::RuntimeUnavailableError, AttemptErrors::EvidenceUnavailable
               # Reservation is already canonical. A failed/lost parent job is
               # held for exact inspection; replay must not activate it again.
@@ -211,6 +251,17 @@ module Ace
           end
           response
           end
+          if native_start
+            begin
+              complete_native_start!(native_start.first, map, journal, peer, role, native_start.last)
+            rescue Ace::Runtime::RuntimeUnavailableError, AttemptErrors::EvidenceUnavailable
+              # Canonical admission remains uncertain; original reserve reply is immutable.
+              nil
+            end
+          end
+          outcome
+        ensure
+          settle_native_issuer!(native_start.first, map) if native_start
         end
 
         def gate_ready(request:, peer:, socket:, deadline:)
@@ -276,27 +327,26 @@ module Ace
           id = params.fetch("assignment_id")
           token!(id)
           journal = journal_for(map)
-          initial = definition(journal, id)
-          raise AttemptErrors::NotFound, "canonical assignment registration is missing" unless initial
-          task = initial.fetch("task_id")
-          token!(task)
-          exclusion = exclusion_for(map, journal)
+          context = control_registration_context!(params, map, journal)
+          exclusion = context.fetch(:exclusion)
           enter = proc do
             @mutex.synchronize do
-              registration = definition(journal, id)
-              unless registration && registration.fetch("task_id") == task
-                raise AttemptErrors::Conflict, "assignment registration changed while entering lifecycle exclusion"
-              end
-              yield journal, JSON.parse(JSON.generate(registration))
+              recheck_control_registration!(context, params, map, journal)
+              yield journal, JSON.parse(JSON.generate(context.fetch(:registration)))
             end
           end
-          with_slot(map) do
+          with_slot(context.fetch(:map), deployment: context.fetch(:descriptor)) do
             if exclusive
-              exclusion.with_exclusive(exclusion.task_key(task)) do
-                exclusion.with_exclusive(exclusion.assignment_key(id)) { enter.call }
+              enter_exclusive = lambda do |offset|
+                if offset == context.fetch(:keys).size
+                  enter.call
+                else
+                  exclusion.with_exclusive(context.fetch(:keys).fetch(offset)) { enter_exclusive.call(offset + 1) }
+                end
               end
+              enter_exclusive.call(0)
             else
-              exclusion.with_shared_multi([exclusion.task_key(task), exclusion.assignment_key(id)]) { enter.call }
+              exclusion.with_shared_multi(context.fetch(:keys)) { enter.call }
             end
           end
         end
@@ -306,11 +356,24 @@ module Ace
           @mutex.synchronize do
             @observations.each_value { |observation| close_observation(observation) }
             @observations.clear
+            @control_channels.each_value(&:close)
+            @control_channels.clear
+            @scope_observers.each_value { |observer| observer.close if observer.is_a?(ExecutionScopeObservation) }
+            @scope_observers.clear
           end
         end
 
         private
 
+        def protected_descriptor_sha256!
+          reference = @deployment.artifact_reference
+          unless reference.is_a?(Hash) && reference["sha256"].is_a?(String) &&
+              Molecules::ExecutionScopeLineage::DIGEST.match?(reference["sha256"])
+            raise AttemptErrors::EvidenceUnavailable, "selected deployment has no protected whole-descriptor provenance"
+          end
+          reference.fetch("sha256")
+        end
+
         def scope_observer_for(mapping_id)
           @scope_observers[mapping_id] ||= @scope_observer_factory.call(mapping_id)
         end
@@ -326,6 +389,11 @@ module Ace
           envelope = {"status" => "ok", "data" => data.merge("generation" => generation, "journal_commit" => "0" * 64),
             "transport" => {"replayed" => false}}
           raise ArgumentError, "accepted launch reply exceeds transport bounds" if JSON.generate(envelope).bytesize + 1 > 16_384
+          if data.key?("prepared_input")
+            permission = data.slice("launch_ticket", "attempt_id", "assignment_id", "prepared_input").merge(
+              "operation" => "release", "generation" => generation, "journal_commit" => "0" * 64)
+            raise ArgumentError, "accepted release exceeds transport bounds" if JSON.generate(permission).bytesize + 1 > 16_384
+          end
         end
 
         def close_observation(observation)
@@ -344,45 +412,67 @@ module Ace
           end
         end
 
-        def exclusion_for(map, journal)
-          exclusion = @exclusions[map.fetch("project_id")] ||= begin
-            common, error, result = Open3.capture3("git", "-C", journal.repo_root,
-              "rev-parse", "--path-format=absolute", "--git-common-dir", stdin_data: "")
-            raise AttemptErrors::EvidenceUnavailable, "canonical lifecycle root is unavailable" unless result.success? && !common.strip.empty?
-            Molecules::LifecycleExclusion.new(root: File.join(common.strip, "ace", "lifecycle-exclusion"))
-          end
-          exclusion
+        def exclusion_for(map, _journal, deployment:, selection:)
+          @control_exclusion_factory.call(authority: deployment.authority(map.fetch("authority_id")),
+            project_id: map.fetch("project_id"), descriptor_sha256: deployment.artifact_reference.fetch("sha256"),
+            root_identity: selection&.fetch("root_identity"))
         end
 
         def with_exclusion(params, map, journal)
-          exclusion = exclusion_for(map, journal)
-          registration = definition(journal, params.fetch("assignment_id"))
-          task = if params.key?("definition_bytes")
-            JSON.parse(params.fetch("definition_bytes")).fetch("task_id")
-          else
-            registration&.fetch("task_id")
+          context = control_registration_context!(params, map, journal)
+          context = campaign_child_context!(params, context, map, journal)
+          enter = proc { with_selected_control_exclusion(context, params, map, journal) { yield context } }
+          enter.call
+        end
+
+        # Containment/recovery never settles Inbox work or grants fresh input.
+        # It retains the same canonical task/slot/assignment exclusions while
+        # permitting the proof prerequisites needed to recover unknown effects.
+        def with_containment_exclusion(params, map, journal)
+          context = control_registration_context!(params, map, journal)
+          with_selected_control_exclusion(context, params, map, journal) { yield context }
+        end
+
+        def with_selected_control_exclusion(context, params, map, journal)
+          exclusion = context.fetch(:exclusion)
+          owners = [context, context[:campaign]&.fetch(:context)].compact
+          keys = owners.flat_map { |owner| owner.fetch(:keys) }.uniq
+          exclusion.provision_keys!(keys: keys) if params.key?("definition_bytes")
+          slots = owners.sort_by { |owner| [owner.fetch(:descriptor).authority(owner.fetch(:map).fetch("authority_id")).fetch("state_root"), owner.fetch(:map).fetch("execution_scope").fetch("slot_id")] }
+            .uniq { |owner| [owner.fetch(:descriptor).authority(owner.fetch(:map).fetch("authority_id")).fetch("state_root"), owner.fetch(:map).fetch("execution_scope").fetch("slot_id")] }
+          enter_slot = lambda do |offset, &body|
+            return body.call if offset == slots.size
+            owner = slots.fetch(offset)
+            with_slot(owner.fetch(:map), deployment: owner.fetch(:descriptor)) { enter_slot.call(offset + 1, &body) }
+          end
+          enter_slot.call(0) do
+            exclusion.with_shared_multi(keys) do
+              @mutex.synchronize { recheck_control_registration!(context, params, map, journal) }
+              yield context
+            end
           end
-          token!(task)
-          keys = [exclusion.task_key(task), exclusion.assignment_key(params.fetch("assignment_id"))]
-          with_slot(map) { exclusion.with_shared_multi(keys) { yield } }
         end
 
         # Slot ownership spans assignment chains and survives authority restart
         # in the existing canonical journal. The file lock only serializes a
         # fresh read/CAS or bounded manager action; its contents convey no facts.
-        def with_slot(map)
-          service = @deployment.authority(map.fetch("authority_id"))
+        def with_slot(map, deployment: @deployment, deadline: nil)
+          service = deployment.authority(map.fetch("authority_id"))
           scope = map.fetch("execution_scope")
-          exclusion = @slot_exclusions[map.fetch("authority_id")] ||= Molecules::LifecycleExclusion.new(
+          exclusion = @slot_exclusions[service.fetch("state_root")] ||= Molecules::LifecycleExclusion.new(
             root: File.join(service.fetch("state_root"), "execution-slot-exclusion"))
-          key = [object_id, map.fetch("authority_id"), scope.fetch("slot_id")]
+          key = [object_id, service.fetch("state_root"), exclusion.slot_key(scope.fetch("slot_id"))]
           held = Thread.current[:ace_assign_scope_exclusions] ||= {}
           raise AttemptErrors::Conflict, "execution slot exclusion cannot be entered recursively" if held[key]
-          exclusion.with_exclusive(exclusion.slot_key(scope.fetch("slot_id"))) do
+          exclusion.with_exclusive(exclusion.slot_key(scope.fetch("slot_id")), deadline: deadline) do
             held[key] = true
+            snapshots = Thread.current[:ace_assign_history_operations] ||= {}
+            owns_snapshot = !snapshots.key?(object_id)
+            snapshots[object_id] = {} if owns_snapshot
             begin
               yield
             ensure
+              snapshots.delete(object_id) if owns_snapshot
               held.delete(key)
             end
           end
@@ -426,27 +516,62 @@ module Ace
           token!(params.fetch("attempt_id"))
         end
 
-        def register(params, map, journal, commit, generation)
-          bytes = params.fetch("definition_bytes")
-          unless bytes.is_a?(String) && bytes.bytesize <= 32_768 && params["definition_digest"].is_a?(String) &&
-              Digest::SHA256.hexdigest(bytes) == params["definition_digest"]
-            raise ArgumentError, "invalid assignment definition digest or size"
+        def admit_prepared_registration!(params, map, transfer)
+          entry = TaskContextEntry.validate!(map.fetch("task_context_entry"))
+          raise AttemptErrors::MalformedTransfer, "Prepared registration transfer unavailable" unless transfer && transfer.count == 1
+          descriptor = params.fetch("transfer")
+          bytes = transfer.bytes
+          work = PreparedWork.admit(bytes: bytes, head: params.fetch("prepared_head"), tree: params.fetch("prepared_tree"),
+            sha256: descriptor.fetch("sha256"), size: descriptor.fetch("bytes"), root: @deployment.project(map.fetch("project_id")).fetch("candidate_root"))
+          unless work.manifest.values_at("assignment_id", "project_id") == [params.fetch("assignment_id"), map.fetch("project_id")] &&
+              work.manifest_sha256 == params.fetch("manifest_sha256")
+            raise ArgumentError, "prepared_input_mismatch: registration association"
+          end
+          definition_bytes = work.definition_bytes(head: params.fetch("prepared_head"), tree: params.fetch("prepared_tree"))
+          unless Digest::SHA256.hexdigest(definition_bytes) == params.fetch("definition_digest")
+            raise ArgumentError, "prepared_input_mismatch: derived definition digest"
           end
+          {work: work, bytes: bytes.freeze, definition_bytes: definition_bytes,
+            task_context_entry: immutable_maintenance_projection(entry)}.freeze
+        end
+
+        def register(params, map, journal, commit, generation, prepared:, lifecycle_control:)
+          assignment = validated_registration_definition!(params, map)
+          bytes = params.fetch("definition_bytes")
           value = JSON.parse(bytes)
-          allowed = %w[session_id name description created_at updated_at source_config parent task_id project_id]
-          unless value.is_a?(Hash) && (value.keys - allowed).empty? &&
-              %w[session_id name created_at source_config task_id project_id].all? { |key| value[key].is_a?(String) && !value[key].empty? } &&
-              value["session_id"] == params["assignment_id"] && value["project_id"] == map["project_id"]
-            raise ArgumentError, "invalid managed assignment definition"
-          end
-          assignment = Models::Assignment.from_h(value)
-          raise ArgumentError, "definition is not managed" unless assignment.managed?
           previous = definition(journal, params.fetch("assignment_id"), commit: commit)
+          if previous
+            original = inventory_definition!(journal, commit,
+              {selector: {"assignment_id" => params.fetch("assignment_id"), "attempt_id" => nil}, registration: previous})
+            if original.campaign_execution &&
+                [assignment.campaign_execution, assignment.parent, assignment.task_id, assignment.project_id] !=
+                  [original.campaign_execution, original.parent, original.task_id, original.project_id]
+              raise AttemptErrors::Conflict, "registered campaign child linkage is immutable"
+            end
+          end
+          if previous && previous.fetch("lifecycle_control") != lifecycle_control
+            raise AttemptErrors::Conflict, "same assignment cannot replace original lifecycle control"
+          end
+          if previous && previous["definition_digest"] == params["definition_digest"] &&
+              previous["task_context_entry"] != prepared.fetch(:task_context_entry)
+            raise AttemptErrors::Conflict, "same prepared definition cannot replace original task context entry"
+          end
           if previous && previous["definition_digest"] != params["definition_digest"] && active_events?(journal.read_events(params.fetch("assignment_id")))
             raise AttemptErrors::Conflict, "active assignment definition cannot change"
           end
+          if previous && previous["definition_digest"] == params["definition_digest"] &&
+              previous.values_at("prepared_bundle_bytes", "prepared_bundle_sha256") != [prepared.fetch(:bytes).bytesize, Digest::SHA256.hexdigest(prepared.fetch(:bytes))]
+            raise AttemptErrors::Conflict, "same prepared definition cannot replace original bundle bytes"
+          end
           path = "execution/definitions/#{params.fetch('assignment_id')}-#{params.fetch('definition_digest')}.json"
-          {events: [], blobs: {path => bytes}, data: {"assignment_id" => params.fetch("assignment_id"),
+          bundle = prepared.fetch(:bytes)
+          bundle_sha = Digest::SHA256.hexdigest(bundle)
+          bundle_path = "execution/prepared/#{params.fetch('assignment_id')}-#{bundle_sha}.bundle"
+          {events: [], blobs: {path => bytes, bundle_path => bundle}, data: {"prepared_work" => value.fetch("prepared_work"),
+            "lifecycle_control" => lifecycle_control,
+            "task_context_entry" => prepared.fetch(:task_context_entry),
+            "prepared_bundle_ref" => bundle_path, "prepared_bundle_bytes" => bundle.bytesize, "prepared_bundle_sha256" => bundle_sha,
+            "selection_sha256" => prepared.fetch(:work).selection_sha256, "assignment_id" => params.fetch("assignment_id"),
             "project_id" => map.fetch("project_id"), "mapping_id" => params.fetch("mapping_id"),
             "phase" => "registered", "definition_ref" => path, "definition_digest" => params.fetch("definition_digest"),
             "definition_generation" => previous && previous["definition_digest"] == params["definition_digest"] ? previous.fetch("definition_generation") : generation + 1, "task_id" => assignment.task_id}}
@@ -460,6 +585,9 @@ module Ace
             raise AttemptErrors::UnauthorizedIdentity, "reservation identity differs"
           end
           scope = Atoms::AssignmentScope.canonicalize(params.fetch("scope"))
+          unless registration.dig("prepared_work", "scope") == scope && registration.dig("prepared_work", "task_id") == registration["task_id"]
+            raise AttemptErrors::Conflict, "reservation differs from prepared selection"
+          end
           ensure_slot_available!(map, journal)
           events = journal.read_events(params.fetch("assignment_id"))
           events.group_by { |event| event["attempt_id"] }.each_value do |chain|
@@ -472,6 +600,11 @@ module Ace
           end
           head = params.fetch("base_head")
           raise ArgumentError, "invalid base revision" unless head.is_a?(String) && head.match?(/\A[0-9a-f]{40}\z/)
+          registered_definition = inventory_definition!(journal, commit,
+            {selector: {"assignment_id" => params.fetch("assignment_id"), "attempt_id" => nil}, registration: registration})
+          if registered_definition.campaign_execution && head != registered_definition.campaign_execution.fetch("base")
+            raise AttemptErrors::Conflict, "campaign child base differs from pinned parent candidate"
+          end
           ticket = SecureRandom.hex(24)
           payload = {"assignment_id" => params.fetch("assignment_id"), "scope" => scope,
             "project_id" => map.fetch("project_id"), "task_id" => registration.fetch("task_id"),
@@ -479,6 +612,7 @@ module Ace
             "launcher_identity" => peer, "launch_ticket" => ticket}
           provisioning = {"slot_id" => map.fetch("execution_scope").fetch("slot_id"),
             "deployment_digest" => Digest::SHA256.hexdigest(JSON.generate(canonical(map))),
+            "descriptor_sha256" => protected_descriptor_sha256!,
             "reservation_generation" => generation + 1}
           {events: [{type: "intent", payload: payload}, {type: "scope_provisioning", payload: provisioning}], blobs: {}, data: payload.merge(
             "attempt_id" => attempt_id, "phase" => "reserved", "mapping_id" => params.fetch("mapping_id"),
@@ -486,6 +620,17 @@ module Ace
         end
 
         def ensure_slot_available!(map, journal, commit: journal.ref_value)
+          if @deployment_history
+            protected = maintenance_journal_for(@deployment, map)
+            unless protected.ref_value == commit
+              raise AttemptErrors::Conflict, "historical admission canonical ref changed"
+            end
+            return with_maintenance_inbox_inventory(@deployment_history.candidate) do
+              maintenance_slot_lineages!(nil, protected, commit, selected_context: [@deployment, map])
+              raise AttemptErrors::Conflict, "historical admission canonical ref changed" unless protected.ref_value == commit
+              true
+            end
+          end
           slot = map.fetch("execution_scope").fetch("slot_id")
           journal.assignment_ids(commit: commit).each do |assignment_id|
             journal.read_events(assignment_id, commit: commit).group_by { |event| event.fetch("attempt_id") }.each do |attempt_id, chain|
@@ -503,11 +648,15 @@ module Ace
                 raise AttemptErrors::EvidenceUnavailable, "canonical slot provisioning identity is incomplete"
               end
               owner = provisioning.first.fetch("payload")
-              unless owner.is_a?(Hash) && owner.keys.sort == %w[deployment_digest reservation_generation slot_id] &&
+              unless owner.is_a?(Hash) && owner.keys.sort == %w[deployment_digest descriptor_sha256 reservation_generation slot_id] &&
                   owner["reservation_generation"] == reservation.fetch("reservation_generation") &&
+                  owner["descriptor_sha256"].is_a?(String) && Molecules::ExecutionScopeLineage::DIGEST.match?(owner["descriptor_sha256"]) &&
                   owner["deployment_digest"].is_a?(String) && Molecules::ExecutionScopeLineage::DIGEST.match?(owner["deployment_digest"])
                 raise AttemptErrors::EvidenceUnavailable, "canonical slot provisioning identity differs"
               end
+              unless owner.fetch("descriptor_sha256") == protected_descriptor_sha256!
+                raise AttemptErrors::EvidenceUnavailable, "historical descriptor requires authenticated maintenance before normal slot reuse"
+              end
               prior_map = @deployment.mapping(reservation.fetch("mapping_id"))
               unless prior_map.fetch("execution_scope").fetch("slot_id") == owner.fetch("slot_id") &&
                   prior_map.fetch("project_id") == reservation.fetch("project_id")
@@ -538,6 +687,8 @@ module Ace
           raise AttemptErrors::Conflict, "launch cannot record another child" unless state["phase"] == "reserved"
           binding = validate_binding!(params.fetch("process_binding"), map, mapping_id: params.fetch("mapping_id"), launch_ticket: params.fetch("launch_ticket"), assignment_id: params.fetch("assignment_id"), attempt_id: params.fetch("attempt_id"), events: events)
           child = binding.fetch("process_identity")
+          guard = Ace::Herdr::Molecules::GuardedNativeOrigin.verify!(params.fetch("guarded_origin"),
+            terminal_id: binding.fetch("terminal_id"), child: child)
           @kernel.live!(child)
           if observation[:child_handle]
             unless @kernel.same?(observation.fetch(:child), child)
@@ -547,7 +698,7 @@ module Ace
             observation[:child_handle] = @kernel.pin(child)
             observation[:child] = child
           end
-          {events: [], blobs: {}, data: state.merge("phase" => "recorded", "process_binding" => binding)}
+          {events: [], blobs: {}, data: state.merge("phase" => "recorded", "process_binding" => binding, "guarded_origin" => guard)}
         end
 
         def bind(params, map, events, peer)
@@ -568,7 +719,7 @@ module Ace
           {events: [{type: "scope_child_bound", payload: child}, {type: "process_start", payload: payload}], blobs: {}, data: state.merge("phase" => "bound")}
         end
 
-        def release(params, map, events, peer)
+        def release(params, map, events, peer, journal:, commit:)
           state, observation = owned(params, events, peer)
           unless state["phase"] == "bound" && state["process_binding"] == params["process_binding"] && @streams.key?(state.fetch("attempt_id"))
             raise AttemptErrors::Conflict, "exact live bound gate is unavailable"
@@ -578,7 +729,9 @@ module Ace
           raise AttemptErrors::Conflict, "canonical original child differs" unless original == params.fetch("process_binding")
           @kernel.live!(observation.fetch(:child))
           raise AttemptErrors::Conflict, "launcher has exited" unless launcher_live?(observation)
-          {events: [], blobs: {}, data: state.merge("phase" => "issued", "execution" => "potentially_executed")}
+          prepared = original_bound_prepared_registration!(journal: journal, params: params, commit: commit)
+          {events: [], blobs: {}, data: state.merge("phase" => "issued", "execution" => "potentially_executed",
+            "prepared_input" => compact_prepared_input(prepared))}
         end
 
         def abort(params, map, events, peer, supervisor: false, journal:, commit:)
@@ -678,7 +831,7 @@ module Ace
         end
 
         def definition(journal, id, commit: journal.ref_value)
-          journal.read_events(id).reverse.filter_map do |event|
+          journal.read_events(id, commit: commit).reverse.filter_map do |event|
             next unless event["type"] == "authority_mutation" && event.dig("payload", "operation") == "register_assignment"
             event.dig("payload", "data")
           end.first
@@ -747,31 +900,47 @@ module Ace
           map = @deployment.mapping(params.fetch("mapping_id"))
           token!(params.fetch("assignment_id")); token!(params.fetch("attempt_id"))
           journal = journal_for(map)
-          @mutex.synchronize do
-            commit = journal.ref_value
-            events = journal.read_events(params.fetch("assignment_id"), commit: commit)
-            state = states(events)[params.fetch("attempt_id")]
-            raise AttemptErrors::NotFound, "launch not found" unless state && state["mapping_id"] == params["mapping_id"]
-            if role == :launcher && !@kernel.same?(state.fetch("launcher_identity"), peer)
-              raise AttemptErrors::UnauthorizedIdentity, "launch belongs to another launcher incarnation"
-            end
-            projection = state.slice("assignment_id", "attempt_id", "phase", "scope", "launch_ticket", "reservation_generation", "generation", "execution", "required_action", "handshake_deadline")
-            if %i[launcher supervisor].include?(role)
-              projection.merge!(state.slice("process_binding", "launcher_identity", "mapping_id"))
-            end
-            observation = @observations[params.fetch("attempt_id")]
-            expired = !%w[issued failed].include?(state["phase"]) && state["handshake_deadline"] && Time.iso8601(state.fetch("handshake_deadline")) <= Time.now.utc
-            child_exited = observation && observation[:child_handle] &&
-              observation[:child] == state.dig("process_binding", "process_identity") && @kernel.exited?(observation.fetch(:child_handle))
-            if !TERMINAL.include?(state["phase"]) && (!observation || !launcher_live?(observation) || expired || child_exited)
-              projection.merge!("phase" => "uncertain", "required_action" => "supervisor_inspect_exact_child_and_release_uncertainty")
-            end
-            if @result_owner
+          with_containment_exclusion(params, map, journal) do
+            @mutex.synchronize do
+              commit = journal.ref_value
+              events = journal.read_events(params.fetch("assignment_id"), commit: commit)
+              state = states(events)[params.fetch("attempt_id")]
+              raise AttemptErrors::NotFound, "launch not found" unless state && state["mapping_id"] == params["mapping_id"]
+              if role == :launcher && !@kernel.same?(state.fetch("launcher_identity"), peer)
+                raise AttemptErrors::UnauthorizedIdentity, "launch belongs to another launcher incarnation"
+              end
               chain = events.select { |event| event["attempt_id"] == params.fetch("attempt_id") }
-              projection.merge!(@result_owner.result_status(journal: journal, events: chain, params: params,
-                map: map, peer: peer, role: role, commit: commit))
+              projection = state.slice("assignment_id", "attempt_id", "phase", "scope", "launch_ticket", "reservation_generation", "generation", "execution", "required_action", "handshake_deadline")
+              projection.merge!("state" => journal.canonical_attempt_state(chain), "generation" => journal.authority_generation(chain))
+              if %i[launcher supervisor].include?(role)
+                projection.merge!(state.slice("process_binding", "launcher_identity", "mapping_id"))
+                original = original_prompt_record!(chain, state, params: params) if chain.any? { |event| event["type"] == "authority_mutation" && event.dig("payload", "operation") == "record_launch" }
+                projection.merge!("original_binding_digest" => original&.fetch("binding_digest"), "terminal_event_id" => nil, "reservation_release_event_id" => nil)
+                if TERMINAL.include?(projection.fetch("state"))
+                  lineage = Molecules::ExecutionScopeLineage.new(events: chain, project_id: map.fetch("project_id"),
+                    assignment_id: params.fetch("assignment_id"), attempt_id: params.fetch("attempt_id"), mapping_id: params.fetch("mapping_id"))
+                  released = scope_reservation_released?(chain, lineage, journal, commit)
+                  if released
+                    release = chain.find { |event| event["type"] == "authority_mutation" && event.dig("payload", "operation") == "scope_reservation_release" }
+                    projection.merge!("terminal_event_id" => release.dig("payload", "data", "terminal_event_id"), "reservation_release_event_id" => release.fetch("digest"))
+                  else
+                    projection["terminal_event_id"] = terminal_scope_receipt!(chain, lineage, journal, commit).fetch("digest")
+                  end
+                end
+              end
+              observation = @observations[params.fetch("attempt_id")]
+              expired = !%w[issued failed].include?(state["phase"]) && state["handshake_deadline"] && Time.iso8601(state.fetch("handshake_deadline")) <= Time.now.utc
+              child_exited = observation && observation[:child_handle] &&
+                observation[:child] == state.dig("process_binding", "process_identity") && @kernel.exited?(observation.fetch(:child_handle))
+              if !TERMINAL.include?(state["phase"]) && (!observation || !launcher_live?(observation) || expired || child_exited)
+                projection.merge!("phase" => "uncertain", "required_action" => "supervisor_inspect_exact_child_and_release_uncertainty")
+              end
+              if @result_owner
+                projection.merge!(@result_owner.result_status(journal: journal, events: chain, params: params,
+                  map: map, peer: peer, role: role, commit: commit))
+              end
+              projection.merge("journal_commit" => commit)
             end
-            projection.merge("journal_commit" => commit)
           end
         end
 
@@ -779,16 +948,9 @@ module Ace
           events.group_by { |event| event["attempt_id"] }.values.any? { |chain| chain.any? { |event| event["type"] == "intent" } && !terminal_events?(chain) }
         end
         def terminal_events?(events)
-          latest = events.reverse.filter_map do |event|
-            case event["type"]
-            when "process_start" then "running"
-            when "transition" then event.dig("payload", "to")
-            when "receipt_accepted" then event.dig("payload", "receipt", "verdict")
-            when "reconciliation" then event.dig("payload", "resolution")
-            end
-          end.first
-          TERMINAL.include?(latest)
+          TERMINAL.include?(Molecules::CanonicalAttemptState.derive(events))
         end
+
         def strict!(value, keys)
           raise ArgumentError, "authority fields differ" unless value.is_a?(Hash) && value.keys.sort == keys.sort
         end
@@ -820,3 +982,16 @@ require_relative "launch_scope_admission"
 require_relative "launch_scope_close"
 require_relative "launch_scope_release"
 require_relative "launch_scope_parent"
+
+require_relative "launch_steering"
+require_relative "launch_input_inhibition"
+
+require_relative "launch_stop"
+require_relative "assignment_inventory"
+require_relative "launch_prepared_work"
+
+require_relative "launch_review"
+require_relative "launch_attempt_consumers"
+require_relative "launch_control_exclusions"
+
+require_relative "launch_campaign_registration"