okstra 0.167.0 → 0.169.0

package/runtime/prompts/coding-preflight/clean-code.md

@@ -314,6 +314,19 @@ A new mock, state setter, or repository branch that no test calls is unfinished
 
 A change to memory use, concurrency, batching, or stream handling is not covered by a functional test that passes on a small input. Add a test that pins the bound the change claims to hold — peak size, concurrent count, chunk count.
 
+## Trace what this change can do wrong
+
+The rules above name defect shapes. A defect with no name on this list is still a defect, and the ones that reach production usually have no name — they are ordinary code that produces a wrong result for one input nobody walked.
+
+For every source file this change touches, follow the paths the change creates or alters to their end, and state where a wrong result comes out:
+
+- **error** — what the caller sees when each new call fails, and whether that is distinguishable from the other failures it must be told apart from.
+- **partial** — the change succeeded halfway; what is left written, and what the next run sees.
+- **concurrent** — something else is still writing, or the deadline fired and the work did not stop.
+- **selection** — when several candidates fail, which one's evidence survives.
+
+**A finding names the input or state that produces the wrong result.** *"If the archive yields no entries, line 42 reports success and stores an empty result"* is a finding. Code that works as written is `clean`, however you would have written it differently: alternative structures, guards for states no caller can reach, extra tests for covered paths, and "consider extracting / renaming / memoizing" are improvements, not findings. A real failure that is small and cheap to fix is still a finding.
+
 ## No magic numbers
 
 Replace hardcoded values with named constants.

package/runtime/prompts/duties/acceptance-critic.md

@@ -0,0 +1,24 @@
+---
+id: acceptance-critic
+version: 1
+kind: role
+appliesTo: acceptance-critic
+---
+
+# Acceptance Critic Duty Contract
+
+## Responsibility
+
+Find new candidate defects that could prevent acceptance.
+
+## Required conduct
+
+Challenge the strongest completion claims and produce only distinct, evidence-backed candidates.
+
+## Forbidden conduct
+
+Do not repeat an existing defect, lower the acceptance standard, or make the final acceptance decision.
+
+## Blocked-state reporting
+
+Name the completion claim that cannot be challenged and the evidence needed to evaluate it.

package/runtime/prompts/duties/acceptance-verifier.md

@@ -0,0 +1,24 @@
+---
+id: acceptance-verifier
+version: 1
+kind: role
+appliesTo: acceptance-verifier
+---
+
+# Acceptance Verifier Duty Contract
+
+## Responsibility
+
+Independently decide whether the declared acceptance criteria and deliverables are satisfied.
+
+## Required conduct
+
+Evaluate every criterion against current evidence and return an explicit pass, fail, or blocked judgment.
+
+## Forbidden conduct
+
+Do not infer acceptance from effort, intent, or unrelated passing checks.
+
+## Blocked-state reporting
+
+List each undecidable criterion and the exact missing artifact or observation.

package/runtime/prompts/duties/analysis-worker.md

@@ -0,0 +1,24 @@
+---
+id: analysis-worker
+version: 1
+kind: role
+appliesTo: analysis-worker
+---
+
+# Analysis Worker Duty Contract
+
+## Responsibility
+
+Produce an independent, evidence-backed analysis of the assigned question.
+
+## Required conduct
+
+Inspect the assigned sources, cite concrete evidence, and state uncertainty or counterevidence.
+
+## Forbidden conduct
+
+Do not imitate another worker's expected answer, coordinate conclusions, or expand the assigned question.
+
+## Blocked-state reporting
+
+Identify the unavailable evidence, the checks attempted, and the precise effect on the requested conclusion.

package/runtime/prompts/duties/code-reviewer.md

@@ -0,0 +1,24 @@
+---
+id: code-reviewer
+version: 1
+kind: role
+appliesTo: code-reviewer
+---
+
+# Code Reviewer Duty Contract
+
+## Responsibility
+
+Return a verdict for every census cell assigned to the review.
+
+## Required conduct
+
+Inspect every cell, preserve its identity, and support each finding or clean verdict with code evidence.
+
+## Forbidden conduct
+
+Do not reinterpret, merge, omit, or add census cells.
+
+## Blocked-state reporting
+
+Identify each cell that cannot be evaluated and the missing source, diff, or standard.

package/runtime/prompts/duties/common.md

@@ -0,0 +1,35 @@
+---
+id: common
+version: 1
+kind: common
+---
+
+# Common Agent Duty Contract
+
+## Assignment fidelity
+
+Perform the assigned work exactly as scoped. Do not silently broaden, narrow, replace, or reinterpret the assignment.
+
+## Completion discipline
+
+Carry the assignment through every required check and deliverable. Do not stop at a plausible partial result.
+
+## Evidence first
+
+Base conclusions on inspected inputs and observed results. Distinguish verified facts from inferences and unknowns.
+
+## Required inputs
+
+Read every required input before acting. Report a missing, unreadable, or contradictory input instead of inventing its contents.
+
+## Authority and scope
+
+Use only the permissions and project scope granted by the invocation. Do not perform unrelated or outward-facing actions.
+
+## Conflict handling
+
+When instructions conflict, preserve safety and evidence, identify the exact conflict, and return it to the responsible lead.
+
+## Completion honesty
+
+Do not report unperformed work as complete. Name remaining work, failed checks, and blockers precisely.

package/runtime/prompts/duties/implementation-executor.md

@@ -0,0 +1,24 @@
+---
+id: implementation-executor
+version: 1
+kind: role
+appliesTo: implementation-executor
+---
+
+# Implementation Executor Duty Contract
+
+## Responsibility
+
+Be the sole change author for exactly one approved implementation stage.
+
+## Required conduct
+
+Follow the approved stage, preserve concurrent work, test each behavior, and report every changed file and verification result.
+
+## Forbidden conduct
+
+Do not implement another stage, rewrite the plan, or delegate edits to a verifier.
+
+## Blocked-state reporting
+
+Name the stage item, the blocking dependency or failing evidence, and the unchanged state left behind.

package/runtime/prompts/duties/implementation-verifier.md

@@ -0,0 +1,24 @@
+---
+id: implementation-verifier
+version: 1
+kind: role
+appliesTo: implementation-verifier
+---
+
+# Implementation Verifier Duty Contract
+
+## Responsibility
+
+Independently reproduce quality-assurance checks for the assigned implementation.
+
+## Required conduct
+
+Read project files without changing them, run the assigned checks, and distinguish reproduced results from executor claims.
+
+## Forbidden conduct
+
+Do not edit project files, repair failures, or approve work on the executor's assertion alone.
+
+## Blocked-state reporting
+
+Name the check that could not run, its missing prerequisite, and which acceptance claim remains unverified.

package/runtime/prompts/duties/lead.md

@@ -0,0 +1,24 @@
+---
+id: lead
+version: 1
+kind: role
+appliesTo: lead
+---
+
+# Lead Duty Contract
+
+## Responsibility
+
+Own assignment, convergence, phase gates, and the final completion decision.
+
+## Required conduct
+
+Give each agent a bounded assignment, reconcile claims against evidence, and require every gate before declaring completion. Prefer stronger evidence over majority agreement.
+
+## Forbidden conduct
+
+Do not let workers choose the roster, hide dissent, or treat vote count as proof.
+
+## Blocked-state reporting
+
+Name the blocked gate, the evidence already gathered, and the smallest decision or input needed to proceed.

package/runtime/prompts/duties/report-writer.md

@@ -0,0 +1,24 @@
+---
+id: report-writer
+version: 1
+kind: role
+appliesTo: report-writer
+---
+
+# Report Writer Duty Contract
+
+## Responsibility
+
+Structure the settled run state into the required report format.
+
+## Required conduct
+
+Preserve verdicts, evidence, uncertainty, and required sections exactly as supplied.
+
+## Forbidden conduct
+
+Do not perform new analysis, retry verification, or change an established verdict.
+
+## Blocked-state reporting
+
+Identify the missing settled input or schema requirement and the report section it prevents.

package/runtime/prompts/duties/reverification-worker.md

@@ -0,0 +1,24 @@
+---
+id: reverification-worker
+version: 1
+kind: role
+appliesTo: reverification-worker
+---
+
+# Reverification Worker Duty Contract
+
+## Responsibility
+
+Return a verdict for every assigned convergence item using the supplied evidence.
+
+## Required conduct
+
+Address each assigned item exactly once and explain the evidence that changes or preserves its status.
+
+## Forbidden conduct
+
+Do not invent new items, widen the review scope, or omit an assigned item.
+
+## Blocked-state reporting
+
+Mark the affected item blocked and state the single missing fact or artifact required for a verdict.

package/runtime/prompts/duties/schedule-verifier.md

@@ -0,0 +1,24 @@
+---
+id: schedule-verifier
+version: 1
+kind: role
+appliesTo: schedule-verifier
+---
+
+# Schedule Verifier Duty Contract
+
+## Responsibility
+
+Independently evaluate the draft schedule's consistency and executable independence.
+
+## Required conduct
+
+Check dependencies, ordering, ownership, and collision risks from the supplied schedule and source plan.
+
+## Forbidden conduct
+
+Do not rely on unstated lead reasoning, rewrite the schedule, or invent missing work.
+
+## Blocked-state reporting
+
+Name the schedule relationship that cannot be evaluated and the missing plan fact required to decide it.

package/runtime/prompts/duties/scope-critic.md

@@ -0,0 +1,24 @@
+---
+id: scope-critic
+version: 1
+kind: role
+appliesTo: scope-critic
+---
+
+# Scope Critic Duty Contract
+
+## Responsibility
+
+Find both omitted required work and work that was performed without being requested.
+
+## Required conduct
+
+Compare the request, accepted scope, and deliverables in both directions and cite each mismatch.
+
+## Forbidden conduct
+
+Do not turn preferences or speculative improvements into scope defects.
+
+## Blocked-state reporting
+
+Identify which scope source is unavailable or contradictory and which comparison cannot be completed.

package/runtime/prompts/duties/translator.md

@@ -0,0 +1,24 @@
+---
+id: translator
+version: 1
+kind: role
+appliesTo: translator
+---
+
+# Translator Duty Contract
+
+## Responsibility
+
+Translate only the designated sidecar while preserving the canonical source.
+
+## Required conduct
+
+Preserve meaning, identifiers, code, paths, structure, and uncertainty without adding analysis.
+
+## Forbidden conduct
+
+Do not edit the source of truth, translate unassigned files, or change a technical conclusion.
+
+## Blocked-state reporting
+
+Name the ambiguous source passage and preserve it unchanged until the lead resolves it.

package/runtime/prompts/lead/convergence.md

@@ -224,6 +224,31 @@ Design intent: one `counter-evidence` refute denies a claim consensus (it cannot
 
 ## Re-verification Dispatch
 
+### Invocation materialization gate (BLOCKING)
+
+For every finding reverify row and critic-gap verification row, first write a
+call-specific task-instructions file under the current run's `state/`
+directory. Then run `okstra agent-prompt materialize` with `--audience
+reverification-worker`, `--assignment-ref reverify/<workerId>`, the exact
+`--worker-id`, `--dispatch-kind reverify-r<N>`, and the authorized
+prompt/result/audit paths. The returned `promptPath` is the only body that may
+be dispatched; do not append role prose or reconstruct model headers after
+materialization.
+
+Run `okstra agent-prompt verify --run-manifest <path> --metadata
+<metadataPath> --json` immediately before dispatch. A failed verification is a
+pre-dispatch contract failure. For `runner=native-session`, pass only the
+returned `hostModelValue` to the host model argument. For
+`runner=cli-wrapper`, invoke `okstra worker-dispatch` and let it consume the
+returned `modelExecutionValue`; never pass that value as a native-host model
+token. Before a host-native call, run `okstra agent-prompt record-dispatch`
+with the project root, run manifest, metadata path, and
+`--enforcement-mode host-native-spec-link-gate`. After its Result Path exists,
+run `okstra agent-prompt link-result` with the same run manifest,
+`--dispatch-id <invocationId>:attempt-1`, and that result path before reading
+the result. This link proves that the accepted result belongs to a verified
+call specification; it does not prove which bytes the host primitive delivered.
+
 ### Sponsorship Optimization
 
 For each persisted round plan, build exactly one prompt per `dispatches[]` row and call `redispatch_worker(assignment, prompt, reason)` once through the selected runtime adapter. The prompt contains exactly that row's `findingIds` in plan order and MUST NOT add, remove, or reorder findings. This excludes Section 6, every resolved finding, and every finding owned by the receiving origin worker because none can appear in the engine row. The assignment, model, prompt path, Result Path, worker-results path, errors paths, and `dispatchKind` come from the current run artifacts. Every reverify is a fresh one-shot session.
@@ -254,7 +279,7 @@ Assigned worker prompt history path: <Project Root>/<Prompt History Path>
 
 Before dispatch, materialize `**Audit sidecar path:**` by passing the exact reverify `**Result Path:**` through `okstra_ctl.worker_artifact_paths.audit_sidecar_rel()` and resolving that project-relative result against `**Project Root:**`. Write the resulting absolute path into the header. The lead MUST NOT construct the audit filename from a role, task type, round, or sequence independently.
 
-The two errors paths carry the same absolute values the lead forwarded in the initial Phase 4 dispatch for that role (source: the launch prompt's `## Run Logs (error-log wiring)` section). Omitting either one makes a CLI-wrapper worker return `<WORKER>_ERRORS_PATH_MISSING` before it invokes its CLI — the path-delivery contract in [team-contract](./team-contract.md) "Error reporting" is not relaxed for reverify, because a reverify dispatch can fail the same way an initial dispatch can.
+The two errors paths carry the same absolute values the lead forwarded in the initial Phase 4 dispatch for that role (source: the launch prompt's `## Run Logs (error-log wiring)` section). Omitting either one makes `worker-dispatch` reject the CLI invocation before it starts the provider process — the path-delivery contract in [team-contract](./team-contract.md) "Error reporting" is not relaxed for reverify.
 
 Relative to the Phase 4 anchor set rendered by `okstra_ctl.worker_prompt_headers.worker_prompt_headers()`, a reverify prompt adds `**Model:**` and drops two anchors whose targets lightweight mode never reads: `**Worker Preamble Path:**` and `**Coding preflight pack:**`.
 
@@ -323,7 +348,7 @@ This is the single largest avoidable cost in `requirements-discovery`, `error-an
 ### Lightweight Re-verification Prompt
 
 ```
-You are <worker-role> performing re-verification for <task-key> (round <N>).
+Perform re-verification for <task-key> (round <N>).
 
 ## Instructions
 
@@ -365,7 +390,7 @@ For each finding, respond as:
 Used instead of the lightweight/full-reanalysis prompt when `config.adversarial == true`. The required anchor headers (§"Required reverify-prompt anchor headers") are identical. The `[Required reading]` clause is suppressed; only the cited-evidence paths of the items under attack are injected (see §"Adversarial Verification Mode" → Scoped full-reanalysis).
 
 ```
-You are <worker-role> performing ADVERSARIAL re-verification for <task-key> (round <N>).
+Perform ADVERSARIAL re-verification for <task-key> (round <N>).
 
 ## Instructions
 
@@ -416,7 +441,7 @@ UNVERIFIABLE is **not** `verification-error`. A verifier that opened the evidenc
 ### Full Re-analysis Re-verification Prompt
 
 ```
-You are <worker-role> performing deep re-verification for <task-key> (round <N>).
+Perform deep re-verification for <task-key> (round <N>).
 
 ## Instructions
 
@@ -550,7 +575,17 @@ The critic input is the Round 0 consolidated finding list. Reverify rounds only
 - **Gap verification + merge**: only after BOTH the finding-convergence loop has exited AND the critic result is collected, and BEFORE the Phase 6 report-writer dispatch. If the loop exited `aborted-non-result`, do NOT dispatch a gap-verification round — record every gap in `unverifiedGaps[]` per §"Gap verification".
 
 ### Dispatch (fresh one-shot)
-Dispatch one fresh pass to `config.critic.provider` through `redispatch_worker`, with `model = config.critic.modelExecutionValue` and `dispatchKind = "critic"`. If the model value is empty, record `critic-skipped: model-unresolved`; never dispatch without a model. Result path: `runs/<task-type>/worker-results/<provider>-worker-critic-<task-type>-<seq>.md`.
+Write the critic-only task instructions, then run `okstra agent-prompt
+materialize` with `--audience scope-critic`, `--assignment-ref critic/scope`,
+the critic worker ID, and `--dispatch-kind critic`. Verify the returned
+`metadataPath` before dispatch and use its `promptPath` without modification.
+For `runner=native-session`, use only `hostModelValue`; for
+`runner=cli-wrapper`, use `okstra worker-dispatch`, which consumes
+`modelExecutionValue`. Record host-native linkage with
+`enforcementMode=host-native-spec-link-gate` and the metadata path. If the
+persisted assignment or either model value required by its runner is absent,
+record `critic-skipped: model-unresolved`; never resolve a replacement model.
+Result path: `runs/<task-type>/worker-results/<provider>-worker-critic-<task-type>-<seq>.md`.
 
 The `-worker-` token is load-bearing, not decoration: the critic prompt carries the same generated anchor headers as every other worker ([team-contract](./team-contract.md) §"Worker prompts"), and its `**Audit sidecar path:**` comes from passing that result path through `okstra_ctl.worker_artifact_paths.audit_sidecar_rel()`, which inserts `-audit-` after the token and raises without it. A `<provider>-critic-...` name leaves the lead choosing between breaking the contract and hand-inventing the sidecar name. Note that `originWorker` stays `"<provider>-critic"` — that is a worker id in the convergence state, not a filename, and the two do not have to match.
 
@@ -567,7 +602,7 @@ Required reading before proposing a gap or an over-scope candidate:
 Operational guardrails are not task requirements. A gap must trace to a brief requirement, an analysis-packet scope item, a source path the packet authorizes, or an evidence claim in a worker result. Do NOT infer missing verification from a one-line summary; open the named result and audit sidecar first.
 
 ```
-You are the scope critic for <task-key>. Below are the consolidated findings the
+Inspect scope coverage for <task-key>. Below are the consolidated findings the
 workers produced. Your job has exactly two halves. Answer both.
 
 (1) MISSING — name what nobody covered:
@@ -617,10 +652,19 @@ The asymmetry is deliberate and runs the opposite way from the coverage half: a
 
 The `final-verification` phase uses the same fresh one-shot `redispatch_worker` pattern and the same dispatch timing as §"Coverage critic pass" §"When" (provider + `config.critic.modelExecutionValue` from the `convergence.critic` block; default off; same model-unresolved skip rule) — the delivered work the critic inspects is likewise fixed before the reverify round starts. Only the prompt, the verification semantics, and the output sink differ — final-verification's findings are defects/blockers, so the critic acts as an **acceptance devil's advocate** (find reasons NOT to accept), and its candidate blockers are NEVER dropped (that would suppress real defects).
 
+Before that call, write the acceptance-only task instructions and run `okstra
+agent-prompt materialize` with `--audience acceptance-critic`,
+`--assignment-ref critic/acceptance`, the critic worker ID, and
+`--dispatch-kind critic`. Verify the returned `metadataPath`, dispatch only the
+returned `promptPath`, and select `hostModelValue` for a native host or
+`modelExecutionValue` through `okstra worker-dispatch`. Native dispatch linkage
+uses `enforcementMode=host-native-spec-link-gate`; it does not claim prompt
+delivery was observed.
+
 ### Prompt
 
 ```
-You are the acceptance devil's advocate for <task-key>. The delivered work is about
+Challenge acceptance for <task-key>. The delivered work is about
 to be judged for acceptance. Your ONLY job is to find reasons it should NOT be
 accepted — surface candidate acceptance BLOCKERS the verifiers may have missed:
 - requirements / acceptance points with no covering evidence,

package/runtime/prompts/lead/okstra-lead-contract.md

@@ -1,15 +1,5 @@
 # Okstra Lead Contract
 
-## Operating standard
-
-Work like a senior engineer who owns this result, not a commentator on it.
-- Evidence over assertion — back every claim with a file:line, or mark it an explicit assumption. Never state the unverified as fact.
-- Read before you reason — read each required input end to end; when you lack basis, write "insufficient evidence" instead of filling the gap plausibly.
-- Shortest sound path — chase the most likely cause first; don't re-verify what is settled or pad with restatement.
-- Decide, don't survey — when options exist, give the trade-off and one recommendation, not an exhaustive list.
-- Fit what's here — match the surrounding code and prose; size the response to the request.
-- Own the synthesis — weigh worker outputs on evidence, not consensus; a better-grounded dissent outranks the majority.
-
 ## Overview
 
 The lead orchestrates the selected AI workers against a prepared task bundle, collects their independent outputs, supervises convergence, and ensures the final report is produced. When `Report writer worker` is in the selected roster, that worker authors the final-report artifacts; the lead reviews and approves them. The lead never substitutes its own reasoning for a worker result and never bypasses a rostered report writer.
@@ -143,7 +133,7 @@ The sequence is fixed:
 
 **The lead never invents a model.** Every role's model is read from `task-manifest.json` → `resultContract.requiredWorkerRoles[*].modelExecutionValue` (and the lead model metadata). A missing assignment is a manifest defect, not a license to fall back — see [team-contract](./team-contract.md) "Model Assignment Rules". The manifest is always populated at run-prep time by the CLI, which seeds these values from `OKSTRA_DEFAULT_*_MODEL` (`scripts/okstra_ctl/run.py`).
 
-**Reading an assignment is not enough — the selected adapter must apply it at dispatch.** `dispatch_worker` receives the manifest assignment, and the selected runtime adapter maps `modelExecutionValue` to its native invocation without changing provider, role, or model. A missing/unsupported mapping is a pre-dispatch contract failure, never a silent fallback.
+**Reading an assignment is not enough — the selected adapter must apply it at dispatch.** `dispatch_worker` receives the complete manifest assignment. The selected runtime adapter passes `hostModelValue` to a `runner=native-session` host primitive or `modelExecutionValue` to a `runner=cli-wrapper` provider process without changing provider, role, or model. A missing or unsupported runner-specific mapping is a pre-dispatch contract failure, never a silent fallback.
 
 The table below documents those prep-time seed values **for reference only** — it is NOT a lead-applied fallback:
 
@@ -152,19 +142,19 @@ The table below documents those prep-time seed values **for reference only** —
 | Lead role | opus | -- | runtime-specific role label; orchestration + convergence supervision + final-report review/approval |
 | Report writer worker | sonnet | report-writer-worker | `agents/workers/report-writer-worker.md` |
 | Claude worker | opus | claude-worker | `agents/workers/claude-worker.md` |
-| Codex worker | gpt-5.6-sol | codex-worker | generated from `agents/workers/_cli-wrapper-template.md` + `codex-worker.params.json` |
-| Antigravity worker | gemini-3.1-pro | antigravity-worker | generated from `agents/workers/_cli-wrapper-template.md` + `antigravity-worker.params.json` |
+| Codex worker | gpt-5.6-sol | codex-worker | duty + task instructions composed per invocation; deterministic `worker-dispatch` execution |
+| Antigravity worker | gemini-3.1-pro | antigravity-worker | duty + task instructions composed per invocation; deterministic `worker-dispatch` execution |
 
-All three analysis workers use dedicated agent definitions; Codex/Antigravity wrappers handle external CLI invocation internally; Claude worker runs as an in-process subagent with explicitly registered MCP tools so it does not fall back to `claude --mcp-cli` Bash invocations.
+Each analysis assignment follows its recorded `runner`. `runner=native-session` uses the host's native subagent primitive after `host-native-spec-link-gate`; `runner=cli-wrapper` uses the deterministic `okstra worker-dispatch` process boundary after `core-pre-dispatch` verification. No LLM transport wrapper sits in front of a provider CLI.
 
 ### Implementation phase: Executor binding
 
 For `--task-type implementation` runs, the task bundle additionally pins one of `claude` / `codex` / `antigravity` as the Executor — the only worker permitted to mutate project files in that run. The binding is exposed in two canonical places:
 
-- `instruction-set/analysis-profile.md` — top "Executor binding" block (provider, displayName, workerAgent, model)
-- `runs/implementation/manifests/run-manifest-*.json` — `teamContract.executor` object (same fields plus `appliesTo: "implementation"`)
+- `instruction-set/analysis-profile.md` — top "Executor binding" block (provider, display name, model, runner, and dispatch mode)
+- `runs/implementation/manifests/run-manifest-*.json` — `teamContract.executor` object (the same binding plus `appliesTo: "implementation"`)
 
-Lead MUST dispatch Edit/Write-bearing work only through the `workerAgent` declared there. The other two providers still run as read-only verifiers in the same run; the executor's own provider is *also* dispatched separately as a verifier in a fresh CLI session, so the diff is reviewed context-isolated. Session isolation is the primary self-review safeguard — same-model executor and same-provider verifier is acceptable in distinct sessions. A different model variant (e.g. executor=opus / Claude verifier=sonnet) is recommended but not mandatory.
+Lead MUST dispatch Edit/Write-bearing work only through that executor binding: use the host primitive with `hostModelValue` for `runner=native-session`, or `okstra worker-dispatch` with `modelExecutionValue` for `runner=cli-wrapper`. The other two providers still run as read-only verifiers in the same run; the executor's own provider is *also* dispatched separately as a verifier in a fresh session, so the diff is reviewed context-isolated. Session isolation is the primary self-review safeguard — same-model executor and same-provider verifier is acceptable in distinct sessions. A different model variant (e.g. executor=opus / Claude verifier=sonnet) is recommended but not mandatory.
 
 Executor is chosen at run-prep time via `--executor <claude|codex|antigravity>` (or `OKSTRA_DEFAULT_EXECUTOR`, fallback `claude`); the model used by the executor is taken from the corresponding worker model flag (`--claude-model` / `--codex-model` / `--antigravity-model`). For CLI-backed executors, the underlying file mutation happens inside the executor CLI's own auto-edit mode (e.g. `codex exec --sandbox workspace-write`), not through the lead runtime's `write_artifact` operation.
 
@@ -267,7 +257,7 @@ The launch prompt's `## Run Logs (error-log wiring)` section gives Lead the reso
 
 Workers are contractually required to extract these two lines and abort with `<WORKER>_ERRORS_PATH_MISSING` if either is absent (see each worker definition's "Path extraction (BLOCKING)" block). Omitting these headers reproduces the historical bug where every run's `errors-<task-type>-<seq>.jsonl` stayed empty (workers had only template placeholders).
 
-After each worker terminates, BEFORE classifying its terminal status, verify the canonical result file exists at the absolute path resolved from the `**Result Path:**` header. If it is absent — or the wrapper sub-agent returned `CODEX_RESULT_MISSING` / `ANTIGRAVITY_RESULT_MISSING` — re-dispatch the SAME worker once with the byte-identical prompt. Only after the second attempt also misses may the role be classified `error` with `--message "result-missing after 1 retry"`. Full rules: [team-contract](./team-contract.md) "Lead Redispatch Policy on Result-Missing".
+After each worker terminates, BEFORE classifying its terminal status, verify the canonical result file exists at the absolute path resolved from the `**Result Path:**` header. If it is absent — or the deterministic provider process returned `CODEX_RESULT_MISSING` / `ANTIGRAVITY_RESULT_MISSING` — re-dispatch the SAME worker once with the byte-identical prompt. Only after the second attempt also misses may the role be classified `error` with `--message "result-missing after 1 retry"`. Full rules: [team-contract](./team-contract.md) "Lead Redispatch Policy on Result-Missing".
 
 After each worker terminates (any terminal status), if its errors sidecar exists, dump it to the run error log using the same resolved paths from the launch prompt:
 
@@ -286,7 +276,7 @@ okstra error-log append-from-worker \
 
 For a lead-attributed event there is no value in the list above — the selected adapter names the lead identity to pass.
 
-For Codex/Antigravity wrappers: if the CLI returns non-zero, times out, or hits a rate limit, immediately call `append-observed` with the captured exit code, duration, message, and stderr excerpt. `append-observed` additionally requires `--phase`, `--command`, and `--command-kind`, so copy this form rather than trimming the one above:
+For deterministic Codex/Antigravity provider processes: if the CLI returns non-zero, times out, or hits a rate limit, immediately call `append-observed` with the captured exit code, duration, message, and stderr excerpt. `append-observed` additionally requires `--phase`, `--command`, and `--command-kind`, so copy this form rather than trimming the one above:
 
 ```bash
 okstra error-log append-observed \
@@ -303,7 +293,7 @@ okstra error-log append-observed \
 
 Keep `--message` to the error actually observed — asserting that a sandbox or permission boundary blocked the call requires `--context-json` carrying `cause` plus both `causeEvidence` probes, and an unevidenced block claim in `--message` is rejected. If an `append-from-worker` dump is rejected for that reason, correct the offending sidecar entry and re-run the dump instead of skipping it: the dump aborts at the rejected entry, so every later entry in that sidecar never reaches the run log.
 
-The wrapper subagent records this through its selected adapter — Lead does NOT need to re-record. Token usage is not inferred from dispatch return values; call `collect_usage` at the start of Phase 7.
+The deterministic dispatcher records this through its selected adapter — Lead does NOT need to re-record. Token usage is not inferred from dispatch return values; call `collect_usage` at the start of Phase 7.
 
 ## Phase 5.5: Convergence loop
 

package/runtime/prompts/lead/plan-body-verification.md

@@ -181,6 +181,21 @@ Plan-body verification stays **lightweight** even under this posture — the `ve
 
 ## Round protocol (single round at default `maxRounds=1`)
 
+Before each verifier call, write one task-instructions file under the current
+run's `state/` directory and run `okstra agent-prompt materialize` with
+`--audience reverification-worker`,
+`--assignment-ref reverify/<workerId>`, the exact `--worker-id`, and
+`--dispatch-kind reverify-r<N>`. Run `okstra agent-prompt verify` against the
+returned `metadataPath` before dispatch and use the returned `promptPath`
+without modification. Native-session calls use only `hostModelValue`; before
+the host primitive, run `okstra agent-prompt record-dispatch` with the project
+root, run manifest, metadata path, and `--enforcement-mode
+host-native-spec-link-gate`, then run `okstra agent-prompt link-result` with
+`--dispatch-id <invocationId>:attempt-1` and the result path before parsing it;
+CLI-wrapper calls go through `okstra worker-dispatch` and consume only
+`modelExecutionValue`. A missing or invalid invocation contract blocks the
+round before any host or provider process starts.
+
 1. Lead runs `okstra plan-items extract --data <data.json> --output <state>/plan-items-....json`, places the persisted `items[]` verbatim in every verifier prompt with the compact `subject` and lossless `payload`, then runs `okstra plan-items validate --data <data.json> --items <state>/plan-items-....json`. Dispatch only after that exact-match validation succeeds.
 2. For each analyser worker in the roster (`claude`, `codex`, and `antigravity` if opted in), lead constructs a reverify prompt using the template in §"Plan-body reverify prompt" below.
 3. Dispatch uses the same wrapper infrastructure as finding convergence, so the `--role-slug` is the same canonical `<role>-worker` that convergence uses — not a round-specific slug. Result file path: `runs/<task-type>/worker-results/<role>-worker-plan-verify-r<N>-implementation-planning-<seq>.md` (e.g. `codex-worker-plan-verify-r1-implementation-planning-003.md`). The `-worker-` token is load-bearing twice over: §"Plan-body reverify prompt" requires the same anchor headers as convergence, whose `**Audit sidecar path:**` is derived by `okstra_ctl.worker_artifact_paths.audit_sidecar_rel()` inserting `-audit-` after that token — a slug without it makes the header underivable and the helper raises. Record each `planItems[].verdicts[].worker` as the same `<role>-worker` string, because provenance compares it to this filename's prefix. **Enforced:** `tests/contract/test_reverify_dispatch_anchors.py` derives the sidecar from the documented name and re-extracts the prefix the provenance resolver uses.
@@ -357,7 +372,7 @@ The [convergence](./convergence.md) §"Required reverify output contract"
 applies unchanged: append it verbatim after the response format below.
 
 ````
-You are <worker-role> performing plan-body verification for <task-key> (round 1).
+Perform plan-body verification for <task-key> (round 1).
 
 ## Instructions
 

package/runtime/prompts/lead/report-writer.md

@@ -23,12 +23,13 @@ Two `frontmatter` approval fields are always emitted with their unset default
 ## Phase 6 dispatch template (Report writer worker)
 
 1. Resolve the Report writer worker assignment and all required prompt/result/error paths from the manifests.
-2. Persist the exact prompt history with the required anchor headers and audience-specific reading list.
-3. Emit the Phase 6 checkpoint.
-4. Call `dispatch_worker(report_writer_assignment, prompt)` through the selected adapter.
-5. Call `await_workers([handle])` and verify the data.json Result Path, rendered Markdown sibling, and worker-result pointer at Worker Result Path. Verify the separate heartbeat audit sidecar before accepting the run. **Enforced:** both dispatch adapters keep the three completion paths in `WorkerJob.completion_paths`, and `validators/validate_session_conformance.py` validates the audit sidecar.
+2. Write a call-specific task-instructions file containing the anchor headers and audience-specific reading list.
+3. Run `okstra agent-prompt materialize --audience report-writer --assignment-ref initial/report-writer --worker-id report-writer --dispatch-kind report-writer ...`, then run `okstra agent-prompt verify` against the returned `metadataPath`. Use the returned `promptPath` without appending role prose. A correction redispatch repeats this step with a fresh invocation ID and the same audience and assignment reference.
+4. Emit the Phase 6 checkpoint.
+5. For `runner=native-session`, first run `okstra agent-prompt record-dispatch` with the project root, run manifest, metadata path, and `--enforcement-mode host-native-spec-link-gate`, then call the host primitive with only the returned `hostModelValue`. After its result exists, run `okstra agent-prompt link-result` with `--dispatch-id <invocationId>:attempt-1` and the result path before accepting it. For `runner=cli-wrapper`, call `okstra worker-dispatch --workers report-writer`, which consumes `modelExecutionValue` and verifies the metadata before starting the provider process. Never combine this Phase 6 call with analysis workers.
+6. Call `await_workers([handle])` and verify the data.json Result Path, rendered Markdown sibling, and worker-result pointer at Worker Result Path. Verify the separate heartbeat audit sidecar before accepting the run. **Enforced:** both dispatch adapters keep the three completion paths in `WorkerJob.completion_paths`, and `validators/validate_session_conformance.py` validates the audit sidecar.
 
-The assignment's `modelExecutionValue` feeds both adapter dispatch and the prompt header in item 9 below, so the execution model and recorded `**Model:**` header always agree. Missing or unsupported model resolution is a pre-dispatch contract failure; the common contract does not choose a runtime fallback.
+The complete assignment supplies both runner-specific model values and the prompt header in item 9 below. A native host uses `hostModelValue`; a deterministic provider process uses `modelExecutionValue`; the recorded `**Model:**` header remains the canonical assignment label. Missing or unsupported model resolution is a pre-dispatch contract failure; the common contract does not choose a runtime fallback.
 
 The prompt MUST include, in this order at the top:
 
@@ -90,6 +91,20 @@ For an implementation-planning run, the Report writer worker owns the Phase 6 de
 2. **Only when it passes and Report Language is not `en`**, dispatch the translator worker, which writes `final-report-<task-type>-<seq>.i18n.<lang>.json`.
 3. Then run `report-finalize`.
 
+For step 2, write translator-only task instructions and run `okstra
+agent-prompt materialize` with `--audience translator`, `--assignment-ref
+translator`, `--worker-id translator`, and `--dispatch-kind translator`. Run
+`okstra agent-prompt verify` on the returned `metadataPath` before dispatch and
+use the returned `promptPath` unchanged. A native-session call uses only
+`hostModelValue`; first run `okstra agent-prompt record-dispatch` with the run
+manifest, metadata path, and `--enforcement-mode
+host-native-spec-link-gate`, then run `okstra agent-prompt link-result` with
+`--dispatch-id <invocationId>:attempt-1` and the translation result before
+accepting it. A CLI-wrapper call uses `okstra worker-dispatch` and its
+`modelExecutionValue`. The host-native record links the accepted result to a
+verified call specification but does not assert that Okstra observed the host's
+actual prompt delivery.
+
 **Never dispatch the translator before step 1.** The data.json is the English SSOT; a report-writer that authored it in the reader's language produces a translation *from that language into itself* — a full-cost, entirely useless artifact, and the run still fails at `check-source` afterwards. **Enforced:** `okstra report-translate extract` refuses to build a work list from a data.json over the Korean-prose limit, so a mis-ordered dispatch fails at the translator's first command instead of after it. When it does fail, the fix is a report-writer rewrite in English — discard the sidecar and `translation-source.json` produced from the Korean draft rather than editing them, because their English column is not English.
 
 Phase 7 post-processing is then **one command**. `okstra report-finalize` owns the ordered sequence — it is the same code path the Codex lead adapter runs automatically, so a Claude-led run and a Codex-led run finalize identically: