ace-assign 0.63.1 → 0.66.0

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

@@ -5,6 +5,8 @@ require "fileutils"
 require "json"
 require "open3"
 require "time"
+require "securerandom"
+require_relative "../atoms/evidence_digest"
 
 module Ace
   module Assign
@@ -25,6 +27,95 @@ module Ace
       # present. Legitimate fresh provisioning (a new worktree for a task)
       # clears the marker explicitly via `reset_removed`.
       class LifecycleExclusion
+        autoload :ControlExclusion, File.expand_path("protected_control_exclusion", __dir__)
+
+        def self.control_exclusion(authority:, project_id:, descriptor_sha256:, root_identity: nil, **boundaries)
+          ControlExclusion.new(authority: authority, project_id: project_id,
+            descriptor_sha256: descriptor_sha256, root_identity: root_identity, **boundaries)
+        end
+
+        autoload :WorkspaceNativeReader, File.expand_path("protected_workspace_exclusion", __dir__)
+        autoload :WorkspaceReader, File.expand_path("protected_workspace_exclusion", __dir__)
+
+        autoload :WorkspaceWriter, File.expand_path("protected_workspace_exclusion", __dir__)
+
+        autoload :WorkspaceFenceReader, File.expand_path("protected_workspace_exclusion", __dir__)
+
+        def self.workspace_fence_reader(projection:, protection: nil, files: File)
+          WorkspaceFenceReader.new(projection: projection, protection: protection, files: files)
+        end
+
+        def self.workspace_writer(projection:, protection: nil, files: File)
+          WorkspaceWriter.new(projection: projection, protection: protection, files: files)
+        end
+
+        autoload :WorkspaceProvisioner, File.expand_path("protected_workspace_provisioner", __dir__)
+
+        def self.provision_workspace!(mapping_id:, project_id:, authority:, cwd_resource:, **boundaries)
+          WorkspaceProvisioner.new(mapping_id: mapping_id, project_id: project_id,
+            authority: authority, cwd_resource: cwd_resource, **boundaries).provision!
+        end
+
+        def self.workspace_reader(projection:, protection: nil, files: File)
+          WorkspaceReader.new(projection: projection, protection: protection, files: files)
+        end
+
+        def self.workspace_selection(mapping_id:, project_id:, authority:, cwd_resource:)
+          fields = %w[device filesystem_type gid host_path inode mount_id uid view_path]
+          unless authority.is_a?(Hash) && cwd_resource.is_a?(Hash) && cwd_resource.keys.sort == fields &&
+              %w[device gid inode uid].all? { |field| cwd_resource[field].is_a?(Integer) && cwd_resource[field] >= 0 } &&
+              cwd_resource["mount_id"].is_a?(Integer) && cwd_resource["mount_id"].positive? &&
+              %w[host_path view_path].all? { |field| cwd_resource[field].is_a?(String) &&
+                cwd_resource[field].valid_encoding? && cwd_resource[field].bytesize.between?(1, 4096) &&
+                !cwd_resource[field].include?("\0") && cwd_resource[field].start_with?("/") &&
+                File.expand_path(cwd_resource[field]) == cwd_resource[field] } &&
+              %w[ext4 xfs btrfs tmpfs].include?(cwd_resource["filesystem_type"]) &&
+              [mapping_id, project_id].all? { |value| value.is_a?(String) && value.match?(/\A[A-Za-z0-9][A-Za-z0-9._-]{0,127}\z/) } &&
+              %w[uid gid].all? { |field| authority[field].is_a?(Integer) && authority[field].positive? } &&
+              authority["state_root"].is_a?(String) && authority["state_root"].valid_encoding? &&
+              authority["state_root"].bytesize.between?(1, 4096) && !authority["state_root"].include?("\0") &&
+              authority["state_root"].start_with?("/") &&
+              File.expand_path(authority["state_root"]) == authority["state_root"]
+            raise AttemptErrors::EvidenceUnavailable, "Original lifecycle workspace selection is malformed"
+          end
+          digest = Atoms::EvidenceDigest.digest(cwd_resource)
+          selection = {"key" => "workspace:#{mapping_id}:#{digest}",
+            "host_path" => File.join(authority.fetch("state_root"), "lifecycle-exclusion", project_id,
+              "workspaces", mapping_id, digest), "view_path" => "/run/ace/lifecycle-exclusion/#{mapping_id}"}
+          unless selection.fetch("host_path").bytesize <= 4096
+            raise AttemptErrors::EvidenceUnavailable, "Original lifecycle workspace path is oversized"
+          end
+          selection.each_value(&:freeze)
+          selection.freeze
+        end
+
+        def self.workspace_initial_marker(key:)
+          unless key.is_a?(String) && key.match?(/\Aworkspace:[A-Za-z0-9][A-Za-z0-9._-]{0,127}:[0-9a-f]{64}\z/)
+            raise AttemptErrors::EvidenceUnavailable, "Original lifecycle workspace key is malformed"
+          end
+          Atoms::EvidenceDigest.canonical_json({"key" => key, "removed" => false, "removed_at" => nil}).freeze
+        end
+
+        def self.workspace_marker!(bytes:, key:)
+          unless bytes.is_a?(String) && bytes.bytesize.between?(1, 8192)
+            raise AttemptErrors::EvidenceUnavailable, "Lifecycle marker bytes differ"
+          end
+          bytes = bytes.dup.force_encoding(Encoding::UTF_8)
+          unless bytes.valid_encoding?
+            raise AttemptErrors::EvidenceUnavailable, "Lifecycle marker is not bounded UTF8"
+          end
+          state = JSON.parse(bytes, create_additions: false, max_nesting: 4, allow_duplicate_key: false)
+          unless state.is_a?(Hash) && state.keys.sort == %w[key removed removed_at] && state.fetch("key") == key &&
+              (state.values_at("removed", "removed_at") == [false, nil] || state["removed"] == true &&
+                state["removed_at"].is_a?(String) && Time.iso8601(state["removed_at"]).utc.iso8601 == state["removed_at"])
+            raise AttemptErrors::EvidenceUnavailable, "Lifecycle marker schema differs"
+          end
+          state.each_value { |value| value.freeze }
+          state.freeze
+        rescue JSON::ParserError, ArgumentError, KeyError
+          raise AttemptErrors::EvidenceUnavailable, "Lifecycle marker schema differs"
+        end
+
         # @param repo_root [String, nil] Repository used to resolve the
         #   shared Git common dir (default: project root)
         # @param root [String, nil] Explicit exclusion root (tests)
@@ -33,27 +124,27 @@ module Ace
         end
 
         # The exclusion root shared by every writer and prune for this repo.
-        # Sandboxed environments (CACHE_BASE) scope it under the cache base,
-        # which itself is never a deletion target; otherwise it lives under
-        # the shared Git common dir, which survives worktree removal.
-        def self.default_root(_repo_root = nil)
-          cache_base = ENV["CACHE_BASE"]
-          if cache_base && !cache_base.empty?
-            return File.join(File.expand_path(cache_base), ".exclusion")
-          end
-
-          repo_root = Ace::Support::Fs::Molecules::ProjectRootFinder.find_or_current
+        # Assignment cache configuration does not select this repository
+        # identity. The Git common dir survives linked worktree removal.
+        def self.default_root(repo_root = nil)
+          repo_root ||= Ace::Support::Fs::Molecules::ProjectRootFinder.find_or_current
           common_dir, _stderr, status = Open3.capture3(
             "git", "-C", repo_root, "rev-parse", "--path-format=absolute", "--git-common-dir"
           )
-          base = status.success? && !common_dir.to_s.strip.empty? ? common_dir.strip : File.join(repo_root, ".git")
-          File.join(base, "ace", "lifecycle-exclusion")
+          unless status.success? && !common_dir.to_s.strip.empty? && File.absolute_path(common_dir.strip) == common_dir.strip
+            raise AttemptErrors::Conflict, "Repository lifecycle root is unavailable"
+          end
+          File.join(common_dir.strip, "ace", "lifecycle-exclusion")
         end
 
         def assignment_key(assignment_id)
           "assignment:#{assignment_id}"
         end
 
+        def slot_key(slot_id)
+          "execution-slot:#{slot_id}"
+        end
+
         # Task identity is the canonical worktree identity: work-on derives
         # the worktree path from the task ref, and prune candidates carry
         # the same task id.
@@ -75,12 +166,17 @@ module Ace
         #
         # @param key [String] Identity key
         # @yield Required block executed under exclusive exclusion
-        def with_exclusive(key)
+        def with_exclusive(key, deadline: nil)
           raise ArgumentError, "exclusion key is required" if key.to_s.empty?
 
-          lock = open_lock(key)
-          lock.flock(File::LOCK_EX)
+          maintenance_deadline!(deadline) unless deadline.nil?
+          lock = open_lock(key, nonblock: !deadline.nil?)
           begin
+            mode = File::LOCK_EX | (deadline ? File::LOCK_NB : 0)
+            unless lock.flock(mode)
+              raise AttemptErrors::MaintenanceBusy, "maintenance exclusion is busy"
+            end
+            maintenance_deadline!(deadline) unless deadline.nil?
             yield
           ensure
             lock.flock(File::LOCK_UN)
@@ -122,8 +218,9 @@ module Ace
           ordered = Array(keys).compact.reject { |key| key.to_s.empty? }.uniq
           raise ArgumentError, "exclusion keys are required" if ordered.empty?
 
-          locks = ordered.map { |key| open_lock(key) }
+          locks = []
           begin
+            ordered.each { |key| locks << open_lock(key) }
             locks.each { |lock| lock.flock(File::LOCK_SH) }
             ordered.each do |key|
               if removed?(key)
@@ -153,25 +250,67 @@ module Ace
         end
 
         def removed?(key)
-          state = JSON.parse(File.read(state_path(key)))
-          state["removed"] == true
-        rescue Errno::ENOENT, JSON::ParserError, TypeError
+          path = state_path(key)
+          opened = false
+          File.open(path, File::RDONLY | File::NOFOLLOW | File::NONBLOCK) do |file|
+            opened = true
+            before = file.stat
+            unless before.file? && before.nlink == 1 && before.size.between?(1, 8192) && (before.mode & 0022).zero?
+              raise AttemptErrors::Conflict, "Lifecycle marker is unsafe"
+            end
+            content = file.read(8193).force_encoding(Encoding::UTF_8)
+            unless content.valid_encoding? && content.bytesize == before.size && same_file?(before, file.stat) && same_file?(before, File.lstat(path))
+              raise AttemptErrors::Conflict, "Lifecycle marker changed"
+            end
+            state = JSON.parse(content, create_additions: false, max_nesting: 4, allow_duplicate_key: false)
+            unless state.is_a?(Hash) && state.keys.sort == %w[key removed removed_at] &&
+                state["key"] == key && state["removed"] == true && state["removed_at"].is_a?(String)
+              raise AttemptErrors::Conflict, "Lifecycle marker is malformed"
+            end
+            Time.iso8601(state.fetch("removed_at"))
+            true
+          end
+        rescue Errno::ENOENT
+          raise AttemptErrors::Conflict, "Lifecycle marker disappeared during read" if opened
           false
+        rescue JSON::ParserError, ArgumentError, TypeError, SystemCallError, IOError
+          raise AttemptErrors::Conflict, "Lifecycle marker is unavailable or malformed"
         end
 
         def clear_removed!(key)
+          return unless removed?(key)
           File.delete(state_path(key))
-        rescue Errno::ENOENT
-          nil
+          sync_directory(root)
         end
 
         private
 
         attr_reader :root
 
-        def open_lock(key)
+        def open_lock(key, nonblock: false)
+          retained = false
           FileUtils.mkdir_p(root)
-          File.open(lock_path(key), File::RDWR | File::CREAT)
+          flags = File::RDWR | File::CREAT | File::NONBLOCK | File::NOFOLLOW
+          file = File.open(lock_path(key), flags, 0600)
+          unless file.stat.file? && file.stat.nlink == 1 && (file.stat.mode & 0022).zero? &&
+              same_file?(file.stat, File.lstat(lock_path(key)))
+            raise AttemptErrors::MaintenanceBusy, "maintenance exclusion is not a regular file"
+          end
+          retained = true
+          file
+        rescue SystemCallError
+          raise AttemptErrors::Conflict, "Lifecycle lock is unavailable"
+        ensure
+          file&.close unless retained
+        end
+
+        def maintenance_deadline!(deadline)
+          unless (deadline.is_a?(Integer) || deadline.is_a?(Float)) && deadline.finite?
+            raise ArgumentError, "maintenance deadline must be finite"
+          end
+          if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+            raise AttemptErrors::MaintenanceBusy, "maintenance admission deadline expired"
+          end
         end
 
         def lock_path(key)
@@ -194,15 +333,32 @@ module Ace
           end
         end
 
+        def same_file?(left, right)
+          [left.dev, left.ino, left.size, left.mtime, left.ctime] == [right.dev, right.ino, right.size, right.mtime, right.ctime]
+        end
+
+        def sync_directory(path)
+          File.open(path, File::RDONLY | File::NOFOLLOW | File::NONBLOCK) { |directory| directory.fsync }
+        end
+
         def atomic_write(path, content)
           dir = File.dirname(path)
-          FileUtils.mkdir_p(dir)
-          temp = File.join(dir, ".tmp-#{Process.pid}-#{rand(1_000_000)}")
-          File.write(temp, content)
+          FileUtils.mkdir_p(dir, mode: 0700)
+          temp = File.join(dir, ".tmp-#{SecureRandom.hex(16)}")
+          File.open(temp, File::WRONLY | File::CREAT | File::EXCL | File::NOFOLLOW | File::NONBLOCK, 0600) do |file|
+            file.write(content)
+            file.flush
+            file.fsync
+          end
+          if File.exist?(path) || File.symlink?(path)
+            removed?(JSON.parse(content).fetch("key"))
+          end
           File.rename(temp, path)
+          sync_directory(dir)
         ensure
           File.delete(temp) if temp && File.exist?(temp)
         end
+
       end
     end
   end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "ace/herdr/molecules/guarded_native_origin"
+require_relative "../models/evidence_event"
+
+module Ace
+  module Assign
+    module Molecules
+      # Exact accepted launch record; this reader grants no native effect.
+      module OriginalLaunchBinding
+        def self.verify!(events:, state:, params:)
+          unless state.is_a?(Hash) && state["guarded_origin"].is_a?(Hash) && state["process_binding"].is_a?(Hash)
+            raise AttemptErrors::EvidenceUnavailable, "Original guarded record is unavailable"
+          end
+          unless Models::EvidenceEvent.chain_valid?(events)
+            raise AttemptErrors::EvidenceUnavailable, "Original guarded record chain is corrupt"
+          end
+          records = events.select { |event| event["type"] == "authority_mutation" && event.dig("payload", "operation") == "record_launch" }
+          raise AttemptErrors::EvidenceUnavailable, "Original guarded record is ambiguous or absent" unless records.size == 1
+          record = records.first
+          data = record.fetch("payload").fetch("data")
+          unless data.is_a?(Hash) && record["attempt_id"] == params.fetch("attempt_id") &&
+              %w[mapping_id assignment_id attempt_id].all? { |key| data[key] == params.fetch(key) } &&
+              data["process_binding"] == state.fetch("process_binding") && data["guarded_origin"] == state.fetch("guarded_origin")
+            raise AttemptErrors::EvidenceUnavailable, "Original guarded record differs from accepted launch"
+          end
+          binding = data.fetch("process_binding")
+          origin = Ace::Herdr::Molecules::GuardedNativeOrigin.verify!(data.fetch("guarded_origin"),
+            terminal_id: binding.fetch("terminal_id"), child: binding.fetch("process_identity"))
+          {"binding_digest" => record.fetch("digest").dup.freeze, "origin" => origin}.freeze
+        rescue KeyError, TypeError, Ace::Runtime::RuntimeUnavailableError
+          raise AttemptErrors::EvidenceUnavailable, "Original guarded record is malformed"
+        end
+      end
+    end
+  end
+end

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