ace-assign 0.70.0 → 0.73.0

data/lib/ace/assign/cli.rb

@@ -9,10 +9,6 @@ require_relative "models/assignment"
 require_relative "models/step"
 require_relative "models/queue_state"
 require_relative "models/assignment_info"
-require_relative "models/attempt_binding"
-require_relative "models/attempt"
-require_relative "models/execution_receipt"
-require_relative "models/evidence_event"
 
 # Atoms
 require_relative "atoms/step_numbering"
@@ -26,14 +22,10 @@ require_relative "atoms/catalog_loader"
 require_relative "atoms/composition_rules"
 require_relative "atoms/assign_frontmatter_parser"
 require_relative "atoms/tree_formatter"
-require_relative "atoms/attempt_state_machine"
-require_relative "atoms/evidence_digest"
-require_relative "atoms/assignment_scope"
 
 # Molecules
 require_relative "molecules/lifecycle_exclusion"
 require_relative "molecules/assignment_manager"
-require_relative "molecules/attempt_store"
 require_relative "molecules/assignment_discoverer"
 require_relative "molecules/queue_scanner"
 require_relative "molecules/step_writer"
@@ -42,28 +34,14 @@ require_relative "molecules/skill_assign_source_resolver"
 require_relative "molecules/fork_session_launcher"
 require_relative "molecules/runtime_control_surface_runner"
 require_relative "molecules/preset_inferrer"
-require_relative "molecules/evidence_calculator"
-require_relative "molecules/evidence_journal"
-require_relative "molecules/canonical_evidence"
-require_relative "molecules/execution_identity_resolver"
-require_relative "molecules/receipt_verifier"
-require_relative "molecules/attempt_reconciler"
 
 # Organisms
 require_relative "organisms/assignment_executor"
-require_relative "organisms/attempt_coordinator"
 
 # Commands
-require_relative "cli/commands/delivery"
 require_relative "cli/commands/assignment_target"
 require_relative "cli/commands/create"
 require_relative "cli/commands/status"
-require_relative "cli/commands/resume"
-require_relative "cli/commands/inbox_bind"
-require_relative "cli/commands/submit_candidate"
-require_relative "cli/commands/submit_result"
-require_relative "cli/commands/campaign_record_round"
-require_relative "cli/commands/campaign_export_result"
 require_relative "cli/commands/step"
 require_relative "cli/commands/start"
 require_relative "cli/commands/finish"
@@ -74,22 +52,6 @@ require_relative "cli/commands/list"
 require_relative "cli/commands/select"
 require_relative "cli/commands/fork_run"
 require_relative "cli/commands/fork_session"
-require_relative "cli/commands/authority/serve"
-require_relative "cli/commands/authority/launch"
-require_relative "cli/commands/authority/status"
-require_relative "cli/commands/authority/terminate"
-require_relative "cli/commands/authority/worker"
-require_relative "cli/commands/authority/task_context"
-require_relative "cli/commands/authority/task_context_principal"
-require_relative "cli/commands/authority/task_context_selection"
-require_relative "cli/commands/authority/inbox_context_principal"
-require_relative "cli/commands/authority/inbox_context_selection"
-require_relative "cli/commands/attempt/base"
-require_relative "cli/commands/attempt/start"
-require_relative "cli/commands/attempt/status"
-require_relative "cli/commands/attempt/finish"
-require_relative "cli/commands/attempt/reconcile"
-require_relative "cli/commands/attempt/evidence"
 
 module Ace
   module Assign
@@ -102,21 +64,6 @@ module Ace
       # Application commands with descriptions (for help output)
       REGISTERED_COMMANDS = [
         ["create", "Create assignment from preset or YAML"],
-        ["authority serve", "Serve the installed protected assignment owner"],
-        ["authority launch", "Launch one mapped native gated worker"],
-        ["authority status", "Inspect protected launch ownership"],
-        ["authority terminate", "Terminate the original native gated child"],
-        ["authority worker", "Consume original authenticated prepared work"],
-        ["authority task-context", "Read captured original task context through the fixed entry"],
-        ["authority task-context-principal", "Classify the actual caller through retained protected owners"],
-        ["authority task-context-selection", "Read the authenticated original context entry selection"],
-        ["authority inbox-context-principal", "Classify the actual caller through every retained protected owner"],
-        ["authority inbox-context-selection", "Read the fixed installed inbox context selection"],
-        ["delivery", "Execute or reconcile attempt-bound forge delivery"],
-        ["submit-candidate", "Submit original protected worker candidate bytes"],
-        ["submit-result", "Submit original protected worker receipt and artifact bytes"],
-        ["campaign-export-result", "Download the original parent campaign's verified accepted result"],
-        ["campaign-record-round", "Consume canonical settled children into the original campaign store"],
         ["status", "Show assignment status"],
         ["step", "Show step instructions"],
         ["start", "Start next workable step"],
@@ -127,12 +74,6 @@ module Ace
         ["list", "List all assignments"],
         ["select", "Select active assignment"],
         ["fork-run", "Run subtree in forked process"],
-        ["attempt start", "Start a scoped attempt for an assignment step"],
-        ["attempt status", "Show attempt status for an assignment"],
-        ["attempt evidence", "Read accepted current-head check evidence"],
-        ["attempt finish", "Finish a protected canonical result or an ordinary local receipt"],
-        ["attempt reconcile", "Recover an exact protected attempt or reconcile an ordinary attempt"],
-        ["inbox-bind", "Bind an original protected Inbox registration"],
       ].freeze
 
       HELP_EXAMPLES = [
@@ -142,10 +83,7 @@ module Ace
         "ace-assign start                      # Start next workable step",
         "ace-assign finish --message done.md    # Complete active step",
         "cat report.md | ace-assign finish     # Complete step via stdin",
-        "ace-assign fork-run 010.01            # Run subtree in subprocess",
-        "ace-assign attempt start --assignment ID --step 010 --project ID",
-        "ace-assign attempt finish --attempt ID --receipt receipt.json",
-        "ace-assign resume --assignment ID --dry-run"
+        "ace-assign fork-run 010.01            # Run subtree in subprocess"
       ].freeze
 
       # Captured command exit code from last run
@@ -181,18 +119,7 @@ module Ace
       end
 
       # Register commands (wrapped to capture exit codes)
-      register "authority serve", wrap_command(Commands::Authority::Serve)
-register "authority launch", wrap_command(Commands::Authority::Launch)
-register "authority status", wrap_command(Commands::Authority::Status)
-register "authority terminate", wrap_command(Commands::Authority::Terminate)
-register "authority worker", wrap_command(Commands::Authority::Worker)
-register "authority task-context", wrap_command(Commands::Authority::TaskContext)
-register "authority task-context-principal", wrap_command(Commands::Authority::TaskContextPrincipal)
-register "authority task-context-selection", wrap_command(Commands::Authority::TaskContextSelection)
-register "authority inbox-context-principal", wrap_command(Commands::Authority::InboxContextPrincipal)
-register "authority inbox-context-selection", wrap_command(Commands::Authority::InboxContextSelection)
       register "create", wrap_command(Commands::Create)
-      register "delivery", wrap_command(Commands::Delivery)
       register "status", wrap_command(Commands::Status)
       register "step", wrap_command(Commands::Step)
       register "start", wrap_command(Commands::Start)
@@ -204,17 +131,6 @@ register "authority inbox-context-selection", wrap_command(Commands::Authority::
       register "select", wrap_command(Commands::Select)
       register "fork-run", wrap_command(Commands::ForkRun)
       register "fork-session", wrap_command(Commands::ForkSession)
-      register "attempt start", wrap_command(Commands::Attempt::Start)
-      register "attempt status", wrap_command(Commands::Attempt::Status)
-      register "attempt evidence", wrap_command(Commands::Attempt::Evidence)
-      register "attempt finish", wrap_command(Commands::Attempt::Finish)
-      register "attempt reconcile", wrap_command(Commands::Attempt::Reconcile)
-      register "resume", wrap_command(Commands::Resume)
-      register "inbox-bind", wrap_command(Commands::InboxBind)
-      register "submit-candidate", wrap_command(Commands::SubmitCandidate)
-      register "submit-result", wrap_command(Commands::SubmitResult)
-      register "campaign-export-result", wrap_command(Commands::CampaignExportResult)
-      register "campaign-record-round", wrap_command(Commands::CampaignRecordRound)
 
       # Register version command
       version_cmd = Ace::Support::Cli::VersionCommand.build(

data/lib/ace/assign/errors.rb

@@ -50,94 +50,22 @@ module Ace
       class InvalidState < Error; end
     end
 
-    # Attempt/evidence-related errors (exit code 5)
-    module AttemptErrors
-      class InvalidTransition < Error
-        def initialize(message = "Illegal attempt state transition")
-          super(message, exit_code: 5)
-        end
-      end
-
-      class InvalidScope < Error
-        def initialize(message = "Invalid attempt scope")
-          super(message, exit_code: 5)
-        end
-      end
-
-      # Duplicate start with a conflicting binding for an owned subtree
+    # Local prune/start exclusion errors (exit code 5).
+    module LifecycleErrors
+      # The identity was pruned or its exclusion artifacts are unsafe, so a
+      # writer must not be started against it.
       class Conflict < Error
-        def initialize(message = "Conflicting active attempt for scope")
-          super(message, exit_code: 5)
-        end
-      end
-
-      # An exact authorization reference is not currently valid for a new
-      # effect: consumed by another live request, expired, or out of scope.
-      class AuthorizationConflict < Conflict; end
-
-      class NotFound < Error
-        def initialize(message = "Attempt not found")
-          super(message, exit_code: 5)
-        end
-      end
-
-      # Untrusted or unknown execution identity; authority fails closed
-      class UnauthorizedIdentity < Error
-        def initialize(message = "Unknown or unauthorized execution identity")
-          super(message, exit_code: 5)
-        end
-      end
-
-      # Receipt failed verification (binding, head, digest, artifacts, review)
-      class ReceiptRejected < Error
-        def initialize(message = "Receipt rejected")
-          super(message, exit_code: 5)
-        end
-      end
-
-      # Byte framing failed before any business receipt could be admitted.
-      class MalformedTransfer < ReceiptRejected; end
-
-      # Recovery settled a prior effect, but did not perform this request.
-      class CurrentEffectRequired < ReceiptRejected
-        def initialize(operation:, recovered_operation:)
-          super("Recovered #{recovered_operation}; requested #{operation} still needs execution")
-        end
-      end
-
-      # Attempt state forbids the requested effect (terminal, uncertain, blocked)
-      class InvalidState < Error
-        def initialize(message = "Attempt state forbids the requested operation")
+        def initialize(message = "Conflicting lifecycle identity")
           super(message, exit_code: 5)
         end
       end
 
-      # Evidence storage is missing or unwritable; external effects are blocked
-      class EvidenceUnavailable < Error
-        def initialize(message = "Evidence storage unavailable")
+      # Maintenance exclusion is busy or its admission deadline expired.
+      class MaintenanceBusy < Error
+        def initialize(message = "Maintenance exclusion is busy")
           super(message, exit_code: 5)
         end
       end
-
-      # Complete maintenance exclusions are busy or their admission deadline expired.
-      class MaintenanceBusy < EvidenceUnavailable
-      end
-
-      # One canonical inventory row cannot fit the fixed protocol frame.
-      class BoundedResultUnavailable < EvidenceUnavailable
-      end
-
-      # Exhaustively authenticated service inventory remains unsettled.
-      class ServiceSettlementPending < EvidenceUnavailable
-      end
-
-      # Exhaustively authenticated current Inbox claims remain queued.
-      class InboxSettlementPending < EvidenceUnavailable
-      end
-
-      # Positively admitted original Inbox work remains pending, not corrupt.
-      class InboxContextPending < EvidenceUnavailable
-      end
     end
   end
 end

data/lib/ace/assign/models/assignment.rb

@@ -20,7 +20,7 @@ module Ace
       # but tests would need to be updated to provide all required fields.
       class Assignment
         attr_reader :id, :name, :description, :created_at, :updated_at, :source_config, :cache_dir, :parent,
-          :task_id, :project_id, :campaign_execution, :review_campaign
+          :task_id, :project_id
 
         # @param id [String] Unique assignment ID (6-char compact timestamp)
         # @param name [String] Human-readable assignment name
@@ -33,7 +33,7 @@ module Ace
         # @param task_id [String, nil] Source task ID attached to this assignment (nil = taskless)
         # @param project_id [String, nil] Project ID this assignment executes in
         def initialize(id:, name:, created_at:, source_config:, description: nil, updated_at: nil, cache_dir: nil,
-          parent: nil, task_id: nil, project_id: nil, campaign_execution: nil, review_campaign: nil)
+          parent: nil, task_id: nil, project_id: nil)
           @id = id.freeze
           @name = name.freeze
           @description = description&.freeze
@@ -44,29 +44,10 @@ module Ace
           @parent = parent&.freeze
           @task_id = task_id&.freeze
           @project_id = project_id&.freeze
-          if !campaign_execution.nil? && !review_campaign.nil?
-            raise ArgumentError, "assignment cannot own both parent campaign and child execution"
-          end
-          @campaign_execution = immutable_campaign_execution(campaign_execution) unless campaign_execution.nil?
-          @review_campaign = immutable_campaign_execution(review_campaign) unless review_campaign.nil?
-        end
-
-        # Keep registered definition bytes stable without retaining caller-owned
-        # mutable objects. Authority validates the closed linkage and provenance.
-        private def immutable_campaign_execution(value)
-          case value
-          when Hash
-            value.to_h { |key, item| [immutable_campaign_execution(key), immutable_campaign_execution(item)] }.freeze
-          when Array then value.map { |item| immutable_campaign_execution(item) }.freeze
-          when String then value.dup.freeze
-          when Integer, NilClass, TrueClass, FalseClass then value
-          else raise ArgumentError, "invalid campaign execution value"
-          end
         end
 
         # @return [Boolean] True when a source task is attached; taskless
-        #   assignments persist attempts locally only and never claim
-        #   Git-backed recovery
+        #   assignments keep their plan state locally only.
         def managed?
           !task_id.nil? && !task_id.to_s.strip.empty?
         end
@@ -83,9 +64,7 @@ module Ace
             "source_config" => source_config,
             "parent" => parent,
             "task_id" => task_id,
-            "project_id" => project_id,
-            "campaign_execution" => campaign_execution,
-            "review_campaign" => review_campaign
+            "project_id" => project_id
           }.compact
         end
 
@@ -104,9 +83,7 @@ module Ace
             cache_dir: cache_dir,
             parent: data["parent"],
             task_id: data["task_id"],
-            project_id: data["project_id"],
-            campaign_execution: data["campaign_execution"],
-            review_campaign: data["review_campaign"]
+            project_id: data["project_id"]
           )
         end
 

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

@@ -195,32 +195,6 @@ module Ace
           updated
         end
 
-        # The attempt store sharing this manager's cache base. The store is
-        # the single authority for attempt records and subtree ownership;
-        # assignment metadata never carries attempt history.
-        #
-        # @return [Molecules::AttemptStore] Attempt store
-        def attempt_store
-          @attempt_store ||= Molecules::AttemptStore.new(cache_base: @cache_base)
-        end
-
-        # Assignment-scoped lookup of the active attempt for a scope.
-        #
-        # @param assignment_id [String] Assignment ID
-        # @param scope [String] Step/subtree scope
-        # @return [Models::Attempt, nil] Active attempt or nil
-        def active_attempt(assignment_id, scope)
-          attempt_store.active(assignment_id, scope)
-        end
-
-        # All attempts recorded for an assignment.
-        #
-        # @param assignment_id [String] Assignment ID
-        # @return [Array<Models::Attempt>] Persisted attempts
-        def attempts(assignment_id)
-          attempt_store.list(assignment_id)
-        end
-
         # List all assignments
         #
         # @return [Array<Models::Assignment>] All assignments

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

@@ -85,22 +85,14 @@ module Ace
         end
 
         def launch_provider_session(assignment_id:, fork_root:, provider:, cli_args: nil, timeout: nil, cache_dir: nil,
-          last_message_file: nil, session_meta_file: nil, prepared_input: nil)
+          last_message_file: nil, session_meta_file: nil)
           ensure_not_same_scoped_refork!(assignment_id: assignment_id, fork_root: fork_root)
           resolved_provider = provider || config.dig("execution", "provider") || DEFAULT_PROVIDER
           resolved_timeout = timeout || config.dig("execution", "timeout") || DEFAULT_TIMEOUT
           scoped_assignment = "#{assignment_id}@#{fork_root}"
-          if prepared_input && prepared_input.descriptor.values_at("assignment_id", "scope") != [assignment_id, fork_root]
-            raise Error, "Prepared provider scope differs"
-          end
-          prompt = prepared_input ? prepared_input.drive_prompt : "/as-assign-drive #{scoped_assignment}"
+          prompt = "/as-assign-drive #{scoped_assignment}"
           last_msg_file = last_message_file || build_last_message_file(cache_dir, fork_root)
           scope_env = self.class.fork_scope_env(assignment_id: assignment_id, fork_root: fork_root)
-          if prepared_input
-            scope_env = scope_env.merge("ACE_ASSIGN_LAUNCH_MAPPING" => prepared_input.descriptor.fetch("mapping_id"),
-              "ACE_ASSIGN_ASSIGNMENT_ID" => assignment_id, "ACE_ASSIGN_ATTEMPT_ID" => prepared_input.descriptor.fetch("attempt_id"),
-              "ACE_ASSIGN_TASK_CONTEXT_ENTRY" => JSON.generate(prepared_input.descriptor.fetch("task_context_entry").fetch("manifest")))
-          end
 
           result = query_interface.query(
             resolved_provider,
@@ -111,7 +103,7 @@ module Ace
             fallback: false,
             last_message_file: last_msg_file,
             subprocess_env: scope_env,
-            working_dir: prepared_input&.working_directory
+            working_dir: nil
           )
 
           if last_msg_file && result[:text] && !result[:text].strip.empty?
@@ -120,7 +112,7 @@ module Ace
           end
 
           write_session_metadata(last_msg_file, result, prompt: prompt, session_meta_file: session_meta_file,
-            discover_session: prepared_input.nil?)
+            discover_session: true)
 
           result
         rescue Ace::LLM::Error => e

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

@@ -6,7 +6,6 @@ require "json"
 require "open3"
 require "time"
 require "securerandom"
-require_relative "../atoms/evidence_digest"
 
 module Ace
   module Assign
@@ -17,108 +16,15 @@ module Ace
       # common dir — so they survive removal of the assignment cache, the
       # worktree, or a recreated lock pathname. Prune holds the exclusive
       # side from its final evidence reads through completion of removal;
-      # every supported start path (attempt registration, fork/driver
-      # session launch, worktree provisioning) holds the shared side while
-      # registering a writer.
+      # every supported start path (fork/driver session launch, worktree
+      # provisioning) holds the shared side while registering a writer.
       #
       # A `removed` marker recorded by prune makes post-deletion starts fail
       # closed instead of recreating the deleted identity: acquiring the
-      # shared side raises {AttemptErrors::Conflict} when the marker is
+      # shared side raises {LifecycleErrors::Conflict} when the marker is
       # 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)
         def initialize(repo_root: nil, root: nil)
           @root = root || self.class.default_root(repo_root)
         end
@@ -132,7 +38,7 @@ module Ace
             "git", "-C", repo_root, "rev-parse", "--path-format=absolute", "--git-common-dir"
           )
           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"
+            raise LifecycleErrors::Conflict, "Repository lifecycle root is unavailable"
           end
           File.join(common_dir.strip, "ace", "lifecycle-exclusion")
         end
@@ -141,9 +47,6 @@ module Ace
           "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
@@ -174,7 +77,7 @@ module Ace
           begin
             mode = File::LOCK_EX | (deadline ? File::LOCK_NB : 0)
             unless lock.flock(mode)
-              raise AttemptErrors::MaintenanceBusy, "maintenance exclusion is busy"
+              raise LifecycleErrors::MaintenanceBusy, "maintenance exclusion is busy"
             end
             maintenance_deadline!(deadline) unless deadline.nil?
             yield
@@ -198,7 +101,7 @@ module Ace
           begin
             if removed?(key)
               unless reset_removed
-                raise AttemptErrors::Conflict, removed_message(key)
+                raise LifecycleErrors::Conflict, removed_message(key)
               end
 
               clear_removed!(key)
@@ -236,7 +139,7 @@ module Ace
             ordered.each do |key|
               if removed?(key)
                 unless reset_removed
-                  raise AttemptErrors::Conflict, removed_message(key)
+                  raise LifecycleErrors::Conflict, removed_message(key)
                 end
 
                 clear_removed!(key)
@@ -267,25 +170,25 @@ module Ace
             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"
+              raise LifecycleErrors::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"
+              raise LifecycleErrors::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"
+              raise LifecycleErrors::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
+          raise LifecycleErrors::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"
+          raise LifecycleErrors::Conflict, "Lifecycle marker is unavailable or malformed"
         end
 
         def clear_removed!(key)
@@ -305,12 +208,12 @@ module Ace
           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"
+            raise LifecycleErrors::MaintenanceBusy, "maintenance exclusion is not a regular file"
           end
           retained = true
           file
         rescue SystemCallError
-          raise AttemptErrors::Conflict, "Lifecycle lock is unavailable"
+          raise LifecycleErrors::Conflict, "Lifecycle lock is unavailable"
         ensure
           file&.close unless retained
         end
@@ -320,7 +223,7 @@ module Ace
             raise ArgumentError, "maintenance deadline must be finite"
           end
           if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
-            raise AttemptErrors::MaintenanceBusy, "maintenance admission deadline expired"
+            raise LifecycleErrors::MaintenanceBusy, "maintenance admission deadline expired"
           end
         end
 

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

@@ -12,9 +12,10 @@ module Ace
       # operation delegates to the resolved Ace::Runtime adapter; assign
       # never calls a runtime-native API directly (k86.3 interface rule).
       class RuntimeControlSurfaceRunner
-        def initialize(runtime: nil, env: ENV)
+        def initialize(runtime: nil, env: ENV, adapter: nil)
           @runtime_name = runtime
           @env = env
+          @runtime = adapter
         end
 
         attr_reader :runtime_name, :env

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

@@ -68,12 +68,6 @@ 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?