okstra 0.219.0 → 0.220.0

package/runtime/python/okstra_ctl/stage_targets.py

@@ -831,76 +831,43 @@ def containing_stage(project_root: Path,
     return single_containing_head(project_root, heads)
 
 
-def integrate_and_teardown_whole_task(
+def teardown_completed_stage_worktrees(
     *, project_root: Path, task_group: str, task_id: str,
+    expected_heads: dict[int, str] | None = None,
 ) -> dict[str, Any]:
-    """판정이 끝난 whole-task 검증의 stage worktree 와 registry 키를 회수한다.
-
-    진입은 통합만 하고 정리를 남겨 두므로(`phases/final_verification/target.py`), 정리는
-    판정 뒤인 Phase 7 에서 여기로 들어온다. 통합은 이미 끝나 있어 Phase A 는 전부
-    `already_merged` 로 지나가고 Phase B 만 실제 일을 한다. 두 번 불려도 결과는 같다 —
-    사라진 worktree 는 건너뛰고, 미커밋 변경이 남은 stage 트리는 보존한다.
-
-    stage_map 은 done 행에서 만든다. 정리 대상은 완료된 stage 뿐이고, 계획에만 있고
-    완료되지 않은 stage 는 Phase A 가 어차피 건너뛰기 때문이다.
-    """
+    """완료된 단계의 작업 트리만 회수하고 브랜치와 기준 기록은 보존한다."""
     from okstra_project.dirs import okstra_home, project_json_path
 
-    from . import consumers, worktree_registry
+    from . import consumers
     from .json_boundary import load_owned_object
     from .locks import worktree_provision_mutex
     from .paths import task_runs_dir
-    from .stage_integrate import integrate_stages
+    from .stage_integrate import reclaim_completed_stage
 
-    try:
-        project_id = load_owned_object(
-            project_json_path(project_root), artifact="project config"
-        ).get("projectId", "")
-    except (OSError, ValueError):
-        project_id = ""
+    config = project_json_path(project_root)
+    if not config.is_file():
+        return {"skipped": "project.json is missing"}
+    project_id = load_owned_object(config, artifact="project config").get("projectId", "")
     if not project_id:
         return {"skipped": "project.json declares no projectId"}
-
-    plan_run_root = task_runs_dir(
-        project_root, task_group, task_id
-    ) / "implementation-planning"
-    done_rows = [
-        row for row in consumers.read_consumers(plan_run_root)
-        if row.get("status") == "done"
-    ]
-    if not done_rows:
-        return {"skipped": "no done stage rows to reclaim"}
-    stage_map = [
-        {"stage_number": stage}
-        for stage in sorted(consumers.latest_done_by_stage(done_rows))
-    ]
-
-    entry = worktree_registry.lookup(project_id, task_group, task_id)
-    if entry is None:
-        return {"skipped": "task worktree is no longer registered"}
-
-    done_by_stage = consumers.latest_done_by_stage(done_rows)
-    tip = containing_stage(project_root, done_by_stage)
+    plan = task_runs_dir(project_root, task_group, task_id) / "implementation-planning"
+    removed, skipped, warnings = [], [], []
     with worktree_provision_mutex(okstra_home(), project_id, task_group, task_id):
-        result = integrate_stages(
-            project_id=project_id,
-            task_group=task_group,
-            task_id=task_id,
-            task_worktree_path=entry.worktree_path,
-            stage_map=stage_map,
-            done_rows=done_rows,
-            teardown=True,
-            # 한 stage 브랜치가 이미 전체를 담고 있으면 검증은 거기서 돌았다
-            # (`phases/final_verification/target.py`). 그 경우 task 브랜치로의 머지는 아무도
-            # 읽지 않는 산출물이므로 정리만 한다.
-            merge=tip is None,
-            verified_head=(done_by_stage.get(tip) or {}).get("head_commit", ""),
-        )
-    return {
-        "tornDown": result.torn_down,
-        "teardownSkipped": [
-            {"stage": stage, "reason": reason}
-            for stage, reason in result.teardown_skipped
-        ],
-        "warnings": result.warnings,
-    }
+        rows = consumers.read_consumers(plan)
+        done = consumers.latest_done_by_stage(rows)
+        statuses = consumers.last_lifecycle_status_by_stage(rows)
+        heads = expected_heads if expected_heads is not None else {
+            stage: row.get("head_commit", "") for stage, row in done.items()
+        }
+        for stage, head in sorted(heads.items()):
+            outcome, detail = reclaim_completed_stage(
+                project_root, project_id, task_group, task_id, stage, head,
+                done.get(stage), statuses.get(stage, ""),
+            )
+            if outcome == "torn_down":
+                removed.append(stage)
+            elif outcome == "skipped":
+                skipped.append({"stage": stage, "reason": detail})
+            else:
+                warnings.append(detail)
+    return {"tornDown": removed, "teardownSkipped": skipped, "warnings": warnings}

package/runtime/python/okstra_ctl/team.py

@@ -228,12 +228,7 @@ def _record_dispatch(args, manifest: Mapping[str, Any], prepared) -> list[str]:
 
 
 def team_dispatch_port(manifest: Mapping[str, Any]) -> WorkerDispatchPort:
-    """이 run 의 워커를 띄울 포트. cmux run 이면 pane, 아니면 리드 호스트의 포트.
-
-    `team dispatch` 와 finalize 의 `translate` 단계가 같이 쓴다 — 번역자만
-    CLI 래퍼 디스패처로 띄우던 동안 cmux run 에서도 번역자는 pane 없이 돌았다
-    (실측 2026-09-22, dev-10860 implementation-planning-001: 18건 중 번역자 1건).
-    """
+    """이 run 의 워커를 띄울 포트. cmux run 이면 pane, 아니면 리드 호스트의 포트."""
     lead_runtime = _require_string(manifest, "leadRuntime")
     fallback_port = default_host_registry().resolve(
         lead_runtime

package/runtime/python/okstra_ctl/wizard/confirmation.py

@@ -333,14 +333,6 @@ def confirmation_block(state: WizardState) -> str:
         lines.append(f"  pr-template   : {state.pr_template_path} ({state.pr_template_scope or 'once'})")
     if state.fix_cycle:
         lines.append(f"  fix-cycle     : {state.fix_cycle}")
-    report_writer_models = state.role_models.get("report-writer", [])
-    translator_model = (
-        report_writer_models[0] if report_writer_models
-        else "(selection required)"
-    )
-    lines.append(_msg(
-        state.workspace_root, "confirmation", "translation_scope", model=translator_model,
-    ))
     lines.append(_msg(
         state.workspace_root, "confirmation", "provider_data_scope",
         project_root=state.project_root,

package/runtime/python/okstra_ctl/wizard/registry.py

@@ -93,10 +93,10 @@ from .state import (
 from .prompts import _opt, _p
 from .sources import (
     _brief_resolved,
+    _clarification_pick_required,
     _has_prior_run_inputs,
     _latest_implementation_planning_report,
     _reverify_scope_pick_required,
-    _suggest_latest_final_report,
 )
 from .roles import _clear_role_selection, _reset_role_selection_from, next_role_prompt
 from .steps_identity import (
@@ -535,8 +535,7 @@ STEPS: list[Step] = [
     Step(S_CLARIFICATION_PICK,
          applies=lambda s: (S_CLARIFICATION_PICK not in s.answered
                             and _identity_ready(s)
-                            and (s.task_type != "implementation-planning"
-                                 or bool(_suggest_latest_final_report(s)))),
+                            and _clarification_pick_required(s)),
          build=_build_clarification_pick, submit=_submit_clarification_pick,
          owns=("clarification_response_path", "clarification_pending_text")),
     Step(S_CLARIFICATION,

package/runtime/python/okstra_ctl/wizard/sources.py

@@ -600,6 +600,16 @@ def _latest_run_inputs(
         phase_segment=phase_segment)
 
 
+def _clarification_pick_required(state: WizardState) -> bool:
+    if state.task_type == "release-handoff":
+        report = _suggest_latest_final_report(state)
+        return bool(report and sidecar_answers(Path(state.project_root) / report))
+    return (
+        state.task_type != "implementation-planning"
+        or bool(_suggest_latest_final_report(state))
+    )
+
+
 def _carried_planning_report(state: WizardState) -> Optional[Path]:
     """이번 재실행이 이어받는 직전 implementation-planning 리포트 (없으면 None)."""
     if state.task_type != "implementation-planning":

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/schemas/final-report-v3.0.schema.json

@@ -1355,6 +1355,14 @@
             "$ref": "#/$defs/LeadFixRow"
           }
         },
+        "correctionRounds": {
+          "type": "array",
+          "description": "Correction rounds run in this run after a verifier FAIL (`_implementation-deliverable.md` \"Correction round\"): each sends the executor a bounded fix and the verifiers a re-verification. `verifierResults` holds the last round's verdicts; earlier FAIL verdicts stay here. Optional so reports of tasks already in flight keep validating.",
+          "maxItems": 2,
+          "items": {
+            "$ref": "#/$defs/CorrectionRoundRow"
+          }
+        },
         "rollbackVerification": {
           "type": "array",
           "minItems": 1,
@@ -10159,6 +10167,76 @@
         }
       }
     },
+    "CorrectionRoundRow": {
+      "type": "object",
+      "description": "One correction round: the findings it fixed, the executor's commit range, and each verifier's re-verification verdict.",
+      "required": [
+        "round",
+        "findingIds",
+        "baseCommit",
+        "commit",
+        "verifierVerdicts",
+        "result"
+      ],
+      "additionalProperties": false,
+      "properties": {
+        "round": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 2
+        },
+        "findingIds": {
+          "type": "array",
+          "minItems": 1,
+          "items": {
+            "type": "string",
+            "minLength": 1
+          }
+        },
+        "baseCommit": {
+          "description": "Stage HEAD before the round.",
+          "type": "string",
+          "pattern": "^[0-9a-f]{7,40}$"
+        },
+        "commit": {
+          "description": "Stage HEAD after the executor's fix.",
+          "type": "string",
+          "pattern": "^[0-9a-f]{7,40}$"
+        },
+        "verifierVerdicts": {
+          "type": "array",
+          "minItems": 1,
+          "items": {
+            "type": "object",
+            "required": [
+              "verifier",
+              "verdict"
+            ],
+            "additionalProperties": false,
+            "properties": {
+              "verifier": {
+                "type": "string",
+                "minLength": 1
+              },
+              "verdict": {
+                "enum": [
+                  "PASS",
+                  "CONCERNS",
+                  "FAIL"
+                ]
+              }
+            }
+          }
+        },
+        "result": {
+          "description": "`pass` when no re-verification verdict is FAIL.",
+          "enum": [
+            "pass",
+            "fail"
+          ]
+        }
+      }
+    },
     "LeadFixRow": {
       "type": "object",
       "description": "One lead minor fix: the verifier findings it answers, the commit that carries it, and the re-run checks that decide whether the run may settle the stage. `changedLines` has no schema maximum on purpose: an over-limit fix must still be recordable, and `_validate_lead_fixes` reports it.",

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-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-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/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": {
@@ -679,6 +678,12 @@
       "lead-fix-changed-lines": "Changed lines",
       "lead-fix-result-pass": "checks pass",
       "lead-fix-result-fail": "checks still fail",
+      "correction-rounds": "Corrected within this run",
+      "correction-rounds-intro": "Verifiers rejected the change. Instead of starting a fix run, the executor fixed the confirmed findings in this run and the verifiers checked the fix again.",
+      "correction-round": "Round",
+      "correction-range": "Fix range",
+      "correction-result-pass": "re-verification passed",
+      "correction-result-fail": "re-verification failed",
       "entry-count": "{count} entries",
       "manual-user-test": "Manual user test",
       "environment": "Environment:",

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

@@ -184,7 +184,6 @@
       "implementer": "구현",
       "planner": "계획",
       "report-writer": "리포트 작성",
-      "translator": "번역",
       "verifier": "검증"
     },
     "requirementStatus": {
@@ -679,6 +678,12 @@
       "lead-fix-changed-lines": "바뀐 줄 수",
       "lead-fix-result-pass": "검사 통과",
       "lead-fix-result-fail": "검사 여전히 실패",
+      "correction-rounds": "이 run 안에서 고친 것",
+      "correction-rounds-intro": "검증자가 변경을 거부했습니다. fix run 을 새로 여는 대신 이 run 안에서 실행자가 확인된 finding 을 고치고, 검증자가 그 수정을 다시 검증했습니다.",
+      "correction-round": "라운드",
+      "correction-range": "수정 범위",
+      "correction-result-pass": "재검증 통과",
+      "correction-result-fail": "재검증 실패",
       "entry-count": "{count}개 항목",
       "manual-user-test": "수동 사용자 테스트",
       "environment": "환경:",