okstra 0.218.0 → 0.219.1

package/runtime/python/okstra_ctl/worker_prompt_policy.py

@@ -13,7 +13,6 @@ PromptAudience = Literal[
     "implementation-executor",
     "implementation-verifier",
     "report-writer",
-    "translator",
     "reverify",
     "lead-only",
 ]
@@ -84,7 +83,6 @@ WORKER_PREAMBLE_FILENAME_BY_AUDIENCE = {
     "implementation-executor": "implementation-worker-preamble.md",
     "implementation-verifier": "implementation-worker-preamble.md",
     "report-writer": "report-writer-prompt-preamble.md",
-    "translator": "translator-prompt-preamble.md",
 }
 WORKER_ERROR_CONTRACT_FILENAME = "worker-error-contract.md"
 # coverage-critic gap 검증 라운드의 dispatch kind. 번호 라운드(`reverify-r<N>`)와
@@ -199,7 +197,7 @@ def resolve_prompt_plan(
     """Resolve prompt policy from the worker's role and the dispatch kind.
 
     Neither the worker id nor the provider or model identity takes part. The id
-    used to: `report-writer`, `translator`, and "the executor's worker id" were
+    used to: `report-writer` and "the executor's worker id" were
     compared by spelling, so a verifier that happened to share the executor's
     id received the executor's prompt.
     """
@@ -210,12 +208,6 @@ def resolve_prompt_plan(
         # 걸리지 않아 분석 계획으로 떨어졌고, 리드 프롬프트가 분석 워커 직무를
         # 달고 나갔다.
         return _plan("lead-only")
-    if dispatch_kind == "translator":
-        if role not in (None, "translator"):
-            raise ValueError(f"translator dispatch cannot run role {role}")
-        return _plan("translator", duty_audience="translator")
-    if role == "translator":
-        raise ValueError("translator role requires the translator dispatch kind")
     if is_verification_dispatch_kind(dispatch_kind):
         return _plan("reverify")
     # A critic pass keeps the full analysis contract — worker anchor headers, the
@@ -307,8 +299,8 @@ def resolve_prompt_plan_for_manifest(
     """Resolve policy from the manifest's task type and the worker's roster role.
 
     *worker_id* is the lookup key into `workerAssignments`; its spelling decides
-    nothing. A worker with no roster row — the translator, or a verification
-    pass whose kind alone decides — resolves with no role.
+    nothing. A worker with no roster row — a verification pass whose kind
+    alone decides — resolves with no role.
     """
     task_type = _required_string(manifest, "taskType")
     if not worker_id.strip():
@@ -383,7 +375,6 @@ def _duty_audience(audience: PromptAudience) -> AgentAudience:
         "implementation-executor": "implementation-executor",
         "implementation-verifier": "implementation-verifier",
         "report-writer": "report-writer",
-        "translator": "translator",
         "reverify": "reverification-worker",
         "lead-only": "lead",
     }[audience]

package/runtime/python/okstra_ctl/worktree/__init__.py

@@ -34,7 +34,7 @@ Side effects:
 `sync_config`(무엇을 옮길지), `git_ops`(git 사실) — 은 서로를 모른다. 그 위에
 `cleanliness`(무엇이 더러운가) · `linking`(실제로 링크 걸기) ·
 `decisions`(무엇이 일어날지 미리 답하기)가 있고, 부수 효과를 내는 것은
-`provision` 하나뿐이다. 이 파일은 밖으로 나가는 이름만 모아 둔다.
+`provision` 과 단계 브랜치를 재배치하는 `rebase` 뿐이다. 이 파일은 밖으로 나가는 이름만 모아 둔다.
 """
 from __future__ import annotations
 

package/runtime/python/okstra_ctl/worktree/decisions.py

@@ -118,10 +118,9 @@ def _stage_entry_is_reusable(entry: worktree_registry.WorktreeEntry) -> bool:
     the fix-run case: a stage whose verifier returned FAIL records a `failed`
     consumers row, which frees the occupancy but deliberately keeps the worktree
     and its branch as the reviewable stack. Re-entry MUST reuse that tree —
-    provisioning anew refuses on the existing path and branch. After whole-task
-    final-verification removes the directory the entry stops being reusable, so
-    the stage provisions from scratch.
+    provisioning anew refuses on the existing branch. A removed directory is
+    restored from that branch on the next implementation or verification entry.
     """
     if entry.status == "active":
         return True
-    return entry.status == "released" and Path(entry.worktree_path).is_dir()
+    return entry.status == "released"

package/runtime/python/okstra_ctl/worktree/provision.py

@@ -13,6 +13,7 @@ from pathlib import Path
 
 from .. import worktree_registry
 from .decisions import preview_worktree_decision, resolve_stage_worktree_decision
+from .rebase import rebase_stage_branch
 from .git_ops import (
     _branch_exists,
     _branch_exists_message,
@@ -259,6 +260,21 @@ def provision_task_worktree(
     )
 
 
+def restore_stage_worktree(project_root: Path, path: str, branch: str) -> None:
+    target = Path(path)
+    if target.exists():
+        return
+    root = main_worktree_path(project_root)
+    target.parent.mkdir(parents=True, exist_ok=True)
+    result = _git(root, "worktree", "add", str(target), branch)
+    if result.returncode:
+        raise RuntimeError(f"cannot restore stage worktree {target}: {result.stderr.strip()}")
+    _link_sync_dirs(root, target)
+    _link_sync_files(root, target)
+    _copy_snapshot_files(root, target)
+    _seed_worktree_settings_symlink(target)
+
+
 def provision_stage_worktree(
     *,
     project_root: Path,
@@ -298,6 +314,17 @@ def provision_stage_worktree(
         stage_number=stage_number,
     )
     if decision.status == "reused":
+        restore_stage_worktree(project_root, decision.path, decision.branch)
+        resolved_base = _resolve_commit_sha(project_root, base_commit)
+        if not resolved_base:
+            raise RuntimeError(f"could not resolve base_commit `{base_commit}`")
+        if decision.base_ref != resolved_base:
+            rebase_stage_branch(project_root, decision.branch, decision.base_ref, resolved_base)
+            worktree_registry.update_stage_base(
+                project_id, task_group_segment, task_id_segment, stage_number,
+                expected_base=decision.base_ref, base_ref=resolved_base,
+            )
+            decision.base_ref = resolved_base
         drift = _sync_key_drift_note(
             main_worktree_path(project_root),
             worktree_registry.lookup(

package/runtime/python/okstra_ctl/worktree/rebase.py

@@ -0,0 +1,108 @@
+"""단계 브랜치 하나를 새 기준 위로 재배치하는 git 작업.
+
+`provision` 의 재진입 경로와 `stage_rebase` 의 의존 순서 재배치가 함께 쓴다.
+"""
+from __future__ import annotations
+
+import tempfile
+from collections.abc import Iterator
+from contextlib import contextmanager
+from pathlib import Path
+
+from .cleanliness import is_dirty_excluding_okstra
+from .git_ops import _git, is_ancestor
+
+
+def _checked_git(root: Path, *args: str) -> str:
+    result = _git(root, *args)
+    if result.returncode:
+        raise RuntimeError(f"git {' '.join(args)} failed: {result.stderr.strip()}")
+    return result.stdout.strip()
+
+
+@contextmanager
+def _stage_worktree(project_root: Path, branch: str) -> Iterator[Path]:
+    worktrees = _checked_git(project_root, "worktree", "list", "--porcelain")
+    holder = None
+    current = None
+    for line in worktrees.splitlines():
+        if line.startswith("worktree "):
+            current = Path(line.removeprefix("worktree "))
+        elif line == f"branch refs/heads/{branch}":
+            holder = current
+    if holder is not None and is_dirty_excluding_okstra(holder):
+        raise RuntimeError(
+            f"cannot rebase {branch}: worktree {holder} has uncommitted changes"
+        )
+    temporary = holder is None
+    if temporary:
+        holder = Path(tempfile.mkdtemp(prefix="okstra-rebase-"))
+        holder.rmdir()
+        _checked_git(project_root, "worktree", "add", str(holder), branch)
+    try:
+        yield holder
+    finally:
+        if temporary:
+            # 복구에 실패한 작업 트리는 삭제하지 않는다.
+            states = ["rebase-merge", "rebase-apply"]
+            if not any(
+                Path(_checked_git(holder, "rev-parse", "--git-path", state)).exists()
+                for state in states
+            ):
+                _checked_git(project_root, "worktree", "remove", str(holder))
+
+
+def rebase_stage_branch(
+    project_root: Path,
+    branch: str,
+    old_base: str,
+    new_base: str,
+) -> str:
+    old = _checked_git(project_root, "rev-parse", f"{old_base}^{{commit}}")
+    new = _checked_git(project_root, "rev-parse", f"{new_base}^{{commit}}")
+    head = _checked_git(project_root, "rev-parse", f"refs/heads/{branch}")
+    if old == new:
+        return head
+    if not is_ancestor(project_root, old, head):
+        raise RuntimeError(
+            f"cannot rebase {branch}: recorded base {old} is not an ancestor"
+        )
+    with _stage_worktree(project_root, branch) as holder:
+        for state in ["rebase-merge", "rebase-apply", "MERGE_HEAD", "CHERRY_PICK_HEAD"]:
+            path = Path(_checked_git(holder, "rev-parse", "--git-path", state))
+            if path.exists():
+                raise RuntimeError(
+                    f"cannot rebase {branch}: unfinished git operation at {path}"
+                )
+        _checked_git(
+            project_root,
+            "update-ref",
+            f"refs/okstra/rebase-backups/{branch}/{head}",
+            head,
+        )
+        return _apply_rebase(holder, branch, old, new)
+
+
+def _apply_rebase(holder: Path, branch: str, old: str, new: str) -> str:
+    result = _git(
+        holder,
+        "rebase",
+        "--no-autostash",
+        "--no-autosquash",
+        "--no-update-refs",
+        "--no-rebase-merges",
+        "--onto",
+        new,
+        old,
+    )
+    if result.returncode:
+        abort = _git(holder, "rebase", "--abort")
+        detail = (result.stderr or result.stdout).strip()
+        if abort.returncode:
+            raise RuntimeError(
+                f"rebase failed for {branch}; recovery worktree: {holder}; {detail}; abort: {abort.stderr}"
+            )
+        raise RuntimeError(
+            f"rebase failed for {branch}; original branch restored: {detail}"
+        )
+    return _checked_git(holder, "rev-parse", "HEAD")

package/runtime/python/okstra_ctl/worktree_registry.py

@@ -310,6 +310,20 @@ def get_stage_row(
         return data["tasks"].get(key)
 
 
+def update_stage_base(
+    project_id: str, task_group: str, task_id: str, stage: int, *,
+    expected_base: str, base_ref: str,
+) -> None:
+    key = task_key(project_id, task_group, task_id, stage)
+    with _registry_lock():
+        data = _load()
+        row = data["tasks"].get(key)
+        if row is None or row.get("base_ref") != expected_base:
+            raise RuntimeError(f"stage base changed concurrently: {key}")
+        row["base_ref"] = base_ref
+        _save(data)
+
+
 def list_active_stage_numbers(
     project_id: str, task_group: str, task_id: str,
 ) -> set:

package/runtime/skills/_fragments/wizard-render-bundle.md

@@ -10,7 +10,7 @@ Output: `{ok: true, outcome: {renderArgv: ["--lead-runtime", "...", ...], render
 
 `renderArgv` is the canonical ordered `okstra render-bundle` argument list. Pass its tokens verbatim and in order. Repeated `--role-count` and `--role-model` flags are intentional. `renderArgs` is a compatibility and inspection view only; do not reconstruct an invocation from it. `orchestration` holds signals this skill acts on itself — never pass its entries to `render-bundle`.
 
-`userAuthorization`, when present, preserves the confirmation prompt actually emitted by this wizard and the relayed `proceed` response. Its `--user-authorization-json` token carries that record into the run manifest; preserve it unchanged. Do not synthesize a receipt for older confirmed states. Include the translator's disclosed provider/model and report material when citing this record in host execution requests, including `report-finalize`. The record documents task scope; it does not grant host execution privileges.
+`userAuthorization`, when present, preserves the confirmation prompt actually emitted by this wizard and the relayed `proceed` response. Its `--user-authorization-json` token carries that record into the run manifest; preserve it unchanged. Do not synthesize a receipt for older confirmed states. The record documents task scope; it does not grant host execution privileges.
 
 Before retrying a worker in an existing run, inspect its last invocation attempt: await running work; append an attempt only after `failed-no-mutation` within the retry budget. Preserve every other terminal attempt. `okstra team dispatch` routes the legacy declaration-only implementer failure to a separate same-model evidence-recovery invocation; collect its result before independent verification. Other terminal failures need `okstra agent-prompt materialize` with a new `--invocation-id`, distinct `--prompt`/`--result` paths, and unchanged assignment/model for a bounded correction. Do not restart completed implementation or request renewed approval for unchanged scope. Enforcement: `dispatch_core._next_attempt` and `execution_manifest._validate_next_attempt`.
 

package/runtime/skills/okstra-code-review/SKILL.md

@@ -167,7 +167,7 @@ Axis scope — each reviewer works all four axes; the `Reads` column names each
 | `structural` | non-test source file × `structural` | core principles 1, 2, 3, 6; `clean-code.md` DRY / KISS / SOLID / YAGNI; the completion sweep's domain-literal and documented-fork items; plus the architecture pack when one was routed |
 | `semantic` | function × `semantic` | core principles 4, 5; `clean-code.md` meaningful naming, functions-do-one-thing, the plain-English summary test, the 50-line cap, nesting depth, magic numbers, comments-explain-why |
 | `state-and-tests` | non-test source file × `state-and-tests`, test file × `state-and-tests` | `clean-code.md` "Mutation and state boundaries" and "Testing discipline"; plus the routed language pack's self-mock signals |
-| `general` | non-test source file × `general` | correctness bugs, swallowed errors, security, clear performance problems, core principle 7 (fix at the cause — nothing previously green edited to silence a failure); `clean-code.md` "Wrapping a third-party call" — a recovery branch the library already performs, a comment naming a condition the call site never establishes, a rethrow that drops the original error; plus the routed language pack's language-specific traps |
+| `general` | non-test source file × `general` | correctness bugs, swallowed errors, `clean-code.md` "Untrusted input and security" (work that grows faster than the input before a size bound rejects it, input building SQL / shell / paths / fetch targets / templates / regexes, a new entry point without auth or ownership checks, secrets or personal data in code, logs or responses, evaluating input), clear performance problems, core principle 7 (fix at the cause — nothing previously green edited to silence a failure); `clean-code.md` "Wrapping a third-party call" — a recovery branch the library already performs, a comment naming a condition the call site never establishes, a rethrow that drops the original error; plus the routed language pack's language-specific traps |
 
 Say it plainly in every brief: **the census is law** — work the cells exactly as given, return a verdict for every one, never re-derive the list. There is no length budget; dropping a finding to stay brief is the failure this skill exists to prevent.
 

package/runtime/skills/okstra-discussion/SKILL.md

@@ -223,7 +223,7 @@ Output: `{ok: true, outcome: {renderArgv: ["--lead-runtime", "...", ...], render
 
 `renderArgv` is the canonical ordered `okstra render-bundle` argument list. Pass its tokens verbatim and in order. Repeated `--role-count` and `--role-model` flags are intentional. `renderArgs` is a compatibility and inspection view only; do not reconstruct an invocation from it. `orchestration` holds signals this skill acts on itself — never pass its entries to `render-bundle`.
 
-`userAuthorization`, when present, preserves the confirmation prompt actually emitted by this wizard and the relayed `proceed` response. Its `--user-authorization-json` token carries that record into the run manifest; preserve it unchanged. Do not synthesize a receipt for older confirmed states. Include the translator's disclosed provider/model and report material when citing this record in host execution requests, including `report-finalize`. The record documents task scope; it does not grant host execution privileges.
+`userAuthorization`, when present, preserves the confirmation prompt actually emitted by this wizard and the relayed `proceed` response. Its `--user-authorization-json` token carries that record into the run manifest; preserve it unchanged. Do not synthesize a receipt for older confirmed states. The record documents task scope; it does not grant host execution privileges.
 
 Before retrying a worker in an existing run, inspect its last invocation attempt: await running work; append an attempt only after `failed-no-mutation` within the retry budget. Preserve every other terminal attempt. `okstra team dispatch` routes the legacy declaration-only implementer failure to a separate same-model evidence-recovery invocation; collect its result before independent verification. Other terminal failures need `okstra agent-prompt materialize` with a new `--invocation-id`, distinct `--prompt`/`--result` paths, and unchanged assignment/model for a bounded correction. Do not restart completed implementation or request renewed approval for unchanged scope. Enforcement: `dispatch_core._next_attempt` and `execution_manifest._validate_next_attempt`.
 

package/runtime/skills/okstra-pr-gen/SKILL.md

@@ -95,6 +95,15 @@ carry. release-handoff drafts its PR bodies from the same rules.
 
 ### A4. Output and offer to create the PR
 
+Write the title and body to a temp file and check them:
+
+```bash
+okstra pr check --body-file <path-to-body>
+```
+
+Each printed `L<line>: <pattern>: <match>` row is an okstra identifier a reviewer cannot open:
+restate that line in the reviewer's terms and check again. `clean` means none is left.
+
 Print the filled PR body to chat as a single fenced markdown block. Then ask the
 user whether to open a real PR. Only on an explicit yes:
 

package/runtime/skills/okstra-run/SKILL.md

@@ -256,7 +256,7 @@ Output: `{ok: true, outcome: {renderArgv: ["--lead-runtime", "...", ...], render
 
 `renderArgv` is the canonical ordered `okstra render-bundle` argument list. Pass its tokens verbatim and in order. Repeated `--role-count` and `--role-model` flags are intentional. `renderArgs` is a compatibility and inspection view only; do not reconstruct an invocation from it. `orchestration` holds signals this skill acts on itself — never pass its entries to `render-bundle`.
 
-`userAuthorization`, when present, preserves the confirmation prompt actually emitted by this wizard and the relayed `proceed` response. Its `--user-authorization-json` token carries that record into the run manifest; preserve it unchanged. Do not synthesize a receipt for older confirmed states. Include the translator's disclosed provider/model and report material when citing this record in host execution requests, including `report-finalize`. The record documents task scope; it does not grant host execution privileges.
+`userAuthorization`, when present, preserves the confirmation prompt actually emitted by this wizard and the relayed `proceed` response. Its `--user-authorization-json` token carries that record into the run manifest; preserve it unchanged. Do not synthesize a receipt for older confirmed states. The record documents task scope; it does not grant host execution privileges.
 
 Before retrying a worker in an existing run, inspect its last invocation attempt: await running work; append an attempt only after `failed-no-mutation` within the retry budget. Preserve every other terminal attempt. `okstra team dispatch` routes the legacy declaration-only implementer failure to a separate same-model evidence-recovery invocation; collect its result before independent verification. Other terminal failures need `okstra agent-prompt materialize` with a new `--invocation-id`, distinct `--prompt`/`--result` paths, and unchanged assignment/model for a bounded correction. Do not restart completed implementation or request renewed approval for unchanged scope. Enforcement: `dispatch_core._next_attempt` and `execution_manifest._validate_next_attempt`.
 

package/runtime/skills/okstra-setup/SKILL.md

@@ -169,8 +169,8 @@ matching section:
 - **D. PR body template** (release-handoff) — opt-in pre-registration; also
   offered on the first release-handoff run.
 - **E. final report language** (`reportLanguage`) — a language tag (`en`,
-  `ko`, `fr`, …); default `en`. The Phase 7 translator translates the human
-  HTML into it.
+  `ko`, `fr`, …); default `en`. The report writer writes the report prose
+  directly in it.
 - **F. declared architecture style** (`architecture.style`) — `hexagonal` /
   `layered` / `none`; hand-added, default `none`. Declaring one makes that
   architecture's placement rules binding in planning + verification.

package/runtime/skills/okstra-setup/references/project-config.md

@@ -196,8 +196,8 @@ per-run override prompt during the next release-handoff run.
 
 ## E. Final report language (`reportLanguage`)
 
-The value is a language tag (`en`, `ko`, `fr`, `pt-BR`, …). The data.json
-stays English; the Phase 7 translator translates the human HTML into the tag.
+The value is a language tag (`en`, `ko`, `fr`, `pt-BR`, …). The report writer
+writes the report prose directly in that language; no translation step runs.
 If you skip, no `reportLanguage` field is written and the runtime uses `en`.
 
 AskUserQuestion (fixed options):

package/runtime/templates/pr/drafting-rules.md

@@ -30,3 +30,7 @@
 
    When the only source for a claim is such an artifact, restate its substance in the reviewer's
    terms — what changed in the code, and why — instead of citing the id.
+
+   Check the drafted title and body with `okstra pr check --body-file <file>` from the repository:
+   it prints each line that still carries one of these identifiers, skipping terms the
+   repository's own tracked files use.

package/runtime/templates/report-writer-prompt-preamble.md

@@ -30,7 +30,7 @@ The narrative is not free-form Markdown. A narrative file is the line `# OKSTRA
 
 Blank lines are ignored. **Every other line is rejected**, including Markdown headings (`#`, `##`, `###`), a pipe table written at column 0, code fences, bare paragraphs, JSON, YAML, and JSON Pointer. A heading or table that belongs in the reader's report is written as the text of a `> ` value, never as a narrative line of its own.
 
-Follow the task-specific schema order and write the prose in English.
+Follow the task-specific schema order. Write every `> ` prose value directly in the language named by `**Report Language:**`; do not draft in English first, because no translation step follows. Field names, `Verdict Token` and other enum or status values, finding and requirement ids, paths, symbols, commands, and model names stay exactly as the schema and sources spell them.
 
 ### Top-level fields you may author
 

package/runtime/templates/reports/html/i18n/en.json

@@ -184,7 +184,6 @@
       "implementer": "Implementer",
       "planner": "Planner",
       "report-writer": "Report writer",
-      "translator": "Translator",
       "verifier": "Verifier"
     },
     "requirementStatus": {

package/runtime/templates/reports/html/i18n/ko.json

@@ -184,7 +184,6 @@
       "implementer": "구현",
       "planner": "계획",
       "report-writer": "리포트 작성",
-      "translator": "번역",
       "verifier": "검증"
     },
     "requirementStatus": {

package/runtime/templates/worker-prompt-preamble.md

@@ -2,7 +2,7 @@
 
 This file is the audience-specific contract for initial `analysis` workers. Read it end-to-end from the path selected by the dispatch prompt. Before doing work, also read the shared file named by `**Worker Error Contract Path:**`; that file is the only source for error-sidecar rules.
 
-Your identity is the stored role execution (`executionLabel`). Canonical roles are `leader`, `analyser`, `critic`, `designer`, `planner`, `implementer`, `verifier`, `report-writer`, and `translator`. `lead` and `executor` are compatibility aliases only.
+Your identity is the stored role execution (`executionLabel`). Canonical roles are `leader`, `analyser`, `critic`, `designer`, `planner`, `implementer`, `verifier`, and `report-writer`. `lead` and `executor` are compatibility aliases only.
 
 ## Required reading
 

package/runtime/validators/validate-run.py

@@ -230,7 +230,6 @@ from okstra_ctl.workflow import (  # noqa: E402
 )
 from okstra_ctl.final_report_paths import (  # noqa: E402
     final_report_data_path as _data_path_for,
-    translation_sidecar_path,
 )
 from okstra_token_usage.report import _match_worker_index  # noqa: E402
 from okstra_ctl.phases.requirements_discovery.validation import (
@@ -3328,7 +3327,7 @@ _CITATION_LIST_KEYS = ("evidenceRefs", "supportingEvidence", "falsifyingEvidence
 
 def _prose_pointers(node: object, key: str = "", pointer: str = "") -> list[tuple[str, str]]:
     """(JSON pointer, value) for every string under a reader-facing prose key."""
-    from okstra_ctl.report_translation import PROSE_KEYS
+    from okstra_ctl.report_prose_keys import PROSE_KEYS
 
     out: list[tuple[str, str]] = []
     if isinstance(node, dict):
@@ -4685,29 +4684,6 @@ def _validate_improvement_discovery(
             failures.append(f"improvement-discovery: {err}")
 
 
-def _validate_translation_sidecar(
-    data: Mapping[str, Any], report_path: Path, failures: list[str]
-) -> None:
-    """영어가 아닌 사람 HTML 은 번역 사이드카가 있어야 한다.
-
-    사이드카가 없으면 렌더러가 크롬만 번역하고 본문은 영어로 남긴다.
-    `render-views` 가 그 조합을 거부하고, 여기가 같은 규칙의 두 번째 게이트다.
-    """
-    if not data:
-        return
-    lang = str((data.get("meta") or {}).get("reportLanguage") or "en")
-    if lang == "en":
-        return
-    sidecar = translation_sidecar_path(report_path, lang)
-    if not sidecar.is_file():
-        failures.append(
-            f"final-report has reportLanguage {lang!r} but no translation "
-            f"sidecar at {sidecar.name}. The human HTML rendered from the "
-            "English source instead; re-run `report-finalize --only translate "
-            "--only render-views` to dispatch the translator and overlay it."
-        )
-
-
 def _validate_session_conformance(
     team_state: dict,
     team_state_path: Path,
@@ -6003,9 +5979,6 @@ def main() -> int:
         ),
     )
     validation_data = report_data if isinstance(report_data, Mapping) else {}
-    _validate_translation_sidecar(
-        validation_data, _data_path_for(report_path), failures
-    )
     validate_report(
         report_path,
         failures,

package/runtime/agents/operations/report-translation.json

@@ -1,6 +0,0 @@
-{
-  "schemaVersion": "1.0",
-  "id": "report-translation",
-  "dutyId": "translator",
-  "count": 1
-}

package/runtime/agents/roles/translator.json

@@ -1,19 +0,0 @@
-{
-  "schemaVersion": "1.0",
-  "id": "translator",
-  "legacyAliases": [],
-  "identity": "Renders the report's reader-facing text in another language without editing the underlying decision.",
-  "responsibilities": [
-    "Carry the source's precision, uncertainty, and operational force into the target language.",
-    "Preserve identifiers, paths, commands, and status tokens exactly as the source writes them."
-  ],
-  "requiredCapabilities": [
-    "extended-artifact-authoring",
-    "source-readonly",
-    "worker-artifact-io"
-  ],
-  "prohibitions": [
-    "Do not edit the source, translate an unassigned file, or add analysis of your own.",
-    "Do not strengthen or weaken a normative statement in translation."
-  ]
-}