okstra 0.218.0 → 0.219.1

package/docs/project-structure-overview.md

@@ -206,7 +206,7 @@ The Module column below is where the command's behaviour lives — a `src/` modu
 | `token-usage` | `scripts/okstra-token-usage.py` | Wrap installed Python token usage CLI |
 | `spawn-followups`, `error-log` | `scripts/okstra-spawn-followups.py`, `scripts/okstra-error-log.py` | Follow-up task bundle creation and run error-log append helpers |
 | `memory` | `src/commands/memory/memory.mts` | Store/find global conversation memory under `~/.okstra/memory-book`; `add --source-key` returns the stored entry for a key it already holds, under a per-key lock (`src/lib/file-lock.mts`, shared with `chat`) |
-| `pr` | `src/commands/pr/pr.mts` | `okstra pr <template\|branches\|gen>` — PR body template store under `~/.okstra/template/pr/` (default `templates/pr/pr-body.template.md`, shared with release-handoff), base-branch recommendation, and a fixed-text generation bundle — template, `<base>..<head>` commits, `<base>...<head>` diffstat and the `templates/pr/drafting-rules.md` drafting rules — used by the okstra-pr-gen skill and the release-handoff lead. `--json` preserves the same fields as a machine contract. Git-only; no project registration required |
+| `pr` | `src/commands/pr/pr.mts` | `okstra pr <template\|branches\|gen>` — PR body template store under `~/.okstra/template/pr/` (default `templates/pr/pr-body.template.md`, shared with release-handoff), base-branch recommendation, and a fixed-text generation bundle — template, `<base>..<head>` commits, `<base>...<head>` diffstat and the `templates/pr/drafting-rules.md` drafting rules — used by the okstra-pr-gen skill and the release-handoff lead; `check` lists okstra identifiers left in a drafted body. `--json` preserves the same fields as a machine contract. Git-only; no project registration required |
 | `recap` | `scripts/okstra_ctl/recap.py` | `okstra recap <assemble\|record\|note>` Node wrapper backing the okstra-inspect `recap` facet — `assemble` is a read-only phase-transition summary for a task or, with `--task-group`, the group's start order plus each task's latest conclusion; `record` appends one line to `recap/recap-log.jsonl` (task) or `.okstra/tasks/<group>/.recap/recap-log.jsonl` (`--task-group`); `note` writes an agent-authored note under `notes/` and prints the `--clarification-response` argument for a follow-up run |
 | `stage-map` | `scripts/okstra_ctl/stage_map_cli.py` | `okstra stage-map <task-key>` — exposes a task's implementation-planning Stage Map as JSON (`stages[].{stage_number,title,depends_on,step_count}` + consumer-state-based `doneStages[]`). If there is no Stage Map, `stages: []`. The read-side basis from which `okstra-schedule-gen` derives stage units and dependency closure |
 | `design-prep` | `scripts/okstra_ctl/design_prep.py` | `okstra design-prep <list\|show\|write>` thin shim into `scripts/okstra_ctl/design_prep.py` — queries (`list`/`show`) the design items that implementation-planning pre-authored with AI, and records the user-confirmed responses as an append-only sidecar under `design-prep-inputs/` (`write`, `--confirmed` required). It never modifies the report snapshot |
@@ -360,7 +360,8 @@ Important modules:
 | `lead_events.py` | Structured JSONL events emitted by artifact-accounted lead runtimes. Its locked append path assigns monotonic `A-NNN` identifiers to activity events in the same canonical event file. |
 | `worker_prompt_headers.py` | shared rendering of phase-aware worker prompt anchors (`worker_prompt_headers`): coding-preflight only for implementation and compact target identity for final-verification |
 | `worker_prompt_body.py` | provider-neutral initial analysis body/input renderer shared by Codex and external/team dispatch paths |
-| `report_language.py` | report-writer `**Report Language:**` resolution (`resolve_report_language`) — precedence project config → global config → `en`; the value is a language tag the Phase 7 translator translates into, shared by both dispatchers so the stamped language does not depend on which dispatch path ran |
+| `report_prose_keys.py` | `PROSE_KEYS` — final-report leaf keys whose values are reader-facing prose; `validators/validate-run.py` uses it to reject null literals (`None`, `null`) in prose cells |
+| `report_language.py` | report-writer `**Report Language:**` resolution (`resolve_report_language`) — precedence project config → global config → `en`; the value is a language tag the report writer authors its prose in, shared by both dispatchers so the stamped language does not depend on which dispatch path ran |
 | `worker_prompt_policy.py` | `PromptPlan` generating SSOT — resolves functional audience, equality group, packet-only input, coding-preflight eligibility, required headers, and size limits without consulting provider/model identity |
 | `worker_prompt_contract.py` | deterministic cross-task initial-prompt validator and normalized cross-worker equality SSOT, reused by dispatch adapters and the Phase 7 persisted-artifact validator |
 | `initial_prompt_materialization.py` | sole owner of roster-derived initial prompt rendering, request compatibility checks, contract validation, and immutable create-if-absent publication; exposes `materialize_initial_prompts(InitialPromptMaterializationRequest) -> tuple[Path, ...]` |
@@ -376,8 +377,7 @@ Important modules:
 | `plan_derivations.py` | the supersession sweep `_common-contract.md` requires an author to do by hand — extracts the symbols, paths, and ids an answered clarification names and reports every plan string that mentions one. Advisory: it locates candidates and never judges which are now false |
 | `scope_provenance.py` | single source of truth for the scope-provenance grammar every phase-emitted requirement must declare, shared by `validators/validate-run.py` and `scripts/okstra_ctl/phases/requirements_discovery/validation.py` so the planning report and fan-out packets cannot drift |
 | `worker_artifact_paths.py` | canonical worker artifact path derivation (e.g. `audit_sidecar_rel` inserts `-audit-` after the first `-worker-` token), so dispatch and validation agree on non-canonical-path rejection |
-| `report_translation_dispatch.py` | Phase 7 `translate` step — for a non-English `reportLanguage` and no `*.i18n.<lang>.json` sidecar, reuses or materializes this run's translator reservation (`agent-prompt materialize --audience translator` in-process, instruction file under `state/`), runs the CLI-wrapper dispatch, and succeeds only when the sidecar exists afterwards. Replaces the manual lead sequence that was skipped in practice |
-| `report_finalize.py` | Phase 7 post-report sequence **SSOT** — runs `translate` → `token-usage` → `render-views` → `spawn-followups` → `record-verified` → `validate-run` → `record-group-memory` → `teardown-stages` → `prune-run-artifacts` in that load-bearing order. A non-zero exit still runs every later check through `validate-run` and names the earliest failure; `record-group-memory` (this run's conclusion into the task-group's `group-context.md`, plus `nextInGroup` for the closeout) and `teardown-stages` are skipped when any earlier step failed; `prune-run-artifacts` (removes `node_modules` / `.next` under the run directory, and a validated run's dispatch snapshots and publication locks) always runs. Both lead paths converge here: the Codex adapter calls it in-process (`codex_dispatch`), a Claude-led run reaches it through `okstra report-finalize`. Neither reimplements the sequence |
+| `report_finalize.py` | Phase 7 post-report sequence **SSOT** — runs `token-usage` → `render-views` → `spawn-followups` → `record-verified` → `validate-run` → `record-group-memory` → `teardown-stages` → `prune-run-artifacts` in that load-bearing order. A non-zero exit still runs every later check through `validate-run` and names the earliest failure; `record-group-memory` (this run's conclusion into the task-group's `group-context.md`, plus `nextInGroup` for the closeout) and `teardown-stages` are skipped when any earlier step failed; `prune-run-artifacts` (removes `node_modules` / `.next` under the run directory, and a validated run's dispatch snapshots and publication locks) always runs. Both lead paths converge here: the Codex adapter calls it in-process (`codex_dispatch`), a Claude-led run reaches it through `okstra report-finalize`. Neither reimplements the sequence |
 | `wrapper_status.py` | worker wrapper status sidecar reader — the host-side reader of the sidecar `worker_runner.py` writes. `is_terminal` is the one question it answers for the dispatch record and the pane reclaim: does `stage` read `exited` |
 | `worker_runner.py` | runs one worker CLI and records what happened — shared by every provider entrypoint. Owns the `selectors` pump over the child's streams, the stream-arrival idle watchdog (`killpg` on breach), the run-wide progress cap on the log copy, and the status sidecar's whole life. A run that dies after launch still closes its sidecar, so `worker_liveness` never reads a dead worker as running |
 | `session_transcript.py` | worker session transcript — one line per event (time, speaker, body) with a run-wide progress-line cap (`LOG_LINE_CAP`, elision notice) so a single-file dispatch's tool echo cannot dominate the project's `.okstra/` bytes; the fixed shape lets a later lead write share the same file |
@@ -492,7 +492,6 @@ Token/cost accounting:
 | `templates/worker-prompt-preamble.md` | Initial analysis audience procedure and output contract |
 | `templates/implementation-worker-preamble.md` | Shared implementation executor/verifier procedure, including coding-preflight and worktree rules |
 | `templates/report-writer-prompt-preamble.md` | Report-writer input and authoring procedure without analysis or implementation instructions |
-| `templates/translator-prompt-preamble.md` | Translator output ownership and translation conduct, delivered to every provider regardless of host |
 | `scripts/okstra_ctl/adapters/hosts/claude-code/worker-session.md` | Rules that hold because a worker runs inside the lead's Claude Code session; delivered to `runner=native-session` prompts only |
 | `templates/worker-error-contract.md` | Audience-neutral error-path, sidecar schema, and write protocol shared by every initial worker |
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okstra",
-  "version": "0.218.0",
+  "version": "0.219.1",
   "description": "Host-aware multi-provider cross-verification orchestrator runtime and agent skills.",
   "license": "MIT",
   "author": "devonshin",

package/runtime/BUILD.json

@@ -1,5 +1,5 @@
 {
-  "package": "0.218.0",
-  "builtAt": "2026-10-16T12:08:35.107Z",
+  "package": "0.219.1",
+  "builtAt": "2026-10-17T05:52:47.996Z",
   "repoRoot": "/home/runner/work/okstra/okstra"
 }

package/runtime/prompts/launch.template.md

@@ -101,7 +101,7 @@ Do not end the turn after the validator result. Task-qualified report paths and
 
 - Task manifest: `{{TASK_MANIFEST_RELATIVE_PATH}}`
 - Run manifest: `{{RUN_MANIFEST_RELATIVE_PATH}}`
-- User authorization evidence: `userAuthorization` in that run manifest preserves the displayed confirmation, submitted response, and selected input scope. Read it during intake and before requesting execution permission for workers, including the translator inside `report-finalize`. Cite the recorded response and exact recipient/material scope in the host tool justification. This record is a relayed user response, not an independent host permission grant. If absent, do not reconstruct approval from current defaults or model selection; use an actual earlier user response or ask only for the missing scope. New recipients or material require a scope comparison before dispatch.
+- User authorization evidence: `userAuthorization` in that run manifest preserves the displayed confirmation, submitted response, and selected input scope. Read it during intake and before requesting execution permission for workers. Cite the recorded response and exact recipient/material scope in the host tool justification. This record is a relayed user response, not an independent host permission grant. If absent, do not reconstruct approval from current defaults or model selection; use an actual earlier user response or ask only for the missing scope. New recipients or material require a scope comparison before dispatch.
 - Active run context: `{{ACTIVE_RUN_CONTEXT_RELATIVE_PATH}}`
 - Analysis packet: `{{ANALYSIS_PACKET_RELATIVE_PATH}}`
 

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

@@ -179,7 +179,6 @@ Every `okstra` command the lead documents cite, grouped by phase, each spelled w
 | Command | Use when | Procedure |
 |---|---|---|
 | `okstra report-finalize --project-root <dir> --run-manifest <path> --report <path>` | Run the whole Phase 7 sequence; do not run its steps separately. Without `--only` it records `phase-7-persist` first; emit its `progressLines` | `report-writer` "Phase 6 → Phase 7 execution sequence" |
-| `okstra report-translate check-data --run-manifest <path>` | Check an existing translation after a narrative correction | `report-writer` "Phase 6 → Phase 7 execution sequence" |
 | `okstra handoff record-verified --plan-run-root <dir> --stage <N> --report-path <path> --data-json <path>` | Record an accepted final-verification against its stage. `report-finalize` runs it in its `record-verified` step; run it by hand only to repair a registry after that step failed | `report-writer` "Phase 6 → Phase 7 execution sequence" |
 | `okstra team teardown --project-root <dir> --run-manifest <path>` | Close every recorded pane at the end of the run | cmux adapter "Semantic operation mapping" |
 
@@ -192,7 +191,7 @@ Every `okstra` command the lead documents cite, grouped by phase, each spelled w
 ## Core operating contract
 
 - The `leader` owns orchestration, convergence supervision, and final-report review. It does not author the report narrative or assembled record when `Report writer worker` is in the roster. `lead` is a compatibility alias for `leader` and must not be written on new artifacts.
-- Dispatch consumes stored role executions, not provider-named worker IDs. Canonical roles are `leader`, `analyser`, `critic`, `designer`, `planner`, `implementer`, `verifier`, `report-writer`, and `translator`. `executor` is a compatibility alias for `implementer`.
+- Dispatch consumes stored role executions, not provider-named worker IDs. Canonical roles are `leader`, `analyser`, `critic`, `designer`, `planner`, `implementer`, `verifier`, and `report-writer`. `executor` is a compatibility alias for `implementer`.
 - Pane titles and operational rows use the stored `executionLabel`. Do not rebuild that label from a provider name or model string.
 - `report-writer`, when in the roster, is the sole author of the report narrative. Lead reviews the draft and may request a revision through a follow-up dispatch, but MUST NOT edit that narrative or the assembled `data.json`. Contract v3 has no lead-authored fallback; a failed writer dispatch is retried or leaves the run blocked. Historical v2 reports may still carry `header.leadAuthoredFallback`, but no new run writes it.
 - "Session resume", "team is no longer alive", and similar are NOT valid reasons to skip Report writer worker dispatch — see [report-writer](./report-writer.md) "Resume-safe dispatch".
@@ -619,7 +618,6 @@ The detailed persistence sequence lives in [report-writer](./report-writer.md).
 Order of operations:
 
 1. Run `okstra report-finalize ...`. Contract v3 collects usage, assembles the role-owned inputs into `data.json` once, renders views, persists follow-ups, validates the run, records this run's conclusion into the task-group's `group-context.md` for the group's sibling tasks, and performs eligible teardown in order. When the task's pointer is terminal and the group has a task not yet started, the result's `nextInGroup` names it and `nextCommand` closes on starting it from its brief — the group's start order is the brief ordinal; the briefs' Related Task Graph edges are quoted as `waits for` and do not reorder it.
-2. When `meta.reportLanguage` is not `en`, the same call dispatches the translator: its `translate` step (directly before `render-views`) materializes the translator prompt when this run has no undispatched reservation, runs the CLI-wrapper dispatch, and requires the `*.i18n.<lang>.json` sidecar. Do not dispatch the translator by hand or split the sequence around it; if the step fails, clear the cause and resume with the `--only translate --only render-views …` hint the result prints (**Enforced:** `okstra_ctl.report_translation_dispatch`).
 
 Keep the assigned worker prompt history paths stable in `team-state`, `run-manifest`, and `task-manifest`. Do not rewrite prompt artifacts to `/tmp` or omit prompt metadata for attempted workers.
 

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

@@ -129,29 +129,22 @@ For historical schema-v1 Markdown only, the following heading table remains a re
 
 **Enforced:** `okstra_ctl.report_finalize.V3_STEP_ORDER` is the order — `report-finalize` runs the steps from that tuple, so the sequence cannot be reordered by a caller. Running the steps by hand is what this rule forbids, and that path is not reachable through the CLI.
 
-Do not run the eleven steps below manually. Invoke `okstra report-finalize`; contract 3.0 runs them in this order:
+Do not run the ten steps below manually. Invoke `okstra report-finalize`; contract 3.0 runs them in this order:
 
 1. **`token-usage`** — collect usage into team state without touching the final record.
 2. **`project-activity`** — report assembly validates every owner input and publishes the final record once.
-3. **`preflight`** — run the same schema and conformance checks used by final validation before translation, without writing run status. Structural failure skips translation; rendering and final validation still record the failure. `--only translate` also includes this check.
-4. **`translate`** — for a non-English `reportLanguage`, materialize and dispatch the translator worker and require its `*.i18n.<lang>.json` sidecar; a no-op for English or when the sidecar already exists.
-5. **`render-views`** — render the Markdown reading copy and human HTML, with the translation sidecar overlaid.
-6. **`spawn-followups`** — materialize registered follow-up tasks.
-7. **`record-verified`** — for a final-verification whose verdict clears the work for release, run `okstra handoff record-verified` once per stage in `finalVerification.stageReports`, so the `verified` rows exist before validation reads them; a no-op for other task types and for a verdict that blocks release. Do not run `handoff record-verified` by hand.
-8. **`validate-run`** — validate the record, views, run manifest, and team state.
-9. **`record-group-memory`** — write this run's conclusion (headline, decisions, watch-outs, open follow-ups, record path, next phase) and the group's start order into the task-group's `group-context.md` okstra region, creating the file when the group has none; skipped, like teardown, when an earlier step failed. Sibling tasks read it as `## Task-Group Memory`.
-10. **`teardown-stages`** — remove eligible stage worktrees after successful validation.
-11. **`prune-run-artifacts`** — remove every `node_modules` and `.next` directory under the run directory, and the dispatch snapshots (`*.mutation-audit.json`) and publication locks (`*.publish.lock`) recorded by a run whose validation passed or by an earlier run in the same run directory as a passed run; it runs even after a failed step.
+3. **`preflight`** — run the same schema and conformance checks used by final validation before rendering, without writing run status. Structural failure skips `spawn-followups`; rendering and final validation still record the failure.
+4. **`render-views`** — render the Markdown reading copy and human HTML from the record. The report writer already wrote the prose in `reportLanguage`; nothing translates it.
+5. **`spawn-followups`** — materialize registered follow-up tasks.
+6. **`record-verified`** — for a final-verification whose verdict clears the work for release, run `okstra handoff record-verified` once per stage in `finalVerification.stageReports`, so the `verified` rows exist before validation reads them; a no-op for other task types and for a verdict that blocks release. Do not run `handoff record-verified` by hand.
+7. **`validate-run`** — validate the record, views, run manifest, and team state.
+8. **`record-group-memory`** — write this run's conclusion (headline, decisions, watch-outs, open follow-ups, record path, next phase) and the group's start order into the task-group's `group-context.md` okstra region, creating the file when the group has none; skipped, like teardown, when an earlier step failed. Sibling tasks read it as `## Task-Group Memory`.
+9. **`teardown-stages`** — remove eligible stage worktrees after successful validation.
+10. **`prune-run-artifacts`** — remove every `node_modules` and `.next` directory under the run directory, and the dispatch snapshots (`*.mutation-audit.json`) and publication locks (`*.publish.lock`) recorded by a run whose validation passed or by an earlier run in the same run directory as a passed run; it runs even after a failed step.
 
 After `report-finalize` returns with `ok: true`, the lead closes the run with the launch prompt's User closeout. A generated HTML file alone does not establish successful validation.
 
-When the result carries `recovery.mode: same-run`, continue the authorized work in this run. Read every `recovery.issues` entry and failed step output. Correct writer-owned fields through the correction ledger procedure above; correct orchestrator-owned inputs through their owning commands. If plan content changes, prepare and verify the affected items before finalizing. Then execute `recovery.resumeCommand`, which retains this run manifest and resumes from the earliest failure, including reassembly of contract 3.0 inputs. After a narrative correction, check an existing translation with `okstra report-translate check-data --run-manifest <manifest>` and regenerate it if its source no longer matches. Keep previous approvals, user decisions, model selections and completed evidence. Do not ask for another `/okstra-run` to repair references, coverage summaries, narrative syntax or command spelling. Ask only when an unresolved user decision or an actual external prerequisite prevents the correction. Do not edit an installed runtime or another repository while recovering a consuming project's task. **Enforced:** `report_finalize._finalize_recovery` returns the same-run command and complete owner issues, `closeout_command` suppresses the new-run closeout for that result, and `tests/report/test_report_finalize.py` checks recovery after a failed step. Execution of the correction remains the lead's responsibility.
-
-### The translation sidecar: the `translate` step
-
-`report-finalize` dispatches the translator itself. Its `translate` step runs directly before `render-views` (which overlays the sidecar), and it is a no-op when `reportLanguage` is `en` or the `*.i18n.<lang>.json` sidecar already exists. When the sidecar is missing, the step reuses this run's undispatched translator reservation if the lead already materialized one, otherwise it materializes the prompt itself — instruction file `state/translator-instructions-<task-type>-<seq>.md` (kept when the lead wrote one), prompt `prompts/translator-worker-prompt-<task-type>-<seq>.md`, `--result worker-results/translator-translations-<task-type>-<seq>.md`, `--audit-source worker-results/translator-worker-<task-type>-<seq>.md`, invocation id `<task-type>-<seq>-translator` (`-r2`, `-r3` after a failed attempt) — then dispatches the worker and waits for it: on a `terminalBackend: cmux-pane` run into a cmux pane like every other worker (the same code as `okstra team dispatch` followed by `okstra team await`; run-end `okstra team teardown` closes that pane), otherwise through the CLI-wrapper dispatcher. Either path records the dispatch and links the result. Do not run `agent-prompt materialize --audience translator` or `worker-dispatch --workers translator` by hand before `report-finalize`; the sequence used to be a manual lead step and was skipped in practice (2026-09-09, fontsninja-v3-site dev-10628-3: a `ko` run finalized in one call, zero translator reservations, English HTML). **Enforced:** `okstra_ctl.report_finalize.V3_STEP_ORDER` places the step; `okstra_ctl.report_translation_dispatch.translate_report` owns it; `_translator_job_from_reservation` in `scripts/okstra_ctl/dispatch_core.py` still refuses two undispatched reservations for one run, which only a hand-made second reservation produces.
-
-The step succeeds only when the sidecar exists afterwards; a translator that exits 0 without publishing it fails the step. A failed `translate` does not stop the sequence: `render-views` still writes the view from the English body, `validate-run` records the missing sidecar as an advisory, and the result's resume hint starts at `--only translate --only render-views …` — run that once the cause (a host approval gate, an unavailable provider) is cleared rather than closing the run on an English view.
+When the result carries `recovery.mode: same-run`, continue the authorized work in this run. Read every `recovery.issues` entry and failed step output. Correct writer-owned fields through the correction ledger procedure above; correct orchestrator-owned inputs through their owning commands. If plan content changes, prepare and verify the affected items before finalizing. Then execute `recovery.resumeCommand`, which retains this run manifest and resumes from the earliest failure, including reassembly of contract 3.0 inputs. Keep previous approvals, user decisions, model selections and completed evidence. Do not ask for another `/okstra-run` to repair references, coverage summaries, narrative syntax or command spelling. Ask only when an unresolved user decision or an actual external prerequisite prevents the correction. Do not edit an installed runtime or another repository while recovering a consuming project's task. **Enforced:** `report_finalize._finalize_recovery` returns the same-run command and complete owner issues, `closeout_command` suppresses the new-run closeout for that result, and `tests/report/test_report_finalize.py` checks recovery after a failed step. Execution of the correction remains the lead's responsibility.
 
 ## Routing pointer
 

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

@@ -13,7 +13,7 @@ Okstra tasks use one lead plus the exact worker assignments selected in the prep
 
 ### Role Definitions
 
-The start screen assigns a **model ref** (`provider/model`) to each **canonical role** slot: `leader`, `analyser`, `critic`, `designer`, `planner`, `implementer`, `verifier`, `report-writer`, `translator`. A provider name is the front of a model ref, not a role. Every `analyser` in the run shares an identical core responsibility. Specialization is additive — it lives in optional Section 7 of the worker output, NOT in differentiated core questions. Cross-verification only converges if every rostered analyser answers the same questions against the same brief.
+The start screen assigns a **model ref** (`provider/model`) to each **canonical role** slot: `leader`, `analyser`, `critic`, `designer`, `planner`, `implementer`, `verifier`, `report-writer`. A provider name is the front of a model ref, not a role. Every `analyser` in the run shares an identical core responsibility. Specialization is additive — it lives in optional Section 7 of the worker output, NOT in differentiated core questions. Cross-verification only converges if every rostered analyser answers the same questions against the same brief.
 
 | Canonical role | Core responsibility | Notes |
 |------|------|------|
@@ -25,7 +25,6 @@ The start screen assigns a **model ref** (`provider/model`) to each **canonical
 | `implementer` | Sole change author for one approved stage | Used by `implementation` |
 | `verifier` | Independent review of the assigned duty's subject | Duty varies by task type |
 | `report-writer` | **Authors** the final-report file in Phase 6 | Excluded from Phase 4/5 and convergence |
-| `translator` | Translates the designated sidecar only | Phase 7 |
 
 **Dispatch does not invent a missing model assignment.** Launch-time empty slots are filled by the model default chain before the run starts. At dispatch the model for every role comes from `resultContract.workerRoles[*].modelExecutionValue` in `task-manifest.json` (and lead model metadata). There is no per-role hard-coded fallback — see "Model Assignment Rules" below.
 

package/runtime/prompts/wizard/prompts.ko.json

@@ -569,7 +569,6 @@
   },
   "confirmation": {
     "header": "선택 확인:",
-    "translation_scope": "  번역 작업자: {model} — 보고서 작성자와 같은 제공자·모델을 사용합니다. 선택 언어의 보고서가 필요하면 보고서 본문과 관련 분석·검증 결과를 전달해 번역하고 최종 보고서를 생성합니다. 같은 작업 범위의 재검증·수정·재시도에도 위에서 선택한 제공자·모델을 사용합니다.",
     "provider_data_scope": "\n전달 대상: 위 역할·모델 목록의 제공자(현재 세션 및 선택한 외부 모델 제공자).\n전달 자료: `{project_root}`의 이 작업에 대한 작업 개요, 작업 수행에 필요한 저장소 소스·문서, 선택한 근거 자료 및 실행 중 생성되는 관련 분석·검증 결과.\n진행을 선택하면 위 대상에 해당 자료를 전달하여 선택한 작업을 실행하는 것을 승인합니다. 선택에 없는 제공자나 작업과 무관한 자료는 승인 범위에 포함되지 않습니다. 실행 환경의 권한 검토는 별도로 적용됩니다.",
     "static_role": "  static-role   : {role}#{ordinal} / {model}",
     "dynamic_role": "  dynamic-role  : {role} / reuse selected participant model",

package/runtime/python/okstra_ctl/adapters/hosts/codex/relay.md

@@ -190,7 +190,7 @@ If preparation has already failed with a Git lock creation error or `Operation n
 
 ### Permission at the dispatch boundary
 
-Read `runManifest.userAuthorization` before a live dispatch, including `report-finalize`, which can start the translator internally. It preserves the confirmation text and the user response relayed through the wizard; quote its relevant recipient/material scope and response in the execution justification alongside the prepared assignment. The translator reuses the report writer's provider/model, as disclosed at confirmation. Do not wait until translation to inspect that authorization. A missing record is not consent, and the record does not override a host rejection. If review reports missing evidence already present in the record, submit that existing evidence through the permitted review mechanism; ask the user only when the actual approved scope does not cover the dispatch.
+Read `runManifest.userAuthorization` before a live dispatch. It preserves the confirmation text and the user response relayed through the wizard; quote its relevant recipient/material scope and response in the execution justification alongside the prepared assignment. A missing record is not consent, and the record does not override a host rejection. If review reports missing evidence already present in the record, submit that existing evidence through the permitted review mechanism; ask the user only when the actual approved scope does not cover the dispatch.
 
 Before a live CLI worker dispatch, check the current host's declared sandbox and approval policy. In a restricted Codex session, request the host's supported execution permission on the dispatch command itself (`sandbox_permissions: "require_escalated"` for `exec_command` when that mechanism is available and permitted). Scope the request to the prepared run and explain that it starts the selected worker processes. Follow the host's approval decision; a wizard confirmation or a successful preflight does not grant this permission.
 

package/runtime/python/okstra_ctl/adapters/providers/antigravity/adapter.py

@@ -303,7 +303,7 @@ def create_provider() -> ProviderSpec:
             role: "gemini-3.1-pro"
             for role in (
                 "lead", "analyser", "critic", "designer", "planner", "executor",
-                "verifier", "report-writer", "translator",
+                "verifier", "report-writer",
             )
         },
         wrapper="okstra-antigravity-exec.sh",

package/runtime/python/okstra_ctl/adapters/providers/claude/adapter.py

@@ -168,7 +168,6 @@ def create_provider() -> ProviderSpec:
             "executor": "opus",
             "verifier": "opus",
             "report-writer": "sonnet",
-            "translator": "sonnet",
         },
         wrapper="okstra-claude-exec.sh",
         supported_roles=ALL_ROLE_TOKENS,

package/runtime/python/okstra_ctl/adapters/providers/codex/adapter.py

@@ -133,7 +133,7 @@ def create_provider() -> ProviderSpec:
         models=CODEX,
         default_models={
             role: "gpt-6.1-sol"
-            for role in ("lead", "analyser", "critic", "designer", "planner", "executor", "verifier", "report-writer", "translator")
+            for role in ("lead", "analyser", "critic", "designer", "planner", "executor", "verifier", "report-writer")
         },
         wrapper="okstra-codex-exec.sh",
         supported_roles=ALL_ROLE_TOKENS,

package/runtime/python/okstra_ctl/adapters/providers/grok/adapter.py

@@ -308,7 +308,6 @@ def create_provider() -> ProviderSpec:
                 "executor",
                 "verifier",
                 "report-writer",
-                "translator",
             )
         },
         wrapper="okstra-grok-exec.sh",

package/runtime/python/okstra_ctl/adapters/providers/kimi/adapter.py

@@ -104,7 +104,6 @@ def create_provider() -> ProviderSpec:
             "executor": "kimi-k3",
             "verifier": "kimi-k3",
             "report-writer": "kimi-k3",
-            "translator": "kimi-k3",
         },
         wrapper="okstra-kimi-exec.sh",
         supported_roles=ALL_ROLE_TOKENS,

package/runtime/python/okstra_ctl/agent/invocation.py

@@ -39,7 +39,6 @@ AgentAudience = Literal[
     "scope-critic",
     "acceptance-critic",
     "report-writer",
-    "translator",
     "code-reviewer",
     "schedule-verifier",
     "business-flow-investigator",
@@ -604,7 +603,7 @@ def load_role_duty_contract(duty_root: Path, audience: AgentAudience) -> DutyCon
 def digest_duty_catalog(duty_root: Path) -> str:
     """Return the canonical digest of every contract file in a snapshot.
 
-    역할 계약은 하위 `roles/` 에 둔다 — `report-writer` 와 `translator` 는 직무
+    역할 계약은 하위 `roles/` 에 둔다 — `report-writer` 는 직무
     id 이면서 역할 id 라, 한 폴더에 두면 두 계약이 같은 파일 이름을 두고 겹친다.
     """
     names = [

package/runtime/python/okstra_ctl/agent/prompt_cli/cli.py

@@ -114,8 +114,8 @@ def _add_materialize_parser(commands: argparse._SubParsersAction) -> None:
     )
     materialize.add_argument(
         "--audit-source",
-        help=run_only + "; accepted only for report-writer and translator, whose "
-             "result is not their own worker result",
+        help=run_only + "; accepted only for report-writer, whose result is "
+             "not its own worker result",
     )
     materialize.add_argument("--host-runtime", help=standalone_only)
     materialize.add_argument("--execution-runner", choices=("cli-wrapper",), help=standalone_only)

package/runtime/python/okstra_ctl/agent/prompt_cli/jobs.py

@@ -81,8 +81,6 @@ def _metadata_job(
     if metadata.get("executionIdentityVersion") != 2 or metadata["dispatchKind"] != dispatch_kind:
         raise AgentPromptCliError(f"{metadata_path}: expected v2 dispatchKind {dispatch_kind!r}")
     execution = next(row for row in manifest["roleExecutions"] if row["roleExecutionRef"] == metadata["roleExecutionRef"])
-    if execution["role"] == "translator":
-        raise AgentPromptCliError("translator uses canonical reservation dispatch: worker-dispatch --workers translator")
     prompt = _project_input(project, metadata["prompt"]["path"], "prompt")
     anchors = prompt_anchor_values(prompt, ("Result Path", "Worker Result Path"))
     result = anchors.get("Worker Result Path") or anchors.get("Result Path")

package/runtime/python/okstra_ctl/agent/prompt_cli/materialize.py

@@ -99,7 +99,7 @@ _AUDIENCES = frozenset(get_args(AgentAudience))
 # 결과 파일과 별개의 워커 결과 포인터를 가진 audience. 이들만 `--audit-source` 로
 # 두 번째 경로를 받고, 프롬프트에 `**Worker Result Path:**` 앵커가 생긴다.
 # 나머지 audience 의 결과는 하나뿐이고 감사 사이드카는 그 이름에서 파생된다.
-_POINTER_AUDIENCES = frozenset({"report-writer", "translator"})
+_POINTER_AUDIENCES = frozenset({"report-writer"})
 
 
 def _materialize(args: argparse.Namespace) -> PreparedAgentInvocation:
@@ -196,7 +196,7 @@ def _materialize_run(
                 "the same path in the jobs file's workerResultPath"
             )
         audit_source_path = result_path
-    elif args.audience == "report-writer":
+    else:
         if audit_source_path is None:
             # The report writer is the one audience whose result path is not its
             # own worker result: it writes the report body, while the audit
@@ -234,31 +234,6 @@ def _materialize_run(
             result_path=result_path,
             audit_source_path=audit_source_path,
         )
-    elif (
-        audit_source_path is None
-        or _normalized(audit_source_path) == _normalized(result_path)
-    ):
-        # translator 다. report-writer 와 같은 두-경로 audience 인데 종전엔 빠진
-        # `--audit-source` 를 `--result` 로 조용히 접었다. 그러면 프롬프트에
-        # `**Worker Result Path:**` 앵커가 안 생기는데, `worker-dispatch` 는 그
-        # 앵커가 `**Result Path:**` 와 다를 것을 요구하므로 발행은 되지만 어떤
-        # 디스패치도 받지 못하는 예약이 남는다. 예약은 회수 명령이 없어 리드가
-        # 두 번째 id 로 다시 만드는 순간 "exactly one reservation" 이 영영
-        # 깨졌다(2026-09-08 실측, fontsninja-v3-site dev-10627-2
-        # requirements-discovery). 발행 시점에 거절한다.
-        raise AgentPromptCliError(
-            "translator materialization requires --audit-source distinct from "
-            "--result: --result is the translator's own report "
-            "(e.g. worker-results/translator-translations-<task-type>-<seq>.md) "
-            "and --audit-source the worker-result .md the audit sidecar is "
-            "derived from (worker-results/translator-worker-<task-type>-<seq>.md). "
-            "`worker-dispatch --workers translator` reads both from the prompt's "
-            "**Result Path:** and **Worker Result Path:** anchors and refuses a "
-            "prompt without the second. To fix a prompt already published "
-            "without it, re-run this command with the same --invocation-id and "
-            "--prompt plus --replace-undispatched; a new invocation id would "
-            "leave two reservations and block the translator for this run"
-        )
     _validate_run_identity(
         manifest,
         worker_id=args.worker_id,

package/runtime/python/okstra_ctl/agent/prompt_cli/run_identity.py

@@ -29,10 +29,6 @@ def _validate_run_identity(
         expected = "lead"
         if worker_id != "lead":
             raise AgentPromptCliError("lead assignment requires worker ID 'lead'")
-    elif assignment_ref == "translator":
-        expected = "translator"
-        if worker_id != "translator":
-            raise AgentPromptCliError("translator assignment requires worker ID 'translator'")
     elif assignment_ref.startswith("critic/"):
         scope = assignment_ref.split("/", 1)[1]
         expected = CRITIC_DUTY_BY_ASSIGNMENT_SEGMENT.get(scope, "")