ace-assign 0.64.0 → 0.66.0

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

@@ -0,0 +1,353 @@
+# frozen_string_literal: true
+
+module Ace
+  module Assign
+    module Authority
+      class LaunchLifecycle
+        def transfer_binding(request) = TRANSFER_OPERATIONS[request.fetch("operation")]
+
+        def authorize_transfer!(request:, peer:, role:)
+          if request["operation"] == "register_assignment"
+            params = request.fetch("params")
+            strict!(params, MUTATIONS.fetch("register_assignment"))
+            map = @deployment.mapping(params.fetch("mapping_id"))
+            TaskContextEntry.validate!(map.fetch("task_context_entry"))
+            unless role == :launcher && peer.values_at("uid", "gid", "groups") == map.values_at("launcher_uid", "launcher_gid", "launcher_groups")
+              raise AttemptErrors::UnauthorizedIdentity, "prepared registration requires mapped launcher"
+            end
+            @kernel.live!(peer)
+            return true
+          end
+          raise ArgumentError, "unsupported launch transfer" unless request["operation"] == "prompt_attempt"
+          steering_principal!(request.fetch("params"), peer, role)
+        end
+
+        def prompt_attempt!(request:, peer:, role:, transfer:)
+          params = request.fetch("params")
+          strict!(params, %w[mapping_id assignment_id attempt_id expected_generation transfer])
+          token!(request.fetch("mutation_id"))
+          generation!(params.fetch("expected_generation"))
+          map = steering_principal!(params, peer, role)
+          raise AttemptErrors::MalformedTransfer, "Prompt transfer unavailable" unless transfer
+          text = transfer.bytes
+          unless text.is_a?(String) && text.force_encoding(Encoding::UTF_8).valid_encoding? && text.bytesize.between?(1, 16_384) && !text.match?(/\A[[:space:]]*\z/)
+            raise AttemptErrors::MalformedTransfer, "Prompt text is malformed"
+          end
+          journal = journal_for(map)
+          binding = intent = channel = reservation = nil
+          prepared = with_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") }
+              state = origin(events, **params.slice("assignment_id", "attempt_id", "mapping_id").transform_keys(&:to_sym))
+              original = original_prompt_record!(events, state, params: params)
+              binding = {"action" => "prompt_attempt", "project_id" => map.fetch("project_id"),
+                "mapping_id" => params.fetch("mapping_id"), "assignment_id" => params.fetch("assignment_id"), "attempt_id" => params.fetch("attempt_id"),
+                "mutation_id" => request.fetch("mutation_id"), "expected_generation" => params.fetch("expected_generation"),
+                "caller" => peer.slice("uid", "gid", "groups").merge("role" => role.to_s),
+                "original_binding_digest" => original.fetch("binding_digest"), "text_bytes" => text.bytesize, "text_sha256" => Digest::SHA256.hexdigest(text)}
+              digest = Digest::SHA256.hexdigest(JSON.generate(canonical(binding)))
+              replay = journal.mutation_result(request.fetch("mutation_id"), commit: commit)
+              if replay
+                unless replay["operation"] == "prompt_attempt" && replay["parameters_digest"] == digest && replay["assignment_id"] == params["assignment_id"] && replay["attempt_id"] == params["attempt_id"]
+                  raise AttemptErrors::Conflict, "Mutation ID is already bound to different input"
+                end
+                next({data: replay.fetch("data").merge("journal_commit" => replay.fetch("journal_commit")), replayed: true})
+              end
+              unless journal.prompt_intent(request.fetch("mutation_id"), commit: commit)
+                channel = @control_channels[steering_key(params, map)]
+                raise AttemptErrors::EvidenceUnavailable, "Original launcher channel is unavailable" unless channel
+                reservation = channel.reserve_dispatch!
+              end
+              issue = journal.issue_prompt(binding: binding, issued_by: peer) do |current, _old, _generation|
+                unless channel && reservation && channel.dispatch_reserved?(reservation)
+                  raise AttemptErrors::EvidenceUnavailable, "Original launcher channel is unavailable"
+                end
+                fresh = origin(current, **params.slice("assignment_id", "attempt_id", "mapping_id").transform_keys(&:to_sym))
+                authenticate = original_prompt_record!(current, fresh, params: params)
+                raise AttemptErrors::EvidenceUnavailable, "Original guarded record changed" unless authenticate == original
+                raise AttemptErrors::Conflict, "Attempt is not available for prompt input" unless fresh["phase"] == "issued" && !terminal_events?(current)
+                scope_open_for_effect!(events: current, params: params, map: map)
+                @kernel.live!(fresh.fetch("process_binding").fetch("process_identity"))
+              end
+              intent = journal.prompt_intent(request.fetch("mutation_id"), commit: issue.dig(:data, "journal_commit"))
+              {issue: issue, original: original}
+            end
+          end
+          return prepared if prepared.key?(:data)
+          evidence = {"outcome" => "uncertain", "origin" => prepared.fetch(:original).fetch("origin")}
+          if channel && !channel.closed? && !prepared.fetch(:issue).fetch(:replayed)
+            frame = {"version" => 1, "type" => "prompt_dispatch", "mutation_id" => request.fetch("mutation_id"),
+              "attempt_id" => params.fetch("attempt_id"), "intent_event_id" => intent.fetch("digest"),
+              "journal_commit" => prepared.dig(:issue, :data, "journal_commit"), "original_binding_digest" => binding.fetch("original_binding_digest"),
+              "text_descriptor" => TransferCodec.new.descriptor([text], purpose: :prompt_text), "transfer_id" => SecureRandom.hex(16)}
+            begin
+              outcome = channel.dispatch_prompt(frame: frame, bytes: text, deadline: wire.deadline(30), reservation: reservation)
+              evidence = outcome.fetch("guarded_evidence")
+            rescue Ace::Runtime::RuntimeUnavailableError, AttemptErrors::EvidenceUnavailable, IOError, SystemCallError
+              # Accepted intent never yields another send permit after uncertainty.
+            end
+          end
+          finish_prompt_outcome!(params, map, intent, evidence)
+        ensure
+          channel&.release_dispatch!(reservation) if reservation
+          text = nil
+        end
+
+        def serve_launch_control!(request:, peer:, socket:, codec:, deadline:)
+          params = request.fetch("params")
+          strict!(params, %w[mapping_id assignment_id attempt_id])
+          raise ArgumentError, "Private control requires null mutation ID" unless request.fetch("mutation_id").nil?
+          map = steering_principal!(params, peer, :launcher)
+          journal = journal_for(map)
+          channel = ready = nil
+          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") }
+              state = origin(events, **params.transform_keys(&:to_sym))
+              raise AttemptErrors::UnauthorizedIdentity, "Private channel belongs to another launcher incarnation" unless @kernel.same?(state.fetch("launcher_identity"), peer)
+              raise AttemptErrors::Conflict, "Original launcher is not issued" unless state["phase"] == "issued"
+              if events.any? { |event| event["type"] == "authority_mutation" && event.dig("payload", "operation") == "scope_reservation_release" }
+                raise AttemptErrors::EvidenceUnavailable, "Released scope cannot retain launcher control"
+              end
+              original = original_prompt_record!(events, state, params: params)
+              key = steering_key(params, map)
+              prior = @control_channels[key]
+              raise AttemptErrors::Conflict, "Original launcher channel already exists" if prior && !prior.closed?
+              channel = LaunchControlChannel.new(socket: socket, codec: codec,
+                outcome: ->(result) { ingest_original_prompt_outcome!(params, map, result) },
+                input_inhibition: ->(result) { record_original_input_inhibition!(params.merge(result.slice("original_binding_digest", "seal_event_id")), map,
+                  result.fetch("guarded_evidence"), peer: peer) })
+              @control_channels[key] = channel
+              ready = {"version" => 1, "type" => "launch_control_ready", "attempt_id" => params.fetch("attempt_id"),
+                "original_binding_digest" => original.fetch("binding_digest"), "journal_commit" => commit, "generation" => journal.authority_generation(events)}
+            end
+          end
+          wire.write(socket, ready, deadline: deadline, limit: 16_384)
+          channel.serve
+        ensure
+          channel&.close
+        end
+
+        # This immutable-prefix query holds no slot/assignment exclusion. The
+        # original waiter dropped all locks before dispatch/ACK handling.
+        def launch_prompt_intent!(request:, peer:, role:)
+          params = request.fetch("params")
+          strict!(params, %w[mapping_id assignment_id attempt_id mutation_id intent_event_id journal_commit])
+          raise ArgumentError, "Intent lookup is read-only" unless request.fetch("mutation_id").nil?
+          map = steering_principal!(params, peer, role)
+          raise AttemptErrors::UnauthorizedIdentity, "Intent lookup requires original launcher" unless role == :launcher
+          unless params.fetch("journal_commit").is_a?(String) && params.fetch("journal_commit").match?(/\A(?:[0-9a-f]{40}|[0-9a-f]{64})\z/)
+            raise ArgumentError, "Invalid immutable intent commit"
+          end
+          journal = journal_for(map)
+          journal.verify_canonical_prefix!(commit: params.fetch("journal_commit"))
+          intent = journal.prompt_intent(params.fetch("mutation_id"), commit: params.fetch("journal_commit"))
+          raise AttemptErrors::EvidenceUnavailable, "Accepted prompt intent differs" unless intent && intent["digest"] == params.fetch("intent_event_id")
+          events = journal.read_events(params.fetch("assignment_id"), commit: params.fetch("journal_commit")).select { |event| event["attempt_id"] == params.fetch("attempt_id") }
+          state = origin(events, **params.slice("assignment_id", "attempt_id", "mapping_id").transform_keys(&:to_sym))
+          raise AttemptErrors::UnauthorizedIdentity, "Intent lookup requires exact launcher incarnation" unless @kernel.same?(state.fetch("launcher_identity"), peer)
+          original = original_prompt_record!(events, state, params: params)
+          binding = intent.fetch("payload").fetch("binding")
+          unless binding["original_binding_digest"] == original.fetch("binding_digest") && binding["mapping_id"] == params["mapping_id"] && binding["assignment_id"] == params["assignment_id"] && binding["attempt_id"] == params["attempt_id"]
+            raise AttemptErrors::EvidenceUnavailable, "Prompt intent does not join original accepted record"
+          end
+          {data: {"intent_event_id" => intent.fetch("digest"), "binding" => binding, "origin" => original.fetch("origin")}, replayed: false}
+        end
+
+        # Only the still-authenticated original launcher may recover its own
+        # already-known native ACK after a private connection disappears.
+        # This grants no input permit and never changes the first public reply.
+        def launch_prompt_completion!(request:, peer:, role:)
+          params = request.fetch("params")
+          strict!(params, %w[mapping_id assignment_id attempt_id mutation_id intent_event_id original_binding_digest guarded_evidence])
+          raise ArgumentError, "Original completion requires null public mutation ID" unless request.fetch("mutation_id").nil?
+          map = steering_principal!(params, peer, role)
+          raise AttemptErrors::UnauthorizedIdentity, "Completion reporting requires original launcher" unless role == :launcher
+          journal = journal_for(map)
+          intent = journal.prompt_intent(params.fetch("mutation_id"))
+          binding = intent&.dig("payload", "binding")
+          unless intent && intent["digest"] == params["intent_event_id"] && binding.is_a?(Hash) &&
+              %w[mapping_id assignment_id attempt_id original_binding_digest].all? { |key| binding[key] == params[key] } &&
+              params.fetch("guarded_evidence").is_a?(Hash) && %w[submitted not_issued].include?(params.dig("guarded_evidence", "outcome"))
+            raise AttemptErrors::EvidenceUnavailable, "Retained native completion does not join accepted issue"
+          end
+          accepted = finish_prompt_outcome!(params.slice("mapping_id", "assignment_id", "attempt_id"), map, intent,
+            params.fetch("guarded_evidence"), peer: peer, completion_ack: true)
+          {data: accepted.merge("intent_event_id" => intent.fetch("digest")), replayed: false}
+        end
+
+        def prompt_status!(request:, peer:, role:)
+          params = request.fetch("params")
+          strict!(params, %w[mapping_id assignment_id attempt_id mutation_id])
+          %w[assignment_id attempt_id mutation_id].each { |key| token!(params.fetch(key)) }
+          raise ArgumentError, "Prompt status requires null public mutation ID" unless request.fetch("mutation_id").nil?
+          map = steering_principal!(params, peer, role)
+          journal = journal_for(map)
+          @mutex.synchronize do
+            commit = journal.ref_value
+            intent = journal.prompt_intent(params.fetch("mutation_id"), commit: commit)
+            raise AttemptErrors::NotFound, "Prompt mutation is missing" unless intent
+            binding = intent.fetch("payload").fetch("binding")
+            unless binding.slice("mapping_id", "assignment_id", "attempt_id") == params.slice("mapping_id", "assignment_id", "attempt_id") &&
+                binding.fetch("project_id") == map.fetch("project_id")
+              raise AttemptErrors::Conflict, "Prompt mutation belongs to another attempt"
+            end
+            unless binding.fetch("caller") == peer.slice("uid", "gid", "groups").merge("role" => role.to_s)
+              raise AttemptErrors::UnauthorizedIdentity, "Prompt mutation belongs to another principal"
+            end
+            events = journal.read_events(params.fetch("assignment_id"), commit: commit).select { |event| event["attempt_id"] == params.fetch("attempt_id") }
+            state = origin(events, **params.slice("assignment_id", "attempt_id", "mapping_id").transform_keys(&:to_sym))
+            original = original_prompt_record!(events, state, params: params)
+            unless binding.fetch("original_binding_digest") == original.fetch("binding_digest")
+              raise AttemptErrors::EvidenceUnavailable, "Prompt original guarded record differs"
+            end
+            reply = journal.mutation_result(params.fetch("mutation_id"), commit: commit)
+            if reply && (reply["operation"] != "prompt_attempt" || reply["parameters_digest"] != intent.dig("payload", "binding_digest") ||
+                reply["assignment_id"] != params["assignment_id"] || reply["attempt_id"] != params["attempt_id"])
+              raise AttemptErrors::EvidenceUnavailable, "Prompt immutable reply differs"
+            end
+            completed = authenticated_prompt_completions!(events, intent, original, journal).last
+            {data: {"attempt_id" => params.fetch("attempt_id"), "mutation_id" => params.fetch("mutation_id"),
+              "outcome" => completed ? completed.dig("payload", "evidence", "outcome") : "uncertain",
+              "intent_event_id" => intent.fetch("digest"), "outcome_event_id" => completed&.fetch("digest"),
+              "generation" => journal.authority_generation(events), "journal_commit" => commit}, replayed: false}
+          end
+        rescue KeyError, TypeError
+          raise AttemptErrors::EvidenceUnavailable, "Prompt status evidence is malformed"
+        end
+
+        private
+
+        def steering_key(params, map)
+          [map.fetch("project_id"), params.fetch("mapping_id"), params.fetch("assignment_id"), params.fetch("attempt_id")]
+        end
+
+        def steering_principal!(params, peer, role)
+          @kernel.live!(peer)
+          map = @deployment.verify!(params.fetch("mapping_id"), kernel: @kernel, authority_state: true)
+          allowed = if role == :launcher
+            peer.values_at("uid", "gid", "groups") == map.values_at("launcher_uid", "launcher_gid", "launcher_groups")
+          elsif role == :supervisor
+            project = @deployment.project(map.fetch("project_id"))
+            credentials = project.fetch("peer_credentials")[peer.fetch("uid").to_s]
+            project.fetch("supervisor_uids").include?(peer.fetch("uid")) && credentials &&
+              peer.values_at("gid", "groups") == credentials.values_at("gid", "groups")
+          end
+          raise AttemptErrors::UnauthorizedIdentity, "Prompt requires installed launcher or supervisor" unless allowed
+          map
+        end
+
+        def finish_prompt_outcome!(params, map, intent, evidence, peer: nil, completion_ack: false)
+          journal = journal_for(map)
+          with_containment_exclusion(params, map, journal) do
+            @mutex.synchronize do
+              authentication = lambda do |events, _commit, _generation|
+                state = origin(events, **params.slice("assignment_id", "attempt_id", "mapping_id").transform_keys(&:to_sym))
+                if peer
+                  @kernel.live!(peer)
+                  unless @kernel.same?(state.fetch("launcher_identity"), peer)
+                    raise AttemptErrors::UnauthorizedIdentity, "Completion reporting requires exact original launcher incarnation"
+                  end
+                end
+                original_prompt_record!(events, state, params: params)
+              end
+              if peer
+                selected = journal.ref_value
+                current = journal.read_events(params.fetch("assignment_id"), commit: selected).select { |event| event["attempt_id"] == params.fetch("attempt_id") }
+                authenticated = authentication.call(current, selected, journal.authority_generation(current))
+                journal.send(:validate_prompt_evidence!, evidence, authenticated.fetch("origin"))
+              end
+              result = journal.finalize_prompt(mutation_id: intent.dig("payload", "external_mutation_id"), intent_event_id: intent.fetch("digest"),
+                binding_digest: intent.dig("payload", "binding_digest"), evidence: evidence, &authentication)
+              accepted = result
+              if %w[submitted not_issued].include?(evidence["outcome"]) && %w[submitted not_issued].include?(result.dig(:data, "outcome")) &&
+                  result.dig(:data, "guarded_evidence") != evidence
+                raise AttemptErrors::Conflict, "Native completion differs from accepted outcome"
+              end
+              if result.dig(:data, "outcome") == "uncertain" && %w[submitted not_issued].include?(evidence["outcome"])
+                accepted = journal.observe_prompt_completion(mutation_id: intent.dig("payload", "external_mutation_id"), intent_event_id: intent.fetch("digest"),
+                  binding_digest: intent.dig("payload", "binding_digest"), evidence: evidence, &authentication)
+              end
+              completion_ack ? accepted.fetch(:data).slice("outcome", "journal_commit") : result
+            end
+          end
+        end
+
+        def ingest_original_prompt_outcome!(params, map, result)
+          journal = journal_for(map)
+          intent = journal.prompt_intent(result.fetch("mutation_id"))
+          unless intent && intent["digest"] == result.fetch("intent_event_id") &&
+              intent.dig("payload", "binding", "original_binding_digest") == result.fetch("original_binding_digest")
+            raise AttemptErrors::EvidenceUnavailable, "Original driver outcome differs from accepted issue"
+          end
+          finish_prompt_outcome!(params, map, intent, result.fetch("guarded_evidence"), completion_ack: true)
+        end
+
+        # An issued actor lives outside the worker unit and must be inhibited
+        # for its full lifetime, even with no prompt rows or only known ACKs.
+        # Accepted original actor input drainage removes the writer blocker. It never
+        # changes an unknown prompt outcome. Channel absence, caller exit and
+        # an empty worker cgroup cannot remove this blocker.
+        def pending_prompt_issuers?(events, journal, commit)
+          return false if accepted_input_inhibition?(events, journal, commit)
+          return true if issued_input_actor?(events)
+          events.select { |event| event["type"] == "prompt_issued" }.any? do |issued|
+            external_id = issued.fetch("payload").fetch("external_mutation_id")
+            intent = journal.prompt_intent(external_id, commit: commit)
+            raise AttemptErrors::EvidenceUnavailable, "Prompt issuer is not canonically accepted" unless intent && intent["digest"] == issued["digest"]
+            binding = intent.fetch("payload").fetch("binding")
+            params = binding.slice("mapping_id", "assignment_id", "attempt_id")
+            state = origin(events, **params.transform_keys(&:to_sym))
+            original = original_prompt_record!(events, state, params: params)
+            unless binding.fetch("original_binding_digest") == original.fetch("binding_digest")
+              raise AttemptErrors::EvidenceUnavailable, "Prompt issuer original binding differs"
+            end
+            authenticated_prompt_completions!(events, intent, original, journal).empty?
+          end
+        rescue KeyError, TypeError, ArgumentError
+          raise AttemptErrors::EvidenceUnavailable, "Prompt issuer history is malformed"
+        end
+
+        def issued_input_actor?(events)
+          releases = events.select { |event| event["type"] == "authority_mutation" && event.dig("payload", "operation") == "release_launch" }
+          return false if releases.empty?
+          unless Models::EvidenceEvent.chain_valid?(events) && releases.one? &&
+              releases.first.dig("payload", "data").is_a?(Hash) && releases.first.dig("payload", "data", "phase") == "issued"
+            raise AttemptErrors::EvidenceUnavailable, "Original outside-unit actor issuance differs"
+          end
+          true
+        end
+
+        def authenticated_prompt_completions!(events, intent, original, journal)
+          external_id = intent.fetch("payload").fetch("external_mutation_id")
+          events.select { |event| %w[prompt_outcome prompt_completion_observed].include?(event["type"]) &&
+            event.dig("payload", "intent_event_id") == intent.fetch("digest") }.select do |event|
+              payload = event.fetch("payload")
+              evidence = payload.fetch("evidence")
+              journal.send(:validate_prompt_evidence!, evidence, original.fetch("origin"))
+              expected_operation = event["type"] == "prompt_outcome" ? "prompt_attempt" : "prompt_observation"
+              expected_id = expected_operation == "prompt_attempt" ? external_id : "prompt-observe.#{intent.fetch('digest')}"
+              acceptance = events.find { |entry| entry["type"] == "authority_mutation" && entry["previous_digest"] == event["digest"] &&
+                entry.dig("payload", "operation") == expected_operation && entry.dig("payload", "mutation_id") == expected_id }
+              unless payload["external_mutation_id"] == external_id && payload["binding_digest"] == intent.dig("payload", "binding_digest") &&
+                  acceptance && acceptance.dig("payload", "data", "outcome") == evidence.fetch("outcome") &&
+                  acceptance.dig("payload", "data", "guarded_evidence") == evidence
+                raise AttemptErrors::EvidenceUnavailable, "Prompt native completion acceptance differs"
+              end
+              %w[submitted not_issued].include?(evidence.fetch("outcome"))
+          end
+        rescue KeyError, TypeError, ArgumentError
+          raise AttemptErrors::EvidenceUnavailable, "Prompt completion history is malformed"
+        end
+
+        # Authentication binds the whole accepted original record, including
+        # its native guard. A plain process-binding digest cannot substitute.
+        def original_prompt_record!(events, state, params:)
+          Molecules::OriginalLaunchBinding.verify!(events: events, state: state, params: params)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+require_relative "../organisms/attempt_coordinator"
+
+module Ace
+  module Assign
+    module Authority
+      class LaunchLifecycle
+        # The stop mutation owns its seal and immutable reply. Input inhibition
+        # waits outside exclusions; manager stop runs after CAS outside @mutex,
+        # retaining the existing containment slot guard.
+        def stop_attempt!(request:, peer:, role:)
+          params = request.fetch("params")
+          strict!(params, %w[mapping_id assignment_id attempt_id expected_generation])
+          %w[assignment_id attempt_id].each { |key| token!(params.fetch(key)) }
+          token!(request.fetch("mutation_id"))
+          generation!(params.fetch("expected_generation"))
+          map = steering_principal!(params, peer, role)
+          journal = journal_for(map)
+          principal = peer.slice("uid", "gid", "groups").merge("role" => role.to_s)
+          digest = Digest::SHA256.hexdigest(JSON.generate(canonical(params.merge("caller" => principal))))
+          closure = nil
+          pending_action = pending_commit = nil
+          prepared = with_containment_exclusion(params, map, journal) do
+            @mutex.synchronize do
+              commit = journal.ref_value
+              events = stop_events!(journal, params, commit)
+              replay = journal.mutation_result(request.fetch("mutation_id"), commit: commit)
+              if replay
+                unless replay.values_at("operation", "parameters_digest", "assignment_id", "attempt_id") ==
+                    ["stop_attempt", digest, params.fetch("assignment_id"), params.fetch("attempt_id")]
+                  raise AttemptErrors::Conflict, "Mutation ID is already bound to different stop input"
+                end
+                if events.any? { |event| event["type"] == "attempt_stopped" }
+                  terminal_scope_stopped!(events, journal, commit, deployment: @deployment)
+                elsif %w[succeeded failed].include?(journal.canonical_attempt_state(events))
+                  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"))
+                  terminal_scope_receipt!(events, lineage, journal, commit)
+                else
+                  stop_owner!(params, map, events)
+                end
+                next({data: replay.fetch("data").merge("journal_commit" => replay.fetch("journal_commit")), replayed: true})
+              end
+              lineage = stop_owner!(params, map, events)
+              if lineage.proof_event && !pending_prompt_issuers?(events, journal, commit)
+                scope_observer_for(params.fetch("mapping_id")).verify_closed!(lineage)
+                raise AttemptErrors::EvidenceUnavailable, "Settlement owner is unavailable" unless @result_owner
+                begin
+                  @result_owner.service_settlement_evidence!(journal: journal, events: events, params: params, map: map, commit: commit)
+                rescue AttemptErrors::EvidenceUnavailable => error
+                  raise unless authenticated_stop_pending_action(error) == "settle_services"
+                  pending_action, pending_commit = "settle_services", commit
+                end
+                next nil
+              end
+              journal.mutate(assignment_id: params.fetch("assignment_id"), attempt_id: params.fetch("attempt_id"),
+                mutation_id: request.fetch("mutation_id"), operation: "stop_attempt", parameters_digest: digest,
+                expected_generation: params.fetch("expected_generation"), with_replay: true) do |current, old, _generation|
+                lineage = stop_owner!(params, map, current)
+                closure = scope_closure_plan!(lineage: lineage, params: params, map: map, events: current, journal: journal, commit: old)
+                plan = closure.fetch(:plan)
+                plan.merge(data: stop_pending_reply(params, plan.fetch(:data)["proof_id"], "reconcile_scope"))
+              end
+            end
+          end
+          if prepared
+            unless prepared.fetch(:replayed)
+              request_original_input_inhibition!(params, map, journal) if closure&.fetch(:inhibit_required)
+              if closure&.fetch(:stop_required)
+                with_containment_exclusion(params, map, journal) do
+                  @mutex.synchronize { stop_owner!(params, map, stop_events!(journal, params, journal.ref_value)) }
+                  scope_observer_for(params.fetch("mapping_id")).stop_sealed_service!
+                end
+              end
+            end
+            return prepared
+          end
+          if pending_action
+            return record_pending_stop!(request, map, journal, digest, pending_action, pending_commit)
+          end
+          final_selection = journal.ref_value
+          begin
+            finalize_stopped_attempt!(request, peer, role, map, journal, digest)
+          rescue AttemptErrors::EvidenceUnavailable => error
+            action = authenticated_stop_pending_action(error)
+            raise unless action
+            record_pending_stop!(request, map, journal, digest, action, final_selection)
+          end
+        end
+
+        private
+
+        def stop_events!(journal, params, commit)
+          journal.read_events(params.fetch("assignment_id"), commit: commit).select { |event| event["attempt_id"] == params.fetch("attempt_id") }
+        end
+
+        def stop_owner!(params, map, events)
+          state = origin(events, **params.slice("assignment_id", "attempt_id", "mapping_id").transform_keys(&:to_sym))
+          original_prompt_record!(events, state, params: params) if issued_input_actor?(events)
+          canonical_state = Molecules::CanonicalAttemptState.derive(events)
+          unless %w[running uncertain].include?(canonical_state)
+            raise AttemptErrors::Conflict, "Attempt is not eligible for proof-authenticated stop"
+          end
+          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"))
+        end
+
+        def stop_pending_reply(params, proof_id, action)
+          {"attempt_id" => params.fetch("attempt_id"), "state" => "uncertain", "proof_id" => proof_id, "required_action" => action}
+        end
+
+        # Only positively authenticated owner-pending subclasses have public
+        # recovery actions. Missing/corrupt evidence and auth failures propagate.
+        def authenticated_stop_pending_action(error)
+          if error.is_a?(AttemptErrors::ServiceSettlementPending)
+            return "settle_services"
+          end
+          nil
+        end
+
+        def record_pending_stop!(request, map, journal, digest, action, selected_commit)
+          params = request.fetch("params")
+          with_containment_exclusion(params, map, journal) do
+            @mutex.synchronize do
+              journal.mutate(assignment_id: params.fetch("assignment_id"), attempt_id: params.fetch("attempt_id"),
+                mutation_id: request.fetch("mutation_id"), operation: "stop_attempt", parameters_digest: digest,
+                expected_generation: params.fetch("expected_generation"), with_replay: true) do |events, commit, _generation|
+                unless commit == selected_commit
+                  raise AttemptErrors::Conflict, "Authenticated pending settlement prefix advanced"
+                end
+                lineage = stop_owner!(params, map, events)
+                unless lineage.proof_event && !pending_prompt_issuers?(events, journal, commit)
+                  raise AttemptErrors::EvidenceUnavailable, "Original scope closure proof is unavailable"
+                end
+                scope_observer_for(params.fetch("mapping_id")).verify_closed!(lineage)
+                {events: [], blobs: {}, data: stop_pending_reply(params, lineage.proof_id, action)}
+              end
+            end
+          end
+        end
+
+        def finalize_stopped_attempt!(request, peer, role, map, journal, digest)
+          params = request.fetch("params")
+          with_exclusion(params, map, journal) do
+            @mutex.synchronize do
+              journal.mutate(assignment_id: params.fetch("assignment_id"), attempt_id: params.fetch("attempt_id"),
+                mutation_id: request.fetch("mutation_id"), operation: "stop_attempt", parameters_digest: digest,
+                expected_generation: params.fetch("expected_generation"), with_replay: true) do |events, commit, _generation|
+                steering_principal!(params, peer, role)
+                lineage = stop_owner!(params, map, events)
+                unless lineage.proof_event && !pending_prompt_issuers?(events, journal, commit)
+                  raise AttemptErrors::EvidenceUnavailable, "Original scope closure proof is unavailable"
+                end
+                scope_observer_for(params.fetch("mapping_id")).verify_closed!(lineage)
+                raise AttemptErrors::EvidenceUnavailable, "Settlement owner is unavailable" unless @result_owner
+                services = @result_owner.service_settlement_evidence!(journal: journal, events: events, params: params, map: map, commit: commit)
+
+                provisioning = events.select { |event| event["type"] == "scope_provisioning" }
+                raise AttemptErrors::EvidenceUnavailable, "Original deployment provenance is ambiguous" unless provisioning.one?
+                selection = params.slice("mapping_id", "assignment_id", "attempt_id").merge("project_id" => map.fetch("project_id"),
+                  "descriptor_sha256" => provisioning.first.fetch("payload").fetch("descriptor_sha256"),
+                  "scope_binding_event_id" => lineage.binding_event.fetch("digest"), "seal_event_id" => lineage.seal_event.fetch("digest"),
+                  "closed_proof_event_id" => lineage.proof_id)
+                plan = Organisms::AttemptCoordinator.stopped_transition_plan(events: events, selection: selection,
+                  service_evidence: services, commit: commit)
+                plan.merge(data: {"attempt_id" => params.fetch("attempt_id"), "state" => "stopped", "proof_id" => lineage.proof_id, "required_action" => nil})
+              end
+            end
+          end
+        end
+
+        # Historical terminal authentication uses the original immutable
+        # descriptor and the actual introduction prefix, not today's pointer.
+        def terminal_scope_stopped!(events, journal, commit, deployment:)
+          terminal = events.select { |event| event["type"] == "attempt_stopped" }
+          raise AttemptErrors::EvidenceUnavailable, "Stopped terminal is missing or ambiguous" unless terminal.one?
+          event = terminal.first
+          acceptance = events.find { |entry| entry["type"] == "authority_mutation" && entry["previous_digest"] == event.fetch("digest") }
+          raise AttemptErrors::EvidenceUnavailable, "Stopped terminal acceptance is missing" unless acceptance
+          assignment_id = event.fetch("payload").fetch("assignment_id")
+          prefix_commit = terminal_event_commit!(journal, assignment_id: assignment_id, event_digest: acceptance.fetch("digest"), commit: commit)
+          verify_stopped_terminal_at_prefix!(events, journal, prefix_commit, deployment: deployment)
+        rescue KeyError, TypeError, NoMethodError
+          raise AttemptErrors::EvidenceUnavailable, "Stopped original terminal evidence is malformed"
+        end
+
+        # Source composition supplies only an introduction authenticated by the
+        # canonical Git owner. This immutable verifier grants no live exclusion.
+        def verify_stopped_terminal_at_prefix!(events, journal, prefix_commit, deployment:)
+          terminals = events.select { |entry| entry["type"] == "attempt_stopped" }
+          raise AttemptErrors::EvidenceUnavailable, "Stopped terminal is missing or ambiguous" unless terminals.one?
+          event = terminals.first
+          accepted = events.select { |entry| entry["type"] == "authority_mutation" && entry["previous_digest"] == event.fetch("digest") }
+          raise AttemptErrors::EvidenceUnavailable, "Stopped terminal acceptance is missing or ambiguous" unless accepted.one?
+          acceptance = accepted.first
+          assignment_id = event.fetch("payload").fetch("assignment_id")
+          prefix = journal.read_events(assignment_id, commit: prefix_commit).select { |entry| entry["attempt_id"] == event.fetch("attempt_id") }
+          unless prefix == events.take(events.index(acceptance) + 1) && Molecules::CanonicalAttemptState.derive(prefix) == "stopped"
+            raise AttemptErrors::EvidenceUnavailable, "Stopped terminal introduction prefix differs"
+          end
+          payload = event.fetch("payload")
+          descriptor = if deployment.artifact_reference&.fetch("sha256") == payload.fetch("descriptor_sha256")
+            deployment
+          else
+            raise AttemptErrors::EvidenceUnavailable, "Original stopped descriptor history is unavailable" unless @deployment_history
+            @deployment_history.descriptor!(sha256: payload.fetch("descriptor_sha256"))
+          end
+          map = descriptor.mapping(payload.fetch("mapping_id"))
+          unless map.fetch("project_id") == payload.fetch("project_id")
+            raise AttemptErrors::EvidenceUnavailable, "Original stopped project differs"
+          end
+          provisioning = prefix.select { |entry| entry["type"] == "scope_provisioning" }
+          reservation = prefix.select { |entry| entry["type"] == "authority_mutation" && entry.dig("payload", "operation") == "reserve_attempt" }
+          unless provisioning.one? && reservation.one?
+            raise AttemptErrors::EvidenceUnavailable, "Original stopped reservation is ambiguous"
+          end
+          identity = provisioning.first.fetch("payload")
+          reservation_data = reservation.first.dig("payload", "data")
+          unless identity.is_a?(Hash) && identity.keys.sort == %w[deployment_digest descriptor_sha256 reservation_generation slot_id] &&
+              reservation_data.is_a?(Hash) && identity["reservation_generation"] == reservation_data["reservation_generation"] &&
+              reservation_data.values_at("mapping_id", "project_id") == payload.values_at("mapping_id", "project_id") &&
+              Digest::SHA256.hexdigest(JSON.generate(canonical(map))) == identity.fetch("deployment_digest") &&
+              map.fetch("execution_scope").fetch("slot_id") == identity.fetch("slot_id") &&
+              descriptor.project(map.fetch("project_id")).values_at("journal_repository", "evidence_git_ref", "evidence_checkout_root") ==
+                [journal.repo_root, journal.ref, journal.checkout_root]
+            raise AttemptErrors::EvidenceUnavailable, "Original stopped descriptor canonical association differs"
+          end
+          params = payload.slice("mapping_id", "assignment_id", "attempt_id")
+          lineage = Molecules::ExecutionScopeLineage.new(events: prefix, **payload.slice("project_id", "assignment_id", "attempt_id", "mapping_id").transform_keys(&:to_sym))
+          unless lineage.binding.fetch("deployment_digest") == identity.fetch("deployment_digest")
+            raise AttemptErrors::EvidenceUnavailable, "Original stopped parent mapping differs"
+          end
+          verify_historical_boot_baseline!(lineage.binding)
+          lineage.require_positive!(scope_generation: lineage.binding.fetch("scope_generation"),
+            scope_binding_event_id: payload.fetch("scope_binding_event_id"), seal_event_id: payload.fetch("seal_event_id"), proof_id: payload.fetch("closed_proof_event_id"))
+          if issued_input_actor?(prefix) && !accepted_input_inhibition?(prefix, journal, prefix_commit)
+            raise AttemptErrors::EvidenceUnavailable, "Stopped original input lifetime is not inhibited"
+          end
+          raise AttemptErrors::EvidenceUnavailable, "Original stopped settlement owner is unavailable" unless @result_owner
+          services = @result_owner.service_settlement_evidence!(journal: journal, events: prefix, params: params, map: map, commit: prefix_commit)
+
+          expected = Molecules::CanonicalAttemptState.stopped_payload!(events: prefix,
+            selection: payload.slice(*Molecules::CanonicalAttemptState::SELECTION_FIELDS), service_evidence: services,
+            commit: prefix_commit)
+          raise AttemptErrors::EvidenceUnavailable, "Stopped exhaustive settlement differs" unless payload == expected
+          event
+        rescue KeyError, TypeError, NoMethodError
+          raise AttemptErrors::EvidenceUnavailable, "Stopped original terminal evidence is malformed"
+        end
+      end
+    end
+  end
+end