ace-assign 0.63.1 → 0.64.0

data/lib/ace/assign/molecules/proposal_journal.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Ace
+  module Assign
+    module Molecules
+      # A decision projection of the existing qjl event chain. No effect
+      # executor, extra ref, file registry, or claim ledger lives here.
+      module ProposalJournal
+        PROPOSAL_REFERENCE = /\Aproposal-[0-9a-f]{24}-r[1-9][0-9]*\z/
+        PROPOSAL_BINDING = %w[operation project_id assignment_id attempt_id input_digest target candidate_head caller_uid].freeze
+
+        PROPOSAL_IMMUTABLE = (PROPOSAL_BINDING + %w[schema proposal_id revision revision_id request_id requester content_digest created_at authorization context options recommendation rationale prerequisites lifecycle_request revision_operation_id expected_source_revision]).freeze
+
+        def proposal_history(id)
+          assignment_ids.flat_map do |assignment|
+            events = read_events(assignment)
+            events.group_by { |event| event["attempt_id"] }.each_value do |chain|
+              unless Models::EvidenceEvent.chain_valid?(chain)
+                raise AttemptErrors::EvidenceUnavailable, "Proposal evidence chain is corrupt"
+              end
+            end
+            events.select { |event| event["type"] == "proposal_state" && event.dig("payload", "record", "proposal_id") == id }
+              .map { |event| event.fetch("payload").fetch("record") }
+          end
+        end
+
+        def proposal_record(id)
+          proposal_history(id).last
+        end
+
+        def proposals
+          assignment_ids.flat_map do |assignment|
+            read_events(assignment).select { |event| event["type"] == "proposal_state" }
+              .map { |event| event.dig("payload", "record", "proposal_id") }
+          end.uniq.map { |id| proposal_record(id) }
+        end
+
+        def proposal_operation_record(operation_id)
+          proposals.each do |record|
+            found = proposal_history(record["proposal_id"]).reverse.find do |entry|
+              entry["revision_operation_id"] == operation_id
+            end
+            return found if found
+          end
+          nil
+        end
+
+        # Admitted HITL policy runs this block while the same canonical
+        # mutation lock/CAS boundary excludes service claims and other replies.
+        def change_proposal(id, assignment_id:, attempt_id:, &policy)
+          3.times do
+            events = read_events(assignment_id).select { |event| event["attempt_id"] == attempt_id }
+            generation = events.count { |event| event["type"] == "authority_mutation" }
+            begin
+              return mutate(assignment_id: assignment_id, attempt_id: attempt_id,
+                mutation_id: "proposal-#{SecureRandom.hex(16)}", operation: "proposal-decision",
+                parameters_digest: Digest::SHA256.hexdigest(id), expected_generation: generation) do |current, _commit, _generation|
+                record = current.reverse.find do |event|
+                  event["type"] == "proposal_state" && event.dig("payload", "record", "proposal_id") == id
+                end&.dig("payload", "record")
+                global = proposal_record(id)
+                if global && (global["assignment_id"] != assignment_id || global["attempt_id"] != attempt_id)
+                  raise AttemptErrors::ReceiptRejected, "Proposal identity belongs to another assignment or attempt"
+                end
+                updated = policy.call(record)
+                return record if updated == record
+                unless updated.is_a?(Hash) && updated["proposal_id"] == id &&
+                    updated["assignment_id"] == assignment_id && updated["attempt_id"] == attempt_id
+                  raise AttemptErrors::ReceiptRejected, "Proposal policy changed immutable ownership"
+                end
+                validate_proposal_revision!(record, updated)
+                entries = []
+                if record && record["revision_id"] != updated["revision_id"]
+                  entries << {type: "proposal_state", payload: {"record" => record.merge("state" => "superseded", "resolution" => "revised")}}
+                end
+                if record.nil? || record["revision_id"] != updated["revision_id"]
+                  entries << {type: "proposal_state", payload: {"record" => updated.merge("state" => "proposed")}}
+                end
+                entries << {type: "proposal_state", payload: {"record" => updated}}
+                {events: entries, data: {"record" => updated}}
+              end.fetch("record")
+            rescue AttemptErrors::Conflict => e
+              raise unless e.message == "Authority registration generation changed"
+            end
+          end
+          raise AttemptErrors::EvidenceUnavailable, "Proposal generation stayed conflicting"
+        end
+
+        def validate_proposal_revision!(previous, updated)
+          if previous && previous["revision_id"] == updated["revision_id"]
+            unless PROPOSAL_IMMUTABLE.all? { |field| previous[field] == updated[field] }
+              raise AttemptErrors::ReceiptRejected, "Proposal revision content is immutable"
+            end
+            return
+          end
+          expected = previous ? previous.fetch("revision") + 1 : 1
+          reference = "#{updated.fetch("proposal_id")}-r#{expected}"
+          valid = updated["revision"] == expected && updated["revision_id"] == reference &&
+            updated["request_id"] == reference && updated["authorization"] == reference &&
+            updated["state"] == "awaiting-delivery" && PROPOSAL_REFERENCE.match?(reference)
+          if previous
+            valid &&= updated["expected_source_revision"] == previous["revision"] &&
+              updated["revision_operation_id"].is_a?(String) &&
+              updated["revision_operation_id"].match?(/\Arevision-[0-9a-f]{24}\z/) &&
+              proposal_operation_record(updated["revision_operation_id"]).nil? &&
+              %w[assignment_id attempt_id project_id requester caller_uid].all? { |field| previous[field] == updated[field] }
+          else
+            valid &&= updated["revision_operation_id"].nil? && updated["expected_source_revision"].nil?
+          end
+          unresolved = previous && proposal_claims(previous["revision_id"]).any? do |claim|
+            claim["state"] != "succeeded" &&
+              !(claim["state"] == "failed-settled" && settlement_evidence_intact?(claim))
+          end
+          raise AttemptErrors::ReceiptRejected, "Claimed proposal cannot be revised; reconcile the existing effect" if unresolved
+          raise AttemptErrors::ReceiptRejected, "Proposal revision must begin with exact immutable delivery scope" unless valid
+        end
+        private :validate_proposal_revision!
+
+        def proposal_claims(reference)
+          service_request_records.select do |request|
+            request["authorization"] == reference &&
+              !(request["state"] == "rejected" && request["consumed"] == false)
+          end
+        end
+
+        def proposal_authorize!(reference, binding)
+          unless reference.is_a?(String) && PROPOSAL_REFERENCE.match?(reference)
+            raise AttemptErrors::ReceiptRejected, "Invalid proposal authorization reference"
+          end
+          id = reference.sub(/-r[1-9][0-9]*\z/, "")
+          record = proposal_record(id)
+          unless record && record["revision_id"] == reference &&
+              record["stop_requested"] != true &&
+              %w[approved-explicitly approved-by-silence].include?(record["state"]) &&
+              PROPOSAL_BINDING.all? { |field| record[field] == binding[field] }
+            raise AttemptErrors::ReceiptRejected, "Proposal is not authorized for this exact effect"
+          end
+          attempt = derived_attempts(binding.fetch("assignment_id")).find do |candidate|
+            candidate.attempt_id == binding.fetch("attempt_id")
+          end
+          unless attempt && attempt.state == "running"
+            raise AttemptErrors::ReceiptRejected, "Proposal effect needs an authoritative bound running attempt"
+          end
+          record
+        end
+      end
+    end
+  end
+end

data/lib/ace/assign/molecules/receipt_verifier.rb

@@ -22,8 +22,14 @@ module Ace
         APPROVED_VERDICT = "approved"
 
         # @param identity_resolver [ExecutionIdentityResolver] Trust boundary
-        def initialize(identity_resolver: nil)
+        # @param artifact_reader [#call, nil] Source-owned canonical byte
+        #   reader for protected composition; nil selects explicit local files
+        def initialize(identity_resolver: nil, artifact_reader: nil)
           @identity_resolver = identity_resolver || ExecutionIdentityResolver.new
+          unless artifact_reader.nil? || artifact_reader.respond_to?(:call)
+            raise ArgumentError, "artifact reader must be a source-owned callable"
+          end
+          @artifact_reader = artifact_reader
         end
 
         # Validate a submitted receipt against an attempt.
@@ -36,6 +42,18 @@ module Ace
         # @return [Models::ExecutionReceipt] Normalized receipt with digest
         # @raise [AttemptErrors::ReceiptRejected] on any validation failure
         def verify!(data, attempt:, identity:, live_head:, repo_root:)
+          verify_receipt!(data, attempt: attempt, live_head: live_head, repo_root: repo_root) do
+            verify_authority(data, identity)
+          end
+        end
+
+        # Submission validates evidence without granting terminal acceptance.
+        # The authenticated owner separately checks the exact worker attribution.
+        def verify_result!(data, attempt:, live_head:, repo_root:)
+          verify_receipt!(data, attempt: attempt, live_head: live_head, repo_root: repo_root)
+        end
+
+        def verify_receipt!(data, attempt:, live_head:, repo_root:)
           reject_unless(data.is_a?(Hash), "receipt must be a JSON object")
 
           if Models::ExecutionReceipt.forbidden_field?(data)
@@ -51,7 +69,7 @@ module Ace
 
           verify_binding(data, attempt)
           verify_producer(data)
-          verify_authority(data, identity)
+          yield if block_given?
           verify_head(data, live_head)
           verify_artifacts(data, repo_root) if data["verdict"] == "succeeded"
           verify_checks(data)
@@ -63,18 +81,22 @@ module Ace
 
           receipt
         end
+        private :verify_receipt!
+
         # Recheck the source artifacts/checks of an already accepted receipt.
-        # Historical reads (recorded at a past head) validate acceptance from
+        # Local historical reads (recorded at a past head) validate acceptance from
         # the append-only journal without re-hashing artifacts: the review
         # lifecycle legitimately archives and annotates finding files after
         # collection, and `.ace-local` working files are disposable, so their
         # current existence proves nothing about an accepted past receipt.
-        # Current-head reads keep full artifact re-verification.
+        # Current-head reads keep full artifact re-verification. Protected
+        # readers always reverify imported bytes, including historical reads.
         def verify_accepted_evidence!(data, live_head:, repo_root:, historical: false)
           verify_head(data, live_head)
-          verify_artifacts(data, repo_root) unless historical
+          verify_artifacts(data, repo_root) if @artifact_reader || !historical
           verify_checks(data)
           verify_review(data)
+          verify_campaign(data, repo_root: repo_root, live_head: live_head) if @artifact_reader
         end
 
         # @param operation [String] Receipt operation
@@ -147,17 +169,7 @@ module Ace
             recorded = artifact["sha256"].to_s
             reject("artifact missing path or sha256") if path.empty? || recorded.empty?
 
-            expanded = begin
-              File.expand_path(path, File.realpath(repo_root))
-            rescue Errno::ENOENT, Errno::EACCES
-              nil
-            end
-            reject("artifact file not found: #{path}") if expanded.nil? || !File.exist?(expanded)
-
-            resolved = safe_resolve(repo_root, path)
-            reject("artifact path escapes project root: #{path}") if resolved.nil?
-
-            actual = Digest::SHA256.hexdigest(File.read(resolved))
+            actual = Digest::SHA256.hexdigest(artifact_bytes(data, artifact, repo_root))
             reject("artifact digest mismatch for #{path}") unless actual == recorded
           end
         end
@@ -225,9 +237,7 @@ module Ace
           unless Array(data["artifacts"]).include?(reference)
             reject("campaign result must be included in verified receipt artifacts")
           end
-          resolved = safe_resolve(repo_root, reference["path"].to_s)
-          reject("campaign result path escapes repository or is missing") unless resolved
-          result = JSON.parse(File.read(resolved))
+          result = JSON.parse(artifact_bytes(data, reference, repo_root))
           reject_unless(result.is_a?(Hash), "campaign result must be an object")
           require "ace/review"
           current = Ace::Review::Organisms::CampaignManager.new(repo_root: repo_root).status(campaign["id"])
@@ -247,6 +257,26 @@ module Ace
           reject("invalid campaign result: #{e.message}")
         end
 
+        # Protected composition injects the canonical imported-byte owner.
+        # Its failure never falls through to the disposable workspace copy.
+        def artifact_bytes(data, artifact, repo_root)
+          if @artifact_reader
+            bytes = @artifact_reader.call(data, artifact)
+            reject("canonical artifact reader did not return bytes") unless bytes.is_a?(String)
+            return bytes.b
+          end
+          path = artifact["path"].to_s
+          expanded = begin
+            File.expand_path(path, File.realpath(repo_root))
+          rescue Errno::ENOENT, Errno::EACCES
+            nil
+          end
+          reject("artifact file not found: #{path}") if expanded.nil? || !File.exist?(expanded)
+          resolved = safe_resolve(repo_root, path)
+          reject("artifact path escapes project root: #{path}") if resolved.nil?
+          File.read(resolved)
+        end
+
         # Resolve a project-relative artifact path to its real location,
         # rejecting traversal and symlink escapes (an in-repo symlink must
         # not smuggle in an external file); returns nil when the path leaves

data/lib/ace/assign/organisms/assignment_executor.rb

@@ -68,6 +68,12 @@ module Ace
 
           assignment_config = config["assignment"] || {}
           steps_config = config["steps"] || []
+          if config.key?("delivery")
+            Atoms::DeliveryParameters.validate(config["delivery"])
+            unless Array(steps_config).any? { |step| %w[create-pr update-pr-desc mark-pr-ready].include?(step["name"]) }
+              raise ArgumentError, "Explicit delivery inputs require remote steps"
+            end
+          end
 
           raise Error, "No steps defined in config" if steps_config.empty?