ace-assign 0.69.0 → 0.71.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 407eb167c22a0bac683f3ac5db391b535f6200f420a38d458cc13bf36590d930
-  data.tar.gz: ef23045c1b5c2915768a21110675121dd390a896347dba0f6be90f134eb5fe12
+  metadata.gz: 5330cebc5f70e683451c7a69082c04f7fb6d8a5d92b24b92c73b37d30c56c4a9
+  data.tar.gz: d1687b8ba44c21a2a0618e61199c3043a67a8c6f0ecf7be38635635696c57b71
 SHA512:
-  metadata.gz: 217a25d646c1499d23196d0d43e1eed171914b01fa91532cf2d996f728eb1ef2b60a7126e3cc46aa8b58d0e7015c844637ee67e18c8fb3cfb36b900c81ee4342
-  data.tar.gz: 4de219ae9bdf137b84d813c599643a459961fd0337b7de987b69ac6edd8cbc4c483bd63def33a30f7bbbb075df66030843dbe71cab847f863edeb2f483ad2c26
+  metadata.gz: e792c5dae1dda172bfa11a6bf7cc08c074796e70dd5fd67b2ba42294975b71b46ef7fbef858ca7e848675ae83fc4d567dcffb5cf5e5867ea3425b6aba25e161a
+  data.tar.gz: 564c47ff609931ae807a8a0f2cd8c1806160272ab9ecc3405a90118e42f184dc93c180b6b7b834844cc3668699f2bcc2fef3632db773ba7da4aa6e29cb0fd912

data/.ace-defaults/assign/presets/deliver-release.yml

@@ -2,7 +2,7 @@
 # Usage: ace-assign create --task TASK[,TASK...] --preset deliver-release
 
 name: deliver-release
-description: Prepare and bind a stable release cut without exercising publication authority
+description: Deliver a bound release cut through the project-authorized publisher and installation owners
 
 parameters:
   taskrefs:
@@ -37,15 +37,18 @@ steps:
       final artifact digest, and update the manifest before it is accepted. Preparation
       is not publication, installation, deployment, or proof of any of those effects.
 
-  - name: publication-authority-placeholder
+  - name: request-authorized-publication
     number: "040"
     instructions: |
-      Publication placeholder only. Do not run a publish command in this preset. Route
-      the exact manifest to the separate publication authority named by project policy.
-      Missing credentials, publisher identity, or admission is
-      BLOCKED(provision, owner). If that authority accepts a request and returns a
-      durable operation reference plus reconciliation path, record
-      WAIT(reference, next-check); otherwise preserve uncertainty and do not retry.
+      Resolve the concrete publication workflow and executor from project policy and
+      invoke that existing workflow with the exact accepted manifest through the separate
+      publication authority. This step grants no credentials or permission by itself.
+      Missing publisher identity, executable binding, or admission is BLOCKED(provision, owner).
+      Use the project's existing publisher, dependency order and scoped HITL OTP route.
+      Record the accepted operation reference and reconciliation path before WAIT.
+      Track published, pending and uncertain artifacts separately. Verify registry version
+      and digest before retry; never republish an already matching artifact or repeat an
+      uncertain effect blindly. Keep delivery open after partial or unknown publication.
 
   - name: record-release-outcome
     number: "050"

data/.ace-defaults/assign/presets/integrate-batch.yml

@@ -32,11 +32,16 @@ steps:
   - name: delegate-renewed-evidence
     number: "030"
     instructions: |
-      After any candidate movement, delegate renewed evidence for the new exact head:
-      prove replay content identity with range-diff or a stronger project-approved
-      comparison, run fresh relevant tests, and obtain an independent reviewer verdict.
-      The reviewer must be independent of the executor. Content beyond the declared
-      replay delta requires the full project review gate, not a verdict-stands shortcut.
+      Require an initial independent reviewer verdict, then record an accepted-head
+      assessment after every candidate movement. Retain old/new head and base SHAs,
+      the executed range-diff/content comparison, full repository context, risks and
+      fresh relevant tests. Proven identical rebases may carry the initial review;
+      patch-id alone is insufficient. An integrator may accept a minor safe correction
+      with recorded reasoning and tests. Material or uncertain changes, including small
+      authority/security changes, require independent delta review. Keep the initial
+      review and formal forge approval actor/state/SHA separate from this assessment.
+      Post and read back the evidence before merge; use the exact accepted head in the
+      server-side merge guard. Failed publication of evidence blocks integration.
 
   - name: reevaluate-integration-readiness
     number: "040"

data/.ace-defaults/assign/presets/supervise-delivery.yml

@@ -20,8 +20,8 @@ steps:
 
       These are references to producer tasks; never reparent, duplicate, reopen, or
       change producer task status. A PR-ready worker remains terminal even while this
-      delivery assignment stays open. No second queue, journal, daemon, or cache may
-      be created. Treat an empty observation as current input only: Transiently empty
+      delivery assignment stays open. A local objective queue may store goals, next actions, blockers and references;
+      no second execution queue, journal, daemon, or cache may be created. Treat an empty observation as current input only: Transiently empty
       is not accepted completion.
 
   - name: supervise-delivery-queue
@@ -42,8 +42,10 @@ steps:
       - policy/plan revision and evidence references used for the decision.
 
       For every entry, evaluate dependency state, exact candidate head SHA, fresh
-      test and independent-review evidence bound to that head, required authority and
-      transport, and grouping constraints. Re-record the decision after dependency,
+      tests, initial independent review and a documented accepted-head assessment.
+      An identical rebase needs executed content-identity proof; a minor safe correction
+      needs integrator reasoning and tests; material or uncertain delta needs independent
+      delta review. Evaluate required authority, transport and grouping constraints. Re-record the decision after dependency,
       candidate head, evidence, authority, transport, or target-branch movement.
 
   - name: reconcile-integration-operation

data/CHANGELOG.md

@@ -7,6 +7,33 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.71.0] - 2026-10-16
+
+### Added
+
+- Compare two independently retained candidate bundles through bounded bare Git object reads, including nonancestor rebases, full context inventories, binary patches and historical symlink bytes without executing or materializing candidate code.
+- Ground candidate and assignment-snapshot wire/expansion ceilings in closed 128MiB budgets backed by a shared fixed `cat-file --batch` codec, explicit 20,000-object bounds (per tree inventory and across the comparison's unique-blob union), and chunked batch reads instead of one Git process per blob; historical journal reads reuse the same codec.
+- Bound candidate, prepared and head-comparison tree paths to finite total/component lengths (4096/255 bytes) before any inventory, delta or filesystem prefix work, so a hostile tree cannot push unbounded path bytes into inventories or directory creation.
+- Retain built ordinary release gems as canonical binary evidence bound to the actual native producer, current accepted candidate, independent review and exact release decision. Recheck authorization on replay; preserve report limits and keep publication dispatch separate.
+- Admit ordinary candidates and independently started native reviewers into the canonical journal. Revalidate original review artifacts and root-witnessed test executions before fixed merge admission and effects; preserve strict protected-review attribution.
+- Drive ordinary work through the installed canonical owner with retained requests, accepted context snapshots and result adoption. Record coordinator replacement in the existing definition chain only after positive old-process termination; preserve worker attempts and reject stale supervisor completion.
+
+### Fixed
+
+- Preserve exact lost-response result replay while allowing canonical-generation CAS conflicts to recover without replacing original inputs.
+
+### Changed
+
+- Keep protected launch identity construction and comparison in its boundary owner while shared fixed service transitions reuse the same checks.
+- Require ace-review 0.61 for the shared complete-head-context ceiling; raise the candidate transfer deadline from 30s to a measured 60s with byte/count bounds unchanged (two full admits plus the complete comparison of the real 82,809,675-byte candidate legitimately need 23–27s on a loaded host; 30s failed closed under recorded load).
+
+## [0.70.0] - 2026-10-16
+
+### Added
+
+- Admit ordinary assignments, native starts, progress, submitted results and terminal settlement through the installed canonical owner. Retain original mutations and immutable snapshots across restart, isolate sibling scopes, and join current HITL, service and Inbox evidence.
+- Preserve historical review checks at their recorded head and align delivery presets with accepted-head assessment and serial integration.
+
 ## [0.69.0] - 2026-10-16
 
 ### Changed

data/handbook/skills/as-assign-drive/SKILL.md

@@ -6,12 +6,13 @@ description: Drive agent execution through an active assignment
 user-invocable: true
 allowed-tools:
   - Bash(ace-assign:*)
+  - Bash(ace-lab:*)
   - Bash(ace-bundle:*)
   - Read
   - Write
   - AskUserQuestion
   - Skill
-argument-hint: "[assignment[@scope]]"
+argument-hint: "[assignment[@scope] | --ordinary <context.json>]"
 last_modified: 2026-04-23
 source: ace-assign
 skill:
@@ -23,6 +24,8 @@ skill:
 
 Load and run `ace-bundle wfi://assign/drive` in the current project, then follow the loaded workflow as the source of truth and execute it end-to-end instead of only summarizing it.
 
+When `--ordinary` or `ACE_ASSIGN_ORDINARY_CONTEXT` is present, follow the workflow’s ordinary installed branch before resolving local assignment state. Its canonical `ace-lab assignment drive` operations own status, start, progress, results and recovery; local commands below apply only outside that branch.
+
 Hard stop rule:
 
 - Do not stop after intermediate progress.
@@ -30,7 +33,7 @@ Hard stop rule:
 - Treat `ace-assign status --assignment <id>@<root>` as the source of truth for fork completion; quiet terminal output is not enough reason to stop or declare a stall.
 - If a prior terminal or drive session ended, re-enter from assignment state and continue from the next runnable work instead of depending on the old terminal handle.
 - Before any final response, re-check pinned assignment status. If any runnable `pending` or `active` work remains, continue driving.
-- If unrelated dirty files are generated side effects outside task scope, clean/reset them instead of auto-committing them.
+- Preserve unrelated dirty files; commit only task-owned changes.
 - Use progress updates for partial status only.
 - Return a final user-facing completion response only when the assignment is complete or the workflow reaches an explicit blocker/failure stop condition.
 - If pending work remains runnable, continue driving.

data/handbook/workflow-instructions/assign/drive.wf.md

@@ -3,6 +3,7 @@ name: assign-drive
 description: Drive an ace-assign assignment until completion or an explicit blocker.
 allowed-tools:
 - Bash(ace-assign:*)
+- Bash(ace-lab:*)
 - Bash(ace-bundle:*)
 - Read
 - Write
@@ -27,6 +28,82 @@ Drive agent execution through an active assignment by continuously checking stat
 - An active assignment exists (created via `ace-assign create` or `/as-assign-create`)
 - Assignment has at least one pending or active step
 
+## Ordinary installed execution
+
+Select this branch **before resolving any local assignment** when invoked with
+`--ordinary <context.json>` or when `ACE_ASSIGN_ORDINARY_CONTEXT` is set. Require
+`ACE_ASSIGN_ORDINARY_PROJECT` and use the exact retained context path throughout.
+Conflicting explicit and environment paths are an error. In this branch every
+execution read and write uses `ace-lab assignment drive --project <project>
+--context <context.json>` against the installed owner. The local assignment
+commands below, `.current`, `.latest`, `fork-run`, and protected `work-on --project`
+are not fallback routes.
+
+1. Run `--operation status`. If `not_started`, run `--operation start` from the
+   actual native worker pane. A launch/send acknowledgement is not a start receipt.
+   Verify canonical status is `running` with the expected assignment, attempt,
+   scope, native binding and producer. Never adopt another pane's execution.
+2. Run `--operation bootstrap --output <new-private-directory>`. Read the returned
+   accepted task/context/report paths and retain their exact manifest and file
+   digests in the work report. These bytes come from canonical prepared work;
+   mutable task files in a checkout cannot replace them. Resolve referenced
+   project workflows/guides with the selected installed packages and record each
+   effective path and digest. A missing or conflicting required asset is a blocker.
+3. Run `--operation next`. Execute the returned current step, or start the returned
+   next step using `--operation step-start --step <number> --generation <observed>`.
+   The accepted root's children run in this already admitted worker; do not fork
+   another execution because a prepared root originated in a batch preset.
+4. After executing a step, write its bounded UTF-8 report and run
+   `--operation step-finish --step <number> --report <path> --generation <observed>`.
+   On an unrecoverable step failure, use `--operation fail --message <reason>
+   --generation <observed>`. Read `next` again after every acknowledged mutation.
+   Do not mark an unexecuted step successful. Nested skills may perform the work,
+   but their local Assign bookkeeping must not replace these canonical operations.
+5. When the scope is complete or failed, prepare an execution receipt and exact
+   artifact files using the receipt contract in the Lab usage documentation.
+   Its producer is the canonical start producer; HEAD is the actual committed
+   candidate; checks describe executed checks. Submit with `--operation result
+   --generation <observed> --receipt <json> --artifact <file>` in receipt order.
+   Submission is not terminal acceptance, merge, publication or installation.
+6. Keep the worker's native process and checkout available until the supervisor
+   accepts the result through `--operation adopt` and canonical `status` becomes
+   terminal. The filesystem watch emits only a hint. Never infer completion from
+   a quiet pane, a hint file, an old message or a send acknowledgement.
+
+Each mutation prints its retained original request path. After any lost reply,
+read canonical `status`/`next` first and use `--operation replay --request <path>`
+only for that original input. Preserve assignment, attempt, mutation, candidate
+and pane identities. Never edit an original request's generation or bytes. For a
+result/finish CAS refusal, reread canonical status. An accepted result replays its
+exact original input; an accepted terminal outcome needs no new finish. If no
+result/terminal was accepted and the attempt generation advanced, the original
+CAS can no longer accept: result/finish may retain a separate request at the new
+observed generation. The driver preserves all old inputs and performs these
+checks; unavailable status remains a blocker. Changed content, project or owner
+is not a generation retry, and never authorizes another worker.
+
+A supervisor installs the `watch_command` returned by `ace-overseer ordinary`
+exactly once in its native session, runs a harmless turn to persist it, and uses
+exact-session resume thereafter. Do not recreate an intentionally removed watch.
+A watch merely requests canonical inspection; recurring native progress audits
+also find accepted results when a wake or reply is lost. Wrong project/attempt
+hints carry no authority. Existing inbound Inbox settlement remains a separate
+owner configuration: without it, nonempty Inbox references refuse completion.
+
+After replacement of the coordinator process, read `--operation supervisor`.
+A new coordinator uses `--operation adopt-supervisor --pane <actual-pane>
+--generation <old-selection-generation> --previous-binding-sha256 <old-digest>`.
+The installed owner authenticates its actual placement and positively verifies
+that the original process generation ended. Live or unobservable old generations
+refuse adoption. Replay the original adoption request after a lost reply. This
+changes only the canonical supervisor selection; existing workers, uncertain
+launches, attempts, pending results and mutation IDs remain intact. Then resume
+canonical inspection and result adoption. Never re-register or relaunch workers
+because the coordinator restarted.
+
+**End of ordinary branch.** The remaining sections apply only to local assignment
+execution; do not enter them from an ordinary installed context.
+
 ## Assignment Context Propagation
 
 When working with multiple concurrent assignments, the active assignment is resolved in this order:

data/lib/ace/assign/atoms/assignment_scope.rb

@@ -47,6 +47,11 @@ module Ace
         rescue Ace::Assign::AttemptErrors::InvalidScope
           false
         end
+
+        # An owner of a subtree also owns every descendant scope.
+        def self.overlap?(left, right)
+          equal?(left, right) || left.start_with?("#{right}.") || right.start_with?("#{left}.")
+        end
       end
     end
   end

data/lib/ace/assign/atoms/candidate_limits.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Ace
+  module Assign
+    module Atoms
+      # Closed candidate-purpose budgets. Reports and release gems retain their
+      # separate bounds; callers cannot select a larger wire/storage ceiling.
+      module CandidateLimits
+        BYTES = 128 * 1024 * 1024
+        PREPARED_BYTES = 64 * 1024 * 1024
+        REVIEW_SNAPSHOT_BYTES = 64 * 1024 * 1024
+        # Explicit finite path shape (PATH_MAX/NAME_MAX-sized) so a hostile
+        # tree entry cannot push unbounded path bytes into inventories,
+        # filesystem prefix creation or per-component scans.
+        PATH_BYTES = 4096
+        PATH_COMPONENT_BYTES = 255
+      end
+    end
+  end
+end

data/lib/ace/assign/atoms/git_blob_batch.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Ace
+  module Assign
+    module Atoms
+      # Git's fixed cat-file batch framing. Owners select process, immutable
+      # repository, deadline and byte/count limits before invoking this codec.
+      module GitBlobBatch
+        OID = /\A[0-9a-f]{40}\z/
+        class Invalid < StandardError
+          attr_reader :reason
+          def initialize(reason)
+            @reason = reason
+            super("invalid Git blob batch #{reason}")
+          end
+        end
+
+        def self.sizes(oids, output)
+          unless oids.is_a?(Array) && oids.all? { |oid| oid.is_a?(String) && OID.match?(oid) } && output.is_a?(String)
+            raise Invalid, :selector
+          end
+          lines = output.b.lines
+          raise Invalid, :count unless lines.size == oids.size
+          lines.zip(oids).map do |line, oid|
+            match = /\A([0-9a-f]{40}) blob (0|[1-9][0-9]*)\n\z/.match(line)
+            raise Invalid, :metadata unless match && match[1] == oid
+            match[2].to_i
+          end
+        end
+
+        def self.decode(entries, output)
+          unless entries.is_a?(Array) && entries.all? { |entry|
+              entry.is_a?(Array) && entry.size == 2 && entry[0].is_a?(String) && OID.match?(entry[0]) &&
+                entry[1].is_a?(Integer) && entry[1] >= 0 } && output.is_a?(String)
+            raise Invalid, :selector
+          end
+          output = output.b
+          offset = 0
+          entries.map do |oid, size|
+            ending = output.index("\n", offset)
+            unless ending && ending - offset <= 127 && output.byteslice(offset, ending - offset) == "#{oid} blob #{size}"
+              raise Invalid, :header
+            end
+            offset = ending + 1
+            content = output.byteslice(offset, size)
+            unless content&.bytesize == size && output.byteslice(offset + size, 1) == "\n" &&
+                Digest::SHA1.new.update("blob #{size}\0").update(content).hexdigest == oid
+              raise Invalid, :bytes
+            end
+            offset += size + 1
+            content
+          end.tap { raise Invalid, :trailing unless offset == output.bytesize }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "digest"
+require "json"
+require_relative "campaign_execution"
+
+module Ace
+  module Assign
+    module Authority
+      # Shared byte/schema validation; each lifecycle separately authenticates
+      # the registration's owner, campaign provenance and original selection.
+      module AssignmentDefinition
+        def self.parse(bytes:, digest:, assignment_id:, project_id:)
+          unless bytes.is_a?(String) && bytes.bytesize <= 32_768 && digest.is_a?(String) &&
+              Digest::SHA256.hexdigest(bytes) == digest
+            raise ArgumentError, "invalid assignment definition digest or size"
+          end
+          value = JSON.parse(bytes)
+          allowed = %w[session_id name description created_at updated_at source_config parent task_id project_id prepared_work review_campaign campaign_execution]
+          unless value.is_a?(Hash) && (value.keys - allowed).empty? &&
+              %w[session_id name created_at source_config task_id project_id].all? { |key| value[key].is_a?(String) && !value[key].empty? } &&
+              value["session_id"] == assignment_id && value["project_id"] == project_id
+            raise ArgumentError, "invalid managed assignment definition"
+          end
+          CampaignExecution.validate_parent!(value.fetch("review_campaign")) if value.key?("review_campaign")
+          assignment = Models::Assignment.from_h(value)
+          unless assignment.managed? && assignment.task_id.match?(/\A[a-zA-Z0-9][a-zA-Z0-9_.-]{0,127}\z/)
+            raise ArgumentError, "definition is not managed or task identity is invalid"
+          end
+          assignment
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "../atoms/git_blob_batch"
+
+module Ace
+  module Assign
+    module Authority
+      # Same cat-file batch dialect/codec as the canonical journal. Chunked
+      # bodies avoid retaining the entire expanded tree a second time.
+      module CandidateBlobBatch
+        BATCH_BYTES = 8 * 1024 * 1024
+        BATCH_OBJECTS = 512
+        MAX_OBJECTS = 20_000
+
+        private
+
+        def candidate_blob_sizes(repository, deadline, oids)
+          unless oids.is_a?(Array) && oids.size <= MAX_OBJECTS &&
+              oids.all? { |oid| oid.is_a?(String) && self.class::SHA.match?(oid) }
+            reject!("Candidate blob inventory is invalid or oversized")
+          end
+          oids.each_slice(64).flat_map do |slice|
+            raw = git(repository, deadline, "cat-file", "--batch-check", stdin_data: slice.join("\n") + "\n", limit: slice.size * 128)
+            Atoms::GitBlobBatch.sizes(slice, raw)
+          end
+        rescue Atoms::GitBlobBatch::Invalid => error
+          reject!("Candidate blob batch #{error.reason} differs")
+        end
+
+        def each_candidate_blob(repository, deadline, entries)
+          batch = []
+          bytes = 0
+          entries.each do |entry|
+            if !batch.empty? && (batch.size >= BATCH_OBJECTS || bytes + entry.last > BATCH_BYTES)
+              yield_candidate_blob_batch(repository, deadline, batch) { |oid, content| yield oid, content }
+              batch = []
+              bytes = 0
+            end
+            batch << entry
+            bytes += entry.last
+          end
+          yield_candidate_blob_batch(repository, deadline, batch) { |oid, content| yield oid, content } unless batch.empty?
+        end
+
+        def yield_candidate_blob_batch(repository, deadline, entries)
+          limit = entries.sum { |_oid, size| size + 128 }
+          raw = git(repository, deadline, "cat-file", "--batch", stdin_data: entries.map { |oid, _size| "#{oid}\n" }.join, limit: limit)
+          Atoms::GitBlobBatch.decode(entries, raw).zip(entries).each { |content, (oid, _size)| yield oid, content }
+        rescue Atoms::GitBlobBatch::Invalid => error
+          reject!("Candidate blob batch #{error.reason} differs")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module Ace
+  module Assign
+    module Authority
+      # Compare retained Git objects in a private bare repository. Historical
+      # links are object bytes, never paths to materialize or follow. This view
+      # supplies evidence; it does not classify a change or grant acceptance.
+      # Host: CandidateTransfer supplies bounded Git/admission, byte encoding,
+      # private-root storage, monotonic deadlines and rejection helpers.
+      module CandidateHeadComparison
+        class ReadView
+          def initialize(owner:, repository:, reviewed:, candidate:, deadline:)
+            @owner, @repository, @reviewed, @candidate, @deadline = owner, repository, reviewed, candidate, deadline
+            @thread, @active = Thread.current, true
+          end
+
+          def close = @active = false
+
+          def context
+            unless @active && Thread.current.equal?(@thread)
+              raise AttemptErrors::EvidenceUnavailable, "head comparison escaped its source lifetime"
+            end
+            @owner.send(:head_comparison_context, @repository, @deadline, @reviewed, @candidate)
+          rescue Timeout::Error
+            raise AttemptErrors::EvidenceUnavailable, "head comparison deadline expired"
+          end
+        end
+
+        def with_head_comparison(before:, after:, before_base:, after_base:)
+          raise ArgumentError, "head comparison requires a block" unless block_given?
+          [before, after].each do |input|
+            unless input.is_a?(Hash) && input.keys.sort == %i[bytes head sha256 size tree] &&
+                input[:tree].is_a?(String) && input[:tree].match?(self.class::SHA)
+              reject!("Head comparison candidate binding is invalid")
+            end
+          end
+          [before_base, after_base].each do |base|
+            reject!("Head comparison base is invalid") unless base.is_a?(String) && base.match?(self.class::SHA)
+          end
+          deadline = monotonic + self.class::DEADLINE
+          # Each complete bundle is independently verified against an empty
+          # repository before either can contribute objects to the comparison.
+          admit(**before.reject { |key, _| key == :tree }, deadline: deadline) do |_old_repo, _old_deadline, reviewed|
+            reject!("Reviewed tree differs from accepted tree") unless reviewed.fetch("tree") == before[:tree]
+            admit(**after.reject { |key, _| key == :tree }, deadline: deadline) do |repository, _new_deadline, candidate|
+              reject!("Candidate tree differs from accepted tree") unless candidate.fetch("tree") == after[:tree]
+              Tempfile.create(["reviewed-", ".bundle"], @root) do |file|
+                file.binmode
+                file.write(reviewed.fetch("bundle")); file.flush
+                git(repository, deadline, "fetch", "--no-tags", file.path, "#{before[:head]}:refs/heads/reviewed")
+                reader = ReadView.new(owner: self, repository: repository,
+                  reviewed: {"head" => before[:head], "base" => before_base, "tree" => before[:tree]},
+                  candidate: {"head" => after[:head], "base" => after_base, "tree" => after[:tree]}, deadline: deadline)
+                yield reader
+              ensure
+                reader&.close
+              end
+            end
+          end
+        end
+
+        private
+
+        def head_comparison_context(repository, deadline, reviewed, candidate)
+          context = {"schema" => "ace.candidate-head-comparison/v1", "reviewed" => reviewed,
+            "candidate" => candidate, "inventories" => {}, "objects" => {}, "changes" => {}}
+          remaining = self.class::MAX_REVIEW_BYTES
+          {"reviewed_head" => reviewed["head"], "reviewed_base" => reviewed["base"],
+            "candidate_head" => candidate["head"], "candidate_base" => candidate["base"]}.each do |label, commit|
+            git(repository, deadline, "cat-file", "-e", "#{commit}^{commit}")
+            tree = git(repository, deadline, "rev-parse", "#{commit}^{tree}").strip
+            inventory = head_comparison_inventory(repository, deadline, tree)
+            remaining -= JSON.generate(inventory).bytesize
+            reject!("Complete head comparison context is oversized") if remaining.negative?
+            context.fetch("inventories")[label] = {"tree" => tree, "entries" => inventory}
+          end
+          oids = context.fetch("inventories").values.flat_map { |inventory| inventory.fetch("entries").map { |entry| entry.fetch("oid") } }.uniq
+          sizes = oids.zip(candidate_blob_sizes(repository, deadline, oids)).to_h
+          reject!("Complete head comparison object content is oversized") if sizes.values.sum > remaining
+          each_candidate_blob(repository, deadline, sizes.to_a) do |oid, content|
+            object = {"size" => content.bytesize, "sha256" => Digest::SHA256.hexdigest(content), "content" => review_bytes(content)}
+            remaining -= JSON.generate(object).bytesize
+            reject!("Complete head comparison context is oversized") if remaining.negative?
+            context.fetch("objects")[oid] = object
+          end
+          {"candidate_delta" => [reviewed["head"], candidate["head"]],
+            "base_delta" => [reviewed["base"], candidate["base"]],
+            "original_scope" => [reviewed["base"], reviewed["head"]],
+            "current_scope" => [candidate["base"], candidate["head"]]}.each do |label, revisions|
+            delta = head_comparison_delta(repository, deadline, revisions, remaining)
+            remaining -= JSON.generate(delta).bytesize
+            reject!("Complete head comparison context is oversized") if remaining.negative?
+            context.fetch("changes")[label] = delta
+          end
+          # Include structural JSON overhead in the final bound as well as all
+          # original bytes. No partial inventory or truncated patch is returned.
+          reject!("Complete head comparison context is oversized") if JSON.generate(context).bytesize > self.class::MAX_REVIEW_BYTES
+          context
+        rescue AttemptErrors::ReceiptRejected => error
+          reject!("Head comparison read failed: #{error.message}")
+        end
+
+        def head_comparison_inventory(repository, deadline, tree)
+          entries = git(repository, deadline, "ls-tree", "-r", "-z", tree, limit: self.class::MAX_BYTES).b.split("\0")
+          reject!("Complete head comparison inventory is oversized") if entries.size > self.class::MAX_OBJECTS
+          entries.map do |entry|
+            metadata, path = entry.split("\t", 2)
+            mode, kind, oid = metadata.to_s.split(" ")
+            # Inventory entries carry whole paths only; bound their bytes
+            # before JSON encoding or delta cross-checks consume them.
+            reject!("Complete head comparison path exceeds bounded length") unless path && !path.empty? &&
+              path.bytesize <= Atoms::CandidateLimits::PATH_BYTES
+            unless kind == "blob" && %w[100644 100755 120000].include?(mode) && oid&.match?(self.class::SHA)
+              reject!("Complete head comparison contains an unsupported Git entry")
+            end
+            {"path" => review_bytes(path), "mode" => mode, "oid" => oid}
+          end
+        end
+
+        def head_comparison_delta(repository, deadline, revisions, remaining)
+          options = ["--no-ext-diff", "--no-textconv", "--no-renames", "--ignore-submodules=none"]
+          patch = git(repository, deadline, "diff", *options, "--binary", "--full-index", "--src-prefix=a/", "--dst-prefix=b/",
+            *revisions, "--", limit: [remaining, 1].max).b
+          paths = git(repository, deadline, "diff", *options, "--name-only", "-z", *revisions, "--", limit: [remaining, 1].max).b.split("\0")
+          stats = git(repository, deadline, "diff", *options, "--numstat", "-z", *revisions, "--", limit: [remaining, 1].max).b.split("\0")
+          binary = stats.filter_map do |entry|
+            added, removed, path = entry.split("\t", 3)
+            reject!("Complete head comparison diff inventory is invalid") unless path && paths.include?(path)
+            path if added == "-" || removed == "-"
+          end
+          {"from" => revisions.first, "to" => revisions.last, "patch" => review_bytes(patch),
+            "patch_sha256" => Digest::SHA256.hexdigest(patch), "paths" => paths.map { |path| review_bytes(path) },
+            "binary_paths" => binary.map { |path| review_bytes(path) }}
+        end
+      end
+    end
+  end
+end