ace-assign 0.58.0 → 0.60.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c66fd1fc72e1bb186537931c960477dc7f9405ce3bc0f41c195a4b6601aa9bd1
-  data.tar.gz: fef52c4c68bbb1435499d7cb0468d09919b5b330d9d7226b4c676c54c12ff9ad
+  metadata.gz: 3a8f387dd91c6da87ca5eb3712cb5fb71051a0326dfa13cf0d9d91e054c1cc00
+  data.tar.gz: 4698ad04a950a1401caec3387ef085e8c66512a07e9dd5af168446d80e7d89eb
 SHA512:
-  metadata.gz: 8e31f4379b900c7906be0b15b92768c904d57bf3fcfccbaf284ca972168413be443907281e1f1b939dff66337daf2835f32fc27c27fc802738dbe19238f220c4
-  data.tar.gz: f77a7e04992fddf9b8ddf99e57243759e1ec8ccbd7502fbae9836e32bd749a60b5feb7d7c4a63017f92b384efdce49654547b7ecb1d18fb29c66cab644dad18a
+  metadata.gz: 89c8df3b2e0823c195dfc3d3b59fbcc58e79c97b3978e0db2e4395c83e86307e8d450a637e633b9aa947efeb79ff94ba78307bc24de577effb8cb55b53e9b8f5
+  data.tar.gz: dd2e0a73591ea2e646c9c8164cb56269ff6353860005acdfb57bc268ca8e2d5c89b77b3a19af8a1b895dcfa8716199ae0272a1705387dc4c5f5bda424c062668

data/CHANGELOG.md

@@ -7,6 +7,27 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.60.0] - 2026-10-01
+
+### Fixed
+- Preserve task/project attachment when the public assignment creation path archives its source configuration, so managed attempts retain immutable journal authority.
+- Cache-free evidence lookup handles a seed-only journal ref without creating a checkout or treating an absent attempt as a corrupt journal.
+
+### Added
+- `attempt evidence --kind review-approval` validates accepted independent approval separately from collection; retained collection/approval receipts support explicit historical-head validation without granting current check authority.
+- Bind campaign check names to accepted executed operations and review collection to accepted `review-collect` artifacts, through `attempt evidence` purpose checks.
+
+- `ace-assign attempt evidence` exposes read-only coordinator-accepted current-head check proof. Journal reads use immutable Git objects without writing cache/audit checkout state.
+- Review receipts may consume a durable ace-review campaign result. The existing coordinator still validates authority, live head, independent reviewer, executed checks and artifact digests; stale or conflicting campaign snapshots are rejected.
+
+## [0.59.0] - 2026-09-29
+
+### Added
+- Durable lifecycle exclusion (`Ace::Assign::Molecules::LifecycleExclusion`): prune holds the exclusive side from final evidence reads through removal while every supported start path -- attempt registration, fork/driver session launch, and worktree provisioning -- holds the shared side. Locks live outside every deletion target (sandbox-aware cache base or the shared Git common dir) so they survive removal of the target, and a `removed` marker makes post-prune starts fail closed instead of recreating a deleted identity.
+
+### Changed
+- `AttemptCoordinator#start` and `ForkSessionLauncher#launch` now participate in the prune exclusion: a concurrent prune blocks new writers for the identity, and a start targeting a pruned assignment raises a conflict instead of writing into a recreated path.
+
 ## [0.58.0] - 2026-09-28
 
 ### Added
@@ -503,7 +524,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Unified dynamic step default instructions under a single `AssignmentExecutor::DEFAULT_DYNAMIC_STEP_INSTRUCTIONS` source.
 - Limited canonical batch expansion to explicit `workflow`, `skill`, or declared `sub_steps` inputs, preserving prior numbering behavior for plain flat batch inserts.
 - Updated usage, getting-started, and handbook docs to cover the new `add --from` workflow.
-- Updated `record-demo` step instructions to require diagnosis before skipping on failure — agents must check config, available fonts, and spike findings before reporting a non-blocking skip.
+- Updated `record-demo` step instructions to require diagnosis before skipping on failure -- agents must check config, available fonts, and spike findings before reporting a non-blocking skip.
 - Added `decision_notes.non_blocking_policy` to `record-demo` step catalog entry clarifying that "non-blocking" means "diagnose and retry before skipping," not "skip on first failure."
 
 ### Technical
@@ -959,7 +980,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [0.20.0] - 2026-03-05
 
 ### Added
-- Provider-specific session detection fallback in `ForkSessionLauncher` — when a provider doesn't return a native `session_id`, scans local session storage via `SessionFinder` to detect the forked session by prompt matching.
+- Provider-specific session detection fallback in `ForkSessionLauncher` -- when a provider doesn't return a native `session_id`, scans local session storage via `SessionFinder` to detect the forked session by prompt matching.
 - Session metadata file (`<root>-session.yml`) written for every fork run, capturing `session_id`, `provider`, `model`, and `completed_at` for traceability.
 - Stall error messages now include `Session: <id>` when session metadata is available, enabling direct trace to agent session.
 
@@ -1044,14 +1065,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [0.16.1] - 2026-03-04
 
 ### Fixed
-- Correct `.agents/skills` typo to `.agent/skills` in default config and `SkillAssignSourceResolver` — skill discovery now uses the canonical provider-neutral path
+- Correct `.agents/skills` typo to `.agent/skills` in default config and `SkillAssignSourceResolver` -- skill discovery now uses the canonical provider-neutral path
 
 ## [0.16.0] - 2026-03-04
 
 ### Added
-- New `onboard-base` catalog step — loads base project context via `ace-bundle project-base`
-- New `task-load` catalog step — loads task behavioral spec via `ace-bundle task://<taskref>`
-- Taskref placeholder substitution in catalog step descriptions — `<taskref>` in step descriptions is replaced with actual task reference during child instruction building
+- New `onboard-base` catalog step -- loads base project context via `ace-bundle project-base`
+- New `task-load` catalog step -- loads task behavioral spec via `ace-bundle task://<taskref>`
+- Taskref placeholder substitution in catalog step descriptions -- `<taskref>` in step descriptions is replaced with actual task reference during child instruction building
 
 ### Changed
 - Default assignment presets updated to use ace-task
@@ -1065,7 +1086,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [0.15.1] - 2026-03-01
 
 ### Added
-- Fork-run crash recovery protocol in drive workflow — detection, commit partial work, progress report, inject recovery steps, re-fork pattern for partial completion scenarios
+- Fork-run crash recovery protocol in drive workflow -- detection, commit partial work, progress report, inject recovery steps, re-fork pattern for partial completion scenarios
 
 ## [0.15.0] - 2026-02-28
 
@@ -1222,7 +1243,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [0.12.14] - 2026-02-22
 
 ### Added
-- Subtree guard step in drive workflow — driver reviews all fork report files before continuing to next step
+- Subtree guard step in drive workflow -- driver reviews all fork report files before continuing to next step
 - Report review instruction in split-subtree-root step template for fork context
 
 ## [0.12.13] - 2026-02-22
@@ -1295,13 +1316,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [0.12.1] - 2026-02-19
 
 ### Fixed
-- `reflect-verify-cycle` pair changed from `sequential` to `conditional` — prevents overriding optional strength of reflect-and-refactor
+- `reflect-verify-cycle` pair changed from `sequential` to `conditional` -- prevents overriding optional strength of reflect-and-refactor
 - Renamed `max_recursion` to `max_reruns` in replan config for clarity
 
 ## [0.12.0] - 2026-02-19
 
 ### Added
-- New `reflect-and-refactor` step in catalog — analyzes implementation against ATOM principles and executes targeted refactoring before PR creation
+- New `reflect-and-refactor` step in catalog -- analyzes implementation against ATOM principles and executes targeted refactoring before PR creation
 - Composition rules for reflect-and-refactor: ordering (after verify, before mark-done/release/retro), pairs (verify cycle, fix cycle, replan cycle), and conditional suggestion
 - `create-retro` step now consumes `findings-report` from reflect-and-refactor as recommended prerequisite
 - `implement-with-pr` recipe updated to include optional reflect-and-refactor step after work-on-task
@@ -1315,7 +1336,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
-- `assignment_state` now checks `completed` before `failed` — assignments where all steps are done/failed correctly report `:completed` instead of `:failed`
+- `assignment_state` now checks `completed` before `failed` -- assignments where all steps are done/failed correctly report `:completed` instead of `:failed`
 
 ### Added
 
@@ -1906,7 +1927,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
-- CLI `start` command crashes with positional argument (`ace-assign start job.yaml`) because `option :config` requires `--config` flag — renamed command to `create` with `argument :config`
+- CLI `start` command crashes with positional argument (`ace-assign start job.yaml`) because `option :config` requires `--config` flag -- renamed command to `create` with `argument :config`
 - `ace-bundle wfi://prepare-assignment` fails due to missing project-level wfi:// protocol registration
 
 ### Added

data/docs/usage.md

@@ -107,6 +107,23 @@ ace-assign attempt reconcile --attempt ATTEMPT --receipt receipt.json
 
 `reserved -> running -> succeeded | failed | stopped | uncertain`; reconciliation may resolve `uncertain -> succeeded | failed`. Terminal attempts accept no new effects, and accepted history is append-only.
 
+### Read accepted execution authority
+
+`attempt evidence` reads a managed coordinator-accepted receipt from immutable journal history without transitions, cache writes, or audit checkout creation. Supply the accepted attempt ID and exact canonical receipt digest. The trusted local operator or OS-enforced service verifies the actual executed outcome before accepting its receipt; worker-authored success claims cannot accept themselves. This reader consumes that attestation and does not execute a test or model.
+
+```sh
+ace-assign attempt evidence --attempt ATTEMPT --receipt-digest SHA256 --format json \
+  --kind check --check-name tests
+ace-assign attempt evidence --attempt ATTEMPT --receipt-digest SHA256 --format json \
+  --kind review-collection
+ace-assign attempt evidence --attempt ATTEMPT --receipt-digest SHA256 --format json \
+  --kind review-collection --historical-head EXACT_RECORDED_HEAD
+ace-assign attempt evidence --attempt ATTEMPT --receipt-digest SHA256 --format json \
+  --kind review-approval
+```
+
+A check proof requires the live candidate head, intact accepted artifacts, and the matching executed operation: `tests` uses `test`, other explicit check names use that operation name. Review collection requires an accepted `review-collect` operation with a passed `review-execution` outcome and the retained metadata/report/prompt artifacts. Review approval requires an ordinary accepted `review` operation with the approved independent reviewer verdict, exact head and retained report artifacts; collection proof cannot substitute for approval. Both collection and approval support an exact `--historical-head`. Historical review validation exposes `historical: true` and the recorded head; it preserves accepted source authority across head drift and cannot certify live checks. Unknown receipts, changed artifacts, unaccepted/unmanaged history, wrong purposes and stale current queries fail closed. Retain the configured evidence ref alongside durable review campaigns.
+
 ### Evidence storage and recovery modes
 
 - Task-attached (managed) attempts journal accepted evidence to the configured evidence Git ref (default `refs/ace/execution`) through an isolated, disposable audit checkout, outside the deliverable candidate branch. Journal commits never advance or exempt the reviewed candidate.

data/lib/ace/assign/cli/commands/attempt/evidence.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+require_relative "base"
+module Ace
+  module Assign
+    module CLI
+      module Commands
+        module Attempt
+          class Evidence < Ace::Support::Cli::Command
+            include Attempt::Base
+            desc "Read coordinator-accepted live execution or historical review authority"
+            option :attempt, required: true, desc: "Accepted execution attempt ID"
+            option :receipt_digest, required: true, desc: "Accepted receipt digest"
+            option :kind, default: "check", desc: "Evidence purpose: check, review-collection or review-approval"
+            option :check_name, default: "tests", desc: "Required check name (tests binds operation test)"
+            option :historical_head, desc: "Recorded collection/approval head for historical authority only"
+            option :format, default: "json", desc: "JSON evidence projection"
+
+            def call(**options)
+              raise Ace::Support::Cli::Error, "evidence supports --format json" unless options[:format] == "json"
+              emit_json(build_coordinator.evidence(attempt_id: options[:attempt], receipt_digest: options[:receipt_digest],
+                kind: options[:kind], check_name: options[:check_name], historical_head: options[:historical_head]))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/assign/cli.rb

@@ -31,6 +31,7 @@ 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"
@@ -70,6 +71,7 @@ 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
@@ -94,6 +96,7 @@ module Ace
         ["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 an attempt with a structured execution receipt"],
         ["attempt reconcile", "Reconcile an interrupted or uncertain attempt"]
       ].freeze
@@ -157,6 +160,7 @@ module Ace
       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)
 

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

@@ -24,7 +24,7 @@ module Ace
         ].freeze
 
         attr_reader :attempt_id, :assignment_id, :project_id, :scope, :operation,
-          :producer, :head, :verdict, :artifacts, :checks, :review, :recorded_at, :digest
+          :producer, :head, :verdict, :artifacts, :checks, :review, :campaign, :recorded_at, :digest
 
         # @param attempt_id [String] Attempt the receipt belongs to
         # @param assignment_id [String] Owning assignment ID
@@ -40,7 +40,7 @@ module Ace
         # @param recorded_at [Time] Receipt creation time
         # @param digest [String, nil] Canonical digest (computed when nil)
         def initialize(attempt_id:, assignment_id:, project_id:, scope:, operation:, producer:, head:, verdict:,
-          artifacts: [], checks: [], review: nil, recorded_at:, digest: nil)
+          artifacts: [], checks: [], review: nil, campaign: nil, recorded_at:, digest: nil)
           @attempt_id = attempt_id
           @assignment_id = assignment_id
           @project_id = project_id
@@ -52,6 +52,7 @@ module Ace
           @artifacts = artifacts
           @checks = checks
           @review = review
+          @campaign = campaign
           @recorded_at = recorded_at
           @digest = digest || Atoms::EvidenceDigest.digest(digest_payload)
         end
@@ -61,7 +62,7 @@ module Ace
         #
         # @return [Hash] Digest payload
         def digest_payload
-          {
+          payload = {
             "attempt_id" => attempt_id,
             "assignment_id" => assignment_id,
             "project_id" => project_id,
@@ -74,6 +75,8 @@ module Ace
             "checks" => checks,
             "review" => review
           }
+          payload["campaign"] = campaign if campaign
+          payload
         end
 
         # Convert to a hash for serialization.
@@ -102,6 +105,7 @@ module Ace
             artifacts: data["artifacts"] || [],
             checks: data["checks"] || [],
             review: data["review"],
+            campaign: data["campaign"],
             recorded_at: parse_time(data["recorded_at"]) || Time.now.utc,
             digest: data["digest"]
           )

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

@@ -97,11 +97,15 @@ module Ace
           value = ref_value
           return [] if value.nil?
 
-          with_lock do
-            ensure_checkout!
-            sync_checkout(value)
-            order_by_chain(event_files(assignment_id).map { |path| JSON.parse(File.read(path)) })
+          paths, stderr, status = git("ls-tree", "-r", "--name-only", value, "--",
+            "execution/#{assignment_id}/events/")
+          raise AttemptErrors::EvidenceUnavailable, "Cannot read journal events: #{stderr}" unless status.success?
+          events = paths.lines.map(&:strip).select { |path| path.end_with?(".json") }.map do |path|
+            content, error, read_status = git("show", "#{value}:#{path}")
+            raise AttemptErrors::EvidenceUnavailable, "Cannot read journal event: #{error}" unless read_status.success?
+            JSON.parse(content)
           end
+          order_by_chain(events)
         rescue JSON::ParserError => e
           raise AttemptErrors::EvidenceUnavailable, "Corrupt journal event for #{assignment_id}: #{e.message}"
         end
@@ -155,14 +159,9 @@ module Ace
           value = ref_value
           return [] if value.nil?
 
-          with_lock do
-            ensure_checkout!
-            sync_checkout(value)
-            Dir.glob(File.join(checkout_dir, "execution", "*"))
-              .select { |path| File.directory?(path) }
-              .map { |path| File.basename(path) }
-              .sort
-          end
+          paths, stderr, status = git("ls-tree", "-d", "--name-only", value, "--", "execution/")
+          raise AttemptErrors::EvidenceUnavailable, "Cannot discover journal assignments: #{stderr}" unless status.success?
+          paths.lines.map { |path| path.strip.delete_prefix("execution/") }.sort
         end
 
         private

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

@@ -42,31 +42,46 @@ module Ace
           @interactive_builder = interactive_builder || Ace::LLM::Molecules::InteractiveCommandBuilder.new
         end
 
+        def initialize(config: nil, query_interface: Ace::LLM::QueryInterface, tmux_runner: nil, interactive_builder: nil,
+          lifecycle_exclusion: nil)
+          @config = config || Ace::Assign.config
+          @query_interface = query_interface
+          @tmux_runner = tmux_runner || TmuxControlSurfaceRunner.new
+          @interactive_builder = interactive_builder || Ace::LLM::Molecules::InteractiveCommandBuilder.new
+          @lifecycle_exclusion = lifecycle_exclusion
+        end
+
         def launch(assignment_id:, fork_root:, provider: nil, cli_args: nil, timeout: nil, cache_dir: nil, launch_mode: nil, callback_pane: 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
           resolved_mode = resolve_launch_mode(launch_mode)
 
-          if resolved_mode == "tmux"
-            launch_tmux(
-              assignment_id: assignment_id,
-              fork_root: fork_root,
-              provider: resolved_provider,
-              cli_args: cli_args,
-              timeout: resolved_timeout,
-              cache_dir: cache_dir,
-              callback_pane: callback_pane
-            )
-          else
-            launch_provider_session(
-              assignment_id: assignment_id,
-              fork_root: fork_root,
-              provider: resolved_provider,
-              cli_args: cli_args,
-              timeout: resolved_timeout,
-              cache_dir: cache_dir
-            )
+          # Driver startup participates in prune exclusion: prune holds the
+          # exclusive side from final evidence reads through removal; a removed
+          # marker fails the launch closed instead of writing into a deleted
+          # assignment.
+          lifecycle_exclusion.with_shared(lifecycle_exclusion.assignment_key(assignment_id)) do
+            if resolved_mode == "tmux"
+              launch_tmux(
+                assignment_id: assignment_id,
+                fork_root: fork_root,
+                provider: resolved_provider,
+                cli_args: cli_args,
+                timeout: resolved_timeout,
+                cache_dir: cache_dir,
+                callback_pane: callback_pane
+              )
+            else
+              launch_provider_session(
+                assignment_id: assignment_id,
+                fork_root: fork_root,
+                provider: resolved_provider,
+                cli_args: cli_args,
+                timeout: resolved_timeout,
+                cache_dir: cache_dir
+              )
+            end
           end
         end
 
@@ -111,6 +126,10 @@ module Ace
 
         attr_reader :config, :query_interface, :tmux_runner, :interactive_builder
 
+        def lifecycle_exclusion
+          @lifecycle_exclusion ||= Molecules::LifecycleExclusion.new
+        end
+
         def resolve_launch_mode(explicit_mode)
           mode = explicit_mode.to_s.strip
           mode = config.dig("execution", "launch_mode").to_s.strip if mode.empty?

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

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+require "digest"
+require "fileutils"
+require "json"
+require "open3"
+require "time"
+
+module Ace
+  module Assign
+    module Molecules
+      # Durable start/prune exclusion for assignment and worktree identities.
+      #
+      # Lock files live OUTSIDE every deletion target — under the shared Git
+      # 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.
+      #
+      # 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
+      # present. Legitimate fresh provisioning (a new worktree for a task)
+      # clears the marker explicitly via `reset_removed`.
+      class LifecycleExclusion
+        # @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
+
+        # 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
+          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")
+        end
+
+        def assignment_key(assignment_id)
+          "assignment:#{assignment_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.
+        def task_key(task_id)
+          "task:#{task_id}"
+        end
+
+        def worktree_key(worktree_path)
+          canonical = begin
+            File.realpath(worktree_path.to_s)
+          rescue Errno::ENOENT, Errno::EACCES
+            File.expand_path(worktree_path.to_s)
+          end
+          "worktree:#{canonical}"
+        end
+
+        # Hold the exclusive side while recomputing proofs and removing the
+        # target. Start paths block for the whole block.
+        #
+        # @param key [String] Identity key
+        # @yield Required block executed under exclusive exclusion
+        def with_exclusive(key)
+          raise ArgumentError, "exclusion key is required" if key.to_s.empty?
+
+          lock = open_lock(key)
+          lock.flock(File::LOCK_EX)
+          begin
+            yield
+          ensure
+            lock.flock(File::LOCK_UN)
+            lock.close
+          end
+        end
+
+        # Hold the shared side while registering a writer or creating a
+        # resource. Fails closed when the identity was pruned.
+        #
+        # @param key [String] Identity key
+        # @param reset_removed [Boolean] Clear a stale removed marker instead
+        #   of raising (legitimate fresh provisioning of the same pathname)
+        def with_shared(key, reset_removed: false)
+          raise ArgumentError, "exclusion key is required" if key.to_s.empty?
+
+          lock = open_lock(key)
+          lock.flock(File::LOCK_SH)
+          begin
+            if removed?(key)
+              unless reset_removed
+                raise AttemptErrors::Conflict, removed_message(key)
+              end
+
+              clear_removed!(key)
+            end
+            yield
+          ensure
+            lock.flock(File::LOCK_UN)
+            lock.close
+          end
+        end
+
+        # Hold the shared side on several identities at once (acquired in the
+        # given order, released in reverse — callers must use one consistent
+        # global order, task before assignment, to avoid deadlock). Fails
+        # closed when any identity was pruned.
+        def with_shared_multi(keys, reset_removed: false)
+          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) }
+          begin
+            locks.each { |lock| lock.flock(File::LOCK_SH) }
+            ordered.each do |key|
+              if removed?(key)
+                unless reset_removed
+                  raise AttemptErrors::Conflict, removed_message(key)
+                end
+
+                clear_removed!(key)
+              end
+            end
+            yield
+          ensure
+            locks.reverse_each do |lock|
+              lock.flock(File::LOCK_UN)
+              lock.close
+            end
+          end
+        end
+
+        # Record that the identity was removed. Call while holding the
+        # exclusive side, BEFORE deleting the target.
+        def record_removed!(key)
+          atomic_write(
+            state_path(key),
+            JSON.generate({"removed" => true, "removed_at" => Time.now.utc.iso8601, "key" => key})
+          )
+        end
+
+        def removed?(key)
+          state = JSON.parse(File.read(state_path(key)))
+          state["removed"] == true
+        rescue Errno::ENOENT, JSON::ParserError, TypeError
+          false
+        end
+
+        def clear_removed!(key)
+          File.delete(state_path(key))
+        rescue Errno::ENOENT
+          nil
+        end
+
+        private
+
+        attr_reader :root
+
+        def open_lock(key)
+          FileUtils.mkdir_p(root)
+          File.open(lock_path(key), File::RDWR | File::CREAT)
+        end
+
+        def lock_path(key)
+          File.join(root, "#{Digest::SHA256.hexdigest(key)}.lock")
+        end
+
+        def state_path(key)
+          File.join(root, "#{Digest::SHA256.hexdigest(key)}.state.json")
+        end
+
+        def removed_message(key)
+          identity = key.to_s.sub(/\A[^:]+:/, "")
+          case key
+          when /\Aassignment:/
+            "Assignment #{identity} was pruned; refusing to start a writer on a removed identity"
+          when /\Atask:/
+            "Task #{identity} worktree was pruned; refusing to start a writer on a removed identity"
+          else
+            "Worktree #{identity} was pruned; refusing to start a writer on a removed identity"
+          end
+        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)
+          File.rename(temp, path)
+        ensure
+          File.delete(temp) if temp && File.exist?(temp)
+        end
+      end
+    end
+  end
+end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "digest"
+require "json"
 
 module Ace
   module Assign
@@ -55,12 +56,21 @@ module Ace
           verify_artifacts(data, repo_root) if data["verdict"] == "succeeded"
           verify_checks(data)
           verify_review(data)
+          verify_campaign(data, repo_root: repo_root, live_head: live_head)
 
           receipt = Models::ExecutionReceipt.from_h(data.merge("recorded_at" => Time.now.utc))
           verify_digest(receipt)
 
           receipt
         end
+        # Recheck the source artifacts/checks of an already accepted receipt.
+        def verify_accepted_evidence!(data, live_head:, repo_root:)
+          verify_head(data, live_head)
+          verify_artifacts(data, repo_root)
+          verify_checks(data)
+          verify_review(data)
+        end
+
         # @param operation [String] Receipt operation
         # @return [Boolean] True when the operation acts outside the repository
         def external_effect?(operation)
@@ -196,6 +206,41 @@ module Ace
           end
         end
 
+        # Consume ace-review's single campaign authority through the existing
+        # receipt boundary; a worker-supplied local result grants no authority.
+        def verify_campaign(data, repo_root:, live_head:)
+          campaign = data["campaign"]
+          return unless campaign
+          reject_unless(campaign.is_a?(Hash), "campaign must be an object")
+          reject("campaign result requires a succeeded review receipt") unless
+            data["operation"] == REVIEW_OPERATION && data["verdict"] == "succeeded"
+          reference = campaign["result"]
+          reject_unless(reference.is_a?(Hash), "campaign requires a result artifact reference")
+          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))
+          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"])
+          unless result["campaign_id"] == campaign["id"] && result["accepted"] == true &&
+              result["dry_run"] == false && current["accepted"] == true &&
+              result["result_identity"] == current["result_identity"] &&
+              result.dig("evidence", "current_head") == live_head && current.dig("evidence", "current_head") == live_head
+            reject("campaign result is stale, incomplete, blocked or does not match live authority")
+          end
+          approval = current["rounds"].last["approval"]
+          unless approval["producer"] == data.dig("producer", "actor") &&
+              approval["reviewer"] == data.dig("review", "reviewer", "actor") &&
+              approval["head"] == data["head"]
+            reject("campaign producer/reviewer attribution does not match independently validated receipt")
+          end
+        rescue JSON::ParserError, ArgumentError, TypeError, KeyError => e
+          reject("invalid campaign result: #{e.message}")
+        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

@@ -114,7 +114,9 @@ module Ace
             updated_at: assignment.updated_at,
             source_config: archived_path,
             cache_dir: assignment.cache_dir,
-            parent: assignment.parent
+            parent: assignment.parent,
+            task_id: assignment.task_id,
+            project_id: assignment.project_id
           )
           assignment_manager.update(assignment)
 

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

@@ -26,13 +26,15 @@ module Ace
         # @param journal [Molecules::EvidenceJournal, nil] Evidence journal (default built per repo)
         # @param identity_resolver [Molecules::ExecutionIdentityResolver, nil] Trust boundary
         # @param verifier [Molecules::ReceiptVerifier, nil] Receipt verifier
-        def initialize(cache_base: nil, repo_root: nil, journal: nil, identity_resolver: nil, verifier: nil)
+        def initialize(cache_base: nil, repo_root: nil, journal: nil, identity_resolver: nil, verifier: nil,
+          lifecycle_exclusion: nil)
           @manager = Molecules::AssignmentManager.new(cache_base: cache_base)
           @store = @manager.attempt_store
           @repo_root = repo_root || Ace::Support::Fs::Molecules::ProjectRootFinder.find_or_current
           @journal = journal
           @identity_resolver = identity_resolver || Molecules::ExecutionIdentityResolver.new
           @verifier = verifier || Molecules::ReceiptVerifier.new(identity_resolver: @identity_resolver)
+          @lifecycle_exclusion = lifecycle_exclusion
         end
 
         attr_reader :store
@@ -62,49 +64,61 @@ module Ace
           identity ||= @identity_resolver.resolve
           base_head = candidate_head!
 
-          @store.with_lock(assignment_id) do
-            journal_actives = assignment.managed? ? active_journal_attempts(assignment) : []
-
-            existing = @store.active(assignment_id, scope) ||
-              journal_actives.find { |attempt| Atoms::AssignmentScope.equal?(attempt.binding.scope, scope) }
-            if existing
-              if existing.binding.project_id == project && existing.binding.task_id == assignment.task_id &&
-                  existing.binding.actor == identity.actor && existing.binding.role == identity.role
-                return existing
+          # Serialize writer registration against prune: prune holds the
+          # exclusive exclusion from its final evidence reads through removal.
+          # A worktree-backed task identity shares the same protocol (task
+          # key first, then assignment key — the one consistent global
+          # order), so a worktree prune and an attempt start cannot interleave.
+          start_keys = []
+          unless assignment.task_id.to_s.strip.empty?
+            start_keys << lifecycle_exclusion.task_key(assignment.task_id)
+          end
+          start_keys << lifecycle_exclusion.assignment_key(assignment_id)
+          lifecycle_exclusion.with_shared_multi(start_keys) do
+            @store.with_lock(assignment_id) do
+              journal_actives = assignment.managed? ? active_journal_attempts(assignment) : []
+
+              existing = @store.active(assignment_id, scope) ||
+                journal_actives.find { |attempt| Atoms::AssignmentScope.equal?(attempt.binding.scope, scope) }
+              if existing
+                if existing.binding.project_id == project && existing.binding.task_id == assignment.task_id &&
+                    existing.binding.actor == identity.actor && existing.binding.role == identity.role
+                  return existing
+                end
+
+                raise AttemptErrors::Conflict,
+                  "Active attempt #{existing.attempt_id} already owns #{assignment_id}@#{scope} " \
+                  "(project #{existing.binding.project_id}); refusing to launch a second writer"
               end
 
-              raise AttemptErrors::Conflict,
-                "Active attempt #{existing.attempt_id} already owns #{assignment_id}@#{scope} " \
-                "(project #{existing.binding.project_id}); refusing to launch a second writer"
-            end
+              active_scopes = @store.list(assignment_id).select(&:active?).map(&:binding)
+              active_scopes.concat(journal_actives.map(&:binding))
+              blocker = active_scopes.find { |binding| scopes_overlap?(binding.scope, scope) }
+              if blocker
+                raise AttemptErrors::Conflict,
+                  "Active attempt scope #{blocker.scope} overlaps requested scope #{scope} on #{assignment_id}; " \
+                  "refusing overlapping writers"
+              end
 
-            active_scopes = @store.list(assignment_id).select(&:active?).map(&:binding)
-            active_scopes.concat(journal_actives.map(&:binding))
-            blocker = active_scopes.find { |binding| scopes_overlap?(binding.scope, scope) }
-            if blocker
-              raise AttemptErrors::Conflict,
-                "Active attempt scope #{blocker.scope} overlaps requested scope #{scope} on #{assignment_id}; " \
-                "refusing overlapping writers"
-            end
+              attempt_id = unique_attempt_id(assignment_id, journal_actives.map(&:attempt_id))
+              events = start_events(assignment_id, assignment, scope, project, identity, base_head, attempt_id)
+              attempt = reserve(assignment, scope, project, identity, base_head, attempt_id)
+              if attempt.managed?
+                commit = journal_for.append(
+                  assignment_id: assignment_id,
+                  attempt_id: attempt.attempt_id,
+                  events: events
+                )
+                attempt = attempt.with(journal_commit: commit)
+                attempt = yield_lost_ownership_race(attempt, assignment_id, scope)
+              else
+                attempt = attempt.with(events: events)
+              end
 
-            attempt_id = unique_attempt_id(assignment_id, journal_actives.map(&:attempt_id))
-            events = start_events(assignment_id, assignment, scope, project, identity, base_head, attempt_id)
-            attempt = reserve(assignment, scope, project, identity, base_head, attempt_id)
-            if attempt.managed?
-              commit = journal_for.append(
-                assignment_id: assignment_id,
-                attempt_id: attempt.attempt_id,
-                events: events
-              )
-              attempt = attempt.with(journal_commit: commit)
-              attempt = yield_lost_ownership_race(attempt, assignment_id, scope)
-            else
-              attempt = attempt.with(events: events)
+              @store.save(attempt)
+              @store.claim(assignment_id, scope, attempt)
+              attempt
             end
-
-            @store.save(attempt)
-            @store.claim(assignment_id, scope, attempt)
-            attempt
           end
         end
 
@@ -165,6 +179,60 @@ module Ace
           attempt.projection
         end
 
+        # Read accepted check evidence without transitions, locks, cache writes
+        # or audit checkout creation. Managed history comes from the Git ref.
+        def evidence(attempt_id:, receipt_digest:, kind: "check", check_name: "tests", historical_head: nil)
+          unless %w[check review-collection review-approval].include?(kind) && check_name.is_a?(String) && !check_name.strip.empty?
+            raise AttemptErrors::ReceiptRejected, "Invalid evidence kind or check name"
+          end
+          if !historical_head.nil? && (!%w[review-collection review-approval].include?(kind) || !historical_head.is_a?(String) ||
+              !historical_head.match?(/\A[0-9a-f]{40,64}\z/))
+            raise AttemptErrors::ReceiptRejected, "Historical evidence requires review collection/approval and an exact recorded head"
+          end
+          unless attempt_id.to_s.match?(/\A[a-zA-Z0-9][a-zA-Z0-9_.-]{0,127}\z/) &&
+              receipt_digest.to_s.match?(/\A[0-9a-f]{64}\z/)
+            raise AttemptErrors::ReceiptRejected, "Invalid attempt ID or receipt digest"
+          end
+          attempt = @store.find(attempt_id) || recover_managed_attempt(nil, attempt_id)
+          raise AttemptErrors::NotFound, "Attempt #{attempt_id} not found" unless attempt
+          raise AttemptErrors::ReceiptRejected, "Execution evidence requires managed immutable journal history" unless attempt.managed?
+          attempt = recover_managed_attempt(attempt.binding.assignment_id, attempt_id)
+          raise AttemptErrors::ReceiptRejected, "No succeeded accepted attempt" unless attempt&.state == "succeeded"
+          accepted = journal_for.accepted_receipts(attempt.binding.assignment_id)
+          data = accepted.find { |r| r["attempt_id"] == attempt_id && r["digest"] == receipt_digest }
+          raise AttemptErrors::ReceiptRejected, "Receipt was not accepted by coordinator" unless data
+          if kind == "check" && (%w[review review-collect].include?(data["operation"]) || @verifier.external_effect?(data["operation"]))
+            raise AttemptErrors::ReceiptRejected, "Review or external-effect operations cannot be check evidence"
+          end
+          expected_operation = case kind
+          when "review-collection" then "review-collect"
+          when "review-approval" then "review"
+          else check_name == "tests" ? "test" : check_name
+          end
+          unless data["campaign"].nil? && data["operation"] == expected_operation
+            raise AttemptErrors::ReceiptRejected, "Accepted receipt operation does not prove #{kind}: #{expected_operation}"
+          end
+          required_check = kind == "review-collection" ? "review-execution" : check_name
+          unless kind == "review-approval" || Array(data["checks"]).any? { |check| check["name"] == required_check && check["verdict"] == "passed" }
+            raise AttemptErrors::ReceiptRejected, "Accepted receipt does not prove the required check #{required_check}"
+          end
+          receipt = Models::ExecutionReceipt.from_h(data)
+          unless receipt.digest == Atoms::EvidenceDigest.digest(receipt.digest_payload)
+            raise AttemptErrors::ReceiptRejected, "Accepted receipt digest is corrupt"
+          end
+          evidence_head = historical_head || candidate_head!
+          unless data["verdict"] == "succeeded" && data["head"] == evidence_head && attempt.candidate_head == evidence_head
+            raise AttemptErrors::ReceiptRejected, "Accepted execution evidence is stale or unsuccessful"
+          end
+          @verifier.verify_accepted_evidence!(data, live_head: evidence_head, repo_root: @repo_root)
+          {"attempt_id" => attempt_id, "receipt_digest" => receipt_digest, "head" => evidence_head, "kind" => kind,
+           "historical" => !historical_head.nil?,
+           "operation" => data["operation"], "checks" => data["checks"], "producer" => data["producer"], "review" => data["review"],
+           "artifacts" => data["artifacts"], "assignment_id" => data["assignment_id"],
+           "project_id" => data["project_id"], "scope" => data["scope"],
+           "evidence_git_ref" => attempt.binding.evidence_git_ref, "journal_commit" => attempt.journal_commit}
+        end
+
         # Reconcile an interrupted attempt.
         #
         # Running attempts are classified conservatively (stopped before
@@ -531,6 +599,12 @@ module Ace
           @journal
         end
 
+        # Prune/writer exclusion shared with overseer prune (durable, outside
+        # every deletion target).
+        def lifecycle_exclusion
+          @lifecycle_exclusion ||= Molecules::LifecycleExclusion.new(repo_root: @repo_root)
+        end
+
         def candidate_head!
           out, status = Open3.capture2("git", "rev-parse", "HEAD", chdir: @repo_root, stdin_data: "")
           head = out.to_s.strip

data/lib/ace/assign/version.rb

@@ -2,6 +2,6 @@
 
 module Ace
   module Assign
-    VERSION = "0.58.0"
+    VERSION = "0.60.0"
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ace-assign
 version: !ruby/object:Gem::Version
-  version: 0.58.0
+  version: 0.60.0
 platform: ruby
 authors:
 - Michal Czyz
 bindir: exe
 cert_chain: []
-date: 2026-09-29 00:00:00.000000000 Z
+date: 2026-10-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ace-support-cli
@@ -107,6 +107,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.39'
+- !ruby/object:Gem::Dependency
+  name: ace-review
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.57'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.57'
 - !ruby/object:Gem::Dependency
   name: ace-task
   requirement: !ruby/object:Gem::Requirement
@@ -294,6 +308,7 @@ files:
 - lib/ace/assign/cli/commands/add.rb
 - lib/ace/assign/cli/commands/assignment_target.rb
 - lib/ace/assign/cli/commands/attempt/base.rb
+- lib/ace/assign/cli/commands/attempt/evidence.rb
 - lib/ace/assign/cli/commands/attempt/finish.rb
 - lib/ace/assign/cli/commands/attempt/reconcile.rb
 - lib/ace/assign/cli/commands/attempt/start.rb
@@ -325,6 +340,7 @@ files:
 - lib/ace/assign/molecules/evidence_journal.rb
 - lib/ace/assign/molecules/execution_identity_resolver.rb
 - lib/ace/assign/molecules/fork_session_launcher.rb
+- lib/ace/assign/molecules/lifecycle_exclusion.rb
 - lib/ace/assign/molecules/preset_inferrer.rb
 - lib/ace/assign/molecules/queue_scanner.rb
 - lib/ace/assign/molecules/receipt_verifier.rb