okstra 0.219.0 → 0.219.1

package/runtime/python/okstra_ctl/stage_rebase.py

@@ -0,0 +1,189 @@
+"""선행 기준이 이동한 단계 브랜치를 의존 순서로 재배치한다."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from . import consumers, worktree_registry
+from .stage_targets import (
+    StageWorktreeIdentity,
+    order_stage_closure,
+    resolve_stage_base_commit,
+)
+from .worktree import is_ancestor
+from .worktree.rebase import _checked_git, rebase_stage_branch
+
+
+def _rebase_completed_stage(
+    project_root: Path,
+    plan_run_root: Path,
+    identity: StageWorktreeIdentity,
+    row: dict,
+    done_row: dict,
+    base: str,
+) -> dict:
+    number, branch = row["stage"], row["branch"]
+    tip = _checked_git(project_root, "rev-parse", f"refs/heads/{branch}")
+    if tip != done_row.get("head_commit"):
+        raise RuntimeError(
+            f"stage {number} branch moved beyond its done commit; reconcile it before rebasing"
+        )
+    head = rebase_stage_branch(project_root, branch, row["base_ref"], base)
+    worktree_registry.update_stage_base(
+        identity.project_id,
+        identity.task_group,
+        identity.task_id,
+        number,
+        expected_base=row["base_ref"],
+        base_ref=base,
+    )
+    consumers.append_consumer(
+        plan_run_root,
+        impl_task_key=done_row["impl_task_key"],
+        stage=number,
+        status="done",
+        force_reappend=True,
+        head_commit=head,
+        replaced_commit=tip,
+        reconciled=True,
+        reconcile_reason="dependency-rebase",
+        report_path=done_row.get("report_path", ""),
+    )
+    return {**done_row, "head_commit": head}
+
+
+def _refresh_predecessor_head(
+    root: Path,
+    plan: Path,
+    row: dict,
+    done_row: dict,
+    active: bool,
+) -> dict:
+    tip = _checked_git(root, "rev-parse", f"refs/heads/{row['branch']}")
+    previous = done_row["head_commit"]
+    if tip == previous:
+        return done_row
+    if active or not is_ancestor(root, previous, tip):
+        raise RuntimeError(
+            f"predecessor stage {row['stage']} is active or rewritten; finish or reconcile it first"
+        )
+    consumers.append_consumer(
+        plan,
+        impl_task_key=done_row["impl_task_key"],
+        stage=row["stage"],
+        status="done",
+        force_reappend=True,
+        head_commit=tip,
+        replaced_commit=previous,
+        reconciled=True,
+        reconcile_reason="predecessor-advance",
+        report_path=done_row.get("report_path", ""),
+    )
+    return {**done_row, "head_commit": tip}
+
+
+def synchronize_stage_stack(
+    *,
+    project_root: Path,
+    plan_run_root: Path,
+    stage_map: list[dict],
+    identity: StageWorktreeIdentity,
+) -> list[int]:
+    """호출자가 task-key provision 잠금을 잡은 상태에서 실행한다."""
+    rows = consumers.read_consumers(plan_run_root)
+    done = consumers.latest_done_by_stage(rows)
+    statuses = consumers.last_lifecycle_status_by_stage(rows)
+    anchor = (
+        worktree_registry.get_implementation_base(
+            identity.project_id,
+            identity.task_group,
+            identity.task_id,
+        )
+        or ""
+    )
+    graph = [(s["stage_number"], s.get("depends_on") or []) for s in stage_map]
+    order = order_stage_closure(graph, {n for n, _ in graph}, set())
+    if len(order) != len(graph):
+        raise RuntimeError("cannot synchronize a cyclic Stage Map")
+    by_number = {s["stage_number"]: s for s in stage_map}
+    predecessors = {dep for _, deps in graph for dep in deps}
+    changed = []
+    for number in order:
+        row = worktree_registry.get_stage_row(
+            identity.project_id,
+            identity.task_group,
+            identity.task_id,
+            number,
+        )
+        stage = by_number[number]
+        if not row or number not in done or stage.get("cancelled"):
+            continue
+        active = statuses.get(number) == "started" or row.get("status") == "active"
+        if _synchronize_recorded_stage(
+            project_root,
+            plan_run_root,
+            identity,
+            stage,
+            row,
+            done,
+            anchor,
+            active,
+            number in predecessors,
+        ):
+            changed.append(number)
+    return changed
+
+
+def _synchronize_recorded_stage(
+    root: Path,
+    plan: Path,
+    identity: StageWorktreeIdentity,
+    stage: dict,
+    row: dict,
+    done: dict[int, dict],
+    anchor: str,
+    active: bool,
+    predecessor: bool,
+) -> bool:
+    number = stage["stage_number"]
+    previous = done[number]["head_commit"]
+    if predecessor:
+        done[number] = _refresh_predecessor_head(root, plan, row, done[number], active)
+    if stage.get("depends_on"):
+        done[number] = _synchronize_dependent(
+            root,
+            plan,
+            identity,
+            stage,
+            row,
+            done,
+            anchor,
+            active,
+        )
+    return previous != done[number]["head_commit"]
+
+
+def _synchronize_dependent(
+    root: Path,
+    plan: Path,
+    identity: StageWorktreeIdentity,
+    stage: dict,
+    row: dict,
+    done: dict[int, dict],
+    anchor: str,
+    active: bool,
+) -> dict:
+    number = stage["stage_number"]
+    base = resolve_stage_base_commit(
+        stage,
+        list(done.values()),
+        anchor,
+        project_root=root,
+        plan_run_root=plan,
+        identity=identity,
+    )
+    if row["base_ref"] == base:
+        return done[number]
+    if active:
+        raise RuntimeError(f"cannot rebase active stage {number}; finish its run first")
+    return _rebase_completed_stage(root, plan, identity, row, done[number], base)

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/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`.