okstra 0.186.6 → 0.187.0

package/runtime/python/okstra_ctl/wizard.py

@@ -28,6 +28,7 @@ import subprocess
 from dataclasses import asdict, dataclass, field
 from datetime import datetime
 from pathlib import Path
+from collections.abc import Mapping
 from typing import Any, Callable, Optional
 
 from okstra_ctl.application.advance_wizard import plan_prompt
@@ -96,6 +97,7 @@ from okstra_ctl.clarification_items import (
 from okstra_ctl.convergence_store import write_json_atomic
 from okstra_ctl.json_boundary import JsonBoundaryError, load_owned_object
 from okstra_ctl.incremental_scope import (
+    CARRY_ALL_SCOPE,
     parse_stage_graph,
     preview_link_availability_for_report,
 )
@@ -242,6 +244,8 @@ _RECOMMENDATION_CAP = 3
 # Pick-vs-free-text tokens shared by suggestion-aware prompts.
 PICK_USE_SUGGESTED = "__use_suggested__"
 PICK_TYPE_CUSTOM = "__free_input__"
+# 취소지 탈출구가 아니다 — 자유 입력 뒤에 올 수 있는 유일한 값.
+_ABORT_OPTION = "__abort__"
 # workers_override 에서 "옵션 워커를 추가하지 않음" 을 뜻하는 sentinel.
 _DEFAULT_ROSTER_TOKEN = "__default_roster__"
 _RECENT_PREFIX = "__recent:"
@@ -590,6 +594,34 @@ class Prompt:
     # only meaningful when kind == "pick_group": one entry per AskUserQuestion tab
     questions: list["Prompt"] = field(default_factory=list)
 
+    def __post_init__(self) -> None:
+        """자유 입력 선택지는 언제나 마지막이다.
+
+        목록이 자유 입력으로 열리면 질문을 통째로 사용자에게 되돌려준 것이다 —
+        앞선 선택지들이 이 run 이 이미 알아낸 것이고, 자유 입력은 그것들이
+        전부 맞지 않을 때의 탈출구다. 실측: 재검증 범위 질문의 `unlinked`
+        분기가 `직접 입력` 을 첫 선택지로 내놓았고, 리드가 preamble 에 해당
+        stage 번호를 이미 적어 놓은 화면에서도 사용자는 그 번호를 다시
+        타이핑해야 했다.
+
+        중단(abort)만 그 뒤에 올 수 있다. 중단은 탈출구가 아니라 취소이고,
+        `brief_carry` 가 실제로 그 모양이다 — 전환(추천) / 직접 입력 / 중단.
+
+        배치 지점이 12곳이라 관례로는 지켜지지 않는다. 값을 만드는 자리에서
+        막는다.
+        """
+        values = [option.value for option in self.options]
+        if PICK_TYPE_CUSTOM not in values:
+            return
+        after = values[values.index(PICK_TYPE_CUSTOM) + 1:]
+        offenders = [value for value in after if value != _ABORT_OPTION]
+        if offenders:
+            raise WizardError(
+                f"wizard step {self.step!r}: the free-input option "
+                f"({PICK_TYPE_CUSTOM!r}) must come after every real choice — "
+                f"only {_ABORT_OPTION!r} may follow it, but {offenders} do"
+            )
+
     @property
     def id(self) -> str:
         """Stable public identifier shared by static and role-instance prompts."""
@@ -649,8 +681,11 @@ def _require_file(path_str: str, project_root: Path, label: str) -> Path:
     return p
 
 
+# 후보는 리포트 **기록**으로 찾는다. 전체 열람본(`.md`)은 `2bcd575` 이후 완료
+# 산출물이 아니라 요청 시 렌더라, `.md` 를 글롭하는 동안 이 목록은 항상 비었고
+# 방향 선택 단계 자체가 뜨지 않았다 — 비교가 끝나도 계획으로 갈 길이 없었다.
 _SELECTION_REPORT_RE = re.compile(
-    r"^final-report-implementation-option-selection-(?P<seq>\d{3,})\.md$"
+    r"^final-report-implementation-option-selection-(?P<seq>\d{3,})\.data\.json$"
 )
 
 
@@ -667,7 +702,9 @@ def _selected_direction_candidates(state: WizardState) -> list[str]:
         / "reports"
     )
     candidates: list[tuple[int, Path]] = []
-    for report in reports.glob("final-report-implementation-option-selection-*.md"):
+    for report in reports.glob(
+        "final-report-implementation-option-selection-*.data.json"
+    ):
         match = _SELECTION_REPORT_RE.fullmatch(report.name)
         if match is None:
             continue
@@ -729,22 +766,55 @@ def _build_selected_direction_pick(state: WizardState) -> Prompt:
         step=S_SELECTED_DIRECTION_PICK,
         kind="pick",
         label=t["label"],
-        options=[_opt(path, path) for path in candidates],
+        options=[
+            _opt(path, _selection_option_label(state, path, t))
+            for path in candidates
+        ],
         echo_template=t["echo_template"],
     )
 
 
+def _selection_option_label(state: WizardState, rel_path: str, t: dict) -> str:
+    """후보 경로에 그 리포트가 실제로 무엇을 담았는지 붙인다.
+
+    목록은 최신순이라 후보가 0건인 최근 재실행이 맨 위에 온다. 경로만 보이면
+    사용자가 그것을 고르고, 방향 없는 리포트로 계획을 열려다 막힌다.
+    """
+    record = Path(state.project_root) / rel_path
+    try:
+        data = load_owned_object(record, artifact="implementation option data")
+    except (OSError, JsonBoundaryError):
+        return rel_path
+    selection = data.get("implementationOptionSelection")
+    if not isinstance(selection, Mapping):
+        return rel_path
+    rows = selection.get("rankedOptions")
+    ids = [
+        str(row.get("id"))
+        for row in rows
+        if isinstance(row, Mapping) and row.get("id")
+    ] if isinstance(rows, list) else []
+    if not ids:
+        return t["labels"]["no_options"].format(path=rel_path)
+    return t["labels"]["options"].format(path=rel_path, ids=", ".join(ids))
+
+
 def _submit_selected_direction_pick(
     state: WizardState, value: str
 ) -> Optional[str]:
+    t = _p(state.workspace_root, S_SELECTED_DIRECTION_PICK)
     candidates = _selected_direction_candidates(state)
     if value not in candidates:
-        raise WizardError(
-            _p(state.workspace_root, S_SELECTED_DIRECTION_PICK)["errors"][
-                "unknown"
-            ].format(value=value)
-        )
+        raise WizardError(t["errors"]["unknown"].format(value=value))
     state.selected_direction_path = value
+    # 두 입력은 상호 배타다 — 방향이 정해진 순간 이 런은 새 계획이고,
+    # clarification 자리에 남은 값은 render-bundle 이 거절할 이유일 뿐이다.
+    # 거절을 여기서 앞당기는 대신 값을 비우고, 무엇이 비워졌는지 echo 로
+    # 알린다. 사용자 답변은 손실되지 않는다: 그 사이드카는
+    # `--selected-direction` 경로로 계획 런에 첨부된다(`run.py` 참조).
+    if state.clarification_response_path:
+        state.clarification_response_path = ""
+        return t["echo_variants"]["cleared_clarification"].format(value=value)
     return f"selected-direction: {value}"
 
 
@@ -1191,8 +1261,6 @@ def _convert_v1_provider_selections(
         for requirement in profile.roles
         if not requirement.dynamic and requirement.min_count > 0
     }
-    if state.host_entry_mode == "spawn-process":
-        static_roles.add("leader")
     for role, provider, raw_model in provider_rows:
         if role not in static_roles or not isinstance(provider, str) or not provider:
             continue
@@ -1231,6 +1299,7 @@ def _wizard_state_from_json(payload: dict[str, Any]) -> WizardState:
     if version != 2:
         state.execution_identity_version = 2
         _convert_v1_provider_selections(state, payload)
+    _discard_implicit_leader_selection(state)
     return state
 
 
@@ -1274,6 +1343,24 @@ def _is_role_selection_step(step_id: str) -> bool:
     return step_id.startswith(("role-count:", "role-model:", "role-add:"))
 
 
+def _discard_implicit_leader_selection(state: WizardState) -> None:
+    """호스트에 고정된 리더의 구형 선택값을 상태에서 제거한다."""
+    state.role_models.pop("leader", None)
+    leader_steps = {
+        step_id
+        for step_id in state.role_selection_order
+        if step_id.startswith("role-model:leader:")
+    }
+    state.role_selection_order = [
+        step_id for step_id in state.role_selection_order
+        if step_id not in leader_steps
+    ]
+    state.answered = [
+        step_id for step_id in state.answered
+        if step_id not in leader_steps
+    ]
+
+
 def _selected_role_count(
     state: WizardState,
     requirement: RoleRequirement,
@@ -1292,16 +1379,12 @@ def _selectable_static_requirements(
     state: WizardState,
     profile: RoleProfile,
 ) -> tuple[RoleRequirement, ...]:
-    requirements: list[RoleRequirement] = []
-    if state.host_entry_mode == "spawn-process":
-        requirements.append(RoleRequirement("leader", 1, 1, 1, "lead"))
-    requirements.extend(
+    return tuple(
         requirement
         for requirement in profile.roles
         if not requirement.dynamic
         and _selected_role_count(state, requirement) > 0
     )
-    return tuple(requirements)
 
 
 def _count_prompt(
@@ -1354,6 +1437,14 @@ def _role_add_prompt(
         maximum=str(requirement.max_count),
     )
     suffix = prompt["options"].get("default_suffix", "")
+    # 역할을 빼면 그 역할이 맡던 판정이 사라진다. 그 결과를 아는 역할만 0 옵션에
+    # 경고를 단다 — 예: critic 이 없으면 분석자 동수를 가를 주체가 없다.
+    skip_warnings = prompt["options"].get("skip_warnings", {})
+    skip_warning = (
+        skip_warnings.get(requirement.role, "")
+        if isinstance(skip_warnings, dict)
+        else ""
+    )
 
     def _default_suffix(count: int) -> str:
         return suffix if count == requirement.recommended_count else ""
@@ -1361,7 +1452,10 @@ def _role_add_prompt(
     options = [
         _opt(
             "0",
-            prompt["options"]["skip"].format(default_suffix=_default_suffix(0)),
+            prompt["options"]["skip"].format(
+                default_suffix=_default_suffix(0),
+                skip_warning=skip_warning,
+            ),
         ),
     ]
     for count in range(1, requirement.max_count + 1):
@@ -1984,10 +2078,12 @@ def _p(workspace_root: str, step_id: str, **vars: str) -> dict:
     label_template = raw.get("label", "")
     fv_label_template = raw.get("label_final_verification", "")
     unlinked_template = raw.get("label_unlinked", "")
+    no_answers_template = raw.get("label_no_answers", "")
     try:
         label = label_template.format(**vars)
         label_final_verification = fv_label_template.format(**vars)
         label_unlinked = unlinked_template.format(**vars)
+        label_no_answers = no_answers_template.format(**vars)
     except KeyError as exc:
         missing = exc.args[0] if exc.args else "<unknown>"
         raise WizardError(
@@ -1997,6 +2093,7 @@ def _p(workspace_root: str, step_id: str, **vars: str) -> dict:
         "label": label,
         "label_final_verification": label_final_verification,
         "label_unlinked": label_unlinked,
+        "label_no_answers": label_no_answers,
         "echo_template": raw.get("echo_template", ""),
         "options": raw.get("options", {}),
         "options_final_verification": raw.get("options_final_verification", {}),
@@ -2304,7 +2401,7 @@ def _submit_task_pick(state: WizardState, value: str) -> Optional[str]:
     # task_type seeded from manifest's nextRecommendedPhase as the recommended default
     root = find_task_root(Path(state.project_root), value)
     manifest = (read_task_manifest(root) or {}) if root else {}
-    state.task_type = next_phase.autofill_task_type(manifest)
+    state.task_type = _recommended_task_type(state, manifest)
     return f"task: {value}"
 
 
@@ -2592,20 +2689,81 @@ def _submit_task_id_text(state: WizardState, value: str) -> Optional[str]:
     return f"task-id: {state.task_id}"
 
 
+def _existing_task_manifest(state: WizardState) -> dict[str, Any]:
+    """현재 task-key 의 task-manifest. 없으면 {}."""
+    if not (state.project_id and state.task_group and state.task_id):
+        return {}
+    key = f"{state.project_id}:{state.task_group}:{state.task_id}"
+    root = find_task_root(Path(state.project_root), key)
+    if root is None:
+        return {}
+    manifest = read_task_manifest(root) or {}
+    return manifest if isinstance(manifest, dict) else {}
+
+
 def _existing_task_workflow(state: WizardState) -> dict:
     """현재 task-key 가 이미 존재하면 그 manifest 의 workflow dict 를 반환한다.
 
     picker 로 기존 task 를 고른 경우뿐 아니라, new-task 흐름으로 같은
     task-group/task-id 를 다시 입력한 경우(=사실상 이어가기)에도 직전 phase
     기반 추천이 끊기지 않게 하는 안전장치. 없으면 {}."""
-    if not (state.project_id and state.task_group and state.task_id):
+    workflow = _existing_task_manifest(state).get("workflow") or {}
+    return workflow if isinstance(workflow, dict) else {}
+
+
+def _report_data_for_pointer(
+    state: WizardState, manifest: Mapping[str, Any],
+) -> dict[str, Any]:
+    rel = manifest.get("latestReportRecordPath")
+    if not isinstance(rel, str) or not rel.strip():
         return {}
-    key = f"{state.project_id}:{state.task_group}:{state.task_id}"
-    root = find_task_root(Path(state.project_root), key)
-    if root is None:
+    path = Path(rel)
+    if not path.is_absolute():
+        path = Path(state.project_root) / rel
+    try:
+        data = load_owned_object(path, artifact="latest report record")
+    except (JsonBoundaryError, OSError):
         return {}
-    workflow = (read_task_manifest(root) or {}).get("workflow") or {}
-    return workflow if isinstance(workflow, dict) else {}
+    return data if isinstance(data, dict) else {}
+
+
+def _recommended_task_type(
+    state: WizardState, manifest: Mapping[str, Any],
+) -> str:
+    """매니페스트 포인터가 ready 면 그 phase, 끝난 계획의 낡은 pending 이면 리포트 투영."""
+    filled = next_phase.autofill_task_type(manifest)
+    if filled:
+        return filled
+    workflow = manifest.get("workflow")
+    if not isinstance(workflow, Mapping):
+        return ""
+    if (
+        workflow.get("currentPhase") != "implementation-planning"
+        or workflow.get("currentPhaseState") != "completed"
+    ):
+        return ""
+    pointer = next_phase.project(_report_data_for_pointer(state, manifest))
+    if pointer["status"] != next_phase.STATUS_READY:
+        return ""
+    return pointer["phase"]
+
+
+def _implementation_needs_approval(
+    state: WizardState,
+    manifest: Mapping[str, Any],
+    workflow: Mapping[str, Any],
+) -> bool:
+    if workflow.get("awaitingApproval") is True:
+        return True
+    if (
+        workflow.get("currentPhase") != "implementation-planning"
+        or workflow.get("currentPhaseState") != "completed"
+    ):
+        return False
+    frontmatter = _report_data_for_pointer(state, manifest).get("frontmatter")
+    if not isinstance(frontmatter, dict):
+        return True
+    return frontmatter.get("approved") is not True
 
 
 def _phase_after(task_type: str) -> str:
@@ -2748,7 +2906,8 @@ def _build_task_type(state: WizardState) -> Prompt:
         options.append(_opt(task_type, f"{task_type}{suffix}",
                             description_by_type[task_type]))
 
-    workflow = _existing_task_workflow(state)
+    manifest = _existing_task_manifest(state)
+    workflow = manifest.get("workflow") if isinstance(manifest.get("workflow"), dict) else {}
     revision_requested = _latest_revision_requested_analysis_type(state)
     # 포인터에서 phase 를 꺼내는 것은 `status` 가 `ready` 일 때뿐이다. prepare 는
     # 실행이 끝나지 않은 run 의 포인터를 일부러 `pending` 으로 내려두는데
@@ -2760,15 +2919,18 @@ def _build_task_type(state: WizardState) -> Prompt:
     # `ready` 가 아니면 추천은 비고, 아래 `currentPhase` 재실행 옵션이 남는다.
     # 실패한 run 의 포인터가 `{"phase": "", "status": "blocked"}` 라는 점에서
     # 그것이 맞는 제안이다 — 그 옵션은 포인터가 아니라 `currentPhase` 에서 온다.
-    # 계획 승인 대기는 `awaitingApproval` 로 표시한다. 구현이 추천이지만 먼저
-    # 승인을 받아야 하므로 접미사로 구분한다. 열린 C-NNN 때문에 blocked 면
-    # 재실행은 답이 기록된 뒤에만 고르라고 접미사로 말한다.
+    # 끝난 계획의 낡은 pending 은 최신 리포트에서 다시 투영한다. 승인 대기는
+    # `awaitingApproval` 또는 미승인 계획 리포트로 접미사를 붙인다. 열린
+    # C-NNN 때문에 blocked 면 재실행은 답이 기록된 뒤에만 고르라고 말한다.
     recommended = (revision_requested or state.task_type
-                   or next_phase.autofill_task_type({"workflow": workflow}))
+                   or _recommended_task_type(state, manifest))
     if not recommended and not workflow:
         recommended = TASK_TYPE_VALUES[0]
     pointer = next_phase.promote(workflow.get("nextRecommendedPhase"))
-    if workflow.get("awaitingApproval") is True and recommended == "implementation":
+    if (
+        recommended == "implementation"
+        and _implementation_needs_approval(state, manifest, workflow)
+    ):
         recommended_suffix = approve_suffix
     if (
         pointer["status"] == next_phase.STATUS_BLOCKED
@@ -2955,7 +3117,7 @@ def _submit_brief_path(state: WizardState, value: str) -> Optional[str]:
 
 
 BRIEF_CARRY_SWITCH_ENTRY = "__switch_entry__"
-BRIEF_CARRY_ABORT = "__abort__"
+BRIEF_CARRY_ABORT = _ABORT_OPTION
 
 
 def _build_brief_carry(state: WizardState) -> Prompt:
@@ -3431,19 +3593,25 @@ def _design_prep_items_by_id(state: WizardState) -> dict[str, dict[str, Any]]:
     return {str(item["id"]): item for item in items}
 
 
-def _ensure_design_prep_queue(state: WizardState) -> None:
-    if state.design_prep_current or state.design_prep_queue:
-        return
-    if S_DESIGN_PREP_DECISION in state.answered:
-        return
+def _selected_impl_stage_numbers(state: WizardState) -> set[int]:
+    numbers: set[int] = set()
+    for token in (state.selected_stages or state.selected_stage or "").split(","):
+        token = token.strip()
+        if token.isdigit():
+            numbers.add(int(token))
+    return numbers
+
+
+def _blocking_unanswered_prep_ids(state: WizardState) -> list[str] | None:
+    """고른 스테이지에서 구현을 막는 unanswered blocked id. 로드 불가면 None."""
     report_path = Path(state.approved_plan_path)
     if not re.fullmatch(
         r"final-report-implementation-planning-\d+\.data\.json",
         report_path.name,
     ):
-        return
+        return None
     if not report_path.is_file():
-        return
+        return None
     try:
         items = load_design_prep_items(report_path)
         effective = resolve_design_prep(report_path)
@@ -3453,13 +3621,48 @@ def _ensure_design_prep_queue(state: WizardState) -> None:
         str(item["id"]): item.get("decision")
         for item in effective.effective_items
     }
-    unresolved = [
-        item for item in items
-        if item.get("status") in ("blocked", "provisional")
+    stages = _selected_impl_stage_numbers(state)
+    # provisional 미응답은 구현을 막지 않는다. 작업 가정을 그대로 쓴다.
+    return [
+        str(item["id"])
+        for item in items
+        if item.get("status") == "blocked"
         and decisions.get(str(item["id"])) == "unanswered"
+        and (
+            not stages
+            or stages.intersection(
+                stage for stage in (item.get("stageRefs") or [])
+                if isinstance(stage, int)
+            )
+        )
+    ]
+
+
+def _prune_design_prep_session(state: WizardState, wanted: list[str]) -> None:
+    """이미 만든 큐에서 더 이상 막지 않는 id 를 뺀다. 새 id 는 넣지 않는다."""
+    wanted_set = set(wanted)
+    if state.design_prep_current and state.design_prep_current not in wanted_set:
+        state.design_prep_current = ""
+        state.design_prep_decision = ""
+        state.design_prep_overrides_json = ""
+        state.design_prep_notes = ""
+    state.design_prep_queue = [
+        item_id for item_id in state.design_prep_queue if item_id in wanted_set
     ]
-    unresolved.sort(key=lambda item: item.get("status") != "blocked")
-    state.design_prep_queue = [str(item["id"]) for item in unresolved]
+    if not state.design_prep_current:
+        _advance_design_prep_item(state)
+
+
+def _ensure_design_prep_queue(state: WizardState) -> None:
+    wanted = _blocking_unanswered_prep_ids(state)
+    if wanted is None:
+        return
+    if state.design_prep_current or state.design_prep_queue:
+        _prune_design_prep_session(state, wanted)
+        return
+    if S_DESIGN_PREP_DECISION in state.answered:
+        return
+    state.design_prep_queue = list(wanted)
     _advance_design_prep_item(state)
 
 
@@ -3579,6 +3782,8 @@ def _submit_design_prep_overrides(
 
 
 def _design_prep_confirm_applies(state: WizardState) -> bool:
+    if state.task_type == "implementation" and state.approved_plan_path:
+        _ensure_design_prep_queue(state)
     if state.design_prep_decision == "accept-draft":
         return True
     if state.design_prep_decision == "modify-draft":
@@ -3916,7 +4121,12 @@ def _suggest_latest_final_report(state: WizardState) -> str:
             f"{seg}/reports/final-report-*.data.json",
             Path(state.project_root),
         )
-    if best is None:
+    # implementation-planning 의 `--clarification-response` 는 같은 phase 의
+    # 계획서만 받는다(`run._validate_planning_entry_inputs`). 그 phase 에 아직
+    # 리포트가 없으면 이 런은 새 계획이고, 답은 `--selected-direction` 으로
+    # 들어간다 — 전체 phase 폴백은 여기서 직전 후보비교 리포트를 추천했고,
+    # 그것을 고른 사용자는 두 상호 배타 입력을 동시에 갖게 됐다.
+    if best is None and state.task_type != "implementation-planning":
         best = _newest_contained_final_report(
             runs_base,
             task_root,
@@ -4148,16 +4358,58 @@ def _reverify_scope_preview(state: WizardState) -> Optional[dict]:
     )
 
 
-def _reverify_scope_pick_required(state: WizardState) -> bool:
-    """좁힐 여지가 있거나, unlinked id 의 stage 번호를 받아야 할 때 묻는다.
+SCOPE_SHAPE_LINKED = "linked"
+SCOPE_SHAPE_UNLINKED = "unlinked"
+SCOPE_SHAPE_NO_ANSWERS = "no-answers"
+
+
+def _reverify_scope_shape(state: WizardState) -> str:
+    """이 재실행에서 되짚기(back-trace)가 무엇을 내놓았는가.
 
-    unlinked 는 full 확정이 아니다. SHA 가 바뀌었거나 입력을 읽을 수 없어
-    `wouldForceFull` 인 경우만 질문이 의미 없다.
+    셋은 서로 다른 picker 를 요구한다 — `linked` 는 자동 판정이 실제로 좁힐 수
+    있고, 나머지 둘은 자동이 낼 수 있는 답이 full 뿐이라 추천으로 내놓으면
+    거짓말이 된다.
     """
-    preview = _reverify_scope_preview(state)
-    return preview is not None and (
-        not preview["wouldForceFull"] or bool(preview["unlinkedIds"])
-    )
+    preview = _reverify_scope_preview(state) or {}
+    if preview.get("unlinkedIds"):
+        return SCOPE_SHAPE_UNLINKED
+    if preview.get("wouldForceFull"):
+        return SCOPE_SHAPE_NO_ANSWERS
+    return SCOPE_SHAPE_LINKED
+
+
+def _prior_stage_map_readable(state: WizardState) -> bool:
+    """직전 리포트의 Stage Map 을 읽을 수 있는가 — 번호를 검증할 수 있는가."""
+    try:
+        return bool(_prior_stage_numbers(state))
+    except WizardError:
+        return False
+
+
+def _reverify_scope_pick_required(state: WizardState) -> bool:
+    """직전 리포트를 읽을 수 있으면 묻는다.
+
+    종전에는 `preview_link_availability` 의 `wouldForceFull` 이 참이면 묻지
+    않았다. 그 값은 답변된 id 가 0건일 때도 참인데, 그 경우야말로 질문이 필요한
+    경우다 — `--impacted` 는 답변과 **독립된 입력**이고
+    `incremental_scope._decision_for_run` 은 answered 가 비어도 impacted 만으로
+    `incremental` 을 낸다. 열린 항목이 하나도 남지 않은 리포트를 재실행하면서
+    한 stage 만 다시 보고 싶은 경우가 정확히 그 형태이고, 종전 게이트는 그때
+    질문을 없애 사용자가 CLI 플래그를 직접 쓰는 것 말고는 길이 없게 만들었다.
+
+    남는 배제 사유는 하나 — Stage Map 을 못 읽으면 입력받은 번호를 검증할 수단이
+    없다(`_prior_stage_numbers` 가 드는 `no_stage_map`). 그때만 묻지 않는다.
+
+    **base ref(C1)는 여기서 안 본다**: `preview_link_availability` 는 이름 그대로
+    SHA 없이 판정하고, 현재 base SHA 는 `render-bundle` 이 매니페스트를 쓴 뒤에야
+    존재한다. base ref 가 움직인 재실행에서도 질문은 그대로 나오고, full 판정은
+    나중에 `decide_scope` 가 내린다.
+    """
+    if _reverify_scope_preview(state) is None:
+        return False
+    if _reverify_scope_shape(state) != SCOPE_SHAPE_NO_ANSWERS:
+        return True
+    return _prior_stage_map_readable(state)
 
 
 def _reverify_scope_step_pending(state: WizardState) -> bool:
@@ -4190,26 +4442,77 @@ def _prior_stage_numbers(state: WizardState) -> set[int]:
     return stages
 
 
+_SCOPE_SHAPE_LABEL_KEY = {
+    SCOPE_SHAPE_UNLINKED: "label_unlinked",
+    SCOPE_SHAPE_NO_ANSWERS: "label_no_answers",
+}
+
+
 def _build_reverify_scope_pick(state: WizardState) -> Prompt:
     t = _p(state.workspace_root, "reverify_scope_pick")
     opts = t["options"]
-    preview = _reverify_scope_preview(state) or {}
-    unlinked = bool(preview.get("unlinkedIds"))
-    options = []
-    if not unlinked:
-        options.append(_opt("auto", opts["auto"]))
-        options.append(_opt("full", opts["full"]))
-        options.append(_opt(PICK_TYPE_CUSTOM, opts[PICK_TYPE_CUSTOM]))
+    shape = _reverify_scope_shape(state)
+    if shape == SCOPE_SHAPE_LINKED:
+        options = [
+            _opt("auto", opts["auto"]),
+            _opt("full", opts["full"]),
+            _opt(PICK_TYPE_CUSTOM, opts[PICK_TYPE_CUSTOM]),
+        ]
+    # 아래 두 모양에서 `auto` 를 빼는 이유는 같다 — 되짚기가 stage 를 못 냈으므로
+    # 그 핀은 CLI 에 빈 `--impacted` 를 보내고 full(또는 `unresolved`)로만
+    # 돌아온다. 고를 수 있는 것처럼 두면 추천이 아니라 함정이 된다.
+    #
+    # `carry-all` 이 그 자리를 메운다. stage 를 **추가만** 하는 재실행에서는
+    # 지정할 번호가 없어 직접 입력도 쓸 수 없고, 남는 선택이 `full` 뿐이면
+    # 이월해도 되는 stage 를 전부 다시 교차검증하는 비용을 치른다.
+    elif shape == SCOPE_SHAPE_UNLINKED:
+        # 되짚기가 stage 를 못 냈으므로 좁힐 근거가 없다 — 이 모양에서 안전한
+        # 기본값은 full 이고, 그것이 추천이다. 직접 입력은 마지막이다: 목록이
+        # 직접 입력으로 열리면 질문을 통째로 되돌려준 것이고, 실측에서 그
+        # 화면은 리드가 preamble 에 stage 번호를 이미 적어 놓고도 자유 입력만
+        # 내놓았다.
+        options = [
+            _opt("full", opts["full_recommended"]),
+            _opt(CARRY_ALL_SCOPE, opts[CARRY_ALL_SCOPE]),
+            _opt(PICK_TYPE_CUSTOM, opts[PICK_TYPE_CUSTOM]),
+        ]
     else:
-        options.append(_opt(PICK_TYPE_CUSTOM, opts[PICK_TYPE_CUSTOM]))
-        options.append(_opt("full", opts["full"]))
-    label = t["label_unlinked"] if unlinked else t["label"]
+        # 답변된 clarification 이 0건인 재실행. 사용자가 목적을 갖고 stage 를
+        # 지정하러 온 자리라 full 을 추천으로 올리면 비싼 쪽으로 몰게 된다 —
+        # 추천 없이 두고, 근거가 없다는 사실을 라벨이 말한다.
+        options = [
+            _opt(CARRY_ALL_SCOPE, opts[CARRY_ALL_SCOPE]),
+            _opt("full", opts["full"]),
+            _opt(PICK_TYPE_CUSTOM, opts[PICK_TYPE_CUSTOM]),
+        ]
+    label = t[_SCOPE_SHAPE_LABEL_KEY.get(shape, "label")] + _scope_pick_context(state, shape, t)
     return Prompt(
         step=S_REVERIFY_SCOPE_PICK, kind="pick", label=label,
         options=options,
         echo_template=t["echo_template"])
 
 
+def _scope_pick_context(state: WizardState, shape: str, t: dict) -> str:
+    """질문이 왜 나왔는지 화면에 싣는 한 문장.
+
+    `unlinked` 는 어느 id 가 연결되지 않았는지가 답을 고르는 근거인데, 종전에는
+    그 목록이 `errors.unlinked_auto`(자동을 고른 뒤에야 보이는 문구)에만 있었다.
+    id 없이 "연결되지 않은 것이 있습니다" 만 받은 사용자는 자기 답변 중 무엇을
+    말하는지 모른 채 stage 번호를 대야 했다.
+
+    `no-answers` 는 추천할 근거가 없다는 사실 자체를 말한다 — 근거 없이 한
+    선택지를 추천으로 꾸미지 않는다.
+    """
+    labels = t.get("labels") or {}
+    if shape == SCOPE_SHAPE_UNLINKED:
+        ids = (_reverify_scope_preview(state) or {}).get("unlinkedIds") or []
+        note = labels.get("unlinked_ids", "")
+        return note.format(ids=", ".join(str(i) for i in ids)) if note and ids else ""
+    if shape == SCOPE_SHAPE_NO_ANSWERS:
+        return labels.get("no_basis", "")
+    return ""
+
+
 def _submit_reverify_scope_pick(state: WizardState, value: str) -> Optional[str]:
     t = _p(state.workspace_root, "reverify_scope_pick")
     picked = value.strip().lower()
@@ -4217,22 +4520,40 @@ def _submit_reverify_scope_pick(state: WizardState, value: str) -> Optional[str]
         state.reverify_scope = ""
         state.reverify_scope_pending_text = True
         return "reverify-scope: 직접 입력"
-    if picked not in ("auto", "full"):
+    if picked not in ("auto", "full", CARRY_ALL_SCOPE):
         raise WizardError(
-            f"expected 'auto' / 'full' / {PICK_TYPE_CUSTOM!r}, got: {value!r}"
+            f"expected 'auto' / 'full' / {CARRY_ALL_SCOPE!r} / "
+            f"{PICK_TYPE_CUSTOM!r}, got: {value!r}"
         )
     if picked == "auto":
-        preview = _reverify_scope_preview(state) or {}
-        unlinked = preview.get("unlinkedIds") or []
-        if unlinked:
-            raise WizardError(
-                t["errors"]["unlinked_auto"].format(ids=", ".join(unlinked))
-            )
+        _refuse_auto_without_a_back_trace(state, t)
     state.reverify_scope = picked
     state.reverify_scope_pending_text = False
     return t["echo_suffixes"][picked]
 
 
+def _refuse_auto_without_a_back_trace(
+    state: WizardState,
+    t: dict,
+    *,
+    auto_key: str = "unlinked_auto",
+    no_answers_key: str = "no_answers_auto",
+) -> None:
+    """되짚기가 stage 를 못 낸 재실행에서 `auto` 를 거절한다.
+
+    두 모양의 사유가 다르므로 문구도 다르다 — 연결 안 된 id 는 그 id 를 이름으로
+    말해 줘야 사용자가 무엇의 stage 를 지정할지 알고, 답변이 아예 없는 경우에는
+    말할 id 자체가 없다. 두 진입점(picker 의 `auto`, stage 입력의 빈 줄)이 같은
+    판정을 쓰도록 한곳에 둔다.
+    """
+    shape = _reverify_scope_shape(state)
+    if shape == SCOPE_SHAPE_UNLINKED:
+        unlinked = (_reverify_scope_preview(state) or {}).get("unlinkedIds") or []
+        raise WizardError(t["errors"][auto_key].format(ids=", ".join(unlinked)))
+    if shape == SCOPE_SHAPE_NO_ANSWERS:
+        raise WizardError(t["errors"][no_answers_key])
+
+
 def _build_reverify_scope_stages(state: WizardState) -> Prompt:
     t = _p(state.workspace_root, "reverify_scope_stages")
     return Prompt(
@@ -4244,12 +4565,11 @@ def _submit_reverify_scope_stages(state: WizardState, value: str) -> Optional[st
     t = _p(state.workspace_root, "reverify_scope_stages")
     tokens = [token.strip() for token in value.split(",") if token.strip()]
     if not tokens:
-        preview = _reverify_scope_preview(state) or {}
-        unlinked = preview.get("unlinkedIds") or []
-        if unlinked:
-            raise WizardError(
-                t["errors"]["unlinked_empty"].format(ids=", ".join(unlinked))
-            )
+        # 빈 줄은 `auto` 로 떨어지므로 picker 의 `auto` 와 같은 배제가 걸린다 —
+        # 여기만 열어 두면 picker 에서 막은 핀이 뒷문으로 들어온다.
+        _refuse_auto_without_a_back_trace(
+            state, t, auto_key="unlinked_empty", no_answers_key="no_answers_empty"
+        )
         state.reverify_scope = "auto"
         state.reverify_scope_pending_text = False
         return t["echo_suffixes"]["auto"]
@@ -4502,8 +4822,24 @@ def _build_reuse_previous(state: WizardState) -> Prompt:
 
 
 def _restore_reused_lead(state: WizardState, inputs: dict) -> None:
-    requested_provider = _safe_provider(inputs.get("leadProvider"), "lead")
+    """리드는 지금 host 에서 파생한다. 직전 run 의 기록을 물려받지 않는다.
+
+    run-inputs 의 ``leadProvider`` 는 그 run 이 어느 host 에서 돌았는지의 기록이지
+    사용자가 고른 값이 아니다. wizard 에는 리드 provider 를 묻는 단계 자체가 없고
+    ``resolve_lead_provider`` 가 host 의 네이티브 provider 로 파생한다. 그 기록을
+    그대로 요청으로 되먹이면 Codex 에서 돌린 run 을 Claude Code 에서 이어받을 때
+    host 검사에 걸려 brief/workers/모델 복원까지 통째로 막힌다.
+
+    네이티브 리드가 없는 host(``external``) 에서만 기록된 값이 유일한 단서이므로
+    그때만 참고한다.
+    """
     try:
+        host = default_host_registry().resolve(state.host_runtime).descriptor
+        requested_provider = (
+            ""
+            if host.native_provider_id
+            else _safe_provider(inputs.get("leadProvider"), "lead")
+        )
         assignment = resolve_lead_provider(
             host_id=state.host_runtime,
             requested_provider=requested_provider,
@@ -5410,6 +5746,12 @@ STEPS: list[Step] = [
                             and S_APPROVE_PLAN_CONFIRM not in s.answered),
          build=_build_approve_plan_confirm, submit=_submit_approve_plan_confirm,
          owns=("approve_plan_candidate",)),
+    Step(S_STAGE_PICK,
+         applies=lambda s: (s.task_type in _STAGE_SCOPED_TASK_TYPES
+                            and bool(s.approved_plan_path)
+                            and S_STAGE_PICK not in s.answered),
+         build=_build_stage_pick, submit=_submit_stage_pick,
+         owns=("selected_stage", "selected_stages")),
     Step(S_DESIGN_PREP_DECISION,
          applies=_design_prep_decision_applies,
          build=_build_design_prep_decision,
@@ -5431,12 +5773,6 @@ STEPS: list[Step] = [
          owns=("design_prep_decision", "design_prep_overrides_json",
                "design_prep_notes"),
          repeatable=True),
-    Step(S_STAGE_PICK,
-         applies=lambda s: (s.task_type in _STAGE_SCOPED_TASK_TYPES
-                            and bool(s.approved_plan_path)
-                            and S_STAGE_PICK not in s.answered),
-         build=_build_stage_pick, submit=_submit_stage_pick,
-         owns=("selected_stage", "selected_stages")),
     Step(S_HANDOFF_STAGE_PICK,
          applies=lambda s: (s.task_type == "release-handoff"
                             and bool(s.task_group)
@@ -5870,6 +6206,18 @@ def init_state(
     )
 
 
+def _auto_start_new_task_when_it_is_the_only_choice(state: WizardState) -> None:
+    """미완료 task 가 없으면 중복된 새 작업 선택 화면을 건너뛴다."""
+    prompt = next_prompt(state)
+    if (
+        prompt.step != S_TASK_PICK
+        or [option.value for option in prompt.options] != [TASK_PICK_NEW_TOKEN]
+    ):
+        return
+    _submit_task_pick(state, TASK_PICK_NEW_TOKEN)
+    state.answered.append(S_TASK_PICK)
+
+
 def _build_group_prompt(state: WizardState, group_id: str) -> Prompt:
     """그룹의 적용가능·미답변 픽 멤버를 최대 GROUP_MAX_TABS 개 모은다.
 
@@ -6313,6 +6661,9 @@ def _reverify_scope_line(state: WizardState) -> Optional[str]:
     if state.reverify_scope == "full":
         return _msg(state.workspace_root, "confirmation",
                     "reverify_scope_user_full")
+    if state.reverify_scope == CARRY_ALL_SCOPE:
+        return _msg(state.workspace_root, "confirmation",
+                    "reverify_scope_user_carry_all")
     if state.reverify_scope and state.reverify_scope != "auto":
         return _msg(state.workspace_root, "confirmation",
                     "reverify_scope_user_stages", stages=state.reverify_scope)
@@ -6378,15 +6729,22 @@ def confirmation_block(state: WizardState) -> str:
         lines.append(f"  workers       : {roster}")
     if role_selection:
         profile = _load_role_profile_for_state(state)
-        if state.host_entry_mode == "current-session":
-            lines.append(_msg(
-                state.workspace_root,
-                "confirmation",
-                "static_role",
-                role="leader",
-                ordinal="1",
-                model="current-session",
-            ))
+        native_provider = default_host_registry().resolve(
+            state.host_runtime
+        ).descriptor.native_provider_id
+        leader_model = (
+            "current-session"
+            if state.host_entry_mode == "current-session"
+            else f"{native_provider} (host runtime default)"
+        )
+        lines.append(_msg(
+            state.workspace_root,
+            "confirmation",
+            "static_role",
+            role="leader",
+            ordinal="1",
+            model=leader_model,
+        ))
         for requirement in _selectable_static_requirements(state, profile):
             count = _selected_role_count(state, requirement)
             selected = state.role_models.get(requirement.role, [])
@@ -6715,6 +7073,7 @@ def _cli(argv: list[str]) -> int:
         )
         if args.critic:
             state.critic = args.critic
+        _auto_start_new_task_when_it_is_the_only_choice(state)
         save_state_file(state_path, state)
         first = next_prompt(state)
         print(json.dumps({"ok": True, "next": prompt_payload(state, first)},
@@ -6750,7 +7109,13 @@ def _cli(argv: list[str]) -> int:
         except WizardError as exc:
             _save_resumed_state_file(state_path, persisted_state)
             try:
-                current = prompt_payload(state, next_prompt(state))
+                # current 는 방금 디스크로 되돌린 상태에서 렌더한다. 뮤테이션이
+                # 진행되다 만 state 로 렌더하면, 검증 전에 필드를 채운 핸들러
+                # (예: reuse_previous)의 실패가 다음 스텝을 current 로 내보내
+                # 재질문 계약("ok:false 면 같은 step 재제출")과 어긋난다.
+                current = prompt_payload(
+                    persisted_state, next_prompt(persisted_state)
+                )
             except WizardError:
                 # 현재 step 의 build 자체가 실패하면(예: 손상된 Stage Map 으로
                 # _build_stage_pick·_build_handoff_stage_pick 가 raise) recovery 재렌더가