okstra 0.186.7 → 0.187.0

package/runtime/python/okstra_ctl/model_pool.py

@@ -118,12 +118,16 @@ class ModelPool:
         )
 
     def list_catalog(self, *, role: str | None = None) -> tuple[ResolvedModel, ...]:
-        canonical_role = self._normalize_role(role) if role else None
-        return tuple(
-            model
-            for model in self._models.values()
-            if self._supports_role(model, canonical_role)
-        )
+        """Every registered row, selectable or not — the listing marks which.
+
+        Filtering this by availability made it identical to `list()` whenever a
+        role was given, so a hidden model became invisible in the one surface
+        meant to explain why it is hidden. `role` is still validated so an
+        unknown role fails here exactly as it does in `list()`.
+        """
+        if role:
+            self._normalize_role(role)
+        return tuple(self._models.values())
 
     def resolve(self, model_ref: str) -> ResolvedModel:
         try:

package/runtime/python/okstra_ctl/models.py

@@ -50,12 +50,6 @@ def lead_launch_spec(provider: str) -> LeadLaunchSpec:
     return spec.lead_launch
 
 
-def bare_lead_launch_argv(provider: str) -> list[str]:
-    """Start this provider CLI with only the flags required by Okstra."""
-    launch = lead_launch_spec(provider)
-    return [launch.executable, *launch.sandbox_waiver]
-
-
 def lead_launch_argv(
     provider: str,
     *,
@@ -160,11 +154,17 @@ def default_model(role: str) -> Optional[str]:
 
 
 def catalog_pricing(provider: str) -> dict:
-    """Selectable-model pricing as input, cached-input, output USD per million."""
+    """Catalog pricing as input, cached-input, output USD per million.
+
+    Every registered row, not only the selectable ones: a model hidden from the
+    picker is still what past runs were billed at, and dropping its rate here
+    silently re-prices that history through the coarser substring fallback in
+    `okstra_token_usage.pricing`.
+    """
     provider_id = provider.strip().lower()
     return {
         model.model_ref.model_id: model.pricing
-        for model in _model_pool().list()
+        for model in _model_pool().list_catalog()
         if model.provider_id == provider_id and model.pricing is not None
     }
 

package/runtime/python/okstra_ctl/mutation_recovery.py

@@ -6,8 +6,11 @@ from pathlib import Path
 from typing import Any, Literal, Mapping, Sequence
 
 from .attempt_evidence import AttemptEvidenceSeal, _sha
-from .dispatch_state import build_dispatch_id
-from .execution_identity import ExecutionManifestError
+from .execution_identity import build_dispatch_id
+from .execution_identity import (  # noqa: F401 — MutationRecoveryDecision 재노출
+    ExecutionManifestError,
+    MutationRecoveryDecision,
+)
 from .execution_manifest import (
     _replace_manifest,
     _write_manifest_over_existing,
@@ -39,67 +42,6 @@ class MutationRecoveryInput:
     current_git_chain_digest: str
 
 
-@dataclass(frozen=True)
-class MutationRecoveryDecision:
-    recovery_ref: str
-    source_invocation_ref: str
-    source_attempt_ref: str
-    source_evidence_seal_ref: str | None
-    original_baseline_digest: str
-    terminal_source_diff_digest: str
-    terminal_git_chain_digest: str
-    verifier_role_execution_ref: str | None
-    verifier_invocation_ref: str | None
-    recovered_evidence_refs: tuple[Mapping[str, Any], ...]
-    recovered_out_of_plan_edits: tuple[Mapping[str, Any], ...]
-    unmet_obligations: tuple[str, ...]
-    decision: Literal["carry-forward", "reject", "cleanup-confirmed"]
-    reason: str = ""
-
-    def to_payload(self) -> dict[str, Any]:
-        return {
-            "recoveryRef": self.recovery_ref,
-            "sourceInvocationRef": self.source_invocation_ref,
-            "sourceAttemptRef": self.source_attempt_ref,
-            "sourceEvidenceSealRef": self.source_evidence_seal_ref,
-            "originalBaselineDigest": self.original_baseline_digest,
-            "terminalSourceDiffDigest": self.terminal_source_diff_digest,
-            "terminalGitChainDigest": self.terminal_git_chain_digest,
-            "verifierRoleExecutionRef": self.verifier_role_execution_ref,
-            "verifierInvocationRef": self.verifier_invocation_ref,
-            "recoveredEvidenceRefs": [dict(row) for row in self.recovered_evidence_refs],
-            "recoveredOutOfPlanEdits": [
-                dict(row) for row in self.recovered_out_of_plan_edits
-            ],
-            "unmetObligations": list(self.unmet_obligations),
-            "decision": self.decision,
-            "reason": self.reason,
-        }
-
-    @classmethod
-    def from_payload(cls, payload: Mapping[str, Any]) -> "MutationRecoveryDecision":
-        return cls(
-            recovery_ref=str(payload["recoveryRef"]),
-            source_invocation_ref=str(payload["sourceInvocationRef"]),
-            source_attempt_ref=str(payload["sourceAttemptRef"]),
-            source_evidence_seal_ref=payload.get("sourceEvidenceSealRef"),
-            original_baseline_digest=str(payload.get("originalBaselineDigest") or ""),
-            terminal_source_diff_digest=str(
-                payload.get("terminalSourceDiffDigest") or ""
-            ),
-            terminal_git_chain_digest=str(payload.get("terminalGitChainDigest") or ""),
-            verifier_role_execution_ref=payload.get("verifierRoleExecutionRef"),
-            verifier_invocation_ref=payload.get("verifierInvocationRef"),
-            recovered_evidence_refs=tuple(payload.get("recoveredEvidenceRefs") or ()),
-            recovered_out_of_plan_edits=tuple(
-                payload.get("recoveredOutOfPlanEdits") or ()
-            ),
-            unmet_obligations=tuple(payload.get("unmetObligations") or ()),
-            decision=str(payload["decision"]),
-            reason=str(payload.get("reason") or ""),
-        )
-
-
 def _seal_for(manifest, seal_ref: str | None) -> AttemptEvidenceSeal | None:
     if not seal_ref:
         return None

package/runtime/python/okstra_ctl/next_phase.py

@@ -1,7 +1,8 @@
 """다음 Phase 포인터의 shape · 승격 · 투영 SSOT.
 
-포인터는 `{phase, status, rationale}` 구조체다. 저작은 리드(report-writer)가
-하고, Phase 7 검증기가 리포트의 Phase 라우팅과 대조해 어긋나면 정정한다.
+포인터는 `{phase, status, rationale}` 구조체다. 값은 리포트의 라우팅 필드에서
+투영된다 — 리드가 그 구조체를 직접 쓰는 표면은 없고, 매니페스트에 있던 값과
+대조하지도 않는다. 리드가 통제하는 것은 리포트의 라우팅 필드뿐이다.
 이 모듈은 세 가지만 소유한다 — 구조체 판별, 구형 문자열 승격, 리포트 투영.
 다음 phase 를 계산하는 다른 알고리즘을 다시 만들지 않는다.
 """
@@ -14,25 +15,26 @@ from okstra_ctl.clarification_items import (
     progress_blocking_ids,
 )
 
-STATUS_READY = "ready"
-STATUS_PENDING = "pending"
-STATUS_BLOCKED = "blocked"
-STATUS_TERMINAL = "terminal"
 
-POINTER_STATUSES = frozenset(
-    {STATUS_READY, STATUS_PENDING, STATUS_BLOCKED, STATUS_TERMINAL}
+# 포인터 값 자체(구조체·판별·승격)는 하위 계층이 소유한다. 읽기측 상태 접근자
+# okstra_project.state 가 매니페스트를 돌려줄 때마다 승격을 해야 하는데, 그 값
+# 타입이 여기 있으면 okstra_ctl 패키지 __init__ 을 통해 순환이 된다. 근거는
+# okstra_project/phase_pointer.py 의 모듈 도크스트링.
+#
+# 이름을 그대로 재노출하므로 next_phase.make / .promote / .STATUS_* 를 쓰는
+# 기존 호출부는 바뀌지 않는다.
+from okstra_project.phase_pointer import (  # noqa: F401 — 의도적 재노출
+    LEGACY_SENTINELS as _LEGACY_SENTINELS,
+    POINTER_STATUSES,
+    STATUS_BLOCKED,
+    STATUS_PENDING,
+    STATUS_READY,
+    STATUS_TERMINAL,
+    is_pointer,
+    make,
+    promote,
 )
 
-# 구형 문자열 포인터가 쓰던 센티널 → status. 이 표는 승격에만 쓰이며
-# 새 포인터를 만드는 데는 절대 쓰지 않는다.
-_LEGACY_SENTINELS = {
-    "": STATUS_PENDING,
-    "unknown": STATUS_PENDING,
-    "pending-routing-decision": STATUS_PENDING,
-    "pending-release-handoff": STATUS_PENDING,
-    "done-or-follow-up": STATUS_TERMINAL,
-}
-
 # 라우팅 필드가 없어 항상 terminal 인 task-type.
 _TERMINAL_TASK_TYPES = frozenset({"release-handoff"})
 
@@ -90,49 +92,6 @@ _FINAL_VERIFICATION_PHASE_ALIASES = {
 }
 
 
-def make(
-    phase: str = "", status: str = STATUS_PENDING, rationale: str = ""
-) -> dict[str, str]:
-    """포인터 구조체 하나를 만든다. status 가 허용 집합 밖이면 거부한다."""
-    if status not in POINTER_STATUSES:
-        raise ValueError(f"unknown next-phase status: {status!r}")
-    return {"phase": phase, "status": status, "rationale": rationale}
-
-
-def is_pointer(value: Any) -> bool:
-    """value 가 유효한 포인터 구조체인지."""
-    return (
-        isinstance(value, Mapping)
-        and isinstance(value.get("phase"), str)
-        and value.get("status") in POINTER_STATUSES
-        and isinstance(value.get("rationale"), str)
-    )
-
-
-def promote(value: Any) -> dict[str, str]:
-    """구형 문자열·None 을 포인터로 올린다.
-
-    이미 포인터인 입력은 같은 값을 담은 새 dict 로 돌려준다 — 입력을 그대로
-    돌려주지 않는다. 호출부가 반환값을 그 자리에서 변형해도 manifest 원본이
-    오염되지 않아야 하기 때문이다.
-
-    pre-v1 무호환 원칙의 의도적 예외다. 근거는 업그레이드를 가로지르는
-    진행 중 태스크가 영구히 막히는 기존 사례 — ADR-0004 Consequences.
-    """
-    if is_pointer(value):
-        return {
-            "phase": value["phase"],
-            "status": value["status"],
-            "rationale": value["rationale"],
-        }
-    if not isinstance(value, str):
-        return make()
-    text = value.strip()
-    if text in _LEGACY_SENTINELS:
-        return make(status=_LEGACY_SENTINELS[text])
-    return make(phase=text, status=STATUS_READY)
-
-
 def autofill_task_type(manifest: Mapping[str, Any]) -> str:
     """매니페스트의 포인터에서 바로 실행 가능한 task-type 을 뽑는다.
 
@@ -157,7 +116,15 @@ def project(report_data: Mapping[str, Any]) -> dict[str, str]:
         task_type = str(header.get("taskType") or "")
 
     if task_type in _TERMINAL_TASK_TYPES:
-        return make(status=STATUS_TERMINAL)
+        # release-handoff 의 라우팅 칸은 자유 문자열이다. phase 로 삼을 값은
+        # 없지만(생애주기가 여기서 끝난다) 그 문장은 태스크가 왜 끝났는지
+        # 말하므로 근거 자리에 싣는다.
+        return make(
+            status=STATUS_TERMINAL,
+            rationale=_text(
+                _block(report_data, "releaseHandoff").get("routingRecommendation")
+            ),
+        )
     if task_type in _SIDETRACK_TASK_TYPES:
         return make(status=STATUS_PENDING)
 
@@ -181,6 +148,11 @@ def _block(report_data: Mapping[str, Any], key: str) -> Mapping[str, Any]:
     return block if isinstance(block, Mapping) else {}
 
 
+def _text(value: Any) -> str:
+    """문자열이면 다듬어 돌려주고, 아니면 결측으로 취급한다."""
+    return value.strip() if isinstance(value, str) else ""
+
+
 def _from_nested(
     report_data: Mapping[str, Any],
     block_key: str,
@@ -193,27 +165,79 @@ def _from_nested(
     강제하면 dict repr 같은 것이 phase 이름 자리에 들어앉고, status 는 ready 가
     되어 소비자에게 "지금 시작 가능한 phase" 로 읽힌다. 결측은 pending 에서
     무해하게 멈추지만 이쪽은 존재하지 않는 phase 로 소비자를 보낸다.
+
+    같은 라우팅 객체의 `rationale` 을 포인터에 함께 싣는다. 그 문장은 리드가
+    "왜 다음이 이 phase 인가" 를 쓴 자리고, 스키마가 네 phase 전부에서 필수로
+    요구한다. 여기서 안 실으면 포인터에 남는 것은 phase 이름 하나뿐이라, 다음
+    작업을 추천받는 사람이 근거 없이 이름만 본다.
+
+    대상이 없으면 근거도 버린다 — 목적지를 설명하는 문장이므로 목적지 없이
+    남으면 무엇을 설명하는지 알 수 없다.
     """
     routing = _block(report_data, block_key).get(routing_key)
     target = ""
+    rationale = ""
     if isinstance(routing, Mapping):
-        raw = routing.get(target_key)
-        target = raw.strip() if isinstance(raw, str) else ""
+        target = _text(routing.get(target_key))
+        rationale = _text(routing.get("rationale"))
     if not target:
         return make(status=STATUS_PENDING)
-    return make(phase=target, status=STATUS_READY)
+    return make(phase=target, status=STATUS_READY, rationale=rationale)
 
 
 def _from_nested_routing(report_data: Mapping[str, Any], key: str) -> dict[str, str]:
     return _from_nested(report_data, key, "routing", "nextTaskType")
 
 
+# 차단된 비교가 "그래서 뭘 하라는 것인가" 를 쓰는 칸. 스키마가 필수로 요구한다
+# (`ImplementationOptionSelectionUserNarrative.required`).
+_SELECTION_GUIDANCE_CAP = 400
+
+
+def _selection_guidance(selection: Mapping[str, Any]) -> str:
+    """`userNarrative.selectionGuidance` 의 첫 문단.
+
+    전체는 여러 문단이고 포인터의 근거는 한 줄로 인용되는 자리다. 첫 문단이
+    "이 run 에서 고를 것이 없다 / 무엇을 갖춰 다시 돌려라" 를 말한다.
+    """
+    narrative = selection.get("userNarrative")
+    if not isinstance(narrative, Mapping):
+        return ""
+    guidance = narrative.get("selectionGuidance")
+    if not isinstance(guidance, Mapping):
+        return ""
+    text = _text(guidance.get("text"))
+    if not text:
+        return ""
+    first = text.split("\n", 1)[0].strip()
+    if len(first) > _SELECTION_GUIDANCE_CAP:
+        first = first[:_SELECTION_GUIDANCE_CAP].rstrip() + "…"
+    return first
+
+
 def _from_option_selection(report_data: Mapping[str, Any]) -> dict[str, str]:
     # 이 phase 의 routing 은 문자열 enum 이다. 이웃 두 phase 가 쓰는 중첩 dict 가
     # 잘못 들어오면 결측과 똑같이 취급한다 — str() 로 강제하면 dict repr 이 phase
     # 이름이 되어 ready 로 나간다.
-    raw = _block(report_data, "implementationOptionSelection").get("routing")
+    selection = _block(report_data, "implementationOptionSelection")
+    raw = selection.get("routing")
     routing = raw.strip() if isinstance(raw, str) else ""
+    if routing == "blocked":
+        # 차단은 목적지가 없다. 근거까지 비우면 포인터에 남는 것이 "막혔다" 뿐이고,
+        # 소비자에게 남는 유일한 행동은 같은 phase 를 그대로 다시 돌리는 것이다.
+        # 그 재실행이 같은 이유로 또 차단되면 사용자는 이유를 한 번도 못 본 채
+        # 같은 자리를 돈다. 이웃 분기들은 이미 근거를 싣는다 — `_from_nested` 는
+        # 라우팅의 `rationale`, `_from_planning` 은 승인 차단 사유,
+        # release-handoff 는 `routingRecommendation`.
+        return make(status=STATUS_BLOCKED, rationale=_selection_guidance(selection))
+    if routing == "pending-direction-selection":
+        # 이 상태는 **성공**이다 — 비교가 끝났고 사용자가 방향을 고르면 된다.
+        # 그런데 근거가 비면 closeout 표에 `pending` 행이 없어 "Otherwise →
+        # /okstra-inspect status" 로 떨어지고, 사용자는 끝난 phase 를 들여다보라는
+        # 안내를 받는다. 실측(dev-10341): 1회차가 IO-001·IO-002 를 내고 여기서
+        # 멈췄는데 안내가 없어 같은 phase 가 세 번 더 돌았고, 그동안 워커가
+        # 무너지며 결과가 0건으로 나빠졌다.
+        return make(status=STATUS_PENDING, rationale=_direction_selection_reason(selection))
     if routing in _OPTION_SELECTION_NON_PHASE:
         return make(status=_OPTION_SELECTION_NON_PHASE[routing])
     if not routing:
@@ -221,6 +245,32 @@ def _from_option_selection(report_data: Mapping[str, Any]) -> dict[str, str]:
     return make(phase=routing, status=STATUS_READY)
 
 
+def _direction_selection_reason(selection: Mapping[str, Any]) -> str:
+    """비교가 끝난 run 이 사용자에게 남기는 다음 행동.
+
+    후보 id 를 이름으로 말한다 — 고르라는 말만 있고 고를 것의 이름이 없으면
+    사용자는 리포트를 열어 목록을 찾아야 한다.
+    """
+    options = selection.get("rankedOptions")
+    ids = [
+        _text(row.get("id"))
+        for row in options
+        if isinstance(row, Mapping) and _text(row.get("id"))
+    ] if isinstance(options, list) else []
+    if not ids:
+        return ""
+    listed = ", ".join(f"`{item}`" for item in ids)
+    recommended = _text(selection.get("recommendedOptionId"))
+    head = f"비교가 끝났습니다. 후보 {listed} 중 하나를 방향으로 고르세요"
+    head += f" (권장 `{recommended}`)." if recommended else "."
+    return (
+        f"{head} 고르는 자리는 계획 단계의 위저드입니다 — `/okstra-run` 으로 "
+        "`implementation-planning` 을 시작하면 이 후보들이 선택지로 나옵니다. "
+        "이 phase 를 다시 돌리지 마세요: 비교는 이미 끝났고, 재실행은 같은 "
+        "비교를 처음부터 다시 합니다."
+    )
+
+
 def _unresolved_approval_ids(report_data: Mapping[str, Any]) -> list[str]:
     return progress_blocking_ids(
         report_data.get("clarificationItems"),
@@ -279,8 +329,8 @@ def _from_planning(report_data: Mapping[str, Any]) -> dict[str, str]:
     outcome = str(planning.get("outcome") or "")
     if outcome == "direction-invalidated":
         return make(phase="implementation-option-selection", status=STATUS_READY)
-    if outcome != "plan-ready":
-        return make(status=STATUS_PENDING)
+    # 후보 비교 계획은 outcome 칸이 없다. 열린 승인 차단과 차단 게이트만
+    # 구현을 막는다. 칸이 없다고 pending 으로 두면 종료 안내가 inspect 로 간다.
     blocked_reason = _planning_approval_block_reason(report_data, planning)
     if blocked_reason:
         return make(status=STATUS_BLOCKED, rationale=blocked_reason)
@@ -294,7 +344,9 @@ def _from_target(report_data: Mapping[str, Any], key: str) -> dict[str, str]:
 def _from_final_verification(report_data: Mapping[str, Any]) -> dict[str, str]:
     pointer = _from_target(report_data, "finalVerification")
     if pointer["phase"] == "done":
-        return make(status=STATUS_TERMINAL)
+        # `done` 은 phase 가 아니라 생애주기 종료다. 근거는 그대로 남긴다 —
+        # 태스크를 끝내도 되는 이유가 사용자에게 가장 필요한 문장이다.
+        return make(status=STATUS_TERMINAL, rationale=pointer["rationale"])
     if pointer["phase"] in _FINAL_VERIFICATION_PHASE_ALIASES:
         return make(
             phase=_FINAL_VERIFICATION_PHASE_ALIASES[pointer["phase"]],

package/runtime/python/okstra_ctl/pane_reclaim.py

@@ -66,11 +66,34 @@ def in_flight_run_dirs(project_root: Path) -> list[Path]:
     return out
 
 
+def cwd_from_hook_payload(raw: str) -> str:
+    """훅이 stdin 으로 넘긴 JSON 에서 `cwd` 만 꺼낸다.
+
+    입력은 훅이 주는 것이라 형태를 보장할 수 없다. 파싱에 실패하거나 키가
+    없으면 빈 문자열을 돌려준다 — 호출부(okstra-compact-reminder.sh)가 그때
+    자신의 $PWD 로 대체한다. 이 함수는 호출부의 폴백을 켜는 신호를 내는 것이
+    역할이므로 빈 문자열이 곧 신호다.
+    """
+    import json
+
+    try:
+        payload = json.loads(raw)
+    except (ValueError, TypeError):
+        return ""
+    if not isinstance(payload, dict):
+        return ""
+    value = payload.get("cwd", "")
+    return value if isinstance(value, str) else ""
+
+
 def main(argv: list[str]) -> int:
     if len(argv) == 2 and argv[0] == "--in-flight-run-dirs-for":
         for run_dir in in_flight_run_dirs(Path(argv[1])):
             print(run_dir)
         return 0
+    if len(argv) == 1 and argv[0] == "--cwd-from-hook-stdin":
+        print(cwd_from_hook_payload(sys.stdin.read()))
+        return 0
     return 1
 
 

package/runtime/python/okstra_ctl/pane_title.py

@@ -115,19 +115,22 @@ def release_pane_title(
     return PaneTitleLease(**{**lease.__dict__, "status": "released"})
 
 
-def cleanup_pane_title(
-    lease: PaneTitleLease, backend: PaneTitleBackend
-) -> PaneTitleLease:
-    if lease.status == "not-applicable":
-        return lease
-    backend.set_title(lease.pane_id, lease.previous_title)
-    return PaneTitleLease(**{**lease.__dict__, "status": "cleaned"})
+_CLI_EPILOG = r"""Usage:
+  okstra pane-title acquire --execution-label <label> [--pane-id <id>]
+  okstra pane-title release
+  okstra pane-title cleanup
+"""
+_CLI_DESCRIPTION = "Lease pane titles from stored execution labels."
 
 
 def main(argv: list[str] | None = None) -> int:
     import argparse
 
-    parser = argparse.ArgumentParser(prog="okstra pane-title")
+    parser = argparse.ArgumentParser(
+        description=_CLI_DESCRIPTION,
+        epilog=_CLI_EPILOG,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        prog="okstra pane-title")
     parser.add_argument("action", choices=("acquire", "release", "cleanup"))
     parser.add_argument("--execution-label", default="")
     parser.add_argument("--pane-id", default="")

package/runtime/python/okstra_ctl/path_hints.py

@@ -12,8 +12,13 @@ from okstra_project.dirs import (
     okstra_home,
 )
 
-from .paths import runs_dir_of, task_manifest_file, task_timeline_file
-from .worker_artifacts import artifacts_from_context
+from .paths import (
+    runs_dir_of,
+    task_manifest_file,
+    task_qa_dir,
+    task_timeline_file,
+)
+from .worker_artifacts import worker_artifact_paths
 
 RUN_CONTEXT_KIND = "run-context"
 RUN_CONTEXT_SCHEMA_VERSION = "2.0"
@@ -101,7 +106,7 @@ def hydrate_active_run_context(payload: Mapping[str, Any]) -> dict[str, Any]:
         "agentContract": dict(_mapping(payload.get("agentContract"))),
         "instructionSet": _hydrate_active_instruction_set(payload, ctx),
         "workers": _hydrate_active_workers(payload, ctx),
-        "errorLogs": _hydrate_active_error_logs(ctx),
+        "errorLogs": _hydrate_active_error_logs(payload, ctx),
         "runtimeResources": {
             "codingPreflightDir": ctx.get("OKSTRA_CODING_PREFLIGHT_DIR", ""),
             "workerPreamblePathByAudience": {
@@ -255,19 +260,36 @@ def _hydrate_active_worker(
 ) -> dict[str, Any]:
     worker_id = str(worker.get("workerId", ""))
     hydrated = dict(worker)
-    paths = artifacts_from_context(ctx, relative=True).get(worker_id, {})
-    hydrated["promptPath"] = paths.get("promptPath", "")
-    hydrated["resultPath"] = paths.get("resultPath", "")
+    paths = worker_artifact_paths(ctx, worker_id, relative=True)
+    hydrated["promptPath"] = paths["promptPath"]
+    hydrated["resultPath"] = paths["resultPath"]
     return hydrated
 
 
-def _hydrate_active_error_logs(ctx: Mapping[str, str]) -> dict[str, Any]:
-    artifacts = artifacts_from_context(ctx, relative=True)
+def _hydrate_active_error_logs(
+    payload: Mapping[str, Any],
+    ctx: Mapping[str, str],
+) -> dict[str, Any]:
+    """사이드카 맵의 키는 이 런의 로스터다.
+
+    복원된 ctx 에는 로스터가 없다 — 경로 힌트만 담기기 때문이다. 그래서 압축
+    payload 가 들고 있는 `workers[]` 행에서 id 를 읽는다. provider registry 목록으로
+    되돌리면 실행자와 검증자가 provider 를 공유할 때 생기는 접미사 id
+    (`claude-2`)의 사이드카 경로가 통째로 빠진다.
+    """
+    workers = payload.get("workers")
+    worker_ids = [
+        str(worker.get("workerId", ""))
+        for worker in (workers if isinstance(workers, list) else [])
+        if isinstance(worker, Mapping) and str(worker.get("workerId", ""))
+    ]
     return {
         "runErrorsLogPath": ctx.get("RUN_ERRORS_LOG_RELATIVE_PATH", ""),
         "sidecarsByWorkerId": {
-            worker_id: paths["errorsSidecarPath"]
-            for worker_id, paths in artifacts.items()
+            worker_id: worker_artifact_paths(
+                ctx, worker_id, relative=True
+            )["errorsSidecarPath"]
+            for worker_id in worker_ids
         },
     }
 
@@ -357,7 +379,7 @@ def _task_path_set(task_root: Path) -> dict[str, Path]:
         "task_index": task_root / "task-index.md",
         "instruction_set": instruction_set,
         "analysis_packet": instruction_set / "analysis-packet.md",
-        "task_qa": task_root / "qa",
+        "task_qa": task_qa_dir(task_root),
         "runs_dir": runs_dir_of(task_root),
         "history_dir": history_dir,
         "timeline_file": task_timeline_file(task_root),
@@ -443,6 +465,7 @@ def _run_files(
         "approval_decisions": run_state / f"approval-decisions-{task_type_segment}-{sequences['state']}.json",
         "design_preparation": run_state / f"design-preparation-{task_type_segment}-{sequences['state']}.json",
         "plan_body_verification": run_state / f"plan-body-verification-{task_type_segment}-{sequences['state']}.json",
+        "incremental_decision": run_state / f"incremental-decision-{task_type_segment}-{sequences['state']}.json",
         "run_errors_log": run_logs / f"errors-{task_type_segment}-{sequences['state']}.jsonl",
         "claude_worker_errors_sidecar": worker_results / f"claude-worker-errors{suffixes['worker_results']}.json",
         "codex_worker_errors_sidecar": worker_results / f"codex-worker-errors{suffixes['worker_results']}.json",
@@ -578,6 +601,7 @@ def _absolute_worker_fields(paths: Mapping[str, Any]) -> dict[str, str]:
         "APPROVAL_DECISIONS_PATH": str(paths["approval_decisions"]),
         "DESIGN_PREPARATION_PATH": str(paths["design_preparation"]),
         "PLAN_BODY_VERIFICATION_STATE_PATH": str(paths["plan_body_verification"]),
+        "INCREMENTAL_DECISION_STATE_PATH": str(paths["incremental_decision"]),
         "CLAUDE_WORKER_ERRORS_SIDECAR_PATH": str(paths["claude_worker_errors_sidecar"]),
         "CODEX_WORKER_ERRORS_SIDECAR_PATH": str(paths["codex_worker_errors_sidecar"]),
         "ANTIGRAVITY_WORKER_ERRORS_SIDECAR_PATH": str(paths["antigravity_worker_errors_sidecar"]),
@@ -682,6 +706,7 @@ def _relative_file_fields(project_root: Path, paths: Mapping[str, Any]) -> dict[
         "APPROVAL_DECISIONS_RELATIVE_PATH": _rel(project_root, paths["approval_decisions"]),
         "DESIGN_PREPARATION_RELATIVE_PATH": _rel(project_root, paths["design_preparation"]),
         "PLAN_BODY_VERIFICATION_STATE_RELATIVE_PATH": _rel(project_root, paths["plan_body_verification"]),
+        "INCREMENTAL_DECISION_STATE_RELATIVE_PATH": _rel(project_root, paths["incremental_decision"]),
         "RUN_ERRORS_LOG_RELATIVE_PATH": _rel(project_root, paths["run_errors_log"]),
         "CLAUDE_WORKER_ERRORS_SIDECAR_RELATIVE_PATH": _rel(project_root, paths["claude_worker_errors_sidecar"]),
         "CODEX_WORKER_ERRORS_SIDECAR_RELATIVE_PATH": _rel(project_root, paths["codex_worker_errors_sidecar"]),