ace-assign 0.71.0 → 0.73.0

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

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-require "fiddle"
-
-module Ace
-  module Assign
-    module Authority
-      # Linux POSIX access ACL evaluation for a fixed unprivileged principal.
-      # No credential switching; unsupported or unreadable policy refuses admission.
-      class PosixAcl
-        def entries(path, attribute: "system.posix_acl_access")
-          unless %w[system.posix_acl_access system.posix_acl_default].include?(attribute)
-            raise ArgumentError, "unsupported POSIX ACL attribute"
-          end
-          raise Ace::Runtime::RuntimeUnavailableError, "receiver ACL inspection requires Linux" unless RUBY_PLATFORM.include?("linux")
-          function = Fiddle::Function.new(Fiddle::Handle::DEFAULT["lgetxattr"],
-            [Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP, Fiddle::TYPE_SIZE_T], Fiddle::TYPE_SSIZE_T)
-          buffer = Fiddle::Pointer.malloc(8192, Fiddle::RUBY_FREE)
-          count = function.call(path, attribute, buffer, 8192)
-          return nil if count == -1 && Fiddle.last_error == Errno::ENODATA::Errno
-          raise Ace::Runtime::RuntimeUnavailableError, "receiver access ACL is unreadable" if count < 4 || (count - 4) % 8 != 0
-          bytes = buffer[0, count]
-          raise Ace::Runtime::RuntimeUnavailableError, "unknown receiver ACL version" unless bytes.unpack1("L<") == 2
-          rows = bytes.byteslice(4..).unpack("S<S<L<" * ((count - 4) / 8)).each_slice(3).to_a
-          validate!(rows)
-          rows
-        rescue Fiddle::DLError
-          raise Ace::Runtime::RuntimeUnavailableError, "receiver ACL inspection is unavailable"
-        end
-
-        def searchable?(path, stat:, uid:, groups:)
-          rows = entries(path)
-          unless rows
-            shift = uid == stat.uid ? 6 : (groups.include?(stat.gid) ? 3 : 0)
-            return ((stat.mode >> shift) & 1) == 1
-          end
-          return (rows.find { |tag, _perm, _id| tag == 1 }[1] & 1) == 1 if uid == stat.uid
-          mask = rows.find { |tag, _perm, _id| tag == 16 }&.at(1) || 7
-          named = rows.find { |tag, _perm, id| tag == 2 && id == uid }
-          return (named[1] & mask & 1) == 1 if named
-          matched = rows.select { |tag, _perm, id| (tag == 4 && groups.include?(stat.gid)) || (tag == 8 && groups.include?(id)) }
-          return matched.any? { |_tag, perm, _id| (perm & mask & 1) == 1 } unless matched.empty?
-          (rows.find { |tag, _perm, _id| tag == 32 }[1] & 1) == 1
-        end
-
-        private
-
-        def validate!(rows)
-          valid = rows.all? { |tag, perm, id| [1, 2, 4, 8, 16, 32].include?(tag) && (0..7).cover?(perm) &&
-            ([2, 8].include?(tag) ? id != 0xffffffff : id == 0xffffffff) }
-          valid &&= [1, 4, 32].all? { |tag| rows.count { |row| row[0] == tag } == 1 }
-          valid &&= rows.count { |row| row[0] == 16 } <= 1
-          valid &&= [2, 8].all? { |tag| ids = rows.select { |row| row[0] == tag }.map(&:last); ids.uniq == ids }
-          valid &&= !rows.any? { |row| [2, 8].include?(row[0]) } || rows.count { |row| row[0] == 16 } == 1
-          raise Ace::Runtime::RuntimeUnavailableError, "invalid receiver access ACL" unless valid
-        end
-      end
-    end
-  end
-end

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

@@ -1,130 +0,0 @@
-# frozen_string_literal: true
-
-require "shellwords"
-require_relative "client"
-require_relative "prepared_work"
-
-module Ace
-  module Assign
-    module Authority
-      # One authenticated original fetch and one immutable verified work graph.
-      # Caller identifiers select; the maintained Client/Endcap authenticates.
-      class PreparedInput
-        attr_reader :descriptor, :work, :working_directory
-
-        def self.fetch(client:, assignment_id:, attempt_id:)
-          reply = client.call("evidence_fetch", {"assignment_id" => assignment_id, "attempt_id" => attempt_id,
-            "kind" => "prepared_work", "purpose_id" => "original_prepared_work", "artifact_id" => "prepared_bundle"},
-            download: true, purpose: :candidate, timeout: 30)
-          new(reply: reply, candidate_loader: -> {
-            client.call("evidence_fetch", {"assignment_id" => assignment_id, "attempt_id" => attempt_id,
-              "kind" => "campaign_candidate", "purpose_id" => "original_campaign_candidate", "artifact_id" => "candidate_bundle"},
-              download: true, purpose: :candidate, timeout: 30)
-          })
-        end
-
-        def initialize(reply:, candidate_reply: nil, candidate_loader: nil)
-          @descriptor = reply.data.fetch("descriptor")
-          Molecules::LifecycleExclusion.workspace_reader(projection: descriptor.fetch("workspace_exclusion"))
-          unless descriptor.dig("workspace_exclusion", "root_resource", "view_path") ==
-              "/run/ace/lifecycle-exclusion/#{descriptor.fetch('mapping_id')}"
-            raise AttemptErrors::EvidenceUnavailable, "prepared_input_unavailable: original lifecycle mapping differs"
-          end
-          unless reply.parts.is_a?(Array) && reply.parts.one?
-            raise AttemptErrors::EvidenceUnavailable, "prepared_input_unavailable: one original bundle required"
-          end
-          root = PrivateDirectory.verify!(descriptor.fetch("original_worker_scratch_root"))
-          @work = PreparedWork.admit(bytes: reply.parts.first, head: descriptor.fetch("prepared_head"),
-            tree: descriptor.fetch("prepared_tree"), sha256: descriptor.fetch("sha256"), size: descriptor.fetch("bytes"), root: root)
-          expected = work.reference(head: descriptor.fetch("prepared_head"), tree: descriptor.fetch("prepared_tree"))
-          definition = work.definition_bytes(head: descriptor.fetch("prepared_head"), tree: descriptor.fetch("prepared_tree"))
-          unless expected == descriptor.slice(*expected.keys) &&
-              descriptor.values_at("assignment_id", "project_id") == work.manifest.values_at("assignment_id", "project_id") &&
-              Digest::SHA256.hexdigest(definition) == descriptor.fetch("definition_digest")
-            raise AttemptErrors::EvidenceUnavailable, "prepared_input_mismatch: original graph association"
-          end
-          execution = work.definition["campaign_execution"]
-          if execution
-            candidate_reply ||= candidate_loader&.call
-            candidate = candidate_reply&.data&.fetch("descriptor")
-            unless candidate.is_a?(Hash) && candidate.keys.sort == %w[head tree bytes sha256 candidate_generation campaign_execution mapping_id assignment_id attempt_id project_id original_worker_identity original_worker_scratch_root original_binding_digest].sort &&
-                candidate.slice("mapping_id", "assignment_id", "attempt_id", "project_id", "original_worker_identity", "original_worker_scratch_root", "original_binding_digest") ==
-                  descriptor.slice("mapping_id", "assignment_id", "attempt_id", "project_id", "original_worker_identity", "original_worker_scratch_root", "original_binding_digest") &&
-                candidate.fetch("campaign_execution") == execution && candidate.fetch("head") == execution.fetch("head") &&
-                candidate.fetch("candidate_generation") == execution.fetch("parent_candidate_generation") &&
-                candidate_reply.parts.is_a?(Array) && candidate_reply.parts.one?
-              raise AttemptErrors::EvidenceUnavailable, "campaign original candidate input differs"
-            end
-            materialized = CandidateTransfer.new(root: root).materialize_repository(bytes: candidate_reply.parts.first,
-              sha256: candidate.fetch("sha256"), size: candidate.fetch("bytes"), head: candidate.fetch("head"),
-              tree: candidate.fetch("tree"), root: root)
-            @working_directory = materialized.fetch("directory").freeze
-          elsif candidate_reply
-            raise AttemptErrors::EvidenceUnavailable, "ordinary prepared input forbids a campaign candidate"
-          end
-          @descriptor = JSON.parse(JSON.generate(descriptor))
-          pending = [@descriptor]
-          until pending.empty?
-            value = pending.pop
-            pending.concat(value.values) if value.is_a?(Hash)
-            pending.concat(value) if value.is_a?(Array)
-            value.freeze
-          end
-          freeze
-        end
-
-        def render(text)
-          values = descriptor.slice("mapping_id", "assignment_id", "scope", "attempt_id")
-          rendered = +""
-          cursor = 0
-          # Only an opening delimiter introduces a token. Closing braces in
-          # literal JSON are preserved; inserted selector values are not parsed.
-          while (opening = text.index("{{", cursor))
-            rendered << text[cursor...opening]
-            closing = text.index("}}", opening + 2)
-            unless closing
-              raise AttemptErrors::EvidenceUnavailable, "prepared_input_invalid: unresolved instruction token"
-            end
-            token = text[(opening + 2)...closing]
-            if token.include?("{") || token.include?("}")
-              raise AttemptErrors::EvidenceUnavailable, "prepared_input_invalid: unresolved instruction token"
-            end
-            field = token.delete_prefix("admitted.")
-            unless token == "admitted." + field && values.key?(field)
-              raise AttemptErrors::EvidenceUnavailable, "prepared_input_invalid: unknown instruction token"
-            end
-            rendered << Shellwords.escape(values.fetch(field))
-            cursor = closing + 2
-          end
-          rendered << text[cursor..]
-          rendered.freeze
-        end
-
-        def drive_prompt
-          target = Shellwords.escape(descriptor.fetch("assignment_id") + "@" + descriptor.fetch("scope"))
-          selectors = "--assignment #{target} --mapping #{Shellwords.escape(descriptor.fetch('mapping_id'))} --attempt #{Shellwords.escape(descriptor.fetch('attempt_id'))}"
-          instructions = ["Drive the authenticated captured assignment subtree. Use ace-assign status #{selectors}, step #{selectors}, start #{selectors}, finish #{selectors} --message REPORT, and fail #{selectors} --message REASON. Do not fork-run, add, retry, renumber, or expand another graph."]
-          if (execution = work.definition["campaign_execution"])
-            instructions << "This is a registered campaign #{execution.fetch('phase')} child. The provider working directory is the private authenticated parent candidate repository at #{Shellwords.escape(execution.fetch('head'))}, with original base #{Shellwords.escape(execution.fetch('base'))}. Do not edit or advance that candidate. Execute the captured #{Shellwords.escape(execution.fetch('operation'))} phase and retain its actual #{Shellwords.escape(execution.fetch('check_name'))} check and report artifacts. Submit an ordinary campaign-free result (campaign null), operation #{Shellwords.escape(execution.fetch('operation'))}, exact original head/base, and actual check outcome. The existing independent reviewer must validate those same artifact bytes; an approval child must retain the exact canonical independent review actor/verdict. No session metadata or completed queue step counts as a settled R1 campaign round."
-          end
-          original = "--mapping #{Shellwords.escape(descriptor.fetch('mapping_id'))} --assignment #{Shellwords.escape(descriptor.fetch('assignment_id'))} --attempt #{Shellwords.escape(descriptor.fetch('attempt_id'))}"
-          instructions << "Before the original worker exits, explicitly submit its tested candidate and real execution result through the protected authority. Queue completion is not candidate/result acceptance. Read ace-assign authority status #{original}; persist its authority_generation with the complete next command arguments and ordered byte inputs. For each NEW operation use a new explicit mutation and a newly selected generation; for exact retries preserve the original generation, mutation and bytes."
-          instructions << "Submit one prepared Git bundle: ace-assign submit-candidate #{original} --head HEAD --candidate-generation CURRENT_CANDIDATE --expected-generation G --mutation CANDIDATE_MUTATION --bundle FILE. Select CURRENT_CANDIDATE from status result_candidate_generation, using 0 when null. Persist the returned candidate_generation and head as REVIEWED_CANDIDATE and HEAD; never derive the next counter by arithmetic or from queue completion."
-          instructions << "Have an independent installed reviewer run ace-overseer review --project #{Shellwords.escape(descriptor.fetch('project_id'))} --agent #{Shellwords.escape(descriptor.fetch('mapping_id'))} --assignment #{Shellwords.escape(descriptor.fetch('assignment_id'))} --attempt #{Shellwords.escape(descriptor.fetch('attempt_id'))} --head HEAD --candidate-generation REVIEWED_CANDIDATE --expected-generation G --mutation REVIEW_REQUEST --accept-mutation REVIEW_ACCEPT. Do not impersonate that principal. The review consumer owns actual candidate export, independent checks and canonical acceptance. After review, read authority status again before the first result submission."
-          instructions << "Produce the real receipt with Ace::Assign::Models::ExecutionReceipt.new/to_h: original assignment/attempt/project and scope #{Shellwords.escape(descriptor.fetch('scope'))}, exact tested candidate head, installed worker actor/role worker/runtime herdr, actual operation/verdict/executed checks and ordered artifact path/SHA256 pairs. No invented successful check or queue-to-receipt conversion. Submit JSON bytes and matching ordered artifact files with ace-assign submit-result #{original} --head HEAD --candidate-generation REVIEWED_CANDIDATE --expected-generation G --mutation RESULT_MUTATION --receipt FILE --artifact FILE ... . Failed empty artifacts use no --artifact; succeeded requires evidence. Supervisor finish is separate and revalidates result, independent review and no-writer/settlement proof."
-          instructions << "For an authorized merge step captured INSIDE this subtree, use the protected delivery rule in wfi://assign/drive. Never execute an outer preset step or expand this graph. Retain the exact approved candidate, structured input bytes, authorization and request ID before the first request; select authority_generation for that new request only."
-          service = "--project #{Shellwords.escape(descriptor.fetch('project_id'))} #{original} --scope #{Shellwords.escape(descriptor.fetch('scope'))} --candidate-head HEAD --candidate-generation REVIEWED_CANDIDATE"
-          instructions << "Request the uniquely installed authorized merge receiver: ace-lab service request #{service} --service SERVICE --operation merge --authorization AUTHORIZATION --request-id REQUEST --expected-generation G --input INPUT_FILE. Credentials alone are not authorization. Persist the returned original input_digest and target with all request arguments. Lost/uncertain replies never permit another effect or refreshed-generation retry."
-          instructions << "Inspect the same request: ace-lab service status #{service} --request REQUEST --input-digest INPUT_DIGEST --target TARGET. Only canonical succeeded evidence permits ace-assign delivery #{original} --scope #{Shellwords.escape(descriptor.fetch('scope'))} --operation merge --service-request REQUEST --candidate-head HEAD --candidate-generation REVIEWED_CANDIDATE --input-digest INPUT_DIGEST --target TARGET. This consumption verifies the imported receipt and never executes merge. Refusal, unavailable or uncertain leaves the active delivery step unfinished; report its exact blocker. Finish the queue step only after succeeded canonical delivery."
-          work.manifest.fetch("context").each do |entry|
-            instructions << render(work.files.fetch(entry.fetch("text").fetch("filename")))
-          end
-          work.manifest.fetch("steps").each do |entry|
-            instructions << "Step #{entry.fetch('number')}:\n" + render(work.parse_queue_step!(work.files.fetch("steps/" + entry.fetch("filename"))).fetch(:body))
-          end
-          instructions.join("\n\n").freeze
-        end
-      end
-    end
-  end
-end

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

@@ -1,185 +0,0 @@
-# frozen_string_literal: true
-
-require "fileutils"
-require "securerandom"
-require "yaml"
-require_relative "prepared_work"
-require_relative "private_directory"
-require_relative "../molecules/lifecycle_exclusion"
-require_relative "../organisms/assignment_executor"
-
-module Ace
-  module Assign
-    module Authority
-      # Existing assignment/progress files, rooted only in the authenticated
-      # original worker scratch. This cache never supplies authority or a graph.
-      class PreparedQueue
-        attr_reader :cache_base, :directory, :work, :descriptor
-
-        def initialize(work:, descriptor:)
-          @work, @descriptor = work, descriptor
-          @scratch = PrivateDirectory.verify!(descriptor.fetch("original_worker_scratch_root"))
-          %w[mapping_id attempt_id assignment_id].each do |field|
-            value = descriptor.fetch(field)
-            unavailable!("queue identity") unless value.is_a?(String) && value.match?(PreparedWork::TOKEN)
-          end
-          @cache_base = File.join(@scratch, "prepared-queues", descriptor.fetch("mapping_id"), descriptor.fetch("attempt_id"))
-          @directory = File.join(cache_base, descriptor.fetch("assignment_id"))
-          definition = JSON.parse(work.definition_bytes(head: descriptor.fetch("prepared_head"), tree: descriptor.fetch("prepared_tree")))
-          unavailable!("captured assignment metadata") unless %w[name source_config created_at].all? do |field|
-            definition[field].is_a?(String) && !definition[field].empty?
-          end
-          validate_timestamp!(definition.fetch("created_at"))
-          validate_timestamp!(definition["updated_at"]) if definition.key?("updated_at")
-          @metadata = Models::Assignment.from_h(definition, cache_dir: directory).to_h
-          lock_root = File.join(@scratch, "prepared-queue-exclusion")
-          private_directory!(lock_root, create: true)
-          @exclusion = Molecules::LifecycleExclusion.new(root: lock_root)
-          @key = @exclusion.assignment_key(descriptor.values_at("mapping_id", "attempt_id", "assignment_id").join(":"))
-        end
-
-        # Called ONLY after the fixed adapter proves actual original self. Later
-        # CLI consumers use with_executor and cannot recreate a missing queue.
-        def activate_original!
-          @exclusion.with_exclusive(@key) do
-            publish_initial! unless File.exist?(directory) || File.symlink?(directory)
-            executor = verified_executor
-            result = executor.status
-            state = result.fetch(:state)
-            unavailable!("selected queue has failed progress") unless state.failed.empty?
-            return nil if state.subtree_complete?(descriptor.fetch("scope"))
-            unless state.steps.all? { |step| step.status == :pending }
-              unavailable!("original adapter has already activated queue progress")
-            end
-            root = state.find_by_number(descriptor.fetch("scope"))
-            unavailable!("original selected fork root") unless root && root.fork?
-            executor.step_writer.mark_active(root.file_path)
-            # Same held-byte consumer validates the resulting progress before
-            # returning to the adapter that may now start its provider.
-            executor.status
-            root
-          end
-        end
-
-        def with_executor
-          @exclusion.with_exclusive(@key) do
-            unavailable!("published queue is unavailable; no reconstruction") unless File.directory?(directory)
-            yield verified_executor
-          end
-        end
-
-        private
-
-        def verified_executor
-          private_directory!(directory)
-          private_directory!(File.join(directory, "steps"))
-          private_directory!(File.join(directory, "reports"))
-          metadata = work.parse_queue_metadata!(held_read(File.join(directory, "assignment.yaml"), PreparedWork::MAX_MANIFEST))
-          unavailable!("queue assignment metadata differs") unless metadata.is_a?(Hash) &&
-            metadata.reject { |key, _| key == "updated_at" } == @metadata.reject { |key, _| key == "updated_at" }
-          validate_timestamp!(metadata["updated_at"]) if metadata.key?("updated_at")
-          unavailable!("queue job differs") unless held_read(File.join(directory, "job.yaml"), PreparedWork::MAX_TEXT) == work.files.fetch("job.yaml")
-          owner = self
-          scanner = Molecules::QueueScanner.new
-          parser = scanner.method(:scan_captured)
-          scanner.define_singleton_method(:scan) do |steps_dir, assignment:|
-            raise AttemptErrors::EvidenceUnavailable, "prepared queue scanner path differs" unless steps_dir == File.join(owner.directory, "steps")
-            steps, reports = owner.send(:captured_queue)
-            parser.call(steps: steps, assignment: assignment, reports: reports)
-          end
-          Organisms::AssignmentExecutor.new(cache_base: cache_base,
-            selected_assignment: Models::Assignment.from_h(metadata, cache_dir: directory), queue_scanner: scanner)
-        end
-
-        def captured_queue
-          expected = work.manifest.fetch("steps").map { |entry| entry.fetch("filename") }
-          steps_dir = File.join(directory, "steps")
-          unavailable!("queue step inventory differs") unless Dir.children(steps_dir).sort == expected.sort
-          steps = expected.to_h do |filename|
-            bytes = held_read(File.join(steps_dir, filename), PreparedWork::MAX_TEXT)
-            parsed = work.parse_queue_step!(bytes)
-            accepted = work.parse_queue_step!(work.files.fetch("steps/" + filename))
-            projection = ->(value) { value.fetch(:frontmatter).reject { |key, _| PreparedWork::PROGRESS.include?(key) } }
-            unless projection.call(parsed) == projection.call(accepted) && parsed.fetch(:body) == accepted.fetch(:body) &&
-                %w[pending active done failed].include?(parsed.fetch(:frontmatter).fetch("status", "pending"))
-              unavailable!("queue work-bearing input differs")
-            end
-            [filename, bytes]
-          end
-          reports_dir = File.join(directory, "reports")
-          allowed = work.manifest.fetch("steps").map do |entry|
-            name = work.parse_queue_step!(work.files.fetch("steps/" + entry.fetch("filename"))).fetch(:frontmatter).fetch("name")
-            Atoms::StepFileParser.generate_report_filename(entry.fetch("number"), name)
-          end
-          reports = Dir.children(reports_dir).to_h do |filename|
-            unavailable!("queue report inventory differs") unless allowed.include?(filename)
-            bytes = held_read(File.join(reports_dir, filename), PreparedWork::MAX_TEXT)
-            work.parse_queue_step!(bytes)
-            [filename, bytes]
-          end
-          [steps.freeze, reports.freeze]
-        end
-
-        def publish_initial!
-          private_directory!(File.join(@scratch, "prepared-queues"), create: true)
-          private_directory!(File.dirname(cache_base), create: true)
-          private_directory!(cache_base, create: true)
-          stage = File.join(cache_base, ".prepared-#{SecureRandom.hex(12)}")
-          Dir.mkdir(stage, 0700)
-          %w[steps reports].each { |name| Dir.mkdir(File.join(stage, name), 0700) }
-          durable_write(File.join(stage, "assignment.yaml"), @metadata.to_yaml)
-          durable_write(File.join(stage, "job.yaml"), work.files.fetch("job.yaml"))
-          work.manifest.fetch("steps").each do |entry|
-            name = entry.fetch("filename")
-            durable_write(File.join(stage, "steps", name), work.files.fetch("steps/" + name))
-          end
-          %w[steps reports].each { |name| File.open(File.join(stage, name), File::RDONLY) { |file| file.fsync } }
-          File.open(stage, File::RDONLY) { |file| file.fsync }
-          unavailable!("queue publication collision") if File.exist?(directory) || File.symlink?(directory)
-          File.rename(stage, directory)
-          File.open(cache_base, File::RDONLY) { |file| file.fsync }
-        ensure
-          FileUtils.remove_entry(stage) if stage && File.directory?(stage) && !File.symlink?(stage)
-        end
-
-        def private_directory!(path, create: false)
-          Dir.mkdir(path, 0700) if create && !File.exist?(path) && !File.symlink?(path)
-          PrivateDirectory.verify!(path)
-        end
-
-        def durable_write(path, bytes)
-          File.open(path, File::WRONLY | File::CREAT | File::EXCL | File::NOFOLLOW, 0600) do |file|
-            file.write(bytes); file.flush; file.fsync
-          end
-        end
-
-        def held_read(path, limit)
-          File.open(path, File::RDONLY | File::NOFOLLOW | File::NONBLOCK) do |file|
-            before = file.stat
-            unavailable!("queue held file kind/size") unless before.file? && before.uid == Process.uid &&
-              (before.mode & 0077).zero? && before.size.between?(1, limit)
-            bytes = file.read(limit + 1).force_encoding(Encoding::UTF_8)
-            after = file.stat
-            unavailable!("queue held file changed") unless bytes.valid_encoding? && !bytes.include?("\0") &&
-              bytes.bytesize == before.size && [before.dev, before.ino, before.size, before.mtime, before.ctime] ==
-                [after.dev, after.ino, after.size, after.mtime, after.ctime]
-            bytes.freeze
-          end
-        rescue SystemCallError
-          unavailable!("queue held file unavailable")
-        end
-
-        def unavailable!(reason)
-          raise AttemptErrors::EvidenceUnavailable, "prepared_input_unavailable: #{reason}"
-        end
-
-        def validate_timestamp!(value)
-          unavailable!("captured assignment timestamp") unless value.is_a?(String)
-          Time.iso8601(value)
-        rescue ArgumentError
-          unavailable!("captured assignment timestamp")
-        end
-      end
-    end
-  end
-end

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

@@ -1,116 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "protected_assignment_context"
-require_relative "task_context_entry"
-
-module Ace
-  module Assign
-    module Authority
-      # The selected immutable Lab owner sets the hook before entry evaluation.
-      # Its presence alone never grants scope; original fetch admission decides.
-      class PreparedTaskContext
-        SCHEMA = "ace.assign.prepared-task-context/v1"
-        MAX_RESPONSE = 6_307_840
-        PRINCIPAL_SCHEMA = "ace.assign.task-context-principal/v1"
-        SELECTION_SCHEMA = "ace.assign.task-context-selection/v1"
-        MAX_PRINCIPAL = 1_024
-        MAX_SELECTION = 65_536
-
-        def initialize(context: nil)
-          @context = context
-        end
-
-        def call(mapping:, assignment:, attempt:, task:)
-          unavailable!("task-context task selector") unless task.is_a?(String) && task.match?(PreparedWork::TOKEN)
-          selected_entry = selected_entry!
-          input = resolved_input(mapping: mapping, assignment: assignment, attempt: attempt)
-          unavailable!("original protected task-context admission") unless input.descriptor.fetch("task_context_entry") == selected_entry
-          item = input.work.manifest.fetch("context").find { |entry| entry.fetch("task_id") == task }
-          unavailable!("task is outside captured original context") unless item
-          text = input.work.files.fetch(item.fetch("text").fetch("filename"))
-          record = input.descriptor.slice("mapping_id", "assignment_id", "attempt_id", "scope", "definition_digest", "selection_sha256")
-            .merge("schema" => SCHEMA, "task_id" => task, "text" => text)
-          response!(record, MAX_RESPONSE)
-        rescue ArgumentError, KeyError
-          unavailable!("task-context input or original entry differs")
-        end
-
-        def principal
-          selected_entry!
-          context = installed_context!
-          response!({"schema" => PRINCIPAL_SCHEMA, "uid" => context.uid, "protected_worker" => context.protected_worker?}, MAX_PRINCIPAL)
-        end
-
-        def selection(mapping:, assignment:, attempt:)
-          selected_entry!
-          # Current discovery selects a trusted classifier only. Original fetch
-          # independently selects the retained entry; no text leaves this mode.
-          input = resolved_input(mapping: mapping, assignment: assignment, attempt: attempt)
-          response!(input.descriptor.slice("mapping_id", "assignment_id", "attempt_id", "scope", "definition_digest", "selection_sha256", "task_context_entry")
-            .merge("schema" => SELECTION_SCHEMA), MAX_SELECTION)
-        rescue ArgumentError, KeyError
-          unavailable!("task-context original selection differs")
-        end
-
-        def inbox_principal
-          selected_entry!
-          context = installed_context!
-          response!({"schema" => "ace.assign.inbox-context-principal/v1", "uid" => context.uid,
-            "protected_participant" => context.protected_participant?}, MAX_PRINCIPAL)
-        end
-
-        def inbox_selection(project:, mapping:, inbox_context:)
-          selected_entry!
-          installed_context!.inbox_context_selection(project: project, mapping: mapping, inbox_context: inbox_context) do |record|
-            response!(record.merge("schema" => "ace.assign.inbox-context-selection/v1"), 16_384)
-          end
-        end
-
-        private
-
-        def selected_entry!
-          unless Object.const_defined?(:ACE_PROTECTED_TASK_CONTEXT_ENTRY, false)
-            unavailable!("selected original task-context entry is absent")
-          end
-          selected_entry = Object.const_get(:ACE_PROTECTED_TASK_CONTEXT_ENTRY, false)
-          TaskContextEntry.validate!(selected_entry)
-          objects = [selected_entry, *selected_entry.keys, *selected_entry.values]
-          selected_entry.values.each { |reference| objects.concat(reference.keys); objects.concat(reference.values) }
-          unavailable!("selected task-context entry is mutable") unless objects.all?(&:frozen?)
-          selected_entry
-        rescue ArgumentError, KeyError, TypeError
-          unavailable!("task-context selected entry differs")
-        end
-
-        def installed_context!
-          @context ||= ProtectedAssignmentContext.load
-          unavailable!("published task-context installed owner is absent") unless @context.installed?
-          @context
-        end
-
-        def resolved_input(mapping:, assignment:, attempt:)
-          unless [mapping, attempt].all? { |value| value.is_a?(String) && value.match?(PreparedWork::TOKEN) } && assignment.is_a?(String)
-            unavailable!("task-context selectors")
-          end
-          assignment_id, scope = assignment.split("@", 2)
-          unless assignment_id&.match?(PreparedWork::TOKEN) && scope&.match?(PreparedWork::SCOPE)
-            unavailable!("task-context scoped assignment")
-          end
-          input = installed_context!.resolve(options: {mapping: mapping, attempt: attempt}, assignment_id: assignment_id, scope: scope)
-          unavailable!("original protected task-context admission") unless input
-          input
-        end
-
-        def response!(record, limit)
-          response = JSON.generate(record) + "\n"
-          unavailable!("task-context response bound") if response.bytesize > limit
-          response.freeze
-        end
-
-        def unavailable!(reason)
-          raise AttemptErrors::EvidenceUnavailable, "prepared_input_unavailable: #{reason}"
-        end
-      end
-    end
-  end
-end