okstra 0.219.0 → 0.219.1

package/runtime/python/okstra_ctl/report_finalize.py

@@ -25,14 +25,6 @@ placeholders, which a v2 report never carries because its numeric cells are
 `null` until this step fills them. Substituting the tokens on a later retry
 then leaves the already-rendered html stale for `validators/validate-report-views.py`.
 
-The translation sidecar is the `translate` step, directly before `render-views`,
-which overlays it. It used to be a manual lead sequence outside this command (materialize the translator
-prompt, dispatch it, resume finalize at `render-views`), written only in a doc
-the lead lazy-reads; a lead that ran the whole sequence at once skipped it and
-the run kept an English view under a `ko` report (2026-09-09, fontsninja-v3-site
-dev-10628-3). `okstra_ctl.report_translation_dispatch` owns the step; an English
-report or an existing sidecar makes it a no-op.
-
 Every lead adapter drives Phase 7 through this module: the Codex adapter calls
 it in-process (``codex_dispatch``), and a Claude-led run reaches the same code
 through the ``okstra report-finalize`` CLI. Neither reimplements the sequence.
@@ -69,12 +61,11 @@ from .handoff_error import HandoffError
 from .paths import RunRef, task_dir, task_manifest_file
 from .report_view_artifacts import html_view_path
 from .release_gate import release_handoff_allowed
-from .report_translation_dispatch import TranslateOutcome, translate_report
 from .json_boundary import JsonBoundaryError, load_owned_object, write_owned_object_atomic
 from .stage_integrate import IntegrateError
 from .stage_targets import (
     StageTargetError,
-    integrate_and_teardown_whole_task,
+    teardown_completed_stage_worktrees,
 )
 from .session import observe_lead_session
 from .lead_progress import record_checkpoint
@@ -92,7 +83,6 @@ from okstra_project.phase_pointer import (
 
 
 STEP_PROJECT_ACTIVITY = "project-activity"
-STEP_TRANSLATE = "translate"
 STEP_TOKEN_USAGE = "token-usage"
 STEP_RENDER_VIEWS = "render-views"
 STEP_SPAWN_FOLLOWUPS = "spawn-followups"
@@ -105,7 +95,6 @@ STEP_PRUNE_RUN_ARTIFACTS = "prune-run-artifacts"
 
 STEP_ORDER = (
     STEP_PROJECT_ACTIVITY,
-    STEP_TRANSLATE,
     STEP_TOKEN_USAGE,
     STEP_RENDER_VIEWS,
     STEP_SPAWN_FOLLOWUPS,
@@ -124,8 +113,6 @@ V3_STEP_ORDER = (
     STEP_TOKEN_USAGE,
     STEP_PROJECT_ACTIVITY,
     STEP_PREFLIGHT,
-    # Before the render that overlays its sidecar.
-    STEP_TRANSLATE,
     STEP_RENDER_VIEWS,
     STEP_SPAWN_FOLLOWUPS,
     # Needs the assembled record; `validate-run` requires the row it writes.
@@ -341,10 +328,6 @@ def build_commands(ctx: FinalizeContext) -> list[tuple[str, list[str]]]:
                 str(ctx.data_path),
             ],
         ),
-        (
-            STEP_TRANSLATE,
-            ["<in-process>", "translate", str(ctx.data_path)],
-        ),
         (
             STEP_TOKEN_USAGE,
             [
@@ -571,38 +554,53 @@ def _teardown_stage_worktrees(
     ctx: FinalizeContext,
     command: list[str],
 ) -> subprocess.CompletedProcess:
-    """판정이 릴리스로 향할 때만 stage worktree 와 registry 키를 정리한다.
-
-    whole-task 진입이 통합만 하고 정리를 남겨두므로(`stage_targets`), 정리는 판정이
-    나온 뒤인 여기서 한다. `blocked` 이거나 릴리스를 막는 조건이 남은 판정에서는
-    stage 작업물을 그대로 둬서 재작업이 바로 이어지게 한다. 이미 정리된 뒤 재실행돼도
-    같은 결과를 낸다 — 병합은 `already_merged` 로, 없는 worktree 는 건너뛴다.
-    """
+    """검증된 보고서와 완료 기록이 일치하는 단계 작업 트리를 회수한다."""
     def _done(payload: Mapping[str, Any]) -> subprocess.CompletedProcess:
         return subprocess.CompletedProcess(command, 0, json.dumps(payload), "")
 
-    if ctx.task_type != "final-verification":
-        return _done({"skipped": "not a final-verification run"})
+    if ctx.task_type not in {"implementation", "final-verification"}:
+        return _done({"skipped": "not an implementation or final-verification run"})
     try:
         data = load_owned_object(Path(ctx.data_path), artifact="final report record")
     except JsonBoundaryError as exc:
         return subprocess.CompletedProcess(
             command, 1, "", f"cannot read final-report data.json: {exc}")
-    if data.get("verificationScope") != "whole-task":
-        return _done({"skipped": "single-stage verification owns no teardown"})
-    if not release_handoff_allowed(data):
+    if ctx.task_type == "final-verification" and not release_handoff_allowed(data):
         return _done({"skipped": "verdict does not clear the work for release"})
+    heads = _stage_cleanup_heads(ctx.task_type, data)
+    if heads == {}:
+        return _done({"skipped": "report names no completed stage commit"})
     try:
-        result = integrate_and_teardown_whole_task(
+        result = teardown_completed_stage_worktrees(
             project_root=ctx.project_root,
             task_group=ctx.task_group,
             task_id=ctx.task_id,
+            expected_heads=heads,
         )
-    except (IntegrateError, StageTargetError, OSError) as exc:
+    except (IntegrateError, StageTargetError, JsonBoundaryError, OSError) as exc:
         return subprocess.CompletedProcess(command, 1, "", str(exc))
     return _done(result)
 
 
+def _stage_cleanup_heads(task_type: str, data: Mapping[str, Any]) -> dict[int, str] | None:
+    if task_type == "implementation":
+        implementation = data.get("implementation") or {}
+        evidence = implementation.get("stageSidecarEvidence") or {}
+        stage = evidence.get("stageNumber")
+        commits = implementation.get("commitList") or []
+        head = commits[-1].get("fullSha", "") if commits else ""
+        return {stage: head} if isinstance(stage, int) and head and not evidence.get("withheld") else {}
+    if data.get("verificationScope") == "whole-task":
+        return None
+    verification = data.get("finalVerification") or {}
+    stages = verification.get("stageReports") or []
+    head = (verification.get("sourceImplementationReport") or {}).get("capturedHeadSha", "")
+    if data.get("verificationScope") == "single-stage" and len(stages) == 1 and head:
+        stage = stages[0].get("stage")
+        return {stage: head} if isinstance(stage, int) else {}
+    return {}
+
+
 def _prune_run_artifacts(
     ctx: FinalizeContext,
     command: list[str],
@@ -684,8 +682,6 @@ def run_finalize(
     if only:
         selected = set(only)
         if ctx.report_contract_version == "3.0":
-            if STEP_TRANSLATE in selected:
-                selected.add(STEP_PREFLIGHT)
             if selected - {STEP_TOKEN_USAGE}:
                 # 부분 재개도 이전 조립본이 아닌 현재 소유자 입력을 소비한다.
                 selected.add(STEP_PROJECT_ACTIVITY)
@@ -799,7 +795,6 @@ def _execute_finalize_steps(
                     if consumer != STEP_TOKEN_USAGE or ctx.report_contract_version != "3.0":
                         blocked[consumer] = name
             elif name == STEP_PREFLIGHT:
-                blocked[STEP_TRANSLATE] = name
                 blocked[STEP_SPAWN_FOLLOWUPS] = name
             elif name == STEP_RENDER_VIEWS:
                 blocked[STEP_VALIDATE_RUN] = name
@@ -865,8 +860,6 @@ def _finalize_recovery(ctx: FinalizeContext, result: Mapping[str, Any]) -> dict[
             "Repair the reported causes in this run using the owning input's correction command, "
             "then execute resumeCommand. Preserve approvals, model choices and completed evidence. "
             "If plan content changes, re-verify the affected items before finalizing. "
-            "After a narrative correction, check existing translations with report-translate check-data "
-            "and regenerate them if their source no longer matches. "
             "Ask only for an unresolved user decision or an actual external prerequisite."
         ),
     }
@@ -1018,8 +1011,6 @@ def _run_finalize_step(
     """한 Phase 7 단계를 실행하고 그 단계의 종료 코드만 돌려준다."""
     if name == STEP_PROJECT_ACTIVITY:
         return _run_project_activity(ctx, command)
-    if name == STEP_TRANSLATE:
-        return _run_translate(ctx, command)
     if name == STEP_TEARDOWN_STAGES:
         return _teardown_stage_worktrees(ctx, command)
     if name == STEP_PRUNE_RUN_ARTIFACTS:
@@ -1043,31 +1034,6 @@ def _run_finalize_step(
     )
 
 
-def _run_translate(
-    ctx: FinalizeContext,
-    command: Sequence[str],
-) -> subprocess.CompletedProcess[str]:
-    """비영어 리포트의 번역 사이드카를 만든다. 영어 리포트는 건너뛴다.
-
-    실패는 다른 단계처럼 기록만 하고 시퀀스는 계속 돈다 — `render-views` 는
-    사이드카 없이 영어 열람본을 내고, `validate-run` 은 권고를 남기며, 결과의
-    `--only translate --only render-views …` 재개 힌트가 그 둘을 다시 돌린다.
-    """
-    try:
-        outcome = translate_report(
-            project_root=ctx.project_root,
-            workspace_root=ctx.workspace_root,
-            manifest_path=ctx.manifest_path,
-            manifest=_load_manifest(ctx.manifest_path),
-            data_path=ctx.data_path,
-        )
-    except (FinalizeError, OSError, JsonBoundaryError) as exc:
-        outcome = TranslateOutcome(1, "", f"translate failed: {exc}")
-    return subprocess.CompletedProcess(
-        command, outcome.returncode, outcome.stdout, outcome.stderr
-    )
-
-
 def _run_project_activity(
     ctx: FinalizeContext,
     command: Sequence[str],
@@ -1206,18 +1172,13 @@ _CLI_EPILOG = r"""Usage:
 Runs the Phase 7 steps in their contractual order against one final-report:
 
   1. project-activity  project the run's activity events into the data.json
-  2. 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
-  3. token-usage       substitute real token/cost numbers into the data.json
-  4. render-views      write the schema-v2 task-specific *.html sibling with
-                       the translation overlaid; v1 keeps the
-                       legacy conditional interactive view
-  5. spawn-followups   turn section 4 rows into task stubs
-  6. validate-run      validate the finished run artifacts
-  7. record-group-memory / 8. teardown-stages  after a clean validation
-  9. prune-run-artifacts  remove node_modules and .next under this run
+  2. token-usage       substitute real token/cost numbers into the data.json
+  3. render-views      write the schema-v2 task-specific *.html sibling;
+                       v1 keeps the legacy conditional interactive view
+  4. spawn-followups   turn section 4 rows into task stubs
+  5. validate-run      validate the finished run artifacts
+  6. record-group-memory / 7. teardown-stages  after a clean validation
+  8. prune-run-artifacts  remove node_modules and .next under this run
                        directory, and the dispatch snapshots and publication
                        locks of a validated run; runs after a failure too
 

package/runtime/python/okstra_ctl/report_html/render.py

@@ -3,16 +3,14 @@ from __future__ import annotations
 
 import hashlib
 import json
-import sys
 from pathlib import Path
 
 import okstra_vendor  # noqa: F401  # registers vendored dependency aliases
 from jinja2 import Environment, StrictUndefined, select_autoescape
 
-from ..final_report_paths import final_report_data_path, translation_sidecar_path
+from ..final_report_paths import final_report_data_path
 from ..final_report_schema import load_schema_for_data, validate
 from ..i18n import HTML_DICTIONARY_REL, load_dictionary, make_jinja_global
-from ..report_translation import overlay
 from ..report_view_artifacts import user_responses_dir_for_report
 from ..usage_cells import format_duration_ms
 from ..json_boundary import load_owned_object
@@ -76,44 +74,8 @@ def _report_meta(data: dict, run_meta: HtmlRunMeta) -> dict[str, object]:
     }
 
 
-def _localize(data: dict, data_path: Path) -> tuple[dict, str]:
-    """이 리포트 언어의 번역 사이드카를 메모리 복사본에 덮어쓴다.
-
-    data.json 은 영어 정본이고 고치지 않는다. 사람이 읽는 HTML 만 독자 언어다.
-    사이드카가 빠진 포인터는 영어로 남긴다.
-
-    사이드카 파일 자체가 없으면 요청 언어를 버리고 전부 영어로 렌더한다.
-    종전에는 여기서 렌더를 거부했다 — 크롬만 번역된 반쪽 페이지를 내보내지
-    않겠다는 이유였고, 그 판단 자체는 옳다. 틀린 것은 남은 선택지였다: 번역
-    워커가 못 도는 이유(호스트 승인 게이트, 공급자 부재)는 리포트의 품질과
-    무관한데, 거부는 열람본을 통째로 없애고 `validate-run` 이 그 부재를 차단
-    실패로 삼아 run 을 `contract-violated` 로 끝냈다 — 분석도 리포트도 끝난
-    run 이 그렇게 끝났다(2026-09-08 FontsNinja/app/jobs dev-10784
-    error-analysis). 언어를 낮추면 크롬과 본문이 같은 영어라 반쪽 페이지도
-    아니고, 독자는 읽을 것을 갖는다. 번역이 나중에 도착하면 다시 렌더해
-    덮어쓴다.
-    """
-    lang = str((data.get("meta") or {}).get("reportLanguage") or "en")
-    if lang == "en":
-        return data, lang
-    sidecar_file = translation_sidecar_path(data_path, lang)
-    if not sidecar_file.is_file():
-        sys.stdout.write(
-            f"no {lang} translation sidecar at {sidecar_file.name}; "
-            "rendering the English source\n"
-        )
-        return data, "en"
-    payload = load_owned_object(sidecar_file, artifact="translation sidecar")
-    strings = payload.get("strings")
-    if not isinstance(strings, dict):
-        raise HtmlRenderError(f"translation sidecar has no 'strings' object: {sidecar_file}")
-    localized, report = overlay(data, strings)
-    sys.stdout.write(
-        f"translated {report.applied} string(s) into {lang}"
-        f" ({len(report.untranslated)} left in English"
-        f", {len(report.unresolved)} unresolved)\n"
-    )
-    return localized, lang
+def _report_language(data: dict) -> str:
+    return str((data.get("meta") or {}).get("reportLanguage") or "en")
 
 
 def _html_path(data_path: Path) -> Path:
@@ -140,9 +102,7 @@ def render_v2_html_view(
     errors = validate(data, load_schema_for_data(data))
     if errors:
         raise HtmlRenderError("invalid v2 final-report data: " + "; ".join(errors[:5]))
-    # Validate the SSOT, then localize — the sidecar carries presentation and
-    # has no say in whether the report is well-formed.
-    data, lang = _localize(data, data_path)
+    lang = _report_language(data)
     route = resolve_html_route(run_meta.task_type)
     view = route.view_builder(data)
     root = _templates_root(templates_root)

package/runtime/python/okstra_ctl/report_language.py

@@ -6,9 +6,9 @@ the run manifest, which report assembly copies into `meta.reportLanguage` and
 the HTML renderer reads. When only the prompt called this, a project could ask
 for `ko`, get a Korean-instructed writer, and still ship an English report.
 
-The value is a language tag (`en`, `ko`, `fr`, `pt-BR`, …). The Phase 7
-translator receives that tag and translates into it; nothing here knows any
-particular language. Precedence: project config → global config → `en`.
+The value is a language tag (`en`, `ko`, `fr`, `pt-BR`, …). The report writer
+authors the report prose in that language; nothing here knows any particular
+language. Precedence: project config → global config → `en`.
 """
 from __future__ import annotations
 

package/runtime/python/okstra_ctl/report_prose_keys.py

@@ -0,0 +1,153 @@
+"""Final-report leaf keys whose values a reader reads as prose and nothing else.
+
+A value under one of these keys is displayed text; ids, enum values, paths and
+anchor targets live under other keys.
+"""
+from __future__ import annotations
+
+PROSE_KEYS = frozenset({
+    "acceptance",
+    "action",
+    "actions",
+    "addedWork",
+    "alternativesConsidered",
+    "answer",
+    "approach",
+    "approvalDisposition",
+    "approvalEvidence",
+    "architectureBoundaries",
+    "assumptions",
+    "behavior",
+    "blastRadius",
+    "blockReason",
+    "blockedReason",
+    "blockers",
+    "body",
+    "boundary",
+    "briefEvidence",
+    "canonical",
+    "carryIn",
+    "causeSummary",
+    "change",
+    "check",
+    "claim",
+    "commitment",
+    "complexity",
+    "condition",
+    "confirmingSignal",
+    "conformanceExemption",
+    "consequences",
+    "constraint",
+    "context",
+    "coreMechanism",
+    "coreReason",
+    "counterevidence",
+    "decision",
+    "decisions",
+    "declinedFixRecommendations",
+    "description",
+    "details",
+    "directionChange",
+    "disagreement",
+    "discrepancy",
+    "disproveWith",
+    "environmentSetup",
+    "escalationTrigger",
+    "evidence",
+    "evidenceRequired",
+    "exemptionReaffirm",
+    "exemptionReason",
+    "exitContract",
+    "exitContractSummary",
+    "expected",
+    "expectedBehaviorAfter",
+    "expectedChangeAreas",
+    "expectedForm",
+    "expectedOutcome",
+    "expectedResult",
+    "expectedVerification",
+    "explanation",
+    "fact",
+    "failureHandling",
+    "falsifyingEvidenceChecked",
+    "finalConclusion",
+    "goal",
+    "guardrails",
+    "headline",
+    "howToStart",
+    "hypothesis",
+    "ifStillOpen",
+    "injectedAs",
+    "interfaces",
+    "item",
+    "justification",
+    "knownFacts",
+    "label",
+    "mitigation",
+    "motivation",
+    "name",
+    "need",
+    "nextStep",
+    "noVariationRationale",
+    "notApplicableReason",
+    "note",
+    "observableFailure",
+    "observed",
+    "option",
+    "outcome",
+    "outputSummary",
+    "performed",
+    "planItem",
+    "position",
+    "problem",
+    "question",
+    "rationale",
+    "readyWhen",
+    "reason",
+    "rejectedSummary",
+    "rejectingSignal",
+    "relation",
+    "replacedInTest",
+    "replacedWith",
+    "requestKind",
+    "requiredDecision",
+    "requiredWork",
+    "requirement",
+    "resolution",
+    "responsibility",
+    "reversibility",
+    "risk",
+    "rolloutCost",
+    "routingRecommendation",
+    "satisfaction",
+    "scope",
+    "selfFixNote",
+    "sliceValue",
+    "stageTitle",
+    "stageValidation",
+    "statement",
+    "suggestedAction",
+    "summary",
+    "supersededStatement",
+    "symptom",
+    "systemInterpretation",
+    "testCaseBoundary",
+    "testCaseFailure",
+    "testCaseSuccess",
+    "testCoverageCost",
+    "text",
+    "title",
+    "topic",
+    "trigger",
+    "triggerSignal",
+    "unblockCondition",
+    "userChoice",
+    "userConstraints",
+    "userInput",
+    "userText",
+    "verification",
+    "verificationMethod",
+    "verificationSignal",
+    "whyItMatters",
+    "workingAssumption",
+})

package/runtime/python/okstra_ctl/report_synthesis_packet.py

@@ -866,7 +866,7 @@ def _attempt_result_specs(
         for row in invocations_value
         if isinstance(row, Mapping) and _string(row.get("invocationRef"))
     }
-    excluded_duties = {"lead", "report-writer", "translator"}
+    excluded_duties = {"lead", "report-writer"}
     specs: list[tuple[str, str, str, bool]] = []
     seen: set[str] = set()
     for attempt in attempts_value:

package/runtime/python/okstra_ctl/run.py

@@ -1896,19 +1896,12 @@ def _build_static_execution_manifest(
     plan: AssignmentPlan,
     context: AssignmentContext,
     lead: ResolvedAssignment,
-    translator: ResolvedAssignment,
 ) -> ExecutionManifest:
     participants: list[ParticipantAssignment] = []
     roles: list[RoleExecution] = []
-    # The translator is resolved outside the role plan, like the lead, and both
-    # are named in `invocationAssignments`. Without a role execution here,
-    # `agent-prompt materialize --audience translator` has no canonical
-    # identity to bind to and refuses — so a `reportLanguage: ko` run could
-    # never write its translation sidecar and rendered the English source.
     assignments = (
         lead,
         *(row for row in plan.assignments if row.role != "leader"),
-        translator,
     )
     for index, assignment in enumerate(assignments, start=1):
         participant_ref = f"participant-{index:03d}"
@@ -2387,7 +2380,6 @@ class _ModelBindings:
     lead_assignment: RoleAssignment
     worker_assignments: tuple[RoleAssignment, ...]
     invocation_assignments: dict[str, dict[str, object]]
-    translator: ResolvedAssignment
 
 
 @dataclass(frozen=True)
@@ -2622,13 +2614,6 @@ def _project_model_bindings(
         if executor_rows
         else None
     )
-    translator = _model_for_role(
-        context=context,
-        provider=report_writer.provider_id,
-        raw_value=report_writer.model_id,
-        role="translator",
-        duty_id="translator",
-    )
     projections = {
         provider: _legacy_projection_from_plan(provider, plan, context)
         for provider in ("claude", "codex", "antigravity")
@@ -2637,7 +2622,6 @@ def _project_model_bindings(
         lead_assignment,
         workers,
         critic_assignment,
-        _role_assignment(resolved=translator, role="translator"),
         inp.task_type,
     )
     worker_by_provider = {row.provider: row for row in workers}
@@ -2668,7 +2652,6 @@ def _project_model_bindings(
         lead_assignment=lead_assignment,
         worker_assignments=workers,
         invocation_assignments=invocation_assignments,
-        translator=translator,
     )
 
 
@@ -2759,7 +2742,6 @@ def _build_invocation_assignments(
     lead: RoleAssignment,
     workers: tuple[RoleAssignment, ...],
     critic: RoleAssignment | None,
-    translator: RoleAssignment,
     task_type: str,
 ) -> dict[str, dict[str, object]]:
     assignments = {"lead": lead.to_model_payload()}
@@ -2776,7 +2758,6 @@ def _build_invocation_assignments(
         # role 라벨을 만들기 때문에 두 행의 이름이 겹쳐 validate-run 이
         # `duplicate worker role detected` 로 런을 실패시킨다.
         assignments[critic_assignment_ref(task_type)] = critic.to_model_payload()
-    assignments["translator"] = translator.to_model_payload()
     return assignments
 
 
@@ -3660,7 +3641,7 @@ def _allowed_agent_audiences(
     inp: PrepareInputs,
     models: _ModelBindings,
 ) -> list[str]:
-    audiences = {"lead", "translator"}
+    audiences = {"lead"}
     if models.worker_assignments:
         audiences.add("reverification-worker")
     if any(item.worker_id == "report-writer" for item in models.worker_assignments):
@@ -4162,7 +4143,6 @@ def prepare_task_bundle(inp: PrepareInputs) -> PrepareOutputs:
         assignment_plan,
         assignment_context,
         models.lead,
-        models.translator,
     )
     dynamic_roles = tuple(
         requirement.role

package/runtime/python/okstra_ctl/stage_integrate.py

@@ -283,8 +283,14 @@ def _teardown_all(project_id, task_group, task_id, task_wt: str,
 
 def _remove_clean_worktree(task_wt: str, wt: str, stage_n: int) -> tuple[str, str] | None:
     """clean stage worktree 를 물리 제거. dirty/실패면 (outcome, detail), 성공이면 None."""
-    from .worktree import is_dirty_excluding_okstra, remove_worktree_force
-
+    from .worktree import (
+        is_dirty_excluding_okstra,
+        nested_worktree_excludes,
+        remove_worktree_force,
+    )
+
+    if nested_worktree_excludes(wt):
+        return ("skipped", "nested worktrees remain — preserved")
     if is_dirty_excluding_okstra(wt):
         return ("skipped", "dirty — 미커밋 변경 보존")
     rm = remove_worktree_force(task_wt, wt)
@@ -293,6 +299,35 @@ def _remove_clean_worktree(task_wt: str, wt: str, stage_n: int) -> tuple[str, st
     return None
 
 
+def reclaim_completed_stage(
+    project_root: Path, project_id: str, task_group: str, task_id: str,
+    stage: int, expected_head: str, done: dict | None, status: str,
+) -> tuple[str, str]:
+    from . import worktree_registry
+    from .worktree import main_worktree_path
+
+    row = worktree_registry.get_stage_row(project_id, task_group, task_id, stage)
+    if not row:
+        return "skipped", "stage worktree is not registered"
+    if status != "done" or row.get("status") == "active":
+        return "skipped", "stage is unfinished or active"
+    if not expected_head or (done or {}).get("head_commit") != expected_head:
+        return "skipped", "completion commit does not match this report"
+    tip = _git(project_root, "rev-parse", "--verify", f"refs/heads/{row['branch']}")
+    if tip.returncode or tip.stdout.strip() != expected_head:
+        return "skipped", "stage branch moved after completion"
+    wt = Path(row["worktree_path"])
+    if wt.resolve() == main_worktree_path(project_root).resolve():
+        return "skipped", "main worktree is preserved"
+    if wt.exists():
+        current = _git(wt, "symbolic-ref", "--short", "HEAD")
+        if current.returncode or current.stdout.strip() != row["branch"]:
+            return "skipped", "worktree no longer holds the registered stage branch"
+    return _teardown_stage(
+        project_id, task_group, task_id, str(project_root), stage, row, expected_head,
+    )
+
+
 def _unmerged_branch_tip_warning(task_wt: str, stage_n: int, branch: str,
                                  verified_head: str = "") -> str:
     """Warn text when the stage branch tip is not an ancestor of the commit