ace-assign 0.71.0 → 0.73.0

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

@@ -6,13 +6,12 @@ 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] | --ordinary <context.json>]"
+argument-hint: "[assignment[@scope]]"
 last_modified: 2026-04-23
 source: ace-assign
 skill:
@@ -24,8 +23,6 @@ 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.

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

@@ -3,7 +3,6 @@ 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
@@ -13,8 +12,8 @@ doc-type: workflow
 title: Drive Assignment Workflow
 purpose: workflow instruction for driving ace-assign assignment execution
 ace-docs:
-  last-updated: '2026-04-23'
-  last-checked: '2026-04-23'
+  last-updated: '2026-10-19'
+  last-checked: '2026-10-19'
 ---
 
 # Drive Assignment Workflow
@@ -28,82 +27,6 @@ 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:
@@ -733,130 +656,54 @@ Follow the instructions directly, performing the described work:
 
 **Agent Action:** Execute each instruction line as a task.
 
-### 4. External Action Rule (Attempt-First)
-
-Every external-facing step (implement, verify, review, merge, publish, deploy, release) runs inside a scoped attempt. The attempt -- not the report and not exit status -- is the delivery record.
-
-For an original protected PreparedWorker, use its already admitted assignment,
-attempt and selected scope. Do not run the local `attempt start`/receipt-file
-sequence below, acquire another attempt, or execute an outer preset step. The
-delivery step must already belong to the immutable captured subtree. Submit the
-actual candidate and obtain the installed independent reviewer acceptance through
-the protected commands supplied by the original drive prompt.
-
-For an authorized protected merge, retain the exact approved head/candidate
-generation, structured input file, installed receiver, authorization and stable
-request ID. Read current authority generation for the first new request. Invoke
-`ace-lab service request` with those original mapping/assignment/attempt/scope
-selectors. Inspect `ace-lab service status` with the same request, input digest and
-target, then consume succeeded canonical evidence with `ace-assign delivery
---operation merge --service-request REQUEST` and the same selectors. Include
-`--artifact-digest` on status and consumption when the original target has one.
-Exact retries retain the original generation, mutation/request ID and input bytes;
-uncertainty never permits refreshing or resending an effect. The protected delivery
-consumer verifies the imported receipt and canonical delivery event without another
-provider mutation. Only that succeeded result permits finishing the active queue
-step. Refusal, unavailable evidence or uncertainty leaves it unfinished and reports
-the exact blocker. Credentials and queue completion do not replace authorization
-or canonical evidence. The following local attempt sequence applies only to
-ordinary standalone assignments.
-
-**Step 1: Start the attempt before executing the step.** Actor identity is derived from the execution boundary; never pass actor flags.
-
-```bash
-ATTEMPT_JSON=$(ace-assign attempt start --assignment "$ASSIGNMENT_ID" --step "$STEP_NUMBER" --project "$PROJECT_ID")
-echo "$ATTEMPT_JSON"
-```
-
-- A repeated identical start returns the same attempt; a conflicting start fails (exit 5). Never launch a second writer for an owned subtree.
-- `base_head` is captured exactly once at start. Record the `attempt_id`.
-
-**Step 2: Execute the step command(s).** If blocked, capture concrete evidence:
-
-- command attempted
-- exact error output
-- why the step cannot proceed
+### 4. Execute the Active Step Directly
 
-Mark the step failed with evidence (do not report synthetic completion):
+Execute the active step's instructions directly, run the checks it requires, and
+record the real results in the step report.
 
-```bash
-ace-assign fail --message "Command failed: <cmd>. Error: <exact stderr>" --assignment "$ASSIGNMENT_TARGET"
-```
-
-**Step 3: Submit a structured receipt -- never prose -- to close the attempt.**
-
-```bash
-cat > /tmp/attempt-receipt.json << 'EOF'
-{
-  "attempt_id": "<ATTEMPT_ID>",
-  "assignment_id": "<ASSIGNMENT_ID>",
-  "project_id": "<PROJECT_ID>",
-  "scope": "<STEP_NUMBER>",
-  "operation": "implement",
-  "producer": {"actor": "<boundary-actor>", "role": "worker", "runtime": "<boundary-runtime>"},
-  "head": "<exact tested/reviewed HEAD sha>",
-  "verdict": "succeeded",
-  "artifacts": [{"path": "report.md", "sha256": "<sha256>"}],
-  "checks": [{"name": "ace-test", "verdict": "passed"}],
-  "review": {"reviewer": {"actor": "<independent-reviewer>", "runtime": "<reviewer-runtime>"}, "verdict": "approved", "head": "<same HEAD sha>"}
-}
-EOF
-
-ace-assign attempt finish --attempt "$ATTEMPT_ID" --receipt /tmp/attempt-receipt.json
-```
-
-Receipt rules enforced by the coordinator:
-
-- `succeeded` verdicts require verifiable artifact digests, passing checks, and trusted coordinator/service authority; worker runtimes may submit attributable results but cannot self-approve.
-- Review approval requires an executed independent reviewer verdict for the exact current head; same author/reviewer and report-only existence are rejected.
-- Receipts carrying credentials, environment dumps, or terminal output are rejected outright.
-- External effects (`merge`, `publish`, `deploy`, `release`) additionally require an accepted independent review receipt for the current head. Taskless assignments cannot record external effects.
-
-**Step 4: Handle interruptions by classifying and reconciling -- never by assuming.**
-
-```bash
-ace-assign attempt status --assignment "$ASSIGNMENT_ID" --format json
-ace-assign attempt reconcile --attempt "$ATTEMPT_ID"
-ace-assign attempt reconcile --attempt "$ATTEMPT_ID" --receipt /tmp/attempt-receipt.json
-```
-
-- A lost receipt after a possible effect is `uncertain`; it resolves only against a verified receipt attributed to the recorded execution boundary.
-- Running attempts stay running only while their recorded process is verifiably live; anything else becomes `stopped` or `uncertain`.
-- Never replay `merge`, `publish`, or `deploy` automatically. Reconciliation records evidence; it never re-executes effects.
+- If the work is blocked, capture the command you ran, the exact error output,
+  and why the step cannot proceed, then fail the step with that evidence (see
+  [Handle Failures](#7-handle-failures)).
+- Record actual test and review results for the exact candidate head in the
+  assignment report (or the project task folder) before advancing. A report or
+  exit code alone is not proof by itself; report only what was actually run.
+- Never replay `merge`, `publish`, or `deploy` automatically. An uncertain
+  external effect is reconciled against the authoritative remote/owner first;
+  reconciliation never re-executes the effect by itself.
 
 #### Integration Gate and Typed Outcomes (every integration invocation)
 
 These gates apply at EVERY integration entry point — a native integrate
-command, a service invocation, or an assignment integration step — with
-shared contract validation so no entry point bypasses them.
+command or an assignment integration step — with shared contract validation so
+no entry point bypasses them.
 
 - Before any mutation, resolve FRESH repository, PR, candidate exact head,
   target base/head, review/test evidence and the authorized executor; recheck
   target/head immediately before the mutation. A detected race invalidates
   eligibility for that invocation.
-- The low-level privileged integrator ENFORCES the gates and returns one typed
+- The low-level integrator ENFORCES the gates and returns one typed
   outcome: `merged`, `needs-rebase`, `blocked` or `uncertain`. It never
   authors, rebases or reviews its own candidate. Relay alone is not
-  execution: the queue owner monitors until receipt and continuation.
+  execution: the integrating agent monitors the actual result and continuation.
 - If the target (current main) is NOT an ancestor of the candidate head, the
-  outcome is `needs-rebase`: never merge and never silently rewrite. The queue
-  owner delegates `wfi://git/rebase` (as-git-rebase, including CHANGELOG
-  preservation) in the candidate's isolated worktree, obtains refreshed
-  exact-head checks plus independent review of the NEW head, updates the PR,
-  verifies remote candidate identity and resubmits. A common old base does
-  NOT make sibling heads sequentially fast-forwardable.
-- Integration is serial in PREPARATION as well as in effect: the accepted
-  receipt for one candidate causes preparation of ONLY the next selected
-  candidate — never a mass rebase of the remaining queue. Each candidate, on
-  its turn: resolve fresh target main; delegate `wfi://git/rebase` in that
-  candidate's isolated worktree IF needed; run the applicable checks; obtain
-  an INDEPENDENT EXPLICIT review of the resulting exact head (patch identity
-  may support a short delta review but never substitutes the explicit
-  independent head approval); verify the remote PR head/base; issue ONE
-  scoped integrator request; wait/reconcile the actual integration receipt;
-  refresh main; select and prepare ONLY the next candidate. Queued later
-  PRs keep their existing branches/heads untouched until their turn; prior
-  batch work is never rolled back or reset.
+  outcome is `needs-rebase`: never merge and never silently rewrite. The
+  integrating agent delegates `wfi://git/rebase` (as-git-rebase, including
+  CHANGELOG preservation) in the candidate's isolated worktree, obtains
+  refreshed exact-head checks plus independent review of the NEW head, updates
+  the PR, verifies remote candidate identity and resubmits. A common old base
+  does NOT make sibling heads sequentially fast-forwardable.
+- Integration is serial in PREPARATION as well as in effect: the confirmed
+  integration result for one candidate causes preparation of ONLY the next
+  selected candidate — never a mass rebase of the remaining queue. Each
+  candidate, on its turn: resolve fresh target main; delegate `wfi://git/rebase`
+  in that candidate's isolated worktree IF needed; run the applicable checks;
+  obtain an INDEPENDENT EXPLICIT review of the resulting exact head (patch
+  identity may support a short delta review but never substitutes the explicit
+  independent head approval); verify the remote PR head/base; issue ONE scoped
+  integrator request; wait/reconcile the actual integration outcome; refresh
+  main; select and prepare ONLY the next candidate. Queued later PRs keep their
+  existing branches/heads untouched until their turn; prior batch work is never
+  rolled back or reset.
 - `uncertain` triggers reconciliation against the original durable reference;
   it never permits blind retry.
 - Never push directly to main; never switch the canonical checkout to a topic
@@ -908,7 +755,9 @@ For a blocked step:
 
 ### 5. Write Report (Only After Real Execution)
 
-After the attempt accepted a receipt (or the step was failed with evidence), write a brief report summarizing what was accomplished. The report advances the queue; the accepted attempt receipt carries the delivery evidence:
+After executing the step (or failing it with concrete evidence), write a brief report summarizing what was accomplished. The report is the local record: state what was actually run and link or paste the actual test/review evidence for the exact head.
+
+**Re-read state before every finish.** In forked assignment subtrees, queued child steps can auto-advance between status checks, and a report submitted against a stale view can land on the wrong step number. Immediately before every `ace-assign finish --message` (and every `ace-assign fail`), re-run `ace-assign status --assignment "$ASSIGNMENT_TARGET"` and confirm the step you are reporting on is still the active step. If the active step moved, re-target or re-plan the report instead of submitting it against the old step.
 
 ```bash
 # Write report content to a temp file
@@ -919,20 +768,23 @@ Completed the setup step successfully:
 
 - Installed all dependencies via npm install
 - Configured PostgreSQL database connection
-- Verified installation with health check
+- Verified installation with health check (command + observed output)
 
 All setup prerequisites are now satisfied.
 EOF
 
+# Re-check active state immediately before submitting the report
+ace-assign status --assignment "$ASSIGNMENT_TARGET"
+
 # Submit report to advance the queue
 ace-assign finish --message /tmp/step-report.md --assignment "$ASSIGNMENT_TARGET"
 ```
 
 Prohibited:
 
-- Advancing a step when its attempt has no accepted receipt (or recorded failure evidence).
-- Treating a written report, exit 0, or prose as proof of completion. Check `ace-assign attempt status --assignment "$ASSIGNMENT_ID" --format json` for accepted evidence and unresolved effects.
-- Reporting `uncertain` attempts as complete; reconcile them first.
+- Advancing a step that was not executed or whose result has no recorded evidence.
+- Treating a written report, exit 0, or prose as proof when the required tests or review were not run.
+- Reporting an uncertain external effect as complete; reconcile the original effect first.
 
 ### 6. Verify State Transition (Required)
 
@@ -1080,7 +932,7 @@ When executing a step with a `skill:` field:
 | Step fails | Attempt first, then use `fail` with command/error evidence; decide retry/add/ask |
 | Skill not found | Execute instructions directly without skill |
 | Unclear instructions | Ask user for clarification |
-| Provider/tool unavailable | For fork steps: see Provider-Unavailability Recovery. For inline steps: attempt with alternate model, then fail with evidence |
+| Provider/tool unavailable | For fork steps: see Provider-Unavailability Recovery. For inline steps: retry with an alternate model, then fail with evidence |
 
 ## Assignment State Reference
 

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

@@ -334,7 +334,7 @@ steps:
 
 ### 8. Output Result
 
-Default output: `<task>/jobs/<timestamp>-job.yml` (e.g., `.ace-task/v.0.9.0/tasks/229-xxx/jobs/k5abc123-job.yml`)
+Default output: `<task>/jobs/<timestamp>-job.yml` (e.g., `.ace-tasks/<task-folder>/jobs/k5abc123-job.yml`)
 
 Custom output: Use `--output path/to/custom.yaml`
 

data/handbook/workflow-instructions/assign/verify-test-suite.wf.md

@@ -3,8 +3,8 @@ doc-type: workflow
 title: Assign Verify Test Suite Workflow
 purpose: Narrow deterministic verification contract for ace-assign orchestration
 ace-docs:
-  last-updated: 2026-04-13
-  last-checked: 2026-04-13
+  last-updated: 2026-10-19
+  last-checked: 2026-10-19
 ---
 
 # Verify Test Suite Workflow
@@ -25,6 +25,12 @@ Do not run `ace-test-e2e` or `ace-test-e2e-suite` from this workflow.
 4. Run `ace-test <package> all --profile 6` for each modified package.
 5. Run `ace-test-suite --target all`.
 
+## Hermetic Environment Rule (Forked Drive Sessions)
+
+Package verification frequently runs inside forked assignment drive sessions, where the launcher exports fork-runtime variables (`ACE_ASSIGN_DEFAULT_TARGET`, `ACE_ASSIGN_CURRENT_ASSIGNMENT_ID`, `ACE_ASSIGN_CURRENT_FORK_ROOT`, `ACE_RUNTIME`, `ACE_ASSIGN_LAUNCH_MODE`, `ACE_ASSIGN_FORK_WINDOW`, `ACE_ASSIGN_CALLBACK_PANE`, `PROJECT_ROOT_PATH`) and ambient tmux session variables (`TMUX`, `TMUX_PANE`) may also be present. Do not scrub these by hand and never bypass the runner with raw `bundle exec rake`/`ruby` inside a forked subtree.
+
+Always verify through `ace-test` / `ace-test-suite`: the deterministic test runner applies a hermetic environment policy that drops all ambient `ACE_*` and `LAB_*` runtime configuration (including every `ACE_ASSIGN_*` fork-runtime variable) before any test executes, in-process and for spawned subprocesses. Verification results are therefore identical whether the command runs from a clean shell or from inside a forked drive session; any other invocation forfeits that guarantee.
+
 ## Skip Guidance
 
 Skip only when all modified files are documentation, retrospectives, task specs, or similarly non-runnable metadata.

data/lib/ace/assign/cli/commands/assignment_target.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-require_relative "../../authority/protected_assignment_context"
 
 module Ace
   module Assign
@@ -12,16 +11,11 @@ module Ace
         # - <assignment-id>@<step-number>
         module AssignmentTarget
           DEFAULT_TARGET_ENV = "ACE_ASSIGN_DEFAULT_TARGET"
-          Target = Struct.new(:assignment_id, :scope, :prepared_input, keyword_init: true)
+          Target = Struct.new(:assignment_id, :scope, keyword_init: true)
           View = Struct.new(:assignment, :state, :scoped_state, :active_steps, :next_step, :focus_step, :scope_root, keyword_init: true)
 
           private
 
-          def refuse_protected_graph_mutation!(options)
-            context = @protected_assignment_context ||= Ace::Assign::Authority::ProtectedAssignmentContext.load
-            context.refuse_graph_mutation!(options: options)
-          end
-
           def resolve_assignment_target(options)
             assignment_raw = options[:assignment]
             explicit_target = unless assignment_raw.nil? || assignment_raw.to_s.strip.empty?
@@ -35,13 +29,7 @@ module Ace
                 "does not match #{DEFAULT_TARGET_ENV}=#{target_identity(env_target)}"
             end
 
-            target = explicit_target || env_target || Target.new(assignment_id: nil, scope: nil)
-            context = @protected_assignment_context ||= Ace::Assign::Authority::ProtectedAssignmentContext.load
-            target.prepared_input = context.resolve(options: options, assignment_id: target.assignment_id, scope: target.scope)
-            if target.prepared_input && ![Status, Step, Start, Finish, Fail, Resume].any? { |command| is_a?(command) }
-              raise AttemptErrors::EvidenceUnavailable, "protected queue command requires a reviewed new prepared version and attempt"
-            end
-            target
+            explicit_target || env_target || Target.new(assignment_id: nil, scope: nil)
           end
 
           def parse_assignment_target(raw)
@@ -75,7 +63,6 @@ module Ace
           end
 
           def build_executor_for_target(target)
-            return Ace::Assign::Authority::PreparedExecutor.new(target.prepared_input) if target.prepared_input
             return Organisms::AssignmentExecutor.new unless target.assignment_id
 
             manager = Molecules::AssignmentManager.new

data/lib/ace/assign/cli/commands/create.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-require "json"
 
 module Ace
   module Assign
@@ -12,7 +11,6 @@ module Ace
 
           desc "Create a new workflow assignment"
 
-          option :delivery_parameters, desc: "JSON file with forge selection and explicit PR provenance (task mode)"
           option :yaml, desc: "Path to job.yaml config file"
           option :task, aliases: ["-t"], type: :array,
             desc: "Task reference(s), repeatable and comma-separated"
@@ -21,17 +19,14 @@ module Ace
           option :debug, aliases: ["-d"], type: :boolean, default: false, desc: "Show debug output"
 
           def call(yaml: nil, task: nil, preset: nil, **options)
-            refuse_protected_graph_mutation!(options)
             validate_modes!(yaml, task, preset)
-            raise Ace::Support::Cli::Error, "--delivery-parameters requires --task" if yaml && options[:delivery_parameters]
 
             result = if yaml
               Organisms::AssignmentExecutor.new.start(yaml)
             else
               Organisms::TaskAssignmentCreator.new.call(
                 task_refs: task,
-                preset_name: preset || Organisms::TaskAssignmentCreator::DEFAULT_PRESET,
-                delivery_parameters: options[:delivery_parameters] && JSON.parse(File.read(options[:delivery_parameters]))
+                preset_name: preset || Organisms::TaskAssignmentCreator::DEFAULT_PRESET
               )
             end
 
@@ -40,8 +35,6 @@ module Ace
               print_assignment_header(result[:assignment])
               print_step_instructions(result[:current] || result[:state]&.next_workable)
             end
-          rescue JSON::ParserError, Errno::ENOENT
-            raise Ace::Support::Cli::Error, "Delivery parameters file unavailable or invalid JSON"
           rescue ArgumentError => e
             raise Ace::Support::Cli::Error, e.message
           end

data/lib/ace/assign/cli/commands/fail.rb

@@ -12,8 +12,6 @@ module Ace
           desc "Mark current step as failed"
 
           option :message, aliases: ["-m"], required: true, desc: "Error message"
-          option :mapping, desc: "Installed protected launch mapping ID"
-          option :attempt, desc: "Original protected attempt ID"
           option :assignment, desc: "Target specific assignment ID"
           option :quiet, aliases: ["-q"], type: :boolean, default: false, desc: "Suppress non-essential output"
           option :debug, aliases: ["-d"], type: :boolean, default: false, desc: "Show debug output"
@@ -30,10 +28,6 @@ module Ace
               puts "Step #{failed.number} (#{failed.name}) marked as failed"
               puts "Updated: #{File.basename(failed.file_path)}"
               puts "Error: #{message}"
-              if target.prepared_input
-                puts "Further work requires a reviewed new prepared version and attempt."
-                return
-              end
               puts
               puts "Options:"
               puts "- ace-assign add \"fix-step\" to add a fix step"

data/lib/ace/assign/cli/commands/finish.rb

@@ -13,8 +13,6 @@ module Ace
 
           argument :step, required: false, desc: "Step number to finish (active assignment only)"
           option :message, aliases: ["-m"], desc: "Report content: string, file path, or pipe stdin"
-          option :mapping, desc: "Installed protected launch mapping ID"
-          option :attempt, desc: "Original protected attempt ID"
           option :assignment, desc: "Target specific assignment ID"
           option :quiet, aliases: ["-q"], type: :boolean, default: false, desc: "Suppress non-essential output"
           option :debug, aliases: ["-d"], type: :boolean, default: false, desc: "Show debug output"
@@ -26,7 +24,7 @@ module Ace
 
             target = resolve_assignment_target(options)
             executor = build_executor_for_target(target)
-            report_content = resolve_report_content(options, protected: !target.prepared_input.nil?)
+            report_content = resolve_report_content(options)
             result = executor.finish_step(
               report_content: report_content,
               step_number: step,
@@ -74,27 +72,8 @@ module Ace
 
           private
 
-          def resolve_report_content(options, protected: false)
+          def resolve_report_content(options)
             message = options[:message]&.strip
-            if protected
-              limit = Ace::Assign::Authority::PreparedWork::MAX_TEXT
-              if message && !message.empty? && File.exist?(message)
-                return File.open(message, File::RDONLY | File::NOFOLLOW | File::NONBLOCK) do |file|
-                  before = file.stat
-                  raise Error, "Report input must be a bounded regular file" unless before.file? && before.size.between?(1, limit)
-                  bytes = file.read(limit + 1)
-                  after = file.stat
-                  unless bytes.bytesize == before.size && [before.dev, before.ino, before.size, before.mtime, before.ctime] ==
-                      [after.dev, after.ino, after.size, after.mtime, after.ctime]
-                    raise Error, "Report input changed"
-                  end
-                  bytes
-                end
-              end
-              bytes = message && !message.empty? ? message : $stdin.read(limit + 1)
-              raise Error, "Report input exceeds captured text bound" unless bytes && bytes.bytesize.between?(1, limit)
-              return bytes
-            end
             return File.read(message) if message && !message.empty? && File.exist?(message)
             return message if message && !message.empty?
 

data/lib/ace/assign/cli/commands/fork_session.rb

@@ -26,7 +26,6 @@ module Ace
           end
 
           def call(**options)
-            refuse_protected_graph_mutation!(options)
             launcher.launch_provider_session(
               assignment_id: options[:assignment],
               fork_root: options[:root],

data/lib/ace/assign/cli/commands/select.rb

@@ -23,7 +23,6 @@ module Ace
           option :debug, aliases: ["-d"], type: :boolean, default: false, desc: "Show debug output"
 
           def call(id: nil, **options)
-            refuse_protected_graph_mutation!(options)
             manager = Molecules::AssignmentManager.new
 
             if options[:clear]

data/lib/ace/assign/cli/commands/start.rb

@@ -12,8 +12,6 @@ module Ace
           desc "Start next workable pending step"
 
           argument :step, required: false, desc: "Step number to start (active assignment only)"
-          option :mapping, desc: "Installed protected launch mapping ID"
-          option :attempt, desc: "Original protected attempt ID"
           option :assignment, desc: "Target specific assignment ID"
           option :quiet, aliases: ["-q"], type: :boolean, default: false, desc: "Suppress non-essential output"
           option :debug, aliases: ["-d"], type: :boolean, default: false, desc: "Show debug output"

data/lib/ace/assign/cli/commands/status.rb

@@ -41,8 +41,6 @@ module Ace
           option :format, desc: "Output format (table, json)", default: "table"
           option :quiet, aliases: ["-q"], type: :boolean, default: false, desc: "Suppress non-essential output"
           option :debug, aliases: ["-d"], type: :boolean, default: false, desc: "Show debug output"
-          option :mapping, desc: "Installed protected launch mapping ID"
-          option :attempt, desc: "Original protected attempt ID"
           option :assignment, desc: "Show status for specific assignment ID"
           option :all, aliases: ["-a"], type: :boolean, default: false, desc: "Include completed assignments in other assignments section"
 
@@ -87,14 +85,9 @@ module Ace
           def status_to_h(assignment, state, active_steps, next_step, target:, scope_root:)
             # Extract auto_merge config if present in assignment settings or preset
             auto_merge = false
-            preset_name = Ace::Assign::Molecules::PresetInferrer.infer_from_assignment(assignment) unless target.prepared_input
+            preset_name = Ace::Assign::Molecules::PresetInferrer.infer_from_assignment(assignment)
             auto_merge = true if preset_name && preset_name.start_with?("work-on-task-auto-merge")
 
-            evidence = Ace::Assign::Molecules::EvidenceCalculator.calculate(
-              auto_merge: auto_merge,
-              assignment_id: assignment.id
-            )
-
             payload = {
               assignment: {
                 id: assignment.id,
@@ -108,9 +101,6 @@ module Ace
 
             payload[:next_step] = step_to_h(next_step, effective_fork_provider: effective_fork_provider_for(next_step, scoped_fork_metadata_step(state, next_step, target.scope, scope_root))) if active_steps.empty? && next_step
             
-            # Merge exact head evidence into root payload
-            payload.merge!(evidence)
-
             payload
           end
 
@@ -137,10 +127,6 @@ module Ace
             lines = []
             lines.concat(compact_summary_lines(view.assignment, view.scoped_state, view.active_steps, view.next_step))
 
-            if !target.prepared_input && (attempt_line = compact_attempt_line(view.assignment.id))
-              lines.insert(1, attempt_line)
-            end
-
             unless target.assignment_id
               other_line = compact_other_assignments_line(view.assignment.id, include_completed: include_completed)
               lines << other_line if other_line
@@ -149,22 +135,6 @@ module Ace
             puts lines.take(10).join("\n")
           end
 
-          # Active attempt summary projected from the coordinator authority.
-          def compact_attempt_line(assignment_id)
-            projection = Organisms::AttemptCoordinator.new.status(assignment_id)
-            return nil unless projection
-
-            base = projection["base_head"].to_s[0, 7]
-            candidate = projection["candidate_head"].to_s[0, 7]
-            line = "Attempt: #{projection['attempt_id']} #{projection['state']}"
-            line += " | base:#{base}" unless base.to_s.empty?
-            line += " | cand:#{candidate.empty? ? 'none' : candidate}"
-            line += " | unresolved: #{projection['unresolved_effects'].join(',')}" if projection["unresolved_effects"].any?
-            line
-          rescue Ace::Assign::Error, Ace::Support::Cli::Error
-            nil
-          end
-
           def compact_summary_lines(assignment, state, active_steps, next_step)
             lines = [
               compact_assignment_line(assignment, state, active_steps, next_step),

data/lib/ace/assign/cli/commands/step.rb

@@ -12,8 +12,6 @@ module Ace
           desc "Show instructions for the active, next, or explicit step"
 
           argument :step, required: false, desc: "Exact step number to inspect"
-          option :mapping, desc: "Installed protected launch mapping ID"
-          option :attempt, desc: "Original protected attempt ID"
           option :assignment, desc: "Target specific assignment ID"
           option :quiet, aliases: ["-q"], type: :boolean, default: false, desc: "Suppress non-essential output"
           option :debug, aliases: ["-d"], type: :boolean, default: false, desc: "Show debug output"
@@ -26,7 +24,7 @@ module Ace
             return if options[:quiet]
 
             if inspected
-              puts(target.prepared_input ? target.prepared_input.render(inspected.instructions) : inspected.instructions)
+              puts(inspected.instructions)
             else
               puts no_work_message(view)
             end