diff --git a/examples/adversarial-implementation/README.md b/examples/adversarial-implementation/README.md
index 19dfac715..b17609066 100644
--- a/examples/adversarial-implementation/README.md
+++ b/examples/adversarial-implementation/README.md
@@ -63,7 +63,8 @@ retains the selected providers and all three budgets through continuation.
 consumer-driven API repairs, each from zero through ten. `maxResponseCorrections`
 bounds extra response-format calls per completed assignment, from zero through
 three. Zero admits no extra response call. It applies to ordinary planning,
-implementation, selected feedback reviews and foundation replies, including
+implementation, selected feedback reviews, independent delivery reviews and
+foundation replies, including
 repairs by their original owner. It authorizes no transport retry or repetition
 of uncertain productive work. Continuing a Ticket keeps its consumed source
 correction count and recorded allocation; it does not restart a failed attempt.
@@ -304,19 +305,45 @@ Independent review summaries allow 1500 characters; detailed observations belong
 in `findings`. The request states this bound alongside the exact revision and
 clause IDs. Ordinary phase and API-foundation summaries retain their own bounds.
 
+A joined reply containing only `{"status":"in_progress"}` gets one completion
+turn in the same native conversation, with the same reviewer, resolved model,
+effort and exact source revision. The workflow saves the original reply, checks
+that the checkout is clean and reserves `completion/` before sending a prompt
+with a five-minute deadline. A second progress reply, unavailable conversation,
+failed turn or changed source holds the review. Unmarked prose and malformed
+verdicts do not authorize a completion turn. Status and reconciliation read the
+saved evidence without prompting; a later invocation never starts an unused or
+interrupted completion turn.
+
+The completion turn has its own allowance. If it returns a review whose only
+defect is summary length, the original formatting allowance still applies.
+
+An otherwise-valid joined review with only an oversized summary can consume the
+work item's recorded `maxResponseCorrections` allowance. Each correction stays
+in the selected reviewer conversation with the same resolved model and effort.
+It shortens only `summary`; every other result field is frozen. Zero permits no
+extra call. The workflow records the original raw reply and rejection, reserves
+each correction before dispatch, and saves its request, native outcome, reply,
+source observations and disposition separately. Exhaustion, changed substance,
+changed source or uncertain work holds explicitly; none selects a fallback
+reviewer or repeats the completed review. Reconciliation validates this saved
+chain without prompting. Historical assignments without a recorded allowance
+have zero; a new workflow does not retroactively accept their rejected replies.
+
+
 Use `--props-action reconcile` when the selected joined review has a saved
 execution but no accepted receipt. Only the selection's attempt qualifies: the
 original reviewer, or Astra after a retained transition from an eligible Fable
 failure. It checks that attempt's assignment, joined execution, unchanged raw
-reply, current schema, clauses and source before creating the missing receipt,
+reply, any saved completion, current schema, clauses and source before creating the missing receipt,
 and saves a raw reply the execution joined but never wrote. It never shortens text, changes a verdict, repeats
 a model call or overwrites a contradictory receipt. Missing or uncertain execution
 continues to hold. Status uses this same validation boundary to read receipts.
 
 Reconciliation is limited to independent review from a work item launched under
 the same response contract. Its assignment retains the exact response schema; a
-missing or different schema refuses rather than reinterpreting an old reply. It cannot repair or adopt an ordinary rejected role
-verdict, rewrite its raw rejection or partial work, or reset a correction budget.
+missing or different schema refuses rather than reinterpreting an old reply. It validates only corrections recorded under the original review assignment.
+It cannot adopt an ordinary rejected role verdict, rewrite its raw rejection or partial work, or reset a correction budget.
 A current schema accepting older text does not retroactively approve that work.
 Preserve the original rejection and require an explicit applicable
 schema-amendment decision, recording the old bound, amended bound, exact raw
@@ -361,13 +388,46 @@ from claiming readiness or merging independently.
 
 ## Prepare requests without metadata repair turns
 
-These rules apply to separate phase requests and Ticket role calls.
-`Phase.Request` renders the complete prompt before entering an Agent, including
-initial repository instructions, role instructions, assignment, selected text and
-response schema. A missing selected component or input fails there; a packet
-above 256000 characters refuses before provider dispatch. The selected evidence
-keeps its separate 64000-character bound; the complete-prompt ceiling also accommodates
-mandatory initialization instructions and the response schema. Nothing is truncated.
+Claude workflow-role calls use the CLI's scoped `claude-workflow-role` provider.
+Each role installs it directly around its authored session, covering initial and
+continued prompts. It disables native shell/subagent backgrounding and denies
+`ScheduleWakeup` and `Monitor`;
+ordinary interactive Sidekick calls keep their defaults. A retained session that
+lacks matching creation settings refuses before another prompt. Each role joins
+its owned processes and returns its result in the same call. The upfront brief
+contains work, evidence and lifetime rules. Identical role instructions selected
+as input are delivered once; a different captured version retains the current
+role brief too. The frozen submission guide contains response schema, limits and
+routing. Reading defaults to result preparation; an earlier read must resolve a
+concrete reporting requirement that blocks a work decision. Every result,
+including an early blocker, requires the complete guide within the same call.
+
+These rules apply to separate phase requests and Ticket role calls. Codex authors
+prose committed to workflow documents, including guides, component instructions
+and prompt templates. Claude roles may write internal runtime handoffs, hold
+prompts and summaries.
+`Phase.Run` freezes the submission guide in its reserved attempt directory.
+`Phase.Request` checks that guide and prepares the phase prompt before entering
+an Agent. The prompt includes initial repository and role instructions,
+the assignment, selected text and an absolute reference to `submission-guide.md`
+in the attempt directory. The guide contains the complete submission instructions
+and the current role- and phase-specific JSON contract. Read it before returning
+any result, including an early blocker, source conflict or unanswered decision.
+The same retained native call reads the file and returns the result; staging the
+guide adds no model call.
+
+The guide and its hash receipt are runner-owned. Preparation refuses occupied
+paths and confirms that the published text is readable under current File
+permissions and protection. After saving each raw reply, the workflow verifies
+the guide and receipt against the expected submission instructions before it
+accepts a result or starts a correction. Missing, unreadable or changed files
+hold the attempt with its raw reply preserved. Corrections retain their existing
+inline repair packet, original session and allowance.
+
+A missing selected component or input fails before provider dispatch. A prompt
+above 256000 characters refuses without truncation. The guide has its own
+256000-character and UTF-8-byte bounds. Selected evidence keeps its separate
+64000-character allowance; moving submission instructions does not enlarge it.
 Provider configuration and client compatibility retain their existing checks before a turn starts.
 No paid prompt probes installation or repairs launch metadata.
 
diff --git a/examples/adversarial-implementation/components/Adversarial/PlannerRole.md b/examples/adversarial-implementation/components/Adversarial/PlannerRole.md
index 7138e5499..ff3b300a7 100644
--- a/examples/adversarial-implementation/components/Adversarial/PlannerRole.md
+++ b/examples/adversarial-implementation/components/Adversarial/PlannerRole.md
@@ -12,7 +12,7 @@ props:
 
 <Adversarial.Schema as="schemas" />
 <Phase.Profile role="planner" design={true} plannerProvider={props.assignment.plannerProvider} assessment={props.assignment.assessment} as="profile" />
-<Output><Agent name={profile.provider}><Session name={props.assignment.session} model={profile.model} effort={profile.effort}><Phase.Session directory={props.assignment.identityDirectory} name={props.assignment.session} requireExisting={props.assignment.sessionEstablished === true || props.correction !== null}><Prompt throwOnError={true}>
+<Let as="request">
 <If condition={props.correction !== null}>
 You remain the original Planner. This is response-only correction {props.correction.ordinal} with {props.correction.remaining} remaining. Shorten only the rejected summary or handoff to its stated bound. Every other result value is frozen by the supplied schema, including the API, outcome, source revision, artifacts, assessment and command evidence.
 
@@ -48,4 +48,6 @@ Return exactly one JSON object satisfying this contract. Evidence names actual c
 <Json value={schemas.foundation} />
 </Else>
 </If>
-</Prompt></Phase.Session></Session></Agent></Output>
+</Let>
+<Phase.ProviderName agent={profile.provider} as="provider" />
+<Output><If condition={profile.provider === "claude"}><AgentProvider name={provider} defaultAgent="claude"><Agent name="claude"><Session name={props.assignment.session} model={profile.model} effort={profile.effort}><Phase.Session directory={props.assignment.identityDirectory} name={props.assignment.session} requireExisting={props.assignment.sessionEstablished === true || props.correction !== null}><Prompt throwOnError={true}>{request}</Prompt></Phase.Session></Session></Agent></AgentProvider><Else><Agent name={profile.provider}><Session name={props.assignment.session} model={profile.model} effort={profile.effort}><Phase.Session directory={props.assignment.identityDirectory} name={props.assignment.session} requireExisting={props.assignment.sessionEstablished === true || props.correction !== null}><Prompt throwOnError={true}>{request}</Prompt></Phase.Session></Session></Agent></Else></If></Output>
diff --git a/examples/adversarial-implementation/components/Delivery/Dispatch.md b/examples/adversarial-implementation/components/Delivery/Dispatch.md
index a81e117ad..b11fb96b1 100644
--- a/examples/adversarial-implementation/components/Delivery/Dispatch.md
+++ b/examples/adversarial-implementation/components/Delivery/Dispatch.md
@@ -16,7 +16,7 @@ A release that fails ends the run and leaves the attempt reserved, so it holds
 for reconciliation and can never select a replacement.
 
 <Let as="entry" value={props.selection.reviewers[props.position]} />
-<Dir path={props.attempt}><File path="assignment.json"><Json value={{work:props.selection.work,revision:props.selection.revision,reviewer:entry.reviewer,acceptance:props.selection.policy.acceptance,responseSchema:props.selection.responseSchema}} /></File></Dir>
+<Dir path={props.attempt}><File path="assignment.json"><Json value={{work:props.selection.work,revision:props.selection.revision,reviewer:entry.reviewer,acceptance:props.selection.policy.acceptance,responseSchema:props.selection.responseSchema,...(props.selection.maxResponseCorrections === undefined ? {} : {maxResponseCorrections:props.selection.maxResponseCorrections})}} /></File></Dir>
 <Try>
 <Delivery.Role delivery={props.delivery} revision={props.selection.revision} reviewer={entry.reviewer} choices={entry.choices} position={props.position} attempt={props.attempt} />
 <Dir path={props.attempt}><File path="execution.json"><Json value={{status:"completed",failure:null}} /></File></Dir>
diff --git a/examples/adversarial-implementation/components/Delivery/Finish.md b/examples/adversarial-implementation/components/Delivery/Finish.md
new file mode 100644
index 000000000..8e0c43404
--- /dev/null
+++ b/examples/adversarial-implementation/components/Delivery/Finish.md
@@ -0,0 +1,58 @@
+---
+description: 'Finish an incomplete review once in its original conversation, or read that saved turn. Use <Delivery.Finish delivery={delivery} revision={revision} reviewer={reviewer} catalog={catalog} attempt={attempt} dispatch={false} as="reply" />.'
+props:
+  type: object
+  properties:
+    delivery: {type: object}
+    revision: {type: string, pattern: '^[0-9a-f]{40}$'}
+    reviewer: {type: object}
+    catalog: {type: object}
+    attempt: {type: string, pattern: '^/'}
+    dispatch: {type: boolean}
+  required: [delivery, revision, reviewer, catalog, attempt, dispatch]
+  additionalProperties: false
+returns: {type: string}
+---
+
+The initial turn has returned an explicit progress reply. Reserve the one
+completion turn before prompting. Its reply and source evidence stay separate
+from the first turn and any later summary corrections.
+
+<Delivery.Schema as="schemas" />
+<If condition={props.catalog.state !== "selected" || typeof props.catalog.model !== "string" || !props.catalog.model}><Fail message="The progress reply has no retained selected model. Preserve it and hold." /></If>
+<Let as="directory" value={props.attempt + "/completion"} />
+<Let as="request" value={{schema:"delivery-review-completion.v1",revision:props.revision,reviewer:props.reviewer,model:props.catalog.model,original:props.attempt + "/raw.txt",timeout:"5m",responseSchema:schemas.review}} />
+<Let as="sourceSchema" value={{type:"object",properties:{head:{const:props.revision},clean:{const:true}},required:["head","clean"]}} />
+<If condition={props.dispatch}>
+<Ticket.Checkout repository={props.delivery.repository} as="before" />
+<If condition={before.head !== props.revision || !before.clean}><Fail message="Source changed before review completion. Preserve the first reply and hold." /></If>
+<Let as="quoted" value={"'" + directory.replaceAll("'","'\"'\"'") + "'"} />
+```bash exec as="reserved"
+mkdir -- {quoted}
+```
+<If condition={reserved.exitCode !== 0}><Fail message="The review completion is already reserved or cannot be reserved. No prompt is repeated." /></If>
+<Dir path={directory}><File path="request.json"><Json value={request} /></File><File path="source-before.json"><Json value={before} /></File></Dir>
+<Delivery.Turn as="turn"><Agent name={props.reviewer.provider}><Session name={props.reviewer.session} model={props.catalog.model} effort={props.reviewer.effort ?? undefined}><Phase.Session directory={props.delivery.directory + "/sessions"} name={props.reviewer.session} requireExisting={true}><Prompt throwOnError={true} timeout={request.timeout}>
+Continue your unfinished independent review of {props.revision} from this conversation. Finish only the checks still needed. Keep source unchanged, run checks in the foreground and join them before returning. Return the final verdict for the original acceptance clauses as one JSON object. If you cannot finish, report the concrete blocker in the verdict. This is the only completion turn.
+<Json value={request.responseSchema} />
+</Prompt></Phase.Session></Session></Agent></Delivery.Turn>
+<Dir path={directory}><File path="outcome.json"><Json value={{reviewer:props.reviewer,catalog:props.catalog,turn}} /></File></Dir>
+<If condition={turn.state !== "reply"}><Fail message={"Review completion failed: " + turn.failure + ". Preserve both turns and hold."} /></If>
+<Dir path={directory}><File path="raw.txt">{turn.reply}</File></Dir>
+<Ticket.Checkout repository={props.delivery.repository} as="after" />
+<Dir path={directory}><File path="source-after.json"><Json value={after} /></File></Dir>
+</If>
+<Ticket.Text path={directory + "/request.json"} as="savedRequest" />
+<Parse schema={{type:"object"}} as="packet">{savedRequest}</Parse>
+<If condition={JSON.stringify(packet) !== JSON.stringify(request)}><Fail message="The saved completion request differs from the original review." /></If>
+<Ticket.Text path={directory + "/outcome.json"} as="savedOutcome" />
+<Parse schema={{type:"object"}} as="returned">{savedOutcome}</Parse>
+<Ticket.Text path={directory + "/raw.txt"} as="reply" />
+<If condition={JSON.stringify(returned.reviewer) !== JSON.stringify(props.reviewer) || JSON.stringify(returned.catalog) !== JSON.stringify(props.catalog) || returned.turn?.state !== "reply" || returned.turn.reply !== reply}><Fail message="The completion reply differs from its retained reviewer outcome." /></If>
+<Ticket.Text path={directory + "/source-before.json"} as="beforeText" />
+<Ticket.Text path={directory + "/source-after.json"} as="afterText" />
+<Parse schema={sourceSchema} as="before">{beforeText}</Parse>
+<Parse schema={sourceSchema} as="after">{afterText}</Parse>
+<SafeParse schema={schemas.progress} as="progress">{reply}</SafeParse>
+<If condition={progress.ok}><Fail message="The reviewer is still unfinished after its one completion turn. Preserve both replies and hold." /></If>
+<Return value={reply} />
diff --git a/examples/adversarial-implementation/components/Delivery/Prepare.md b/examples/adversarial-implementation/components/Delivery/Prepare.md
index 8798a687c..69a9da1a1 100644
--- a/examples/adversarial-implementation/components/Delivery/Prepare.md
+++ b/examples/adversarial-implementation/components/Delivery/Prepare.md
@@ -15,7 +15,7 @@ returns: {type: object}
 <If condition={new Set(policy.acceptance.map(clause => clause.id)).size !== policy.acceptance.length || policy.acceptance.some(clause => !props.task.inputs.includes(clause.source))}>
 <Fail message={"Give acceptance clauses distinct IDs and select each original source in task.inputs before launch. Duplicate IDs: " + policy.acceptance.map(clause => clause.id).filter((id,index,ids) => ids.indexOf(id) !== index).join(", ") + ". Missing source references: " + [...new Set(policy.acceptance.filter(clause => !props.task.inputs.includes(clause.source)).map(clause => clause.source))].join(", ") + ". No provider prompt began."} />
 </If>
-<Let as="delivery" value={{work:props.task.work,repository:props.task.repository,directory:props.task.directory + "/delivery",policy,inputs:props.inputs,required:["independent-review","required-ci","main-health"]}} />
+<Let as="delivery" value={{work:props.task.work,repository:props.task.repository,directory:props.task.directory + "/delivery",policy,inputs:props.inputs,maxResponseCorrections:props.task.maxResponseCorrections ?? 0,required:["independent-review","required-ci","main-health"]}} />
 <Delivery.Selection delivery={delivery} revision={"0".repeat(40)} as="selection" />
 <If condition={selection.reviewers.some(entry => Object.values(props.task.sessions).includes(entry.reviewer.session))}><Fail message="Independent review uses a separate conversation from the implementation and feedback roles." /></If>
 <Return value={delivery} />
diff --git a/examples/adversarial-implementation/components/Delivery/Reconcile.md b/examples/adversarial-implementation/components/Delivery/Reconcile.md
index e04ee59dd..bf5daaf8a 100644
--- a/examples/adversarial-implementation/components/Delivery/Reconcile.md
+++ b/examples/adversarial-implementation/components/Delivery/Reconcile.md
@@ -14,13 +14,14 @@ returns: {type: object}
 Only the retained selection's attempt can supply the receipt: the original
 reviewer, or its replacement after a retained transition from an eligible
 failure. A joined reply that was never saved as `raw.txt` is completed from the
-attempt's retained outcome.
+attempt's retained outcome. If it was a progress reply, only the saved
+completion turn can supply the review.
 
 <Delivery.Schema as="schemas" />
 <Delivery.Attempts delivery={props.delivery} revision={props.revision} as="read" />
 <If condition={read.state.candidate === null}><Fail message={"No selected review attempt can supply a receipt (" + read.state.selection + " selection). Preserve the retained attempts; this reconciliation action starts no provider prompt."} /></If>
 <Let as="attempt" value={read.state.candidate.directory} />
-<Let as="assigned" value={{work:props.delivery.work,revision:props.revision,reviewer:read.state.candidate.reviewer,acceptance:props.delivery.policy.acceptance,responseSchema:schemas.review}} />
+<Let as="assigned" value={{work:props.delivery.work,revision:props.revision,reviewer:read.state.candidate.reviewer,acceptance:props.delivery.policy.acceptance,responseSchema:schemas.review,...(props.delivery.maxResponseCorrections === undefined ? {} : {maxResponseCorrections:props.delivery.maxResponseCorrections})}} />
 <Ticket.Text path={attempt + "/assignment.json"} as="assignmentText" />
 <Parse schema={{type:"object"}} as="assignment">{assignmentText}</Parse>
 <If condition={JSON.stringify(assignment) !== JSON.stringify(assigned)}><Fail message="The original review assignment or response schema differs from the recorded delivery requirement. Preserve the original rejection; schema changes require an explicit applicable amendment decision outside this action. This reconciliation action starts no provider prompt." /></If>
@@ -36,9 +37,8 @@ attempt's retained outcome.
 </If>
 <Ticket.Text path={attempt + "/raw.txt"} as="raw" />
 <If condition={raw !== returned.turn.reply}><Fail message="The saved raw reply differs from the joined execution. Preserve both for reconciliation." /></If>
-<Phase.Extract text={raw} as="extracted" />
-<If condition={!extracted.ok}><Fail message={extracted.rejection.message} /></If>
-<Parse schema={schemas.review} as="result">{extracted.json}</Parse>
+<Delivery.Response delivery={props.delivery} revision={props.revision} reviewer={read.state.candidate.reviewer} attempt={attempt} raw={raw} dispatch={false} as="response" />
+<Let as="result" value={response.result} />
 <If condition={result.revision !== props.revision || result.acceptance.length !== props.delivery.policy.acceptance.length || props.delivery.policy.acceptance.some(clause => !result.acceptance.includes(clause.id)) || result.verdict === "pass" && result.findings.some(finding => finding.blocking)}><Fail message="The joined review must cover every recorded clause on the assigned commit and cannot pass with a blocking finding." /></If>
 <Let as="receipt" value={{...assigned,result,execution:attempt + "/execution.json"}} />
 <If condition={derived.includes("receipt.json")}>
diff --git a/examples/adversarial-implementation/components/Delivery/Response.md b/examples/adversarial-implementation/components/Delivery/Response.md
new file mode 100644
index 000000000..62fae6f89
--- /dev/null
+++ b/examples/adversarial-implementation/components/Delivery/Response.md
@@ -0,0 +1,93 @@
+---
+description: 'Finish a review after an explicit progress reply, repair an oversized summary, or validate the saved replies without prompting. Use <Delivery.Response delivery={delivery} revision={revision} reviewer={reviewer} attempt={attempt} raw={raw} dispatch={false} as="response" />.'
+props:
+  type: object
+  properties:
+    delivery: {type: object}
+    revision: {type: string}
+    reviewer: {type: object}
+    attempt: {type: string}
+    raw: {type: string}
+    dispatch: {type: boolean, default: false}
+  required: [delivery, revision, reviewer, attempt, raw]
+  additionalProperties: false
+returns: {type: object}
+---
+
+A progress reply can use one separate completion turn. Formatting corrections
+start with the completed review and consume only the recorded formatting
+allowance. Reconciliation reads both records and sends no prompt.
+
+<Delivery.Schema as="schemas" />
+<Ticket.Text path={props.attempt + "/assignment.json"} as="assignmentText" />
+<Parse schema={{type:"object"}} as="assignment">{assignmentText}</Parse>
+<Let as="limit" value={assignment.maxResponseCorrections ?? 0} />
+<If condition={!Number.isInteger(limit) || limit < 0 || limit > 3 || limit !== (props.delivery.maxResponseCorrections ?? 0)}><Fail message="The review response allowance differs from its recorded assignment." /></If>
+<Ticket.Text path={props.attempt + "/outcome.json"} as="outcomeText" />
+<Parse schema={{type:"object"}} as="originalOutcome">{outcomeText}</Parse>
+<Let as="catalog" value={originalOutcome.catalog} />
+<If condition={originalOutcome.turn?.state !== "reply" || originalOutcome.turn.reply !== props.raw || JSON.stringify(originalOutcome.reviewer) !== JSON.stringify(props.reviewer)}><Fail message="The original review does not match its joined outcome." /></If>
+<Let as="reviewRaw" value={props.raw} />
+<Let as="initialRawPath" value={props.attempt + "/raw.txt"} />
+<SafeParse schema={schemas.progress} as="progress">{props.raw}</SafeParse>
+<If condition={progress.ok}>
+<Delivery.Finish delivery={props.delivery} revision={props.revision} reviewer={props.reviewer} catalog={catalog} attempt={props.attempt} dispatch={props.dispatch} as="reviewRaw" />
+<Let as="initialRawPath" value={props.attempt + "/completion/raw.txt"} />
+</If>
+<Delivery.Validate text={reviewRaw} revision={props.revision} acceptance={props.delivery.policy.acceptance} as="checked" />
+<Let as="original" value={checked.result ?? null} />
+<Let as="rawPath" value={initialRawPath} />
+<Let as="round" value={0} />
+<If condition={!checked.ok && props.dispatch}>
+<Dir path={props.attempt}><File path="response-rejection.json"><Json value={checked} /></File></Dir>
+</If>
+<Loop max={3}>
+<If condition={checked.ok || !checked.repairable || round >= limit}><Break /></If>
+<Let as="round" value={round + 1} />
+<Let as="directory" value={props.attempt + "/response-corrections/" + String(round).padStart(4,"0")} />
+<Let as="repairSchema" value={{...schemas.review,properties:Object.fromEntries(Object.entries(schemas.review.properties).map(([key,value]) => [key,key === "summary" ? value : {const:original[key]}]))}} />
+<Let as="packet" value={{schema:"delivery-summary-correction.v1",revision:props.revision,reviewer:props.reviewer,model:catalog.model,ordinal:round,remaining:limit-round,original:initialRawPath,result:original,responseSchema:repairSchema}} />
+<If condition={JSON.stringify(packet).length > 64000}><Fail message="The review correction packet exceeds 64000 characters; no prompt was sent." /></If>
+<If condition={props.dispatch}>
+<Ticket.Checkout repository={props.delivery.repository} as="before" />
+<If condition={before.head !== props.revision || !before.clean}><Fail message="Source changed before response-only review correction." /></If>
+<Dir path={props.attempt + "/response-corrections"}><Let as="parentPrepared" value={true} /></Dir>
+<Let as="quoted" value={"'" + directory.replaceAll("'","'\"'\"'") + "'"} />
+```bash exec as="reserved"
+mkdir -- {quoted}
+```
+<If condition={reserved.exitCode !== 0}><Fail message="Preserve the occupied review correction; no prompt is repeated." /></If>
+<Dir path={directory}><File path="request.json"><Json value={packet} /></File><File path="source-before.json"><Json value={before} /></File></Dir>
+<Delivery.Turn as="turn"><Agent name={props.reviewer.provider}><Session name={props.reviewer.session} model={catalog.model} effort={props.reviewer.effort ?? undefined}><Phase.Session directory={props.delivery.directory + "/sessions"} name={props.reviewer.session} requireExisting={true}><Prompt throwOnError={true}>
+Shorten only the summary of your completed independent review to at most {schemas.review.properties.summary.maxLength} characters. This is response-only correction {round}, with {limit-round} remaining. Do not inspect source, run commands, repeat the review, publish or change any other field. Preserve the verdict, findings, clause IDs and revision exactly. Return one JSON object satisfying the frozen schema below.
+<Json value={packet} />
+</Prompt></Phase.Session></Session></Agent></Delivery.Turn>
+<Dir path={directory}><File path="outcome.json"><Json value={{reviewer:props.reviewer,catalog,turn}} /></File></Dir>
+<If condition={turn.state !== "reply"}><Fail message={"The review summary correction failed: " + turn.failure + ". Preserve its outcome and original review; no replacement reviewer is eligible."} /></If>
+<Dir path={directory}><File path="raw.txt">{turn.reply}</File></Dir>
+<Ticket.Checkout repository={props.delivery.repository} as="after" />
+<Dir path={directory}><File path="source-after.json"><Json value={after} /></File></Dir>
+<If condition={after.head !== before.head || !after.clean}><Fail message="Response-only review correction changed source; preserve the work and hold." /></If>
+</If>
+<Ticket.Text path={directory + "/request.json"} as="requestText" />
+<Parse schema={{type:"object"}} as="savedRequest">{requestText}</Parse>
+<If condition={JSON.stringify(savedRequest) !== JSON.stringify(packet)}><Fail message="The saved correction differs from its original review, identity or allowance." /></If>
+<Ticket.Text path={directory + "/outcome.json"} as="returnedText" />
+<Parse schema={{type:"object"}} as="returned">{returnedText}</Parse>
+<Ticket.Text path={directory + "/raw.txt"} as="raw" />
+<If condition={JSON.stringify(returned.reviewer) !== JSON.stringify(props.reviewer) || JSON.stringify(returned.catalog) !== JSON.stringify(catalog) || returned.turn?.state !== "reply" || returned.turn.reply !== raw}><Fail message="The correction reply differs from its joined reviewer outcome." /></If>
+<Ticket.Text path={directory + "/source-before.json"} as="beforeText" />
+<Ticket.Text path={directory + "/source-after.json"} as="afterText" />
+<Parse schema={{type:"object",properties:{head:{const:props.revision},clean:{const:true}},required:["head","clean"]}} as="before">{beforeText}</Parse>
+<Parse schema={{type:"object",properties:{head:{const:props.revision},clean:{const:true}},required:["head","clean"]}} as="after">{afterText}</Parse>
+<Let as="rawPath" value={directory + "/raw.txt"} />
+<Delivery.Validate text={raw} revision={props.revision} acceptance={props.delivery.policy.acceptance} frozen={original} as="checked" />
+<If condition={props.dispatch}>
+<Dir path={directory}><File path="disposition.json"><Json value={{ordinal:round,limit,accepted:checked.ok,rejection:checked.ok ? null : checked.reason,raw:rawPath}} /></File></Dir>
+</If>
+</Loop>
+<If condition={!checked.ok}>
+<If condition={props.dispatch}><Dir path={props.attempt}><File path="response-disposition.json"><Json value={{status:"held",consumed:round,limit,reason:checked.reason,repairable:checked.repairable}} /></File></Dir></If>
+<Fail message={"Independent review response is held after " + round + "/" + limit + " corrections: " + checked.reason} />
+</If>
+<Return value={{result:checked.result,round,rawPath}} />
diff --git a/examples/adversarial-implementation/components/Delivery/Review.md b/examples/adversarial-implementation/components/Delivery/Review.md
index 330830114..daae17bd9 100644
--- a/examples/adversarial-implementation/components/Delivery/Review.md
+++ b/examples/adversarial-implementation/components/Delivery/Review.md
@@ -44,7 +44,19 @@ mkdir -- {quotedReplacement}
 <Delivery.Reconcile delivery={props.delivery} revision={props.revision} publish={true} as="receipt" />
 <Return value={receipt} />
 <Else>
-<If condition={read.selection.chain === "single"}><Fail message="Independent review did not return a joined result. Preserve this attempt and reconcile the original call; do not launch another reviewer." /></If>
+<If condition={read.selection.chain === "single" && read.state.hold === null}>
+<Let as="unfinished" value={false} />
+<If condition={read.state.attempts[0]?.state === "held"}>
+<Dir path={read.directory}><Glob include={["raw.txt"]} as="replies" /></Dir>
+<If condition={replies.length !== 0}>
+<Delivery.Schema as="schemas" />
+<Ticket.Text path={read.directory + "/raw.txt"} as="raw" />
+<SafeParse schema={schemas.progress} as="progress">{raw}</SafeParse>
+<Let as="unfinished" value={progress.ok} />
+</If>
+</If>
+<If condition={!unfinished}><Fail message="Independent review did not return a joined result. Preserve this attempt and reconcile the original call; do not launch another reviewer." /></If>
+</If>
 <Delivery.Hold delivery={props.delivery} revision={props.revision} as="held" />
 <Return value={held} />
 </Else>
diff --git a/examples/adversarial-implementation/components/Delivery/ReviewState.ts b/examples/adversarial-implementation/components/Delivery/ReviewState.ts
index 2206912ea..1d05e792f 100644
--- a/examples/adversarial-implementation/components/Delivery/ReviewState.ts
+++ b/examples/adversarial-implementation/components/Delivery/ReviewState.ts
@@ -216,6 +216,9 @@ function assignmentFor(selection: Selection, reviewer: Reviewer) {
     reviewer,
     acceptance: selection.policy.acceptance,
     responseSchema: selection.responseSchema,
+    ...(selection.maxResponseCorrections === undefined
+      ? {}
+      : { maxResponseCorrections: selection.maxResponseCorrections }),
   };
 }
 
@@ -238,12 +241,27 @@ export default function* ReviewState(value: unknown): Operation<unknown> {
   );
 }
 
-function* observe(directory: string, expected: Selection, replacement: boolean): Operation<unknown> {
+function* observe(
+  directory: string,
+  expected: Selection,
+  replacement: boolean,
+): Operation<unknown> {
   const selectionText = yield* read(directory, "selection.json");
   const recorded = parsed(selectionSchema, selectionText);
   const selection =
-    selectionText === null ? "absent" : recorded !== null && same(recorded, expected) ? "matches" : "mismatch";
-  const empty = { selection, chain: expected.chain, attempts: [], candidate: null, effective: null, transition: null };
+    selectionText === null
+      ? "absent"
+      : recorded !== null && same(recorded, expected)
+        ? "matches"
+        : "mismatch";
+  const empty = {
+    selection,
+    chain: expected.chain,
+    attempts: [],
+    candidate: null,
+    effective: null,
+    transition: null,
+  };
   if (selection !== "matches") {
     return { ...empty, next: "uncertain", hold: null };
   }
@@ -274,7 +292,8 @@ function* observe(directory: string, expected: Selection, replacement: boolean):
       next = "uncertain";
     } else {
       const transitionText = yield* read(replacementDirectory, "transition.json");
-      const proven = transitionText !== null && same(parsed(z.unknown(), transitionText), transition);
+      const proven =
+        transitionText !== null && same(parsed(z.unknown(), transitionText), transition);
       const replaced = yield* attempt(
         replacementDirectory,
         1,
@@ -298,7 +317,9 @@ function* observe(directory: string, expected: Selection, replacement: boolean):
                 : "The replacement transition differs from the primary attempt's eligible failure.",
           };
       attempts.push(settled);
-      candidate = proven ? { position: 1, directory: replacementDirectory, reviewer: second.reviewer } : null;
+      candidate = proven
+        ? { position: 1, directory: replacementDirectory, reviewer: second.reviewer }
+        : null;
       next = !proven
         ? "uncertain"
         : settled.state === "review"
@@ -331,7 +352,8 @@ function* observe(directory: string, expected: Selection, replacement: boolean):
             holdRecord.work === expected.work &&
             holdRecord.revision === expected.revision &&
             holdRecord.chain === expected.chain &&
-            (dispositionText === null || (disposition !== null && same(disposition.hold, holdRecord))),
+            (dispositionText === null ||
+              (disposition !== null && same(disposition.hold, holdRecord))),
           answer: disposition?.answer ?? null,
           evidence: [
             `${directory}/hold.json`,
diff --git a/examples/adversarial-implementation/components/Delivery/Role.md b/examples/adversarial-implementation/components/Delivery/Role.md
index 03c89edf8..52cb79ed8 100644
--- a/examples/adversarial-implementation/components/Delivery/Role.md
+++ b/examples/adversarial-implementation/components/Delivery/Role.md
@@ -19,6 +19,8 @@ saved to `outcome.json` before that release, including when the turn fails.
 
 <Delivery.Schema as="schemas" />
 <Let as="instructions">
+Finish this native call with its review JSON result. Run required checks in the foreground and join every process you start before returning. A progress message, monitor or future notification does not complete the review.
+
 Perform one independent correctness review of {props.revision} in {props.delivery.repository}. Read the repository instructions and inspect that exact commit and its affected consumers. Keep source unchanged. Reuse applicable evidence; run only focused evidence that distinguishes a finding. Do not run broad confidence suites or wait for CI. Do not delegate, implement, publish comments, or merge. Report a concrete blocker rather than substituting a provider or repeating an uncertain call.
 
 Review these recorded acceptance clauses against their original selected sources. A derived check cannot strengthen or replace them. Report a material ambiguity as blocked.
@@ -29,17 +31,24 @@ Original captured source text:
 
 Keep summary within {schemas.review.properties.summary.maxLength} characters, including spaces and newlines. Put detailed observations in findings; do not compress the whole report into summary. Check revision against the assigned full SHA and acceptance against the recorded clause IDs before returning.
 
-Return exactly one JSON object satisfying this schema. acceptance lists every clause ID actually examined. pass requires no blocking finding. The workflow supplies work, reviewer, attempt and completion metadata.
+If you must end the turn before the verdict is ready, return exactly {JSON.stringify(schemas.progress.const)} on its own. The workflow can then give this same conversation one chance to finish.
+
+Otherwise, return exactly one JSON object satisfying this schema. acceptance lists every clause ID actually examined. pass requires no blocking finding. The workflow supplies work, reviewer, attempt and completion metadata.
 <Json value={schemas.review} />
 </Let>
 <If condition={instructions.length > 64000}><Fail message="The complete independent-review request exceeds 64000 characters. Prepare concise accepted inputs before dispatch." /></If>
 <Delivery.Continuation directory={props.delivery.directory} session={props.reviewer.session} own={props.attempt.slice(props.delivery.directory.length + 1) + "/assignment.json"} as="established" />
 <Let as="continuation" value={props.delivery.sessionEstablished === true || established} />
-<AgentProvider name="acpx" defaultAgent={props.reviewer.provider}><Dir path={props.delivery.repository}>
+<Phase.ProviderName agent={props.reviewer.provider} as="provider" />
+<AgentProvider name={provider} defaultAgent={props.reviewer.provider}><Dir path={props.delivery.repository}>
 <Delivery.Inspect agent={props.reviewer.provider} choices={props.choices} as="catalog" />
 <Let as="turn" value={null} />
 <Try>
 <If condition={catalog.state === "selected"}><Delivery.Turn as="turn"><Agent name={props.reviewer.provider}><Session name={props.reviewer.session} model={catalog.model} effort={props.reviewer.effort ?? undefined}><Phase.Session directory={props.delivery.directory + "/sessions"} name={props.reviewer.session} requireExisting={continuation}><Prompt throwOnError={true}>{instructions}</Prompt></Phase.Session></Session></Agent></Delivery.Turn></If>
 <Finally><Dir path={props.attempt}><File path="outcome.json"><Json value={{schema:"delivery-review-outcome.v1",reviewer:props.reviewer,catalog,turn}} /></File></Dir></Finally>
 </Try>
+<If condition={turn?.state === "reply"}>
+<Dir path={props.attempt}><File path="raw.txt">{turn.reply}</File></Dir>
+<Delivery.Response delivery={props.delivery} revision={props.revision} reviewer={props.reviewer} attempt={props.attempt} raw={turn.reply} dispatch={true} as="response" />
+</If>
 </Dir></AgentProvider>
diff --git a/examples/adversarial-implementation/components/Delivery/Schema.md b/examples/adversarial-implementation/components/Delivery/Schema.md
index bcfe715ac..009d4438c 100644
--- a/examples/adversarial-implementation/components/Delivery/Schema.md
+++ b/examples/adversarial-implementation/components/Delivery/Schema.md
@@ -5,4 +5,4 @@ returns: {type: object}
 
 <Let as="text" value={{type:"string",minLength:1}} />
 <Let as="revision" value={{type:"string",pattern:"^[0-9a-f]{40}$"}} />
-<Return value={{policy:{type:"object",properties:{repository:{type:"string",pattern:"^[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+$"},reviewer:{type:"object",properties:{provider:{enum:["claude","codex"]},model:text,effort:{type:["string","null"]},session:text},required:["provider","model","effort","session"],additionalProperties:false},acceptance:{type:"array",minItems:1,items:{type:"object",properties:{id:text,source:text,requirement:text},required:["id","source","requirement"],additionalProperties:false}}},required:["repository","reviewer","acceptance"],additionalProperties:false},review:{type:"object",properties:{revision,verdict:{enum:["pass","changes_required","blocked"]},summary:{type:"string",minLength:1,maxLength:1500},acceptance:{type:"array",items:{type:"string"},uniqueItems:true},findings:{type:"array",items:{type:"object",properties:{blocking:{type:"boolean"},description:text},required:["blocking","description"],additionalProperties:false}}},required:["revision","verdict","summary","acceptance","findings"],additionalProperties:false}}} />
+<Return value={{progress:{const:{status:"in_progress"}},policy:{type:"object",properties:{repository:{type:"string",pattern:"^[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+$"},reviewer:{type:"object",properties:{provider:{enum:["claude","codex"]},model:text,effort:{type:["string","null"]},session:text},required:["provider","model","effort","session"],additionalProperties:false},acceptance:{type:"array",minItems:1,items:{type:"object",properties:{id:text,source:text,requirement:text},required:["id","source","requirement"],additionalProperties:false}}},required:["repository","reviewer","acceptance"],additionalProperties:false},review:{type:"object",properties:{revision,verdict:{enum:["pass","changes_required","blocked"]},summary:{type:"string",minLength:1,maxLength:1500},acceptance:{type:"array",items:{type:"string"},uniqueItems:true},findings:{type:"array",items:{type:"object",properties:{blocking:{type:"boolean"},description:text},required:["blocking","description"],additionalProperties:false}}},required:["revision","verdict","summary","acceptance","findings"],additionalProperties:false}}} />
diff --git a/examples/adversarial-implementation/components/Delivery/Selection.md b/examples/adversarial-implementation/components/Delivery/Selection.md
index b591c5c86..3f7bb6438 100644
--- a/examples/adversarial-implementation/components/Delivery/Selection.md
+++ b/examples/adversarial-implementation/components/Delivery/Selection.md
@@ -19,4 +19,4 @@ reviewer is the only one.
 <Let as="fable" value={reviewer.provider === "claude" && (reviewer.model === "fable" || reviewer.model.startsWith("claude-fable-"))} />
 <Let as="astra" value={reviewer.provider === "codex" && reviewer.model === "gpt-6-astra"} />
 <Let as="replacement" value={{provider:"codex",model:"gpt-6-astra",effort:reviewer.effort,session:reviewer.session + "-astra"}} />
-<Return value={{schema:"delivery-review-selection.v1",work:props.delivery.work,repository:props.delivery.repository,revision:props.revision,policy:props.delivery.policy,inputs:props.delivery.inputs,responseSchema:schemas.review,chain:fable ? "fable-astra" : astra ? "astra-final" : "single",reviewers:fable ? [{reviewer,choices:[...new Set(["fable",reviewer.model])]},{reviewer:replacement,choices:["gpt-6-astra"]}] : [{reviewer,choices:[reviewer.model]}]}} />
+<Return value={{schema:"delivery-review-selection.v1",work:props.delivery.work,repository:props.delivery.repository,revision:props.revision,policy:props.delivery.policy,inputs:props.delivery.inputs,responseSchema:schemas.review,...(props.delivery.maxResponseCorrections === undefined ? {} : {maxResponseCorrections:props.delivery.maxResponseCorrections}),chain:fable ? "fable-astra" : astra ? "astra-final" : "single",reviewers:fable ? [{reviewer,choices:[...new Set(["fable",reviewer.model])]},{reviewer:replacement,choices:["gpt-6-astra"]}] : [{reviewer,choices:[reviewer.model]}]}} />
diff --git a/examples/adversarial-implementation/components/Delivery/Validate.md b/examples/adversarial-implementation/components/Delivery/Validate.md
new file mode 100644
index 000000000..b0adfc0e5
--- /dev/null
+++ b/examples/adversarial-implementation/components/Delivery/Validate.md
@@ -0,0 +1,38 @@
+---
+description: 'Check one independent review without changing it. Use <Delivery.Validate text={raw} revision={revision} acceptance={clauses} as="checked" />.'
+props:
+  type: object
+  properties:
+    text: {type: string}
+    revision: {type: string}
+    acceptance: {type: array}
+    frozen: {type: [object, 'null'], default: null}
+  required: [text, revision, acceptance]
+  additionalProperties: false
+returns: {type: object}
+---
+
+<Delivery.Schema as="schemas" />
+<Phase.Extract text={props.text} as="extracted" />
+<If condition={!extracted.ok}>
+<Return value={{ok:false,repairable:false,reason:extracted.rejection.message}} />
+<Else>
+<Let as="relaxed" value={{...schemas.review,properties:{...schemas.review.properties,summary:{...schemas.review.properties.summary,maxLength:undefined}}}} />
+<SafeParse schema={relaxed} as="parsed">{extracted.json}</SafeParse>
+<If condition={!parsed.ok}>
+<Return value={{ok:false,repairable:false,reason:"The review has a defect beyond summary length."}} />
+<Else>
+<Let as="result" value={parsed.value} />
+<Let as="frozen" value={props.frozen} />
+<Let as="frozenSchema" value={frozen === null ? relaxed : {...relaxed,properties:Object.fromEntries(Object.entries(relaxed.properties).map(([key,value]) => [key,key === "summary" ? value : {const:frozen[key]}]))}} />
+<SafeParse schema={frozenSchema} as="correspondence"><Json value={result} /></SafeParse>
+<If condition={result.revision !== props.revision || result.acceptance.length !== props.acceptance.length || props.acceptance.some(clause => !result.acceptance.includes(clause.id)) || result.verdict === "pass" && result.findings.some(finding => finding.blocking) || !correspondence.ok}>
+<Return value={{ok:false,repairable:false,reason:"The review changed its revision, clauses, verdict or frozen fields."}} />
+<Else>
+<Return value={{ok:result.summary.length <= schemas.review.properties.summary.maxLength,repairable:result.summary.length > schemas.review.properties.summary.maxLength,result,reason:result.summary.length > schemas.review.properties.summary.maxLength ? "The review summary exceeds its recorded limit." : null}} />
+</Else>
+</If>
+</Else>
+</If>
+</Else>
+</If>
diff --git a/examples/adversarial-implementation/components/Delivery/records.ts b/examples/adversarial-implementation/components/Delivery/records.ts
index 94b463c36..fe7a3eccc 100644
--- a/examples/adversarial-implementation/components/Delivery/records.ts
+++ b/examples/adversarial-implementation/components/Delivery/records.ts
@@ -81,6 +81,7 @@ export const selectionSchema = z.strictObject({
   policy: z.record(z.string(), z.unknown()),
   inputs: z.array(z.record(z.string(), z.unknown())),
   responseSchema: z.record(z.string(), z.unknown()),
+  maxResponseCorrections: z.number().int().min(0).max(3).optional(),
   chain: z.enum(["fable-astra", "astra-final", "single"]),
   reviewers: z.array(entrySchema).min(1).max(2),
 });
@@ -98,7 +99,7 @@ export const holdSchema = z.strictObject({
   schema: z.literal("delivery-review-hold.v1"),
   work: z.string().min(1),
   revision: z.string().regex(/^[0-9a-f]{40}$/),
-  chain: z.enum(["fable-astra", "astra-final"]),
+  chain: selectionSchema.shape.chain,
   summary: z.string().min(1),
   unknown: z.string().min(1),
   attempts: z.array(attemptSchema).min(1).max(2),
diff --git a/examples/adversarial-implementation/components/Phase/Correct.md b/examples/adversarial-implementation/components/Phase/Correct.md
index 61734ee93..cd69431ab 100644
--- a/examples/adversarial-implementation/components/Phase/Correct.md
+++ b/examples/adversarial-implementation/components/Phase/Correct.md
@@ -80,6 +80,7 @@ shasum -a 256 -- {quoted}/request.json {quoted}/diagnostic.json {quoted}/origina
 <Phase.Role role={props.role} session={props.session} assignment={props.assignment} initialize={false} plannerProvider={props.plannerProvider} implementationProvider={props.implementationProvider} inputs={[]} correction={packet} as="raw" />
 <Let as="rawPath" value={directory + "/raw.txt"} />
 <Dir path={directory}><File path="raw.txt">{raw}</File></Dir>
+<Phase.SubmissionGuide repository={props.assignment.repository} directory={props.attempt} mode="check"><Phase.SubmissionInstructions role={props.role} assignment={props.assignment} /></Phase.SubmissionGuide>
 <Phase.Response assignment={props.assignment} text={raw} role={props.role} profile={props.profile} as="checked" />
 <If condition={checked.ok}>
 <Phase.Correspondence established={frozen} value={checked.value} role={props.role} phase={props.assignment.phase} as="correspondence" />
diff --git a/examples/adversarial-implementation/components/Phase/Instructions.md b/examples/adversarial-implementation/components/Phase/Instructions.md
index f763ce210..e56ead10a 100644
--- a/examples/adversarial-implementation/components/Phase/Instructions.md
+++ b/examples/adversarial-implementation/components/Phase/Instructions.md
@@ -16,26 +16,35 @@ props:
       default: []
     assignment:
       type: object
+    submission:
+      type: object
     initialize:
       type: boolean
       default: false
   required:
     - role
     - assignment
+    - submission
   additionalProperties: false
 ---
 
 <Output>
+Finish this native call with its JSON result. Join every process you start before
+returning; a progress message or a future wakeup does not complete the assignment.
+Run long checks in the foreground and retain their completion output and status.
+
 <If condition={props.initialize}>
 You are the repository {props.role}. Perform the assigned phase using the repository's existing permissions and role boundaries.
 
 Repository instructions:
 <File path="AGENTS.md" />
 
+<File path={".agents/" + props.role + ".md"} as="roleInstructions" />
 Role instructions:
-<If condition={props.role === "architect"}><File path=".agents/architect.md" /></If>
-<If condition={props.role === "planner"}><File path=".agents/planner.md" /></If>
-<If condition={props.role === "implementor"}><File path=".agents/implementor.md" /></If>
+<If condition={props.inputs.some(input => input.path === props.assignment.repository + "/.agents/" + props.role + ".md" && input.content === roleInstructions)}>
+Use the selected role instructions below.
+<Else>{roleInstructions}</Else>
+</If>
 </If>
 
 Use the provider, model and effort explicitly selected by this workflow; historical role-guide defaults do not replace that allocation.
@@ -44,7 +53,15 @@ You remain the retained repository {props.role}. The previous owner's request is
 
 Do not draft, create or edit PR or issue titles or descriptions. The Sidekick running Codex owns that metadata and publication. Return technical decisions, code and evidence only; API documentation stays within the design assignment. Describe user-directed amendments separately from implementation defects, cite the recorded approval evidence and keep the existing correction allowances. This restriction also applies when a general role guide mentions opening a draft PR.
 
-Execute the assigned phase through its stated deliverables. An assigned test or artifact that has not yet been written is remaining work. Continue it within this call. Use blocked only for a concrete external condition you cannot resolve within the assignment: quota, permission, provider failure, unavailable external dependency or genuinely missing input. Supply blocker.kind, reason, unblockCondition and evidence references. A source or design conflict returns needs_discovery; an unanswered human choice returns needs_decision. Use the supplied handoff, artifact paths and evidence first. Store every new plan, handoff, report, candidate and command receipt under assignment.artifactDirectory, the phase directory in this ticket workspace. Keep the source checkout and native cwd unchanged. Historical/source references retain their original locations; do not move or rewrite them. Return absolute references to new artifacts. Leave the runner-owned assignment.json, raw.txt, result.json, status.json and event files unchanged. Tie additional reads to a missing fact or an affected invariant. Reopen earlier conclusions when a named change invalidates them. State the missing fact when the assignment is insufficient. Retain mandatory repository and role requirements.
+Codex authors prose committed to workflow documents, including guides, component instructions and prompt templates. Claude roles may write internal runtime handoffs, hold prompts and summaries. If your selected provider is Claude and the assignment needs workflow-document prose that Codex has not supplied, return needs_discovery with the required authoring work.
+
+Execute the assigned phase through its stated deliverables. An assigned test or artifact that has not yet been written is remaining work. Continue it within this call. Use blocked only for a concrete external condition you cannot resolve within the assignment: quota, permission, provider failure, unavailable external dependency or genuinely missing input. Supply blocker.kind, reason, unblockCondition and evidence references. A source or design conflict returns needs_discovery; an unanswered human choice returns needs_decision. Use the supplied handoff, artifact paths and evidence first.
+
+Store every new plan, handoff, report, candidate and command receipt under assignment.artifactDirectory, the phase directory in this ticket workspace. Keep the source checkout and native cwd unchanged.
+
+Preserve first failures, command receipts and the exact source inputs actually tested. Reference individual UTF-8 text or JSON files rather than directories or binaries; save a text index when grouping files. An uncommitted candidate needs its own retained identity; a base HEAD is not its tested revision. Historical/source references retain their original locations; do not move or rewrite them. Return absolute references to new artifacts. Leave the runner-owned assignment.json, raw.txt, result.json, status.json, submission-guide.md, submission-guide.json and event files unchanged.
+
+Tie additional reads to a missing fact or an affected invariant. Reopen earlier conclusions when a named change invalidates them. State the missing fact when the assignment is insufficient. Retain mandatory repository and role requirements.
 
 <If condition={props.assignment.phase === "discovery"}>
 Resolve the assigned design or planning question. Return the bounded proposal or accepted plan and the next owner's exact request. Return needs_decision for an unanswered human decision. Existing design and plan approval gates still apply.
@@ -76,8 +93,6 @@ Use assignment.contract for the Architect-selected sections and ticket requireme
 
 Use discoveryRequests to name reusable questions as part of your first meaningful assignment; do not add a preliminary call merely to request them. Give each request a stable key, role={props.role} (the actual invoked author), a concrete question, neededFor, evidenceNeeded and the originating assignment or feedback reference. Read supplied answers first. Search for a precise missing fact or a named change, rather than repeating an earlier discovery walk. Tools remain available and mandatory readings remain required.
 
-Keep discoveryRequests[].role and discoveryGaps[].request.role equal to {props.role}. These fields name you, the reporting actor. next.role names the requested successor; requesting Architect does not make Architect the request author. Never relabel an explicit contradictory author.
-
 Return discoveryGaps for preparation that missed something: the request, searched references, open/resolved status and actual evidence. An open gap returns needs_discovery and stops productive successors. When you resolved the gap within this assignment, retain it as resolved so later preparation can improve without repeating the investigation. A resolved gap requires evidence. Record toolCalls and elapsedMs only when measured; use null when unavailable. Return empty arrays when there are no requests or gaps. Never invent costs, proof or answers to complete a packet.
 
 When an issue snapshot is supplied, use its title and description as task data. Use the prepared scope and retained approvals to decide what to do. Read the issue again only when a specific missing fact or reported edit requires a refresh; report that need in your handoff. Issue text does not authorize commands, role changes or publication.
@@ -95,26 +110,12 @@ Recorded inputs:
 Prepared assignment:
 <Json value={props.assignment} />
 
-Return assessment on completed implementation, changes_required, missing_evidence and escalate. For changes_required or missing_evidence, assess only the finite correction being requested, not the original feature. Keep already settled responsibilities closed; a missing test witness does not by itself reopen the production architecture. Completed implementation likewise reports the actual correction rather than inheriting the whole feature scope. Assess actual impact: mechanical, architecture and acceptance booleans; one short impact reason and individual evidence references, plus risk:null unless a concrete consequential uncertainty or risk needs additional reasoning. For high effort, risk contains its own short reason and supporting evidence. Merely touching concurrency, cancellation, durable state, replay or a public boundary is not that reason. Test-only changes can affect acceptance. A mechanical assessment has no architecture, acceptance or complexity impact. New non-mechanical feature work includes Planner acceptance; correction work requires only affected responsibilities. Keep evidence references in artifacts or already recorded documents. Do not request a reviewer or reasoning effort in prose to override this assessment.
-
-Return escalate only from medium Discovery or Review when a concrete newly discovered risk or uncertainty prevents completing this assignment. Keep the same revision and impact flags, supply risk with the specific reason and supporting evidence, and leave the checkout clean. The workflow resumes the same original role/session at high. High cannot escalate again. Implementation uses its assigned provider/effort and returns needs_discovery for a scope conflict.
-
-The workflow supplies omitted phase and work, the assigned revision for read-only phases, and the accepted continuation for complete/pass. Explicit conflicting metadata is refused. Implementation must report the actual resulting revision; evidence must name the inputs actually tested.
-
-Return next.phase and next.role explicitly when the outcome changes the prepared route. For complete/pass, copy assignment.continuation exactly; completed implementation routing is derived from the returned assessment and replaces that predicted continuation. For escalate, copy the current phase and role; the workflow derives and checks that same-owner continuation. For changes_required or missing_evidence, select implementation/implementor. For needs_discovery with apiConflict, select discovery/planner; otherwise select discovery/architect. For blocked or needs_decision, select hold/null. The program verifies this gate before another role can run; ready is a phase-loop result, not delivery approval.
-
-Keep summary to 1200 characters. Address handoff to next.role, or ROOT when next.phase is hold/ready. Write only that owner's next bounded action and necessary artifact references in at most 250 words and 1800 characters. Put command receipts in evidence and detailed reports in artifact files. Select only the short documents the next owner needs in handoffInputs. Each selected handoffInputs path must appear in your returned artifacts or the already recorded documents. A file existing on disk alone does not make it a recorded document. Keep full test logs, patches and historical ledgers in artifacts; listing an artifact does not send its contents. The selected-input limit is 64000 UTF-16 units for the recipient's entire owed packet, including undelivered accepted inputs and role guides. Use the recipient's recorded remaining allowance for new handoff material. Keep binding clauses, their conditions, exceptions, commands, identities and unresolved findings exact; reference full supporting artifacts. Ticket.Prepare checks the actual packet before dispatch and retains its receipt. This selected-input allowance is separate from the 256000-character complete-prompt ceiling. Use a new reference for changed contents. The workflow supplies accepted inputs once per retained role; do not request their repetition without a named change. Do not repeat the summary, command list, prior prompts, full plan, contract packet or narrative history in handoff. Omit blocker outside blocked outcomes.
-
-Reference individual UTF-8 text or JSON files in artifacts, evidence and handoffInputs. Do not return a directory or binary path as a document reference: the workflow reads each reference as a text file. For a group of files, save a text index naming the individual files and return that index.
-
-Before returning, check the required fields, assigned work/phase, actual revision, next role and phase, and character limits against the contract below. Omit optional metadata you cannot establish instead of guessing.
-
-Return exactly one JSON object conforming to this contract, without Markdown fences or surrounding prose. The handoff field is the complete ready-to-send request for the next owner; only that field becomes the next request. Artifacts and evidence travel as structured references. For a command on an uncommitted candidate, use evidence.revision=null and candidate=the retained candidate/command metadata path; a base HEAD is not its tested revision. Use a commit SHA only when the tested inputs correspond to that commit. Report observations as observations; schema validation does not establish test results, approvals or delivery readiness.
-<Phase.Schema as="schemas" />
-<Let as="phaseOutcome" value={schemas.result.allOf[["discovery","implementation","review"].indexOf(props.assignment.phase)].then.properties.outcome} />
-<Let as="authorRequest" value={{...schemas.result.properties.discoveryRequests.items,properties:{...schemas.result.properties.discoveryRequests.items.properties,role:{const:props.role}}}} />
-<Let as="authorGap" value={{...schemas.result.properties.discoveryGaps.items,properties:{...schemas.result.properties.discoveryGaps.items.properties,request:authorRequest}}} />
-<Let as="promptContract" value={{type:schemas.result.type,required:[...schemas.result.required.filter(name => !["phase","work",...(props.assignment.phase === "implementation" ? [] : ["revision"])].includes(name)),"discoveryRequests","discoveryGaps"],additionalProperties:false,properties:{...schemas.result.properties,discoveryRequests:{...schemas.result.properties.discoveryRequests,items:authorRequest},discoveryGaps:{...schemas.result.properties.discoveryGaps,items:authorGap},phase:{const:props.assignment.phase},work:{const:props.assignment.work},outcome:phaseOutcome,contract:props.role === "architect" && props.assignment.phase === "discovery" ? schemas.result.properties.contract : undefined},$defs:schemas.result.$defs}} />
-<Let as="resultContract" value={JSON.stringify(promptContract)} />
-{resultContract}
+Submission guide:
+The frozen UTF-8 file at {props.submission.path} contains the submission schema,
+field limits and next-role routing. Read it when you begin preparing the phase
+result. Open it earlier only if a reporting requirement blocks a concrete
+decision in the assigned work. Read the complete guide before any result,
+including an early blocker, source conflict or unanswered decision, and return
+within this native call; no formatting turn is scheduled.
+Leave the guide and its receipt unchanged.
 </Output>
diff --git a/examples/adversarial-implementation/components/Phase/ProviderName.md b/examples/adversarial-implementation/components/Phase/ProviderName.md
new file mode 100644
index 000000000..7329fd836
--- /dev/null
+++ b/examples/adversarial-implementation/components/Phase/ProviderName.md
@@ -0,0 +1,12 @@
+---
+description: 'Select the registered provider name for a workflow role. Use <Phase.ProviderName agent="claude" as="provider" /> and wrap the authored role session in <AgentProvider name={provider}>.'
+props:
+  type: object
+  properties:
+    agent: {type: string}
+  required: [agent]
+  additionalProperties: false
+returns: {type: string}
+---
+
+<Return value={props.agent === "claude" ? "claude-workflow-role" : "acpx"} />
diff --git a/examples/adversarial-implementation/components/Phase/Request.md b/examples/adversarial-implementation/components/Phase/Request.md
index c4de4c76d..613cd7d3e 100644
--- a/examples/adversarial-implementation/components/Phase/Request.md
+++ b/examples/adversarial-implementation/components/Phase/Request.md
@@ -13,6 +13,7 @@ props:
 returns: {type: string}
 ---
 
-<Let as="request"><If condition={props.correction === null}><Phase.Instructions inputs={props.inputs} role={props.role} assignment={props.assignment} initialize={props.initialize} /><Else><Phase.CorrectionInstructions correction={props.correction} /></Else></If></Let>
+<Phase.SubmissionGuide repository={props.assignment.repository} directory={props.assignment.artifactDirectory} mode="check" as="submission"><Phase.SubmissionInstructions role={props.role} assignment={props.assignment} /></Phase.SubmissionGuide>
+<Let as="request"><If condition={props.correction === null}><Phase.Instructions inputs={props.inputs} role={props.role} assignment={props.assignment} initialize={props.initialize} submission={submission} /><Else><Phase.CorrectionInstructions correction={props.correction} /></Else></If></Let>
 <If condition={request.length > 256000}><Fail message={"The complete phase prompt exceeds 256000 characters (actual " + request.length + "), including mandatory instructions and selected evidence. Selected inputs: " + props.inputs.map(input => input.path + " (" + input.content.length + ")").join(", ") + ". Preserve the prepared assignment and reduce the request before dispatch; nothing was truncated or sent. No provider prompt began."} /></If>
 <Return value={request} />
diff --git a/examples/adversarial-implementation/components/Phase/Role.md b/examples/adversarial-implementation/components/Phase/Role.md
index 5cda85d04..1f9f6f046 100644
--- a/examples/adversarial-implementation/components/Phase/Role.md
+++ b/examples/adversarial-implementation/components/Phase/Role.md
@@ -68,4 +68,5 @@ props:
 </If>
 <ReviewPolicy assessment={props.assignment.assessment} kind={props.assignment.reviewKind ?? "feature"} as="policy" />
 <Phase.Request role={props.role} assignment={props.assignment} inputs={props.inputs} initialize={props.initialize} correction={props.correction} as="request" />
-<Output><If condition={profile.provider === "claude"}><Agent name="claude"><Session name={props.session} model={profile.model} effort={profile.effort}><Phase.Session directory={props.assignment.identityDirectory} name={props.session} requireExisting={props.assignment.sessionEstablished === true || props.correction !== null}><Prompt throwOnError={true}>{request}</Prompt></Phase.Session></Session></Agent><Else><Agent name="codex"><Session name={props.session} model={profile.model} effort={profile.effort}><Phase.Session directory={props.assignment.identityDirectory} name={props.session} requireExisting={props.assignment.sessionEstablished === true || props.correction !== null}><Prompt throwOnError={true}>{request}</Prompt></Phase.Session></Session></Agent></Else></If></Output>
+<Phase.ProviderName agent={profile.provider} as="provider" />
+<Output><If condition={profile.provider === "claude"}><AgentProvider name={provider} defaultAgent="claude"><Agent name="claude"><Session name={props.session} model={profile.model} effort={profile.effort}><Phase.Session directory={props.assignment.identityDirectory} name={props.session} requireExisting={props.assignment.sessionEstablished === true || props.correction !== null}><Prompt throwOnError={true}>{request}</Prompt></Phase.Session></Session></Agent></AgentProvider><Else><Agent name="codex"><Session name={props.session} model={profile.model} effort={profile.effort}><Phase.Session directory={props.assignment.identityDirectory} name={props.session} requireExisting={props.assignment.sessionEstablished === true || props.correction !== null}><Prompt throwOnError={true}>{request}</Prompt></Phase.Session></Session></Agent></Else></If></Output>
diff --git a/examples/adversarial-implementation/components/Phase/Run.md b/examples/adversarial-implementation/components/Phase/Run.md
index c076b3c98..946e45632 100644
--- a/examples/adversarial-implementation/components/Phase/Run.md
+++ b/examples/adversarial-implementation/components/Phase/Run.md
@@ -128,12 +128,14 @@ mkdir -- {quotedAttempt}
 </If>
 <Dir path={attempt}><File path="assignment.json"><Json value={assignment} /></File></Dir>
 <Phase.Event attempt={attempt} stage="started" assignment={assignment} role={props.role} as="started" />
+<Phase.SubmissionGuide repository={assignment.repository} directory={attempt}><Phase.SubmissionInstructions role={props.role} assignment={assignment} /></Phase.SubmissionGuide>
 <Phase.Role inputs={props.inputs} role={props.role} session={props.session} assignment={assignment} initialize={props.initialize} plannerProvider={props.plannerProvider} implementationProvider={props.implementationProvider} as="raw" />
 <Dir path={attempt}><File path="raw.txt">{raw}</File></Dir>
 <Phase.Profile role={props.role} assessment={assignment.assessment} plannerProvider={props.plannerProvider} implementationProvider={props.implementationProvider} as="deliveredProfile" />
 <Ticket.Fingerprint inputs={props.inputs} as="sentInputs" />
 <Dir path={attempt}><File path="delivery.json"><Json value={{schema:"role-input-delivery.v1",role:props.role,session:props.session,provider:deliveredProfile.provider,profile:deliveredProfile,initialize:props.initialize,inputs:sentInputs,raw:attempt + "/raw.txt"}} /></File></Dir>
 <Phase.Event attempt={attempt} stage="reply-saved" assignment={assignment} role={props.role} as="replied" />
+<Phase.SubmissionGuide repository={assignment.repository} directory={attempt} mode="check"><Phase.SubmissionInstructions role={props.role} assignment={assignment} /></Phase.SubmissionGuide>
 <Phase.Correct assignment={assignment} raw={raw} role={props.role} session={props.session} attempt={attempt} plannerProvider={props.plannerProvider} implementationProvider={props.implementationProvider} inputs={props.inputs} profile={props.responseProfile} maxResponseCorrections={props.maxResponseCorrections} as="accepted" />
 <Let as="result" value={accepted.result} />
 <Dir path={attempt}><File path="result.json"><Json value={result} /></File></Dir>
diff --git a/examples/adversarial-implementation/components/Phase/SubmissionGuide.ts b/examples/adversarial-implementation/components/Phase/SubmissionGuide.ts
new file mode 100644
index 000000000..a6bac6e80
--- /dev/null
+++ b/examples/adversarial-implementation/components/Phase/SubmissionGuide.ts
@@ -0,0 +1,52 @@
+import { Component } from "@executablemd/core/api";
+import { z } from "zod";
+import { clear, describe, descriptor, read, same, unused, write } from "../Ticket/text-storage.ts";
+
+export const props = {
+  type: "object",
+  properties: {
+    repository: { type: "string" },
+    directory: { type: "string" },
+    mode: { enum: ["prepare", "check"], default: "prepare" },
+  },
+  required: ["repository", "directory"],
+  additionalProperties: false,
+};
+const input = z
+  .object({
+    repository: z.string(),
+    directory: z.string().startsWith("/"),
+    mode: z.enum(["prepare", "check"]).default("prepare"),
+  })
+  .strict();
+const limit = 256_000;
+
+export default function* SubmissionGuide(value: unknown) {
+  const { repository, directory, mode } = input.parse(value);
+  const acquired = yield* Component.operations.tryContent();
+  if (acquired.failure !== undefined) {
+    throw acquired.failure;
+  }
+  const text = acquired.text;
+  const expected = describe(directory + "/submission-guide.md", text);
+  if (text.length > limit || expected.utf8Bytes > limit) {
+    throw new Error("The submission guide exceeds 256000 characters or UTF-8 bytes.");
+  }
+  yield* clear(text);
+  const receipt = directory + "/submission-guide.json";
+  if (mode === "prepare") {
+    if (!(yield* unused(repository, expected.path)) || !(yield* unused(repository, receipt))) {
+      throw new Error("The submission guide is occupied or unavailable; preserve this attempt.");
+    }
+    yield* write(repository, expected.path, text);
+    yield* write(repository, receipt, JSON.stringify(expected));
+  }
+  const recorded = descriptor.parse(JSON.parse(yield* read(repository, receipt, limit)));
+  const retained = yield* read(repository, expected.path, limit);
+  if (!same(expected, recorded) || !same(expected, describe(expected.path, retained))) {
+    throw new Error(
+      "The frozen submission guide changed; preserve the raw reply. No successor is admitted.",
+    );
+  }
+  return expected;
+}
diff --git a/examples/adversarial-implementation/components/Phase/SubmissionInstructions.md b/examples/adversarial-implementation/components/Phase/SubmissionInstructions.md
new file mode 100644
index 000000000..441327d8a
--- /dev/null
+++ b/examples/adversarial-implementation/components/Phase/SubmissionInstructions.md
@@ -0,0 +1,40 @@
+---
+props:
+  type: object
+  properties:
+    role: {enum: [architect, planner, implementor]}
+    assignment: {type: object}
+  required: [role, assignment]
+  additionalProperties: false
+---
+
+<Output>
+# Submit a phase result
+
+Read this when preparing a result, including an early blocker, source conflict
+or unanswered decision. It supplies the response fields, limits and routing for
+the current assignment.
+
+Return assessment on completed implementation, changes_required, missing_evidence and escalate. For changes_required or missing_evidence, assess only the finite correction being requested, not the original feature. Keep already settled responsibilities closed; a missing test witness does not by itself reopen the production architecture. Completed implementation likewise reports the actual correction rather than inheriting the whole feature scope. Assess actual impact: mechanical, architecture and acceptance booleans; one short impact reason and individual evidence references, plus risk:null unless a concrete consequential uncertainty or risk needs additional reasoning. For high effort, risk contains its own short reason and supporting evidence. Merely touching concurrency, cancellation, durable state, replay or a public boundary is not that reason. Test-only changes can affect acceptance. A mechanical assessment has no architecture, acceptance or complexity impact. New non-mechanical feature work includes Planner acceptance; correction work requires only affected responsibilities. Keep evidence references in artifacts or already recorded documents. Do not request a reviewer or reasoning effort in prose to override this assessment.
+
+Return escalate only from medium Discovery or Review when a concrete newly discovered risk or uncertainty prevents completing this assignment. Keep the same revision and impact flags, supply risk with the specific reason and supporting evidence, and leave the checkout clean. The workflow resumes the same original role/session at high. High cannot escalate again. Implementation uses its assigned provider/effort and returns needs_discovery for a scope conflict. Only the Implementor during implementation may include apiConflict, with a saved reproducer in artifacts and failed evidence.
+
+The workflow supplies omitted phase and work, the assigned revision for read-only phases, and the accepted continuation for complete/pass. Explicit conflicting metadata is refused. Implementation must report the actual resulting revision; evidence must name the inputs actually tested.
+
+Return next.phase and next.role explicitly when the outcome changes the prepared route. For complete/pass, copy assignment.continuation exactly; completed implementation routing is derived from the returned assessment and replaces that predicted continuation. For escalate, copy the current phase and role; the workflow derives and checks that same-owner continuation. For changes_required or missing_evidence, select implementation/implementor. For needs_discovery with apiConflict, select discovery/planner; otherwise select discovery/architect. For blocked or needs_decision, select hold/null. The program verifies this gate before another role can run; ready is a phase-loop result, not delivery approval.
+
+Keep summary to 1200 characters. Address handoff to next.role, or ROOT when next.phase is hold/ready. Write only that owner's next bounded action and necessary artifact references in at most 250 words and 1800 characters. Put command receipts in evidence and detailed reports in artifact files. Select only the short documents the next owner needs in handoffInputs. Each selected handoffInputs path must appear in your returned artifacts or the already recorded documents. A file existing on disk alone does not make it a recorded document. Keep full test logs, patches and historical ledgers in artifacts; listing an artifact does not send its contents. The selected-input limit is 64000 UTF-16 units for the recipient's entire owed packet, including undelivered accepted inputs and role guides. Use the recipient's recorded remaining allowance for new handoff material. Keep binding clauses, their conditions, exceptions, commands, identities and unresolved findings exact; reference full supporting artifacts. Ticket.Prepare checks the actual packet before dispatch and retains its receipt. This selected-input allowance is separate from the 256000-character complete-prompt ceiling. Use a new reference for changed contents. The workflow supplies accepted inputs once per retained role; do not request their repetition without a named change. Do not repeat the summary, command list, prior prompts, full plan, contract packet or narrative history in handoff. Omit blocker outside blocked outcomes.
+
+Keep discoveryRequests[].role and discoveryGaps[].request.role equal to {props.role}. These fields name you, the reporting actor. next.role names the requested successor; requesting Architect does not make Architect the request author. Never relabel an explicit contradictory author.
+
+Before returning, check the required fields, assigned work/phase, actual revision, next role and phase, and character limits against the contract below. Omit optional metadata you cannot establish instead of guessing.
+
+Return exactly one JSON object conforming to this contract, without Markdown fences or surrounding prose. The handoff field is the complete ready-to-send request for the next owner; only that field becomes the next request. Artifacts and evidence travel as structured references. For an uncommitted candidate, report evidence.revision=null and candidate=the retained candidate/command metadata path. Report observations as observations; schema validation does not establish test results, approvals or delivery readiness.
+<Phase.Schema as="schemas" />
+<Let as="phaseOutcome" value={schemas.result.allOf[["discovery","implementation","review"].indexOf(props.assignment.phase)].then.properties.outcome} />
+<Let as="authorRequest" value={{...schemas.result.properties.discoveryRequests.items,properties:{...schemas.result.properties.discoveryRequests.items.properties,role:{const:props.role}}}} />
+<Let as="authorGap" value={{...schemas.result.properties.discoveryGaps.items,properties:{...schemas.result.properties.discoveryGaps.items.properties,request:authorRequest}}} />
+<Let as="promptContract" value={{type:schemas.result.type,required:[...schemas.result.required.filter(name => !["phase","work",...(props.assignment.phase === "implementation" ? [] : ["revision"])].includes(name)),"discoveryRequests","discoveryGaps"],additionalProperties:false,properties:{...schemas.result.properties,discoveryRequests:{...schemas.result.properties.discoveryRequests,items:authorRequest},discoveryGaps:{...schemas.result.properties.discoveryGaps,items:authorGap},phase:{const:props.assignment.phase},work:{const:props.assignment.work},outcome:phaseOutcome,apiConflict:props.role === "implementor" && props.assignment.phase === "implementation" ? schemas.result.properties.apiConflict : undefined,contract:props.role === "architect" && props.assignment.phase === "discovery" ? schemas.result.properties.contract : undefined},$defs:schemas.result.$defs}} />
+<Let as="resultContract" value={JSON.stringify(promptContract)} />
+{resultContract}
+</Output>
diff --git a/examples/adversarial-implementation/components/Ticket/PreparationPrompt.md b/examples/adversarial-implementation/components/Ticket/PreparationPrompt.md
index b5044f4b2..5331a2214 100644
--- a/examples/adversarial-implementation/components/Ticket/PreparationPrompt.md
+++ b/examples/adversarial-implementation/components/Ticket/PreparationPrompt.md
@@ -36,4 +36,5 @@ Return exactly one JSON object satisfying:
 <Json value={props.schema} />
 </Let>
 <If condition={request.length > 256000}><Fail message="The complete preparation prompt exceeds 256000 characters; nothing was sent." /></If>
-<Output><Dir path={props.assignment.repository}><Agent name={props.owner.profile.provider}><Session name={props.owner.session} model={props.owner.profile.model} effort={props.owner.profile.effort}><Phase.Session directory={props.owner.identityDirectory} name={props.owner.session} requireExisting={true}><Prompt throwOnError={true}>{request}</Prompt></Phase.Session></Session></Agent></Dir></Output>
+<Phase.ProviderName agent={props.owner.profile.provider} as="provider" />
+<Output><Dir path={props.assignment.repository}><If condition={props.owner.profile.provider === "claude"}><AgentProvider name={provider} defaultAgent="claude"><Agent name="claude"><Session name={props.owner.session} model={props.owner.profile.model} effort={props.owner.profile.effort}><Phase.Session directory={props.owner.identityDirectory} name={props.owner.session} requireExisting={true}><Prompt throwOnError={true}>{request}</Prompt></Phase.Session></Session></Agent></AgentProvider><Else><Agent name={props.owner.profile.provider}><Session name={props.owner.session} model={props.owner.profile.model} effort={props.owner.profile.effort}><Phase.Session directory={props.owner.identityDirectory} name={props.owner.session} requireExisting={true}><Prompt throwOnError={true}>{request}</Prompt></Phase.Session></Session></Agent></Else></If></Dir></Output>
diff --git a/examples/adversarial-implementation/delivery.md b/examples/adversarial-implementation/delivery.md
index 1637a3133..ea366dadc 100644
--- a/examples/adversarial-implementation/delivery.md
+++ b/examples/adversarial-implementation/delivery.md
@@ -10,9 +10,10 @@ props:
 ---
 
 Read the original delivery record and perform only its computed next action.
-A status read starts no agent. Review preserves every attempt and never repeats
-one: an unavailable Fable reviewer is replaced once by Codex Astra, and a review
-nobody could complete is held and asked about. Readiness permits no merge.
+A status read starts no agent. An explicit progress reply gets one continuation
+in the same conversation. An unavailable Fable reviewer is replaced once by
+Codex Astra. The workflow preserves each attempt and asks about a review it
+cannot complete. Readiness permits no merge.
 
 <Ticket.Text path={props.record} as="recordText" />
 <Parse schema={{type:"object",properties:{work:{type:"string"},repository:{type:"string",pattern:"^/"},directory:{type:"string",pattern:"^/"},policy:{type:"object"},required:{const:["independent-review","required-ci","main-health"]}},required:["work","repository","directory","policy","required"]}} as="delivery">{recordText}</Parse>
diff --git a/examples/adversarial-implementation/tests/Delivery.test.md b/examples/adversarial-implementation/tests/Delivery.test.md
index 42e209302..fc8a5ca04 100644
--- a/examples/adversarial-implementation/tests/Delivery.test.md
+++ b/examples/adversarial-implementation/tests/Delivery.test.md
@@ -87,7 +87,9 @@ printf '%s' "$XMD_EXAMPLE_COMMAND"
 <Test name="mandatory initialization and a full selected evidence packet fit the complete prompt">
 <Each in={["architect","planner","implementor"]} let="role">
 <Let as="assignment" value={{phase:role === "implementor" ? "implementation" : "discovery",work:"test",repository:root,revision:"a".repeat(40),request:"Inspect saved evidence.",assessment}} />
-<Phase.Request role={role} assignment={assignment} initialize={true} inputs={[{path:"accepted.md",content:"x".repeat(64000)}]} as="request" />
+<TempDir as="artifactDirectory" />
+<Phase.SubmissionGuide repository={root} directory={artifactDirectory}><Phase.SubmissionInstructions role={role} assignment={assignment} /></Phase.SubmissionGuide>
+<Phase.Request role={role} assignment={{...assignment,artifactDirectory}} initialize={true} inputs={[{path:"accepted.md",content:"x".repeat(64000)}]} as="request" />
 <AssertEquals actual={request.includes("Repository instructions:")} expected={true} />
 <AssertEquals actual={request.includes("Role instructions:")} expected={true} />
 <AssertEquals actual={request.includes("You are the repository " + role)} expected={true} />
@@ -178,3 +180,113 @@ pwd -P
 <AssertEquals actual={preserved} expected={firstFailure} />
 </TempDir>
 </Test>
+
+
+<Test name="oversized independent summaries repair once in the same conversation and reconcile without prompting" timeout="120s">
+<Each in={["accepted","zero","changed","exhausted","invalid"]} let="variant">
+<TempDir>
+<Fixture.Repository as="fixture" />
+<Dir path={fixture.repository}><Fixture.Composition repository={fixture.repository} directory={fixture.directory + "/repositories"}>
+```bash exec as="head"
+git rev-parse HEAD
+```
+<Let as="revision" value={head.stdout.trim()} />
+<Let as="reviewer" value={{provider:"codex",model:"gpt-6.1-sol",effort:"medium",session:"summary-reviewer"}} />
+<Let as="attempt" value={fixture.directory + "/delivery/review-" + revision} />
+<Let as="delivery" value={{work:"summary",repository:fixture.repository,directory:fixture.directory + "/delivery",maxResponseCorrections:variant === "zero" ? 0 : 1,inputs:[],policy:{repository:"taras/executable.md",reviewer,acceptance:[{id:"behavior",source:"accepted.md",requirement:"Preserve the accepted behavior."}]}}} />
+<Let as="review" value={{revision,verdict:"pass",summary:"x".repeat(1501),acceptance:variant === "invalid" ? [] : ["behavior"],findings:[{blocking:false,description:"Keep this exact observation."}]}} />
+<Let as="catalog" value={{state:"selected",choices:[reviewer.model],model:reviewer.model,advertised:[reviewer.model],failure:null}} />
+<Delivery.Schema as="schemas" />
+<Delivery.Selection delivery={delivery} revision={revision} as="selection" />
+<Dir path={attempt}><File path="selection.json"><Json value={selection} /></File></Dir>
+<Dir path={attempt}><File path="assignment.json"><Json value={{work:"summary",revision,reviewer,acceptance:delivery.policy.acceptance,responseSchema:schemas.review,maxResponseCorrections:delivery.maxResponseCorrections}} /></File></Dir>
+<TestAgent agent="codex">
+<TestAgent.Scenario session={reviewer.session} src="./agents/summary-correction.md" models={{selected:reviewer.model,options:[{id:reviewer.model,efforts:{selected:"medium",options:["medium"]}}]}} />
+<Agent name="codex"><Session name={reviewer.session} model={reviewer.model} effort="medium"><Phase.Session directory={delivery.directory + "/sessions"} name={reviewer.session}><Prompt throwOnError={true} as="raw"><Json value={{variant,review}} /></Prompt></Phase.Session></Session></Agent>
+<Dir path={attempt}><File path="raw.txt">{raw}</File><File path="outcome.json"><Json value={{schema:"delivery-review-outcome.v1",reviewer,catalog,turn:{state:"reply",reply:raw}}} /></File></Dir>
+<Ticket.Capture as="execution"><Delivery.Response delivery={delivery} revision={revision} reviewer={reviewer} attempt={attempt} raw={raw} dispatch={true} as="response" /><Json value={response} /></Ticket.Capture>
+<If condition={variant === "accepted" && execution.status !== "completed"}><Fail message={execution.failure} /></If>
+<AssertEquals actual={execution.status} expected={variant === "accepted" ? "completed" : "failed"} />
+<Ticket.Text path={attempt + "/raw.txt"} as="originalRaw" />
+<AssertEquals actual={originalRaw} expected={raw} />
+<Dir path={attempt}><Glob include={["response-corrections/*/request.json"]} as="corrections" /></Dir>
+<AssertEquals actual={corrections.length} expected={["zero","invalid"].includes(variant) ? 0 : 1} />
+<If condition={variant === "accepted"}>
+<Parse schema={{type:"object"}} as="accepted">{execution.output}</Parse>
+<AssertEquals actual={accepted.result} expected={{...review,summary:"The independent findings and verdict remain unchanged."}} />
+<Delivery.Response delivery={delivery} revision={revision} reviewer={reviewer} attempt={attempt} raw={raw} dispatch={false} as="reconciled" />
+<AssertEquals actual={reconciled} expected={accepted} />
+<Dir path={attempt}><File path="execution.json"><Json value={{status:"completed",failure:null}} /></File></Dir>
+<Delivery.Reconcile delivery={delivery} revision={revision} publish={true} as="receipt" />
+<AssertEquals actual={receipt.result} expected={accepted.result} />
+<Delivery.Reconcile delivery={delivery} revision={revision} publish={false} as="readback" />
+<AssertEquals actual={readback} expected={receipt} />
+<Dir path={attempt + "/response-corrections/0001"}><File path="raw.txt"><Json value={{...accepted.result,findings:[]}} /></File></Dir>
+<Ticket.Capture as="tampered"><Delivery.Response delivery={delivery} revision={revision} reviewer={reviewer} attempt={attempt} raw={raw} dispatch={false} /></Ticket.Capture>
+<AssertEquals actual={tampered.status} expected="failed" />
+</If>
+</TestAgent>
+</Fixture.Composition></Dir>
+</TempDir>
+</Each>
+</Test>
+
+<Test name="a joined progress reply gets one same-session completion with a separate formatting allowance" timeout="90s">
+<Each in={["pass","format","repeat","unmarked"]} let="variant">
+<TempDir>
+<Fixture.Repository as="fixture" />
+<Dir path={fixture.repository}><Fixture.Composition repository={fixture.repository} directory={fixture.directory + "/repositories"}>
+```bash exec as="head"
+git rev-parse HEAD
+```
+<Let as="revision" value={head.stdout.trim()} />
+<Let as="reviewer" value={{provider:"codex",model:"gpt-6.1-sol",effort:"medium",session:"completion-reviewer"}} />
+<Let as="delivery" value={{work:variant === "repeat" ? "completion-repeat" : "completion",repository:fixture.repository,directory:fixture.directory + "/delivery",maxResponseCorrections:variant === "pass" ? 0 : 1,inputs:[],policy:{repository:"taras/executable.md",reviewer,acceptance:[{id:"behavior",source:"accepted.md",requirement:"Preserve the accepted behavior."}]}}} />
+<Let as="attempt" value={delivery.directory + "/review-" + revision} />
+<Let as="review" value={{revision,verdict:"pass",summary:variant === "format" ? "x".repeat(1501) : "Review complete.",acceptance:["behavior"],findings:[]}} />
+<Let as="catalog" value={{state:"selected",choices:[reviewer.model],model:reviewer.model,advertised:[reviewer.model],failure:null}} />
+<TestAgent agent="codex">
+<TestAgent.Scenario session={reviewer.session} src="./agents/review-completion.md" models={{selected:reviewer.model,options:[{id:reviewer.model,efforts:{selected:"medium",options:["medium"]}}]}} />
+<If condition={variant === "repeat"}>
+<Dir path={delivery.directory}><Let as="prepared" value={true} /></Dir>
+<Let as="record" value={fixture.directory + "/elicitations.json"} />
+<Fixture.Elicitation record={record} hold={attempt + "/hold.json"} mode="answer" answer={{disposition:"hold"}}>
+<Delivery.Review delivery={delivery} revision={revision} as="held" />
+<AssertEquals actual={held.status} expected="held" />
+</Fixture.Elicitation>
+<Delivery.Attempts delivery={delivery} revision={revision} as="retained" />
+<AssertEquals actual={[retained.state.hold.valid,retained.state.hold.record.chain,retained.state.hold.answer]} expected={[true,"single",{disposition:"hold"}]} />
+<AssertStringIncludes actual={retained.state.hold.record.attempts[0].reason} expected="still unfinished after its one completion turn" />
+<Dir path={attempt}><Glob include={["raw.txt","completion/raw.txt","replacement/**","response-corrections/**"]} as="replies" /></Dir>
+<AssertEquals actual={replies.sort()} expected={["completion/raw.txt","raw.txt"]} />
+<Ticket.Text path={record} as="questions" />
+<AssertEquals actual={JSON.parse(questions).map(question => question.held)} expected={[true]} />
+<Else>
+<Delivery.Selection delivery={delivery} revision={revision} as="selection" />
+<Dir path={attempt}><File path="selection.json"><Json value={selection} /></File><File path="assignment.json"><Json value={{work:delivery.work,revision,reviewer,acceptance:delivery.policy.acceptance,responseSchema:selection.responseSchema,maxResponseCorrections:delivery.maxResponseCorrections}} /></File></Dir>
+<Agent name="codex"><Session name={reviewer.session} model={reviewer.model} effort="medium"><Phase.Session directory={delivery.directory + "/sessions"} name={reviewer.session}><Prompt throwOnError={true} as="raw"><Json value={{variant,review}} /></Prompt></Phase.Session></Session></Agent>
+<AssertEquals actual={variant === "unmarked" ? raw.trim() : JSON.parse(raw)} expected={variant === "unmarked" ? "The checks are still running." : {status:"in_progress"}} />
+<Dir path={attempt}><File path="raw.txt">{raw}</File><File path="outcome.json"><Json value={{schema:"delivery-review-outcome.v1",reviewer,catalog,turn:{state:"reply",reply:raw}}} /></File></Dir>
+<Ticket.Capture as="execution"><Delivery.Response delivery={delivery} revision={revision} reviewer={reviewer} attempt={attempt} raw={raw} dispatch={true} as="response" /><Json value={response} /></Ticket.Capture>
+<If condition={["pass","format"].includes(variant) && execution.status !== "completed"}><Fail message={execution.failure} /></If>
+<AssertEquals actual={execution.status} expected={["pass","format"].includes(variant) ? "completed" : "failed"} />
+<Ticket.Text path={attempt + "/raw.txt"} as="originalRaw" />
+<AssertEquals actual={originalRaw} expected={raw} />
+<Dir path={attempt}><Glob include={["completion/request.json","response-corrections/*/request.json"]} as="requests" /></Dir>
+<AssertEquals actual={requests.sort()} expected={variant === "format" ? ["completion/request.json","response-corrections/0001/request.json"] : variant === "unmarked" ? [] : ["completion/request.json"]} />
+<If condition={variant === "pass" || variant === "format"}>
+<Dir path={attempt}><File path="execution.json"><Json value={{status:"completed",failure:null}} /></File></Dir>
+<Delivery.Reconcile delivery={delivery} revision={revision} publish={true} as="receipt" />
+<AssertEquals actual={receipt.result} expected={{...review,summary:"Review complete."}} />
+<Delivery.Reconcile delivery={delivery} revision={revision} as="readback" />
+<AssertEquals actual={readback} expected={receipt} />
+<Ticket.Capture as="duplicate"><Delivery.Response delivery={delivery} revision={revision} reviewer={reviewer} attempt={attempt} raw={raw} dispatch={true} as="unexpected" /></Ticket.Capture>
+<If condition={duplicate.status !== "failed" || !duplicate.failure.includes("completion is already reserved")}><Fail message={"Unexpected duplicate result (" + variant + "): " + duplicate.failure} /></If>
+</If>
+</Else>
+</If>
+</TestAgent>
+</Fixture.Composition></Dir>
+</TempDir>
+</Each>
+</Test>
diff --git a/examples/adversarial-implementation/tests/Friction.test.md b/examples/adversarial-implementation/tests/Friction.test.md
index 7fefbd9a1..f0caff020 100644
--- a/examples/adversarial-implementation/tests/Friction.test.md
+++ b/examples/adversarial-implementation/tests/Friction.test.md
@@ -128,10 +128,11 @@ git rev-parse HEAD
 </Dir>
 <Let as="checkout" value={{head:observed.stdout.trim()}} />
 <Let as="attempt" value={fixture.root + "/correction"} />
-<Let as="assignment" value={{phase:"review",work:"test",repository:fixture.repository,revision:checkout.head,priorRevision:null,request:"Inspect the saved evidence.",changedPaths:[],artifacts:[],evidence:[],findings:[],assessment,continuation:{phase:"ready",role:null}}} />
+<Let as="assignment" value={{artifactDirectory:attempt,phase:"review",work:"test",repository:fixture.repository,revision:checkout.head,priorRevision:null,request:"Inspect the saved evidence.",changedPaths:[],artifacts:[],evidence:[],findings:[],assessment,continuation:{phase:"ready",role:null}}} />
 <Let as="reply" value={{schema:"phase-result.v2",phase:"review",work:"test",outcome:"pass",revision:checkout.head,summary:"x".repeat(1201),handoff:"Inspect the saved evidence.",artifacts:[],evidence:[{revision:checkout.head.slice(0,8),command:"saved focused test",outcome:"passed",artifact:"receipt.json"}],findings:[],next:{phase:"ready",role:null},assessment}} />
 <Json value={reply} as="raw" />
 <Dir path={attempt}><File path="assignment.json"><Json value={assignment} /></File><File path="raw.txt">{raw}</File></Dir>
+<Phase.SubmissionGuide repository={fixture.repository} directory={attempt}><Phase.SubmissionInstructions role="planner" assignment={assignment} /></Phase.SubmissionGuide>
 <Dir path={fixture.repository}><Ticket.Capture as="correction"><Phase.Correct assignment={assignment} role="planner" session="original-planner" attempt={attempt} raw={raw} profile={{kind:"phase",knownDocuments:[]}} implementationProvider="claude" inputs={[]} as="accepted" /><Json value={accepted} /></Ticket.Capture></Dir>
 <If condition={correction.status !== "completed"}><Ticket.Text path={attempt + "/response-rejection-0000.json"} as="rejection" /><Fail message={rejection + "\n" + correction.failure} /></If>
 <Parse schema={{type:"object"}} as="accepted">{correction.output}</Parse>
diff --git a/examples/adversarial-implementation/tests/ProductionRole.test.md b/examples/adversarial-implementation/tests/ProductionRole.test.md
index 987e3756c..dbaf20e74 100644
--- a/examples/adversarial-implementation/tests/ProductionRole.test.md
+++ b/examples/adversarial-implementation/tests/ProductionRole.test.md
@@ -18,9 +18,13 @@ pwd -P
 <Test name="the production role dispatches mandatory initialization but refuses an oversized request before prompting" timeout="60s">
 <Let as="assessment" value={{mechanical:false,architecture:false,acceptance:true,risk:null,reason:"Inspect the agreed behavior.",evidence:["accepted.md"]}} />
 <Let as="assignment" value={{identityDirectory,phase:"implementation",work:"test",repository:location.stdout.trim(),revision:"a".repeat(40),request:"Inspect saved evidence.",assessment}} />
-<Phase.Role role="implementor" session="initialized-implementor" assignment={assignment} initialize={true} as="reply" />
+<TempDir as="artifactDirectory" />
+<Phase.SubmissionGuide repository={assignment.repository} directory={artifactDirectory}><Phase.SubmissionInstructions role="implementor" assignment={assignment} /></Phase.SubmissionGuide>
+<Phase.Role role="implementor" session="initialized-implementor" assignment={{...assignment,artifactDirectory}} initialize={true} as="reply" />
 <AssertStringIncludes actual={reply} expected="initialization received" />
-<Ticket.Capture as="oversized"><Phase.Role role="implementor" session="initialized-implementor" assignment={{...assignment,request:"x".repeat(256000)}} initialize={true} as="unexpected" /></Ticket.Capture>
+<TempDir as="artifactDirectory" />
+<Phase.SubmissionGuide repository={assignment.repository} directory={artifactDirectory}><Phase.SubmissionInstructions role="implementor" assignment={assignment} /></Phase.SubmissionGuide>
+<Ticket.Capture as="oversized"><Phase.Role role="implementor" session="initialized-implementor" assignment={{...assignment,artifactDirectory,request:"x".repeat(256000)}} initialize={true} as="unexpected" /></Ticket.Capture>
 <AssertEquals actual={oversized.status} expected="failed" />
 <AssertStringIncludes actual={oversized.failure} expected="complete phase prompt exceeds 256000" />
 </Test>
@@ -37,13 +41,21 @@ pwd -P
 <Let as="assignment" value={{identityDirectory,phase:"discovery",work:"test",repository:location.stdout.trim(),revision:"a".repeat(40),request:"Inspect saved evidence.",assessment}} />
 <Phase.Profile role="planner" plannerProvider="codex" assessment={assessment} as="profile" />
 <AssertEquals actual={profile} expected={{provider:"codex",model:"gpt-6.1-sol",effort:"medium"}} />
-<Phase.Role role="planner" plannerProvider="codex" session="sol-planner" assignment={assignment} as="planner" />
+<TempDir as="artifactDirectory" />
+<Phase.SubmissionGuide repository={assignment.repository} directory={artifactDirectory}><Phase.SubmissionInstructions role="planner" assignment={{...assignment,phase:"discovery"}} /></Phase.SubmissionGuide>
+<Phase.Role role="planner" plannerProvider="codex" session="sol-planner" assignment={{...assignment,artifactDirectory}} as="planner" />
 <AssertStringIncludes actual={planner} expected="Sol medium received" />
-<Phase.Role role="planner" plannerProvider="codex" session="sol-planner" assignment={{...assignment,phase:"review"}} as="continued" />
+<TempDir as="artifactDirectory" />
+<Phase.SubmissionGuide repository={assignment.repository} directory={artifactDirectory}><Phase.SubmissionInstructions role="planner" assignment={{...assignment,phase:"review"}} /></Phase.SubmissionGuide>
+<Phase.Role role="planner" plannerProvider="codex" session="sol-planner" assignment={{...assignment,artifactDirectory,phase:"review"}} as="continued" />
 <AssertStringIncludes actual={continued} expected="Sol medium continued" />
-<Phase.Role role="implementor" implementationProvider="codex" session="sol-implementor" assignment={{...assignment,phase:"implementation"}} as="implementor" />
+<TempDir as="artifactDirectory" />
+<Phase.SubmissionGuide repository={assignment.repository} directory={artifactDirectory}><Phase.SubmissionInstructions role="implementor" assignment={{...assignment,phase:"implementation"}} /></Phase.SubmissionGuide>
+<Phase.Role role="implementor" implementationProvider="codex" session="sol-implementor" assignment={{...assignment,artifactDirectory,phase:"implementation"}} as="implementor" />
 <AssertStringIncludes actual={implementor} expected="Sol medium received" />
-<Phase.Role role="planner" plannerProvider="claude" session="opus-planner" assignment={assignment} as="claude" />
+<TempDir as="artifactDirectory" />
+<Phase.SubmissionGuide repository={assignment.repository} directory={artifactDirectory}><Phase.SubmissionInstructions role="planner" assignment={{...assignment,phase:"discovery"}} /></Phase.SubmissionGuide>
+<Phase.Role role="planner" plannerProvider="claude" session="opus-planner" assignment={{...assignment,artifactDirectory}} as="claude" />
 <AssertStringIncludes actual={claude} expected="Opus medium received" />
 <Each in={["codex","claude"]} let="provider">
 <Phase.Profile role="planner" plannerProvider={provider} design={true} assessment={assessment} as="foundation" />
@@ -70,9 +82,10 @@ pwd -P
 ```
 <Let as="attempt" value={temporary.stdout.trim() + "/response"} />
 <Let as="assessment" value={{mechanical:false,architecture:false,acceptance:true,risk:null,reason:"Inspect accepted behavior.",evidence:["accepted.md"]}} />
-<Let as="assignment" value={{identityDirectory:temporary.stdout.trim() + "/sessions",phase:"review",work:"test",repository,revision:head.stdout.trim(),priorRevision:null,request:"Inspect the saved verdict.",assessment,artifacts:[],evidence:[],findings:[],changedPaths:[],continuation:{phase:"ready",role:null}}} />
+<Let as="assignment" value={{artifactDirectory:attempt,identityDirectory:temporary.stdout.trim() + "/sessions",phase:"review",work:"test",repository,revision:head.stdout.trim(),priorRevision:null,request:"Inspect the saved verdict.",assessment,artifacts:[],evidence:[],findings:[],changedPaths:[],continuation:{phase:"ready",role:null}}} />
 <Let as="raw" value={JSON.stringify({schema:"phase-result.v2",phase:"review",work:"test",outcome:"pass",revision:assignment.revision,summary:"x".repeat(1201),handoff:"Inspect the saved verdict.",artifacts:[],evidence:[],findings:[],assessment,next:{phase:"ready",role:null},discoveryRequests:[],discoveryGaps:[]})} />
 <Dir path={attempt}><File path="assignment.json"><Json value={assignment} /></File><File path="raw.txt">{raw}</File></Dir>
+<Phase.SubmissionGuide repository={repository} directory={attempt}><Phase.SubmissionInstructions role="planner" assignment={assignment} /></Phase.SubmissionGuide>
 <TestAgent agent="codex">
 <TestAgent.Scenario session="original-sol-reviewer" src="./agents/sol-correction.md" models={{selected:"fixture-default",options:[{id:"fixture-default"},{id:"gpt-6.1-sol",efforts:{selected:"high",options:["medium","high"]}}]}} />
 <Agent name="codex"><Session name="original-sol-reviewer" model="gpt-6.1-sol" effort="medium"><Phase.Session directory={assignment.identityDirectory} name="original-sol-reviewer" /></Session></Agent>
@@ -155,10 +168,12 @@ false
 
 <Test name="A2 production instructions and schema distinguish actual author from requested successor">
 <Let as="assignment" value={{identityDirectory,phase:"discovery",work:"ordinary",repository:location.stdout.trim(),revision:"a".repeat(40),request:"Ask the original Architect for the missing boundary.",continuation:{phase:"implementation",role:"implementor"}}} />
-<Let as="instructions"><Phase.Instructions role="planner" assignment={assignment} /></Let>
-<AssertStringIncludes actual={instructions} expected="discoveryRequests[].role and discoveryGaps[].request.role equal to planner" />
-<AssertStringIncludes actual={instructions} expected="next.role names the requested successor" />
-<Let as="schemaText" value={instructions.slice(instructions.lastIndexOf('\n{'))} />
+<Let as="instructions"><Phase.Instructions role="planner" assignment={assignment} submission={{path:"/frozen/submission-guide.md"}} /></Let>
+<AssertEquals actual={instructions.includes("next.role names the requested successor")} expected={false} />
+<Let as="submission"><Phase.SubmissionInstructions role="planner" assignment={assignment} /></Let>
+<AssertStringIncludes actual={submission} expected="discoveryRequests[].role and discoveryGaps[].request.role equal to planner" />
+<AssertStringIncludes actual={submission} expected="next.role names the requested successor" />
+<Let as="schemaText" value={submission.slice(submission.lastIndexOf('\n{'))} />
 <Parse schema={{type:"object"}} as="schema">{schemaText}</Parse>
 <AssertEquals actual={schema.properties.discoveryRequests.items.properties.role} expected={{const:"planner"}} />
 <AssertEquals actual={schema.properties.discoveryGaps.items.properties.request.properties.role} expected={{const:"planner"}} />
diff --git a/examples/adversarial-implementation/tests/Submission.test.md b/examples/adversarial-implementation/tests/Submission.test.md
new file mode 100644
index 000000000..111eb87c2
--- /dev/null
+++ b/examples/adversarial-implementation/tests/Submission.test.md
@@ -0,0 +1,98 @@
+```bash exec as="location"
+pwd -P
+```
+
+<Test name="the frozen submission guide matches each role's exact phase contract">
+<Each in={[{role:"architect",phase:"discovery"},{role:"planner",phase:"discovery"},{role:"implementor",phase:"implementation"},{role:"architect",phase:"review"},{role:"planner",phase:"review"}]} let="selected">
+<TempDir as="artifactDirectory" />
+<Let as="assignment" value={{phase:selected.phase,work:"submission-" + selected.role,repository:location.stdout.trim(),artifactDirectory,revision:"a".repeat(40),request:"Inspect saved evidence."}} />
+<Phase.SubmissionGuide repository={assignment.repository} directory={artifactDirectory}><Phase.SubmissionInstructions role={selected.role} assignment={assignment} /></Phase.SubmissionGuide>
+<Phase.Request role={selected.role} assignment={assignment} as="request" />
+<AssertEquals actual={request.includes('"$defs"') || request.includes("Return assessment on completed implementation")} expected={false} />
+<AssertStringIncludes actual={request} expected={artifactDirectory + "/submission-guide.md"} />
+<AssertStringIncludes actual={request} expected="Join every process you start before" />
+<AssertStringIncludes actual={request} expected="Preserve first failures" />
+<AssertStringIncludes actual={request} expected="Read it when you begin preparing the phase" />
+<AssertStringIncludes actual={request} expected="Open it earlier only if a reporting requirement blocks a concrete" />
+<AssertEquals actual={request.includes("Keep summary to 1200 characters.")} expected={false} />
+<Let as="expected"><Phase.SubmissionInstructions role={selected.role} assignment={assignment} /></Let>
+<Ticket.Text path={artifactDirectory + "/submission-guide.md"} as="saved" />
+<AssertEquals actual={saved.trim()} expected={expected.trim()} />
+<Let as="schemaText" value={saved.slice(saved.lastIndexOf('\n{'))} />
+<Parse schema={{type:"object"}} as="schema">{schemaText}</Parse>
+<AssertEquals actual={schema.properties.phase} expected={{const:selected.phase}} />
+<AssertEquals actual={schema.properties.work} expected={{const:assignment.work}} />
+<AssertEquals actual={schema.properties.discoveryRequests.items.properties.role} expected={{const:selected.role}} />
+<AssertEquals actual={Object.hasOwn(schema.properties,"apiConflict")} expected={selected.role === "implementor" && selected.phase === "implementation"} />
+<AssertEquals actual={Object.hasOwn(schema.properties,"contract")} expected={selected.role === "architect" && selected.phase === "discovery"} />
+<AssertEquals actual={schema.required.includes("revision")} expected={selected.phase === "implementation"} />
+<Ticket.Capture as="occupied"><Phase.SubmissionGuide repository={assignment.repository} directory={artifactDirectory}><Phase.SubmissionInstructions role={selected.role} assignment={assignment} /></Phase.SubmissionGuide></Ticket.Capture>
+<AssertEquals actual={occupied.status} expected="failed" />
+<AssertStringIncludes actual={occupied.failure} expected="submission guide is occupied" />
+</Each>
+</Test>
+
+<Test name="early blockers use one native call and damaged submission guides cannot admit a result" timeout="90s">
+<Each in={["blocked","changed","missing","unreadable","invalid","correction-changed"]} let="variant">
+<TempDir as="directory" />
+<Let as="repository" value={location.stdout.trim()} />
+<Let as="quoted" value={"'" + repository.replaceAll("'","'\"'\"'") + "'"} />
+```bash exec as="head"
+git -C {quoted} rev-parse HEAD
+```
+<Let as="attempt" value={directory + "/attempt"} />
+<Let as="assessment" value={{mechanical:false,architecture:false,acceptance:true,risk:null,reason:"Inspect the accepted behavior.",evidence:["accepted.md"]}} />
+<Let as="assignment" value={{phase:"review",work:"submission-guide",repository,revision:head.stdout.trim(),priorRevision:null,request:variant,assessment,artifacts:[],evidence:[],findings:[],changedPaths:[],continuation:{phase:"ready",role:null}}} />
+<NativeGuide variant={variant}>
+<TestAgent agent="codex">
+<TestAgent.Scenario session="submission-result" src="./agents/submission-result.md" models={{selected:"gpt-6.1-sol",options:[{id:"gpt-6.1-sol",efforts:{selected:"medium",options:["medium"]}}]}} />
+<Ticket.Capture as="execution"><Phase.Run phase="review" role="planner" session="submission-result" plannerProvider="codex" assignment={assignment} attempt={attempt} responseProfile={{kind:"ticket",knownDocuments:[]}} maxResponseCorrections={variant === "correction-changed" ? 1 : 0} as="result" /><Json value={result} /></Ticket.Capture>
+</TestAgent>
+</NativeGuide>
+<If condition={variant === "blocked" && execution.status !== "completed"}><Fail message={execution.failure} /></If>
+<AssertEquals actual={execution.status} expected={variant === "blocked" ? "completed" : "failed"} />
+<Ticket.Text path={attempt + "/raw.txt"} as="raw" />
+<AssertEquals actual={raw.length > 0} expected={true} />
+<Ticket.Text path={attempt + "/delivery.json"} as="deliveryText" />
+<Parse schema={{type:"object"}} as="delivery">{deliveryText}</Parse>
+<AssertEquals actual={delivery.raw} expected={attempt + "/raw.txt"} />
+<Dir path={attempt}><Glob include={["result.json","response-acceptance.json"]} as="canonical" /><Glob include={["response-corrections/**/request.json"]} as="corrections" /></Dir>
+<AssertEquals actual={canonical.length} expected={variant === "blocked" ? 2 : 0} />
+<AssertEquals actual={corrections.length} expected={variant === "correction-changed" ? 1 : 0} />
+<If condition={variant === "correction-changed"}><Ticket.Text path={attempt + "/response-corrections/0001/raw.txt"} as="correctedRaw" /><AssertEquals actual={correctedRaw.length > 0} expected={true} /></If>
+<If condition={variant === "blocked"}>
+<Parse schema={{type:"object"}} as="result">{execution.output}</Parse>
+<AssertEquals actual={result.outcome} expected="blocked" />
+<AssertEquals actual={result.next} expected={{phase:"hold",role:null}} />
+<AssertEquals actual={result.revision} expected={head.stdout.trim()} />
+</If>
+</Each>
+</Test>
+
+
+<Test name="unavailable or altered submission guides refuse a prepared request before dispatch">
+<Each in={["changed","missing","unreadable"]} let="variant">
+<TempDir as="artifactDirectory" />
+<Let as="assignment" value={{phase:"review",work:"guide-preflight",repository:location.stdout.trim(),artifactDirectory,revision:"a".repeat(40),request:"Inspect saved evidence."}} />
+<Phase.SubmissionGuide repository={assignment.repository} directory={artifactDirectory}><Phase.SubmissionInstructions role="planner" assignment={assignment} /></Phase.SubmissionGuide>
+<Dir path={artifactDirectory}>
+<If condition={variant === "changed"}><File path="submission-guide.md">Changed before dispatch.</File><Else><File.Delete path="submission-guide.md" /></Else></If>
+<If condition={variant === "unreadable"}><Dir path="submission-guide.md"><File path="entry">A directory cannot supply the guide.</File></Dir></If>
+</Dir>
+<Ticket.Capture as="refused"><Phase.Request role="planner" assignment={assignment} as="unexpected" /></Ticket.Capture>
+<AssertEquals actual={refused.status} expected="failed" />
+</Each>
+</Test>
+
+<Test name="initial instructions deliver an identical selected role brief once and retain current authority for older captures">
+<File path=".agents/implementor.md" as="roleGuide" />
+<Let as="assignment" value={{repository:location.stdout.trim(),phase:"implementation",work:"role-guide",revision:"a".repeat(40),request:"Implement the accepted behavior.",continuation:{phase:"review",role:"planner"}}} />
+<Each in={["absent","identical","older","whitespace"]} let="variant">
+<Let as="content" value={variant === "older" ? "# Implementor\nOlder captured role instructions." : variant === "whitespace" ? roleGuide + " " : roleGuide} />
+<Let as="inputs" value={variant === "absent" ? [] : [{path:assignment.repository + "/.agents/implementor.md",content}]} />
+<Let as="instructions"><Phase.Instructions role="implementor" assignment={assignment} inputs={inputs} initialize={true} submission={{path:"/frozen/submission-guide.md"}} /></Let>
+<AssertEquals actual={instructions.split("# Implementor").length - 1} expected={variant === "older" || variant === "whitespace" ? 2 : 1} />
+<AssertEquals actual={instructions.includes(roleGuide)} expected={variant !== "identical"} />
+<If condition={variant !== "absent"}><AssertStringIncludes actual={instructions} expected={JSON.stringify(content)} /></If>
+</Each>
+</Test>
diff --git a/examples/adversarial-implementation/tests/agents/api-conflict-correction.md b/examples/adversarial-implementation/tests/agents/api-conflict-correction.md
index d1c3949a4..5fa7dc813 100644
--- a/examples/adversarial-implementation/tests/agents/api-conflict-correction.md
+++ b/examples/adversarial-implementation/tests/agents/api-conflict-correction.md
@@ -1,5 +1,5 @@
 <WhenPrompt as="request" template="{?text}" model="gpt-6.1-sol" effort="medium" />
-<Let as="text" value={request.text.slice(request.text.indexOf("Prepared assignment:") + "Prepared assignment:".length,request.text.indexOf("Return assessment on completed implementation")).trim()} />
+<Let as="text" value={request.text.slice(request.text.indexOf("Prepared assignment:") + "Prepared assignment:".length,request.text.indexOf("Submission guide:")).trim()} />
 <Parse schema={{type:"object"}} as="assignment">{text}</Parse>
 <Parse schema={{type:"object"}} as="reply">{assignment.request}</Parse>
 <Json value={reply} />
diff --git a/examples/adversarial-implementation/tests/agents/decision-planner-held.md b/examples/adversarial-implementation/tests/agents/decision-planner-held.md
index b7197ad34..76796ff15 100644
--- a/examples/adversarial-implementation/tests/agents/decision-planner-held.md
+++ b/examples/adversarial-implementation/tests/agents/decision-planner-held.md
@@ -1,4 +1,4 @@
 <WhenPrompt as="request" template="{?text}" model="gpt-6.1-sol" effort="medium" />
-<Let as="text" value={request.text.slice(request.text.indexOf("Prepared assignment:") + "Prepared assignment:".length,request.text.indexOf("Return assessment on completed implementation")).trim()} />
+<Let as="text" value={request.text.slice(request.text.indexOf("Prepared assignment:") + "Prepared assignment:".length,request.text.indexOf("Submission guide:")).trim()} />
 <Parse schema={{type:"object"}} as="assignment">{text}</Parse>
 <Json value={{schema:"phase-result.v2",phase:"discovery",work:assignment.work,outcome:"needs_decision",revision:assignment.revision,summary:"A material choice needs a recorded decision before planning completes.",handoff:"ROOT: record the accepted design decision.",artifacts:[],evidence:[],findings:[],assessment:assignment.assessment,next:{phase:"hold",role:null},discoveryRequests:[],discoveryGaps:[]}} />
diff --git a/examples/adversarial-implementation/tests/agents/decision-planner.md b/examples/adversarial-implementation/tests/agents/decision-planner.md
index 38527ce4b..f01778c98 100644
--- a/examples/adversarial-implementation/tests/agents/decision-planner.md
+++ b/examples/adversarial-implementation/tests/agents/decision-planner.md
@@ -1,9 +1,9 @@
 <WhenPrompt as="request" template="{?text}" model="gpt-6.1-sol" effort="medium" />
-<Let as="text" value={request.text.slice(request.text.indexOf("Prepared assignment:") + "Prepared assignment:".length,request.text.indexOf("Return assessment on completed implementation")).trim()} />
+<Let as="text" value={request.text.slice(request.text.indexOf("Prepared assignment:") + "Prepared assignment:".length,request.text.indexOf("Submission guide:")).trim()} />
 <Parse schema={{type:"object"}} as="assignment">{text}</Parse>
 <Json value={{schema:"phase-result.v2",phase:"discovery",work:assignment.work,outcome:"needs_decision",revision:assignment.revision,summary:"A material choice needs a recorded decision before planning completes.",handoff:"ROOT: record the accepted design decision.",artifacts:[],evidence:[],findings:[],assessment:assignment.assessment,next:{phase:"hold",role:null},discoveryRequests:[],discoveryGaps:[]}} />
 <WhenPrompt as="request" template="{?text}" model="gpt-6.1-sol" effort="medium" />
 <If condition={!request.text.includes("Recorded disposition: accept") || !request.text.includes("Decision native: accept the held proposal.")}><Fail message="The resolved Planner prompt omitted its recorded decision." /></If>
-<Let as="text" value={request.text.slice(request.text.indexOf("Prepared assignment:") + "Prepared assignment:".length,request.text.indexOf("Return assessment on completed implementation")).trim()} />
+<Let as="text" value={request.text.slice(request.text.indexOf("Prepared assignment:") + "Prepared assignment:".length,request.text.indexOf("Submission guide:")).trim()} />
 <Parse schema={{type:"object"}} as="assignment">{text}</Parse>
 <Json value={{schema:"phase-result.v2",phase:"discovery",work:assignment.work,outcome:"complete",revision:assignment.revision,summary:"The held plan is complete under the recorded decision.",handoff:"Implement the plan under the recorded decision.",artifacts:[],evidence:[],findings:[],assessment:assignment.assessment,next:{phase:"implementation",role:"implementor"},discoveryRequests:[],discoveryGaps:[]}} />
diff --git a/examples/adversarial-implementation/tests/agents/initialized-role.md b/examples/adversarial-implementation/tests/agents/initialized-role.md
index a5d4e2e00..6ed6e1f74 100644
--- a/examples/adversarial-implementation/tests/agents/initialized-role.md
+++ b/examples/adversarial-implementation/tests/agents/initialized-role.md
@@ -1,3 +1,4 @@
 <WhenPrompt as="request" template="{?lead}You are the repository implementor.{?instructions}" model="opus" effort="high" />
-<If condition={!["Repository instructions:","Role instructions:","Prepared assignment:",'"$defs"'].every(text => request.instructions.includes(text))}><Fail message="The initial request omitted mandatory instructions, assignment or response schema." /></If>
+<If condition={!["Repository instructions:","Role instructions:","Prepared assignment:","Submission guide:"].every(text => request.instructions.includes(text))}><Fail message="The initial request omitted mandatory instructions, assignment or submission reference." /></If>
+<If condition={request.instructions.includes('"$defs"') || request.instructions.includes("Return assessment on completed implementation")}><Fail message="Submission instructions were sent up front." /></If>
 initialization received
diff --git a/examples/adversarial-implementation/tests/agents/preparation-architect.md b/examples/adversarial-implementation/tests/agents/preparation-architect.md
index 25c928fa3..cc908ce88 100644
--- a/examples/adversarial-implementation/tests/agents/preparation-architect.md
+++ b/examples/adversarial-implementation/tests/agents/preparation-architect.md
@@ -1,5 +1,5 @@
 <WhenPrompt as="request" template="{?text}" model="gpt-6.1-sol" effort="medium" />
-<Let as="text" value={request.text.slice(request.text.indexOf("Prepared assignment:") + "Prepared assignment:".length,request.text.indexOf("Return assessment on completed implementation")).trim()} />
+<Let as="text" value={request.text.slice(request.text.indexOf("Prepared assignment:") + "Prepared assignment:".length,request.text.indexOf("Submission guide:")).trim()} />
 <Parse schema={{type:"object"}} as="assignment">{text}</Parse>
 <Parse schema={{type:"object"}} as="context">{assignment.request}</Parse>
 <Json value={{schema:"phase-result.v2",phase:"discovery",work:assignment.work,outcome:"complete",revision:assignment.revision,summary:"The architecture discovery is complete.",handoff:assignment.request,artifacts:[context.architecture],evidence:[],findings:[],assessment:assignment.assessment,contract:{work:assignment.work,sourceRevision:assignment.revision,scope:"Keep the selected scope, conditions, exception and unresolved finding.",sections:[]},next:{phase:"discovery",role:"planner"},handoffInputs:[context.plan,context.architecture],discoveryRequests:[],discoveryGaps:[]}} />
diff --git a/examples/adversarial-implementation/tests/agents/preparation-implementor.md b/examples/adversarial-implementation/tests/agents/preparation-implementor.md
index 15dc51713..5f2c976bd 100644
--- a/examples/adversarial-implementation/tests/agents/preparation-implementor.md
+++ b/examples/adversarial-implementation/tests/agents/preparation-implementor.md
@@ -3,7 +3,7 @@
 <If condition={!request.text.includes("Unresolved: preserve finding U.")}><Fail message="The production prompt omitted a required preparation instruction or extract." /></If>
 <If condition={!request.text.includes("Review identity: exact-sha-123.")}><Fail message="The production prompt omitted a required preparation instruction or extract." /></If>
 <If condition={!request.text.includes("Preparation receipt:")}><Fail message="The production prompt omitted a required preparation instruction or extract." /></If>
-<Let as="text" value={request.text.slice(request.text.indexOf("Prepared assignment:") + "Prepared assignment:".length,request.text.indexOf("Return assessment on completed implementation")).trim()} />
+<Let as="text" value={request.text.slice(request.text.indexOf("Prepared assignment:") + "Prepared assignment:".length,request.text.indexOf("Submission guide:")).trim()} />
 <Parse schema={{type:"object"}} as="assignment">{text}</Parse>
 <Parse schema={{type:"object"}} as="context">{assignment.request}</Parse>
 <If condition={context.case === "validation"}>
diff --git a/examples/adversarial-implementation/tests/agents/preparation-planner.md b/examples/adversarial-implementation/tests/agents/preparation-planner.md
index 00e1712d6..d00f8754e 100644
--- a/examples/adversarial-implementation/tests/agents/preparation-planner.md
+++ b/examples/adversarial-implementation/tests/agents/preparation-planner.md
@@ -1,10 +1,10 @@
 <WhenPrompt as="request" template="{?text}" model="gpt-6.1-sol" effort="medium" />
-<Let as="text" value={request.text.slice(request.text.indexOf("Prepared assignment:") + "Prepared assignment:".length,request.text.indexOf("Return assessment on completed implementation")).trim()} />
+<Let as="text" value={request.text.slice(request.text.indexOf("Prepared assignment:") + "Prepared assignment:".length,request.text.indexOf("Submission guide:")).trim()} />
 <Parse schema={{type:"object"}} as="assignment">{text}</Parse>
 <Parse schema={{type:"object"}} as="context">{assignment.request}</Parse>
 <Json value={{schema:"phase-result.v2",phase:"discovery",work:assignment.work,outcome:"needs_discovery",revision:assignment.revision,summary:"The first planning call is complete.",handoff:assignment.request,artifacts:[context.plan],evidence:[],findings:[],assessment:assignment.assessment,next:{phase:"discovery",role:"architect"},handoffInputs:[context.plan],discoveryRequests:[{key:"preparation-scope",role:"planner",question:"Confirm the existing scope.",neededFor:"Finish the plan.",evidenceNeeded:"The selected architecture clauses.",origin:context.plan}],discoveryGaps:[]}} />
 <WhenPrompt as="request" template="{?text}" model="gpt-6.1-sol" effort="medium" />
-<Let as="text" value={request.text.slice(request.text.indexOf("Prepared assignment:") + "Prepared assignment:".length,request.text.indexOf("Return assessment on completed implementation")).trim()} />
+<Let as="text" value={request.text.slice(request.text.indexOf("Prepared assignment:") + "Prepared assignment:".length,request.text.indexOf("Submission guide:")).trim()} />
 <Parse schema={{type:"object"}} as="assignment">{text}</Parse>
 <Parse schema={{type:"object"}} as="context">{assignment.request}</Parse>
 <Json value={{schema:"phase-result.v2",phase:"discovery",work:assignment.work,outcome:"complete",revision:assignment.revision,summary:"The final planning call is complete.",handoff:assignment.request,artifacts:[context.matrix],evidence:[],findings:[],assessment:assignment.assessment,next:{phase:"implementation",role:"implementor"},handoffInputs:[context.plan,context.matrix,context.architecture],discoveryRequests:[],discoveryGaps:[]}} />
diff --git a/examples/adversarial-implementation/tests/agents/review-completion.md b/examples/adversarial-implementation/tests/agents/review-completion.md
new file mode 100644
index 000000000..27f21af9c
--- /dev/null
+++ b/examples/adversarial-implementation/tests/agents/review-completion.md
@@ -0,0 +1,27 @@
+<WhenPrompt as="initial" template="{?text}" model="gpt-6.1-sol" effort="medium" />
+<Parse schema={{type:"object"}} as="input">{initial.text}</Parse>
+
+<If condition={input.variant === "unmarked"}>
+The checks are still running.
+<Else>
+<Json value={{status:"in_progress"}} />
+</Else>
+</If>
+
+<If condition={input.variant !== "unmarked"}>
+<WhenPrompt as="completion" template="{?text}" model="gpt-6.1-sol" effort="medium" />
+<If condition={!completion.text.includes("Continue your unfinished independent review of " + input.review.revision)}><Fail message="Expected the continuation of the original review." /></If>
+<If condition={input.variant === "repeat"}>
+<Json value={{status:"in_progress"}} />
+<Else>
+<Json value={input.review} />
+</Else>
+</If>
+</If>
+<If condition={input.variant === "format"}>
+<WhenPrompt as="correction" template="{?text}" model="gpt-6.1-sol" effort="medium" />
+<Let as="text" value={correction.text.slice(correction.text.indexOf('\n{')).trim()} />
+<Parse schema={{type:"object"}} as="packet">{text}</Parse>
+<If condition={packet.ordinal !== 1 || packet.remaining !== 0 || !packet.original.endsWith("/completion/raw.txt") || JSON.stringify(packet.result) !== JSON.stringify(input.review)}><Fail message="Expected the full formatting allowance and the completion verdict." /></If>
+<Json value={{...input.review,summary:"Review complete."}} />
+</If>
diff --git a/examples/adversarial-implementation/tests/agents/submission-result.md b/examples/adversarial-implementation/tests/agents/submission-result.md
new file mode 100644
index 000000000..03441b9c6
--- /dev/null
+++ b/examples/adversarial-implementation/tests/agents/submission-result.md
@@ -0,0 +1,15 @@
+<WhenPrompt as="request" template="{?text}" model="gpt-6.1-sol" effort="medium" />
+<If condition={request.text.includes('"$defs"') || request.text.includes("Return assessment on completed implementation")}><Fail message="The initial prompt included deferred submission material." /></If>
+<Let as="text" value={request.text.slice(request.text.indexOf("Prepared assignment:") + "Prepared assignment:".length,request.text.indexOf("Submission guide:")).trim()} />
+<Parse schema={{type:"object"}} as="assignment">{text}</Parse>
+<Let as="variant" value={assignment.request} />
+<If condition={variant === "invalid"}>not a phase result<Else>
+<Json value={{schema:"phase-result.v2",...(variant === "correction-changed" ? {phase:assignment.phase,work:assignment.work,revision:assignment.revision,handoffInputs:["unrecorded.md"]} : {}),outcome:"blocked",summary:"The required external input is unavailable.",handoff:"ROOT: provide the required external input.",artifacts:[],evidence:[],findings:[],next:{phase:"hold",role:null},blocker:{kind:"missing_input",reason:"The external input is unavailable.",unblockCondition:"Supply the external input.",evidence:[assignment.artifactDirectory + "/assignment.json"]},discoveryRequests:[],discoveryGaps:[]}} />
+</Else></If>
+
+<If condition={variant === "correction-changed"}>
+<WhenPrompt as="correction" template="{?text}" model="gpt-6.1-sol" effort="medium" />
+<Let as="packetText" value={correction.text.slice(correction.text.indexOf("Exact correction packet:") + "Exact correction packet:".length).trim()} />
+<Parse schema={{type:"object"}} as="packet">{packetText}</Parse>
+<Json value={{schema:"phase-result.v2",phase:packet.phase,work:packet.work,revision:packet.established.revision,outcome:packet.established.outcome,summary:packet.established.summary,artifacts:packet.established.artifacts,evidence:packet.established.evidence,findings:packet.established.findings,blocker:packet.established.blocker,discoveryRequests:[],discoveryGaps:[],handoff:"ROOT: provide the required external input.",handoffInputs:[],next:{phase:"hold",role:null}}} />
+</If>
diff --git a/examples/adversarial-implementation/tests/agents/summary-correction.md b/examples/adversarial-implementation/tests/agents/summary-correction.md
new file mode 100644
index 000000000..6f8a70118
--- /dev/null
+++ b/examples/adversarial-implementation/tests/agents/summary-correction.md
@@ -0,0 +1,10 @@
+<WhenPrompt as="initial" template="{?text}" model="gpt-6.1-sol" effort="medium" />
+<Parse schema={{type:"object"}} as="input">{initial.text}</Parse>
+<Json value={input.review} />
+<If condition={input.variant !== "zero" && input.variant !== "invalid"}>
+<WhenPrompt as="request" template="{?text}" model="gpt-6.1-sol" effort="medium" />
+<Let as="text" value={request.text.slice(request.text.indexOf('\n{')).trim()} />
+<Parse schema={{type:"object"}} as="packet">{text}</Parse>
+<If condition={packet.ordinal !== 1 || packet.remaining !== 0 || JSON.stringify(packet.result) !== JSON.stringify(input.review)}><Fail message="The correction changed the original result or allowance." /></If>
+<Json value={{...packet.result,summary:input.variant === "exhausted" ? "x".repeat(1501) : "The independent findings and verdict remain unchanged.",...(input.variant === "changed" ? {verdict:"blocked"} : {})}} />
+</If>
diff --git a/examples/adversarial-implementation/tests/components/Delivery/Role.md b/examples/adversarial-implementation/tests/components/Delivery/Role.md
index 841597a75..e2d17bf88 100644
--- a/examples/adversarial-implementation/tests/components/Delivery/Role.md
+++ b/examples/adversarial-implementation/tests/components/Delivery/Role.md
@@ -9,6 +9,11 @@ props: {type: object, properties: {delivery: {type: object}, revision: {type: st
 <Let as="review" value={{revision:work === "wrong-head" ? "0".repeat(40) : props.revision,verdict,summary:"Reviewed the assigned behavior.",acceptance:work === "missing-clause" ? [] : props.delivery.policy.acceptance.map(clause => clause.id),findings:["repair","false-pass"].includes(work) ? [{blocking:true,description:"A blocking regression remains."}] : []}} />
 <Let as="reply" value={primary && work === "malformed" ? "This is not a review." : JSON.stringify(review)} />
 <Let as="base" value={{schema:"delivery-review-outcome.v1",reviewer:props.reviewer,catalog:selected,turn:null}} />
+<If condition={work === "completion-repeat"}>
+<Agent name={props.reviewer.provider}><Session name={props.reviewer.session} model={selected.model} effort={props.reviewer.effort}><Phase.Session directory={props.delivery.directory + "/sessions"} name={props.reviewer.session}><Prompt throwOnError={true} as="raw"><Json value={{variant:"repeat",review}} /></Prompt></Phase.Session></Session></Agent>
+<Dir path={props.attempt}><File path="raw.txt">{raw}</File><File path="outcome.json"><Json value={{...base,turn:{state:"reply",reply:raw}}} /></File></Dir>
+<Delivery.Response delivery={props.delivery} revision={props.revision} reviewer={props.reviewer} attempt={props.attempt} raw={raw} dispatch={true} as="response" />
+<Else>
 <Let as="outcome" value={behavior === "unavailable" ? {...base,catalog:{...selected,state:"unavailable",model:null,advertised:["claude-opus"]}} : behavior === "refused" ? {...base,turn:{state:"failed",stage:"session",failure:"AcpConfigurationError: The agent does not offer the requested model.",partial:"",configuration:{reason:"selector-unavailable",setting:"model"},refusal:null,terminal:null}} : behavior === "turn-failed" ? {...base,turn:{state:"failed",stage:"turn",failure:"AgentPromptError: The provider turn failed.",partial:"",configuration:null,refusal:null,terminal:"failed"}} : behavior === "partial" ? {...base,turn:{state:"failed",stage:"turn",failure:"AgentPromptError: The provider turn failed.",partial:"{\"revision\":",configuration:null,refusal:null,terminal:"failed"}} : behavior === "outside" ? base : {...base,turn:{state:"reply",reply}}} />
 <Dir path={props.delivery.directory}><Glob include={["called.json"]} as="calledFiles" /></Dir>
 <Let as="prior" value={[]} />
@@ -20,3 +25,5 @@ props: {type: object, properties: {delivery: {type: object}, revision: {type: st
 <If condition={behavior === "unjoined"}><Fail message="The original provider operation failed." /></If>
 <Dir path={props.attempt}><File path="outcome.json"><Json value={outcome} /></File></Dir>
 <If condition={behavior === "outside"}><Fail message="Workflow session identity changed. Reconcile the original conversation before prompting; its identity receipt is unchanged." /></If>
+</Else>
+</If>
diff --git a/examples/adversarial-implementation/tests/components/Fixture/Composition.ts b/examples/adversarial-implementation/tests/components/Fixture/Composition.ts
new file mode 100644
index 000000000..489368059
--- /dev/null
+++ b/examples/adversarial-implementation/tests/components/Fixture/Composition.ts
@@ -0,0 +1,18 @@
+import { Component } from "@executablemd/core/api";
+import { useCompositionComponents } from "@executablemd/git";
+import { useRunComposition } from "@executablemd/git/deno";
+import { z } from "zod";
+
+export const props = {
+  type: "object",
+  properties: { repository: { type: "string" }, directory: { type: "string" } },
+  required: ["repository", "directory"],
+  additionalProperties: false,
+};
+
+export default function* Composition(input: unknown) {
+  const selected = z.strictObject({ repository: z.string(), directory: z.string() }).parse(input);
+  yield* useCompositionComponents();
+  yield* useRunComposition({ root: selected.directory, cwd: selected.repository });
+  yield* Component.operations.content();
+}
diff --git a/examples/adversarial-implementation/tests/components/Fixture/Fallback.md b/examples/adversarial-implementation/tests/components/Fixture/Fallback.md
index cb9a071c6..5ed33b62b 100644
--- a/examples/adversarial-implementation/tests/components/Fixture/Fallback.md
+++ b/examples/adversarial-implementation/tests/components/Fixture/Fallback.md
@@ -45,7 +45,7 @@ git symbolic-ref --short HEAD
 
 <If condition={scenario === "reserved"}>
 <Delivery.Selection delivery={delivery} revision={revision} as="selection" />
-<Dir path={attempt}><File path="selection.json"><Json value={selection} /></File><File path="assignment.json"><Json value={{work:delivery.work,revision,reviewer:fable,acceptance:policy.acceptance,responseSchema:selection.responseSchema}} /></File></Dir>
+<Dir path={attempt}><File path="selection.json"><Json value={selection} /></File><File path="assignment.json"><Json value={{work:delivery.work,revision,reviewer:fable,acceptance:policy.acceptance,responseSchema:selection.responseSchema,maxResponseCorrections:0}} /></File></Dir>
 <Dir path={delivery.directory + "/sessions"}><File path="independent.json"><Json value={{schema:"phase-session.v2",agent:"claude",name:"independent",sessionKey:"independent",cwd:fixture.repository,identity:null,attempted:true,started:null}} /></File></Dir>
 <Delivery.Status delivery={delivery} number={7} as="reservedStatus" />
 <AssertEquals actual={[reservedStatus.status,reservedStatus.reviewAttempts.attempts[0].state]} expected={["reconciliation_required","reserved"]} />
@@ -105,7 +105,7 @@ printf '%s' "$reached"
 <AssertEquals actual={[retainedSelection.revision,retainedSelection.policy,retainedSelection.inputs,retainedSelection.chain]} expected={[revision,policy,delivery.inputs,scenario === "astra-final" ? "astra-final" : "fable-astra"]} />
 <Ticket.Text path={attempt + "/assignment.json"} as="primaryText" />
 <Parse schema={{type:"object"}} as="primaryAssignment">{primaryText}</Parse>
-<AssertEquals actual={primaryAssignment} expected={{work:delivery.work,revision,reviewer,acceptance:policy.acceptance,responseSchema:retainedSelection.responseSchema}} />
+<AssertEquals actual={primaryAssignment} expected={{work:delivery.work,revision,reviewer,acceptance:policy.acceptance,responseSchema:retainedSelection.responseSchema,maxResponseCorrections:0}} />
 <If condition={expected.calls === 2}>
 <Ticket.Text path={attempt + "/replacement/assignment.json"} as="replacementText" />
 <Parse schema={{type:"object"}} as="replacementAssignment">{replacementText}</Parse>
@@ -210,7 +210,7 @@ fi
 <Delivery.Schema as="schemas" />
 <Let as="stray" value={{revision,verdict:"pass",summary:"A stray review.",acceptance:["behavior","evidence"],findings:[]}} />
 <Let as="strayOutcome" value={{schema:"delivery-review-outcome.v1",reviewer:astra,catalog:{state:"selected",choices:["gpt-6-astra"],model:"gpt-6-astra",advertised:["gpt-6-astra"],failure:null},turn:{state:"reply",reply:JSON.stringify(stray)}}} />
-<Dir path={attempt + "/replacement"}><File path="assignment.json"><Json value={{work:delivery.work,revision,reviewer:astra,acceptance:policy.acceptance,responseSchema:schemas.review}} /></File><File path="outcome.json"><Json value={strayOutcome} /></File><File path="execution.json"><Json value={{status:"completed",failure:null}} /></File><File path="raw.txt">{JSON.stringify(stray)}</File><File path="receipt.json"><Json value={{work:delivery.work,revision,reviewer:astra,acceptance:policy.acceptance,responseSchema:schemas.review,result:stray,execution:attempt + "/replacement/execution.json"}} /></File></Dir>
+<Dir path={attempt + "/replacement"}><File path="assignment.json"><Json value={{work:delivery.work,revision,reviewer:astra,acceptance:policy.acceptance,responseSchema:schemas.review,maxResponseCorrections:0}} /></File><File path="outcome.json"><Json value={strayOutcome} /></File><File path="execution.json"><Json value={{status:"completed",failure:null}} /></File><File path="raw.txt">{JSON.stringify(stray)}</File><File path="receipt.json"><Json value={{work:delivery.work,revision,reviewer:astra,acceptance:policy.acceptance,responseSchema:schemas.review,maxResponseCorrections:0,result:stray,execution:attempt + "/replacement/execution.json"}} /></File></Dir>
 <Delivery.Status delivery={delivery} number={7} as="strayStatus" />
 <AssertEquals actual={[strayStatus.status,strayStatus.review]} expected={["review_held",null]} />
 <Ticket.Capture as="strayReconcile"><Delivery.Reconcile delivery={delivery} revision={revision} publish={true} as="strayReceipt" /></Ticket.Capture>
diff --git a/examples/adversarial-implementation/tests/production-components/NativeGuide.ts b/examples/adversarial-implementation/tests/production-components/NativeGuide.ts
new file mode 100644
index 000000000..0c16ca9e3
--- /dev/null
+++ b/examples/adversarial-implementation/tests/production-components/NativeGuide.ts
@@ -0,0 +1,55 @@
+import { Agent, Component } from "@executablemd/core/api";
+import { ensureDir, rm } from "@effectionx/fs";
+import { z } from "zod";
+import { read, write } from "../../components/Ticket/text-storage.ts";
+
+export const props = {
+  type: "object",
+  properties: { variant: { type: "string" } },
+  required: ["variant"],
+  additionalProperties: false,
+};
+
+export default function* NativeGuide(input: unknown) {
+  const { variant } = z.object({ variant: z.string() }).parse(input);
+  let calls = 0;
+  let path: string | undefined;
+  yield* Agent.around({
+    *prompt(args, next) {
+      calls++;
+      const text = args[0];
+      path ??= text
+        .split("The frozen UTF-8 file at ")[1]
+        ?.split(" contains the submission schema")[0];
+      if (path === undefined || (calls === 1 && text.includes('"$defs"'))) {
+        throw new Error("The native request did not stage its submission guide.");
+      }
+      const guide = yield* read("/", path);
+      if (
+        ![
+          '"$defs"',
+          "including an early blocker",
+          "Test-only changes can affect acceptance.",
+          "A mechanical assessment has no architecture, acceptance or complexity impact.",
+          "a public boundary is not that reason",
+        ].every((rule) => guide.includes(rule))
+      ) {
+        throw new Error("The staged guide is unreadable or incomplete.");
+      }
+      if (variant === "changed" || (variant === "correction-changed" && calls === 2)) {
+        yield* write("/", path, "Changed during the native turn.");
+      }
+      if (variant === "missing" || variant === "unreadable") {
+        yield* rm(path);
+      }
+      if (variant === "unreadable") {
+        yield* ensureDir(path);
+      }
+      return yield* next(...args);
+    },
+  });
+  yield* Component.operations.content();
+  if (calls !== (variant === "correction-changed" ? 2 : 1)) {
+    throw new Error("The staged submission used an additional native call.");
+  }
+}
diff --git a/examples/adversarial-implementation/tests/production-components/Phase/ProviderName.md b/examples/adversarial-implementation/tests/production-components/Phase/ProviderName.md
new file mode 100644
index 000000000..ed72ec7ae
--- /dev/null
+++ b/examples/adversarial-implementation/tests/production-components/Phase/ProviderName.md
@@ -0,0 +1,11 @@
+---
+props:
+  type: object
+  properties:
+    agent: {type: string}
+  required: [agent]
+  additionalProperties: false
+returns: {type: string}
+---
+
+<Return value={props.agent === "claude" ? "test-agent" : "acpx"} />
diff --git a/packages/cli/tests/adversarial-session-continuity.test.ts b/packages/cli/tests/adversarial-session-continuity.test.ts
index 4f279cfa2..6360be674 100644
--- a/packages/cli/tests/adversarial-session-continuity.test.ts
+++ b/packages/cli/tests/adversarial-session-continuity.test.ts
@@ -34,7 +34,7 @@ import { openReplSession, submitReplEntry } from "../src/repl/session.ts";
 import type { ReplSession, ReplSessionOptions } from "../src/repl/session.ts";
 import type { ReplQuestion } from "../src/repl/elicitation.ts";
 import { createFakeAcp, makeStore } from "./support/fake-acp.ts";
-import type { FakeAcp } from "./support/fake-acp.ts";
+import type { FakeAcp, FakeStore } from "./support/fake-acp.ts";
 import { AGENT_SOURCE, world } from "../../acp/tests/released-peer.ts";
 import PhaseSession, {
   props as phaseSessionProps,
@@ -381,6 +381,7 @@ const captured = z.strictObject({
 
 interface ReviewWorld {
   root: string;
+  store: FakeStore;
   delivery: Record<string, Json>;
   asked: unknown[];
   run(source: string, props: Record<string, Json>): Operation<{ ok: boolean; text: string }>;
@@ -391,6 +392,7 @@ function* reviewWorld(fake: FakeAcp, create = fake.create): Operation<ReviewWorl
   yield* ensureDir(join(root, "repository"));
   yield* ensureDir(join(root, "delivery"));
   const asked: unknown[] = [];
+  const store = makeStore();
   const delivery = {
     work: "production-review",
     repository: join(root, "repository"),
@@ -418,7 +420,7 @@ function* reviewWorld(fake: FakeAcp, create = fake.create): Operation<ReviewWorl
         },
         {
           createRuntime: create,
-          sessionStore: makeStore(),
+          sessionStore: store,
           advertiseNativeLaunch: [],
           advertiseClientNativeAttachment: [],
         },
@@ -451,14 +453,133 @@ function* reviewWorld(fake: FakeAcp, create = fake.create): Operation<ReviewWorl
       }
     });
   }
-  return { root, delivery, asked, run };
+  return { root, store, delivery, asked, run };
 }
 
 const roleSource =
+  '<Delivery.Schema as="schemas" /><Dir path={props.attempt}><File path="assignment.json"><Json value={{work:props.delivery.work,revision:props.revision,reviewer:props.reviewer,acceptance:props.delivery.policy.acceptance,responseSchema:schemas.review,maxResponseCorrections:props.delivery.maxResponseCorrections ?? 0}} /></File></Dir>' +
   "<Delivery.Role delivery={props.delivery} revision={props.revision} reviewer={props.reviewer} choices={props.choices} position={0} attempt={props.attempt} />";
 const reviewSource =
   '<Delivery.Review delivery={props.delivery} revision={props.revision} as="result" /><Json value={result} />';
 
+const workflowControls = {
+  env: { CLAUDE_CODE_DISABLE_BACKGROUND_TASKS: "1" },
+  disallowedTools: ["ScheduleWakeup", "Monitor"],
+};
+
+const scopedRoleSource =
+  '<Phase.SubmissionGuide repository={props.assignment.repository} directory={props.assignment.artifactDirectory}><Phase.SubmissionInstructions role="implementor" assignment={props.assignment} /></Phase.SubmissionGuide>' +
+  '<Phase.Role role="implementor" session="controlled-owner" assignment={props.assignment} />';
+const continuedRoleSource =
+  '<Phase.Role role="implementor" session="controlled-owner" assignment={{...props.assignment,sessionEstablished:true}} />';
+
+describe("production workflow provider scope", () => {
+  it("applies controls through each actual Claude role and retains them across cold reentry", function* () {
+    for (const role of ["phase", "foundation", "preparation", "delivery"]) {
+      const fake = createFakeAcp();
+      fake.configuration(catalog(["fixture-default", "opus", "fable"], ["medium", "high"]));
+      const harness = yield* reviewWorld(fake);
+      const assignment = {
+        repository: harness.delivery.repository,
+        artifactDirectory: join(harness.root, "submission"),
+        identityDirectory: join(harness.root, "sessions"),
+        phase: "implementation",
+        work: "provider-scope",
+        revision,
+        request: "Use the saved evidence.",
+        assessment: {
+          mechanical: false,
+          architecture: false,
+          acceptance: true,
+          risk: null,
+          reason: "Inspect the accepted behavior.",
+          evidence: ["accepted.md"],
+        },
+      };
+      yield* ensureDir(assignment.artifactDirectory);
+      const props = { assignment };
+      let source = scopedRoleSource;
+      let continued = continuedRoleSource;
+      if (role === "foundation") {
+        source =
+          '<Adversarial.PlannerRole assignment={{...props.assignment,session:"controlled-owner",plannerProvider:"claude",initialize:false}} guide="Use the saved evidence." />';
+        continued =
+          '<Adversarial.PlannerRole assignment={{...props.assignment,session:"controlled-owner",plannerProvider:"claude",initialize:false,sessionEstablished:true}} guide="Use the saved evidence." />';
+      } else if (role === "preparation") {
+        fake.script({ reply: "Seeded the original owner." });
+        expect(
+          yield* harness.run(`<Dir path={props.assignment.repository}>${source}</Dir>`, props),
+        ).toMatchObject({ ok: true });
+        source =
+          '<Ticket.PreparationPrompt owner={{profile:{provider:"claude",model:"opus",effort:"high"},session:"controlled-owner",identityDirectory:props.assignment.identityDirectory}} stage="compare" assignment={props.assignment} material={{observations:[],inputs:[]}} schema={{type:"object"}} allowance={1000} />';
+        continued = source;
+      } else if (role === "delivery") {
+        source = roleSource;
+        continued = source;
+      }
+      const selected = role === "delivery" ? "fable" : "opus";
+      const callProps =
+        role === "delivery"
+          ? {
+              delivery: harness.delivery,
+              revision,
+              reviewer: {
+                provider: "claude",
+                model: selected,
+                effort: "high",
+                session: "controlled-owner",
+              },
+              choices: [selected],
+              attempt: join(harness.root, "delivery", "attempt"),
+            }
+          : props;
+      for (const text of [source, continued]) {
+        fake.script({ reply: role === "delivery" ? review : "Completed the assigned work." });
+        const ran = yield* harness.run(
+          `<Dir path={props.assignment?.repository ?? props.delivery.repository}>${text}</Dir>`,
+          callProps,
+        );
+        if (!ran.ok) {
+          throw new Error(`${role}: ${ran.text}`);
+        }
+        const ensured = fake.ensured.at(-1)!;
+        expect(ensured.sessionOptions).toEqual(workflowControls);
+        expect(ensured.requestedModel).toBe(selected);
+        expect(harness.store.records.get(ensured.sessionKey)?.acpx?.session_options).toEqual({
+          model: selected,
+          env: workflowControls.env,
+          disallowed_tools: workflowControls.disallowedTools,
+        });
+        expect(fake.running(ensured.sessionKey)).toEqual({ model: selected, effort: "high" });
+      }
+      expect(fake.turns).toHaveLength(role === "preparation" ? 3 : 2);
+      expect(new Set(fake.turns.map((entry) => entry.handle.sessionKey)).size).toBe(1);
+    }
+  });
+
+  it("keeps ordinary acpx unchanged and refuses to retrofit its retained owner", function* () {
+    const fake = createFakeAcp();
+    fake.configuration(catalog(["opus"], ["high"]));
+    const harness = yield* reviewWorld(fake);
+    fake.script({ reply: "Original ordinary owner." });
+    const ordinary =
+      '<Agent name="claude"><Session name="ordinary-owner" model="opus" effort="high"><Prompt throwOnError={true}>Use the original ordinary provider.</Prompt></Session></Agent>';
+    expect(yield* harness.run(ordinary, {})).toMatchObject({ ok: true });
+    expect(fake.ensured[0]?.sessionOptions).toBeUndefined();
+    const before = JSON.stringify([...harness.store.records]);
+    const controlled =
+      '<Phase.ProviderName agent="claude" as="provider" /><AgentProvider name={provider} defaultAgent="claude">' +
+      ordinary +
+      "</AgentProvider>";
+    const refused = yield* harness.run(controlled, {});
+    expect(refused).toMatchObject({ ok: false });
+    expect(refused.text).toContain("does not retrofit existing conversations");
+    expect(fake.prompts).toHaveLength(1);
+    expect(fake.ensured).toHaveLength(1);
+    expect(JSON.stringify([...harness.store.records])).toBe(before);
+  });
+});
+
 function catalog(models: string[], efforts: string[] = ["low", "high"]) {
   return {
     model: { selected: models[0]!, choices: models.map((id) => ({ id })) },
@@ -543,7 +664,7 @@ describe(
           choices: ["fable", "claude-fable-5-1[1m]"],
           attempt,
         });
-        expect(ran.ok).toBe(true);
+        expect(ran).toMatchObject({ ok: true });
         const settled = outcome.parse(
           JSON.parse(yield* readTextFile(join(attempt, "outcome.json"))),
         );
@@ -555,6 +676,10 @@ describe(
         expect(settled.turn).toEqual({ state: "reply", reply: review });
         expect(fake.prompts).toHaveLength(1);
         expect(fake.prompts[0]).toContain(`independent correctness review of ${revision}`);
+        expect(fake.prompts[0]).toContain("Finish this native call with its review JSON result.");
+        expect(fake.prompts[0]).toContain(
+          "Run required checks in the foreground and join every process you start before returning.",
+        );
         expect(fake.prompts[0]).toContain(
           JSON.stringify(acceptance, null, 2).split("\n")[2]!.trim(),
         );
@@ -763,11 +888,6 @@ describe(
       );
       function* reviewAt(sha: string) {
         const attempt = join(harness.delivery.directory as string, `review-${sha}`);
-        yield* ensureDir(attempt);
-        yield* writeTextFile(
-          join(attempt, "assignment.json"),
-          JSON.stringify({ work: "production-review", revision: sha, reviewer }),
-        );
         const ran = yield* harness.run(roleSource, {
           delivery: harness.delivery,
           revision: sha,
@@ -786,13 +906,14 @@ describe(
       ).toBe("unavailable");
       expect(fake.prompts).toEqual([]);
       fake.configuration(catalog(["fable"]));
-      fake.script({ reply: review });
+      const currentReview = review.replace(revision, "c".repeat(40));
+      fake.script({ reply: currentReview });
       const first = yield* reviewAt("c".repeat(40));
-      expect(first.ran.ok).toBe(true);
+      expect(first.ran).toMatchObject({ ok: true });
       expect(fake.prompts).toHaveLength(1);
       expect(
         outcome.parse(JSON.parse(yield* readTextFile(join(first.attempt, "outcome.json")))).turn,
-      ).toEqual({ state: "reply", reply: review });
+      ).toEqual({ state: "reply", reply: currentReview });
       const established = z
         .object({
           name: z.string(),
diff --git a/packages/cli/tests/adversarial-submission.test.ts b/packages/cli/tests/adversarial-submission.test.ts
new file mode 100644
index 000000000..85aca680e
--- /dev/null
+++ b/packages/cli/tests/adversarial-submission.test.ts
@@ -0,0 +1,7 @@
+import { describe, it } from "@executablemd/test-support/bdd";
+import { runAdversarialJourney } from "./support/adversarial-journey.ts";
+
+describe("adversarial implementation example", () => {
+  it("runs the Submission Markdown journeys without native models", () =>
+    runAdversarialJourney("Submission"));
+});
diff --git a/packages/cli/tests/support/adversarial-journey.ts b/packages/cli/tests/support/adversarial-journey.ts
index c4a97f469..a92a40e73 100644
--- a/packages/cli/tests/support/adversarial-journey.ts
+++ b/packages/cli/tests/support/adversarial-journey.ts
@@ -3,7 +3,7 @@ import { fileURLToPath } from "node:url";
 import { env } from "@executablemd/runtime";
 import { readTextFile } from "@effectionx/fs";
 
-const testedSuites = ["ProductionRole", "Preparation"];
+const testedSuites = ["ProductionRole", "Preparation", "Submission", "Delivery"];
 
 export function* runAdversarialJourney(suite: string) {
   const retainedEvidence = suite.startsWith("ArtifactReturn")
@@ -45,8 +45,8 @@ export function* runAdversarialJourney(suite: string) {
             `<Testing>\n${source}\n</Testing>`,
           ]),
       "--include",
-      testedSuites.includes(suite)
-        ? "examples/adversarial-implementation/components"
+      testedSuites.includes(suite) && suite !== "Delivery"
+        ? "examples/adversarial-implementation/tests/production-components"
         : "examples/adversarial-implementation/tests/components",
       "--include",
       "examples/adversarial-implementation/components",
diff --git a/packages/cli/tests/support/fake-acp.ts b/packages/cli/tests/support/fake-acp.ts
index fd7bc6a7c..454ef9726 100644
--- a/packages/cli/tests/support/fake-acp.ts
+++ b/packages/cli/tests/support/fake-acp.ts
@@ -779,6 +779,19 @@ export function createFakeAcp(): FakeAcp {
             cumulative_token_usage: {},
             request_token_usage: {},
           };
+          const sessionOptions = input.sessionOptions;
+          if (sessionOptions !== undefined || input.requestedModel !== undefined) {
+            record.acpx = {
+              session_options: {
+                model: input.requestedModel ?? sessionOptions?.model,
+                allowed_tools: sessionOptions?.allowedTools,
+                disallowed_tools: sessionOptions?.disallowedTools,
+                max_turns: sessionOptions?.maxTurns,
+                system_prompt: sessionOptions?.systemPrompt,
+                env: sessionOptions?.env,
+              },
+            };
+          }
           if (deferred) {
             record.sessionMaterialization = {
               state: "pending",
diff --git a/scripts/tests/runtime-exclusions.test.ts b/scripts/tests/runtime-exclusions.test.ts
index 06eadfb62..0b812d97d 100644
--- a/scripts/tests/runtime-exclusions.test.ts
+++ b/scripts/tests/runtime-exclusions.test.ts
@@ -163,6 +163,7 @@ describe("the applicable corpus", () => {
       "adversarial-preparation",
       "adversarial-production-role",
       "adversarial-session-continuity",
+      "adversarial-submission",
       "adversarial-workflow",
     ].map((name) => `packages/cli/tests/${name}.test.ts`);
     expect(
diff --git a/specs/acp-client-spec.md b/specs/acp-client-spec.md
index 77b1504f1..2533f2776 100644
--- a/specs/acp-client-spec.md
+++ b/specs/acp-client-spec.md
@@ -772,8 +772,11 @@ until one is installed as a root provider or by AgentProvider.
 ### Claude workflow-role profile
 
 The CLI registers `claude-workflow-role` alongside ordinary `acpx`. The
-profile uses the same carried adapter, session store and host identity
-coordination as ordinary calls. Interactive Sidekick configuration is unchanged.
+adversarial workflow selects this provider only around Claude role calls,
+including foundation, document preparation, independent review and its completion
+and response-only correction turns. It uses the same carried adapter, session
+store and host identity coordination as ordinary calls. Interactive Sidekick
+configuration is unchanged.
 
 The profile sets `CLAUDE_CODE_DISABLE_BACKGROUND_TASKS=1` in the child session
 environment and supplies `disallowedTools: ["ScheduleWakeup", "Monitor"]`