okstra 0.207.1 → 0.209.0

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

@@ -1,4 +1,4 @@
-"""위저드 상태 — `WizardState`·`Prompt`·`Option`·`Step` 데이터 타입, v1 provider 선택의 v2 변환, 상태 술어."""
+"""위저드 상태 — `WizardState`·`Prompt`·`Option`·`Step` 데이터 타입, 직전 run 입력의 역할 선택 변환, 상태 술어."""
 from __future__ import annotations
 
 from dataclasses import asdict, dataclass, field
@@ -30,8 +30,7 @@ from .ids import (
 
 @dataclass
 class WizardState:
-    # execution identity v2: role-first canonical model selections
-    execution_identity_version: int = 1
+    # role-first canonical model selections
     role_counts: dict[str, int] = field(default_factory=dict)
     role_models: dict[str, list[str]] = field(default_factory=dict)
     role_selection_order: list[str] = field(default_factory=list)
@@ -61,8 +60,6 @@ class WizardState:
 
     # task-type + dependents
     task_type: str = ""
-    profile_workers: list[str] = field(default_factory=list)
-    profile_optional_workers: list[str] = field(default_factory=list)
 
     # brief
     keep_existing_brief: Optional[bool] = None
@@ -100,9 +97,6 @@ class WizardState:
     design_prep_notes: str = ""
     selected_stage: str = "auto"
     selected_stages: str = ""   # implementation 다중선택 위상정렬 CSV
-    executor: str = ""
-    critic: str = ""
-    critic_pending_text: bool = False
 
     # release-handoff: PR 을 열 stage 들. stage 하나가 PR 하나다.
     handoff_stages: str = ""  # csv ("2,3")
@@ -111,18 +105,6 @@ class WizardState:
     reuse_previous: Optional[bool] = None
 
     # customize
-    use_defaults: Optional[bool] = None
-    workers_override: str = ""
-    workers_custom_pending: bool = False
-    lead_provider: str = ""
-    lead_model: str = ""
-    claude_model: str = ""
-    codex_model: str = ""
-    antigravity_model: str = ""
-    grok_model: str = ""
-    kimi_model: str = ""
-    report_writer_provider: str = ""
-    report_writer_model: str = ""
     directive: str = ""
     directive_pending_text: bool = False
     last_directive_cached: str = ""
@@ -159,13 +141,10 @@ class WizardState:
 
     def to_json(self) -> dict[str, Any]:
         payload = asdict(self)
-        payload.pop("execution_identity_version")
-        payload["executionIdentityVersion"] = 2
+        payload["executionIdentityVersion"] = WIZARD_STATE_VERSION
         payload["roleCounts"] = payload.pop("role_counts")
         payload["roleModels"] = payload.pop("role_models")
         payload["roleSelectionOrder"] = payload.pop("role_selection_order")
-        for field_name in _V1_PROVIDER_STATE_FIELDS:
-            payload.pop(field_name, None)
         return payload
 
     @classmethod
@@ -314,6 +293,9 @@ def _profile_path(workspace_root: Path, task_type: str) -> Path:
         raise WizardError(str(exc)) from exc
 
 
+WIZARD_STATE_VERSION = 2
+
+
 _V2_STATE_FIELDS = (
     "roleCounts",
     "roleModels",
@@ -321,37 +303,6 @@ _V2_STATE_FIELDS = (
 )
 
 
-_V1_PROVIDER_STATE_FIELDS = (
-    "workers_override",
-    "lead_provider",
-    "lead_model",
-    "claude_model",
-    "codex_model",
-    "antigravity_model",
-    "grok_model",
-    "kimi_model",
-    "report_writer_provider",
-    "report_writer_model",
-    "executor",
-    "critic",
-)
-
-
-_V1_PROVIDER_STATE_JSON_FIELDS = frozenset({
-    *_V1_PROVIDER_STATE_FIELDS,
-    "workers",
-    "leadProvider",
-    "leadModel",
-    "claudeModel",
-    "codexModel",
-    "antigravityModel",
-    "grokModel",
-    "kimiModel",
-    "reportWriterProvider",
-    "reportWriterModel",
-})
-
-
 def _load_role_profile_for_state(state: WizardState) -> RoleProfile:
     try:
         return load_role_profile(
@@ -361,22 +312,12 @@ def _load_role_profile_for_state(state: WizardState) -> RoleProfile:
         raise WizardError(str(exc)) from exc
 
 
-def _role_selection_enabled(state: WizardState) -> bool:
-    if (
-        state.execution_identity_version != 2
-        or not state.workspace_root
-        or not state.task_type
-    ):
-        return False
-    try:
-        load_role_profile(_profile_path(Path(state.workspace_root), state.task_type))
-    except (OSError, RoleProfileError, WizardError):
-        return False
-    return True
-
+def _role_selection_ready(state: WizardState) -> bool:
+    """역할 화면을 만들 수 있을 만큼 task 정체성이 정해졌는가.
 
-def _legacy_value(payload: dict[str, Any], snake: str, camel: str) -> Any:
-    return payload.get(snake, payload.get(camel, ""))
+    프로필 로드 실패는 여기서 삼키지 않는다 — 로드하는 쪽이 WizardError 로 낸다.
+    """
+    return bool(state.workspace_root and state.task_type)
 
 
 def _legacy_model_ref(
@@ -404,7 +345,7 @@ def _legacy_model_ref(
 
 
 def _legacy_worker_providers(payload: dict[str, Any]) -> list[str]:
-    raw = _legacy_value(payload, "workers_override", "workers")
+    raw = payload.get("workers", "")
     if isinstance(raw, list):
         values = raw
     elif isinstance(raw, str):
@@ -436,12 +377,11 @@ def _initial_cross_verification_requirement(
     ), None)
 
 
-def _convert_v1_provider_selections(
+def _role_selections_from_run_inputs(
     state: WizardState,
     payload: dict[str, Any],
 ) -> None:
-    if not _role_selection_enabled(state):
-        return
+    """직전 run-inputs 의 provider·모델 기록을 역할별 모델 선택으로 옮긴다."""
     profile = _load_role_profile_for_state(state)
     pool = ModelPool.from_registry(default_provider_registry())
     cross_requirement = _initial_cross_verification_requirement(profile)
@@ -461,11 +401,7 @@ def _convert_v1_provider_selections(
                 for model in pool.default_candidates(cross_requirement.role)
             ]
         for ordinal, provider in enumerate(providers[:selected_count], start=1):
-            raw_model = _legacy_value(
-                payload,
-                f"{provider}_model",
-                f"{provider}Model",
-            )
+            raw_model = payload.get(f"{provider}Model", "")
             model_ref = _legacy_model_ref(
                 pool,
                 provider,
@@ -479,43 +415,17 @@ def _convert_v1_provider_selections(
             # 여러 인스턴스 역할의 답은 체크박스 한 장이다.
             state.role_selection_order.append(f"role-models:{cross_requirement.role}")
 
+    executor = payload.get("executor") or "claude"
+    critic = payload.get("critic") or ""
+    # 리더는 호스트가 정하므로 옮기지 않는다(`_discard_implicit_leader_selection`).
     provider_rows = (
-        (
-            "leader",
-            _legacy_value(payload, "lead_provider", "leadProvider") or "claude",
-            _legacy_value(payload, "lead_model", "leadModel"),
-        ),
         (
             "report-writer",
-            _legacy_value(
-                payload,
-                "report_writer_provider",
-                "reportWriterProvider",
-            ) or "claude",
-            _legacy_value(
-                payload,
-                "report_writer_model",
-                "reportWriterModel",
-            ),
-        ),
-        (
-            "implementer",
-            _legacy_value(payload, "executor", "executor") or "claude",
-            _legacy_value(
-                payload,
-                f"{_legacy_value(payload, 'executor', 'executor') or 'claude'}_model",
-                f"{_legacy_value(payload, 'executor', 'executor') or 'claude'}Model",
-            ),
-        ),
-        (
-            "critic",
-            _legacy_value(payload, "critic", "critic"),
-            _legacy_value(
-                payload,
-                f"{_legacy_value(payload, 'critic', 'critic')}_model",
-                f"{_legacy_value(payload, 'critic', 'critic')}Model",
-            ),
+            payload.get("reportWriterProvider") or "claude",
+            payload.get("reportWriterModel", ""),
         ),
+        ("implementer", executor, payload.get(f"{executor}Model", "")),
+        ("critic", critic, payload.get(f"{critic}Model", "")),
     )
     static_roles = {
         requirement.role
@@ -532,34 +442,25 @@ def _convert_v1_provider_selections(
         state.role_selection_order.append(f"role-model:{role}:1")
 
 
+class StaleWizardStateError(WizardError):
+    """저장된 상태가 현재 형식(`WIZARD_STATE_VERSION`)이 아니다 — 이어갈 수 없다."""
+
+
 def _wizard_state_from_json(payload: dict[str, Any]) -> WizardState:
     if not isinstance(payload, dict):
         raise WizardError("wizard state must be a JSON object")
     data = dict(payload)
     version = data.pop("executionIdentityVersion", None)
-    has_v2_fields = any(field_name in data for field_name in _V2_STATE_FIELDS)
-    has_v1_fields = any(
-        field_name in data for field_name in _V1_PROVIDER_STATE_JSON_FIELDS
-    )
-    if version == 2:
-        if has_v1_fields or not all(field_name in data for field_name in _V2_STATE_FIELDS):
-            raise WizardError("mixed wizard state versions are not allowed")
-        data["role_counts"] = data.pop("roleCounts")
-        data["role_models"] = data.pop("roleModels")
-        data["role_selection_order"] = data.pop("roleSelectionOrder")
-        data["execution_identity_version"] = 2
-        _validate_v2_state_fields(data)
-    elif version in (None, 1):
-        if has_v2_fields:
-            raise WizardError("mixed wizard state versions are not allowed")
-        data.pop("execution_identity_version", None)
-    else:
-        raise WizardError(f"unsupported wizard state version: {version!r}")
+    if version != WIZARD_STATE_VERSION:
+        raise StaleWizardStateError(f"unsupported wizard state version: {version!r}")
+    if not all(field_name in data for field_name in _V2_STATE_FIELDS):
+        raise WizardError("wizard state is missing role selection fields")
+    data["role_counts"] = data.pop("roleCounts")
+    data["role_models"] = data.pop("roleModels")
+    data["role_selection_order"] = data.pop("roleSelectionOrder")
+    _validate_v2_state_fields(data)
     allowed = WizardState.__dataclass_fields__.keys()
     state = WizardState(**{key: value for key, value in data.items() if key in allowed})
-    if version != 2:
-        state.execution_identity_version = 2
-        _convert_v1_provider_selections(state, payload)
     _discard_implicit_leader_selection(state)
     return state
 
@@ -632,7 +533,7 @@ class Step:
 
 
 def _identity_ready(s: WizardState) -> bool:
-    """All identity questions (task pick → executor for impl) answered."""
+    """All identity questions (task pick → stage/handoff picks) answered."""
     if not s.task_type:
         return False
     # release-handoff 는 brief 가 없다 — prepare 가 검증 보고서 인용 input 을 생성한다.
@@ -645,9 +546,6 @@ def _identity_ready(s: WizardState) -> bool:
     if s.task_type in _STAGE_SCOPED_TASK_TYPES:
         if not s.approved_plan_path:
             return False
-    if s.task_type == "implementation" and not _role_selection_enabled(s):
-        if not s.executor:
-            return False
     if (s.task_type == "release-handoff"
             and S_HANDOFF_STAGE_PICK not in s.answered):
         return False
@@ -659,7 +557,6 @@ _FIELD_DEFAULTS: dict[str, Any] = {
     "existing_brief_path": "", "task_type": "",
     "task_group_suggestion": "", "task_id_suggestion": "",
     "task_group_pending_text": False, "task_id_pending_text": False,
-    "profile_workers": [], "profile_optional_workers": [],
     "keep_existing_brief": None,
     "brief_path": "", "brief_path_pending_text": False,
     "project_evidence_path": "", "project_evidence_pending_text": False,
@@ -675,15 +572,9 @@ _FIELD_DEFAULTS: dict[str, Any] = {
     "selected_stage": "auto",
     "selected_stages": "",
     "handoff_stages": "",
-    "executor": "", "critic": "", "critic_pending_text": False,
-    "execution_identity_version": 1,
     "role_counts": {}, "role_models": {}, "role_selection_order": [],
     "reuse_previous": None,
-    "use_defaults": None, "workers_override": "",
-    "workers_custom_pending": False,
-    "lead_provider": "", "lead_model": "", "claude_model": "", "codex_model": "",
-    "antigravity_model": "", "grok_model": "", "kimi_model": "",
-    "report_writer_provider": "", "report_writer_model": "", "directive": "",
+    "directive": "",
     "directive_pending_text": False,
     "related_tasks_raw": "", "related_tasks_pending_text": False,
     "clarification_response_path": "", "clarification_pending_text": False,

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

@@ -1,144 +1,43 @@
-"""위저드 상태 파일 — `load_state_file`·`save_state_file` 과 v2 companion 파일 탐색."""
+"""위저드 상태 파일 — `load_state_file`·`save_state_file`."""
 from __future__ import annotations
 
-import hashlib
 from pathlib import Path
-from typing import Any
 
 from okstra_ctl.convergence_store import write_json_atomic
-from okstra_ctl.json_boundary import JsonBoundaryError, load_owned_object
+from okstra_ctl.json_boundary import load_owned_object
 
-from .state import WizardError, WizardState
+from .state import StaleWizardStateError, WizardState
 
 
-# ---- File I/O helpers (used by CLI) -------------------------------------
+# 형식이 바뀐 상태 파일에서도 살리는 값 — 위저드를 처음부터 다시 여는 데 필요한 부트스트랩뿐이다.
+_BOOTSTRAP_FIELDS = (
+    "workspace_root",
+    "project_root",
+    "project_id",
+    "preferred_task_key",
+    "host_runtime",
+    "host_entry_mode",
+    "available_functions",
+)
 
-_LEGACY_SOURCE_FIELD = "legacySource"
 
-
-def _legacy_v2_companion_path(path: Path) -> Path:
-    return path.with_name(f"{path.name}.v2.json")
-
-
-def _content_addressed_v2_companion_path(
-    path: Path,
-    source_digest: str,
-    suffix: int | None = None,
-) -> Path:
-    numbered = f".{suffix}" if suffix is not None else ""
-    return path.with_name(f"{path.name}.v2.{source_digest}{numbered}.json")
-
-
-def _content_addressed_v2_companion_paths(
-    path: Path,
-    source_digest: str,
-) -> tuple[Path, ...]:
-    canonical = _content_addressed_v2_companion_path(path, source_digest)
-    numbered_prefix = f"{path.name}.v2.{source_digest}."
-    numbered = tuple(sorted(
-        candidate
-        for candidate in path.parent.iterdir()
-        if candidate.is_file()
-        and candidate.name.startswith(numbered_prefix)
-        and candidate.name.endswith(".json")
-    ))
-    return (canonical, *numbered)
-
-
-def _available_v2_companion_path(path: Path, source_digest: str) -> Path:
-    candidate = _content_addressed_v2_companion_path(path, source_digest)
-    suffix = 1
-    while candidate.exists():
-        candidate = _content_addressed_v2_companion_path(
-            path,
-            source_digest,
-            suffix,
-        )
-        suffix += 1
-    return candidate
-
-
-def _legacy_source_metadata(path: Path, source: bytes) -> dict[str, str]:
-    return {
-        "path": str(path.resolve()),
-        "sha256": hashlib.sha256(source).hexdigest(),
-    }
-
-
-def _matching_v2_companion(
-    path: Path,
-    source_metadata: dict[str, str],
-) -> dict[str, Any] | None:
-    try:
-        payload = load_owned_object(path, artifact="wizard state")
-    except (OSError, UnicodeError, JsonBoundaryError):
-        return None
-    if not isinstance(payload, dict):
-        return None
-    if payload.get("executionIdentityVersion") != 2:
-        return None
-    if payload.get(_LEGACY_SOURCE_FIELD) != source_metadata:
-        return None
-    return payload
-
-
-def _load_matching_v2_state(
-    paths: tuple[Path, ...],
-    source_metadata: dict[str, str],
-) -> tuple[WizardState | None, Path | None]:
-    for companion_path in paths:
-        payload = _matching_v2_companion(companion_path, source_metadata)
-        if payload is None:
-            continue
-        try:
-            return WizardState.from_json(payload), companion_path
-        except WizardError:
-            continue
-    return None, None
+def _fresh_state_from_stale(payload: dict) -> WizardState:
+    defaults = WizardState()
+    kwargs = {}
+    for name in _BOOTSTRAP_FIELDS:
+        value = payload.get(name)
+        if isinstance(value, type(getattr(defaults, name))):
+            kwargs[name] = value
+    return WizardState(**kwargs)
 
 
 def load_state_file(path: Path) -> WizardState:
-    source_path = Path(path)
-    source = source_path.read_bytes()
-    data = load_owned_object(source_path, artifact="wizard state")
-    source_version = data.get("executionIdentityVersion", 1)
-    source_metadata = _legacy_source_metadata(source_path, source)
-    source_digest = source_metadata["sha256"]
-    resumed_state = None
-    companion_path = None
-    if source_version in (None, 1):
-        content_paths = _content_addressed_v2_companion_paths(
-            source_path,
-            source_digest,
-        )
-        resumed_state, companion_path = _load_matching_v2_state(
-            content_paths,
-            source_metadata,
-        )
-        if resumed_state is None:
-            resumed_state, _ = _load_matching_v2_state(
-                (_legacy_v2_companion_path(source_path),),
-                source_metadata,
-            )
-    state = resumed_state or WizardState.from_json(data)
-    state._source_execution_identity_version = source_version
-    if source_version in (None, 1):
-        state._legacy_source_metadata = source_metadata
-        state._v2_companion_path = companion_path or _available_v2_companion_path(
-            source_path,
-            source_digest,
-        )
-    return state
-
-
-def _save_resumed_state_file(path: Path, state: WizardState) -> None:
-    """Persist native v2 state while keeping legacy resume sources read-only."""
-    if getattr(state, "_source_execution_identity_version", 2) in (None, 1):
-        payload = state.to_json()
-        payload[_LEGACY_SOURCE_FIELD] = state._legacy_source_metadata
-        write_json_atomic(state._v2_companion_path, payload)
-        return
-    save_state_file(path, state)
+    data = load_owned_object(Path(path), artifact="wizard state")
+    try:
+        return WizardState.from_json(data)
+    except StaleWizardStateError:
+        # 이전 형식의 진행분은 옮기지 않는다 — 같은 프로젝트로 새 세션을 시작한다.
+        return _fresh_state_from_stale(data)
 
 
 def save_state_file(path: Path, state: WizardState) -> None:

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

@@ -63,8 +63,6 @@ from .sources import (
     _file_recency,
     _git_main_worktree,
     _latest_revision_requested_analysis_type,
-    _load_profile_optional_workers,
-    _load_profile_workers,
     _parse_iso_timestamp,
     _phase_after,
     _project_relative_path,
@@ -671,12 +669,6 @@ def _apply_task_type(state: WizardState, value: str) -> str:
     # 퍼지해야 downstream 재선택 시 carry 단계가 다시 나온다.
     state.answered = [a for a in state.answered if a != S_BRIEF_CARRY]
     carried = _carry_in_existing_brief(state)
-    state.profile_workers = _load_profile_workers(
-        Path(state.workspace_root), value
-    )
-    state.profile_optional_workers = _load_profile_optional_workers(
-        Path(state.workspace_root), value
-    )
     # Reuse-worktree is decided once identity is final. Recompute here so
     # subsequent base-ref step knows whether to apply.
     state.reuse_worktree = _resolve_reuse_worktree(state)
@@ -839,11 +831,31 @@ def _build_brief_carry(state: WizardState) -> Prompt:
     )
 
 
+def _checked_out_canonical_ref(project_root: Path) -> str:
+    """The main worktree's branch when it is one of the listed base refs, else ''.
+
+    Projects differ in their integration branch (main vs preprod), and nothing in
+    okstra records it; the branch the user keeps checked out is the observed hint.
+    """
+    try:
+        main_wt = _git_main_worktree(project_root)
+    except WizardError:
+        return ""
+    result = subprocess.run(
+        ["git", "-C", str(main_wt), "symbolic-ref", "--quiet", "--short", "HEAD"],
+        capture_output=True, text=True,
+    )
+    branch = result.stdout.strip() if result.returncode == 0 else ""
+    return branch if branch in CANONICAL_BASE_REFS else ""
+
+
 def _build_base_ref_pick(state: WizardState) -> Prompt:
     t = _p(state.workspace_root, "base_ref_pick")
     recommended_suffix = t["options"].get("_RECOMMENDED_SUFFIX", "")
-    options = [_opt(r, f"main{recommended_suffix}" if r == "main" else r)
-               for r in CANONICAL_BASE_REFS]
+    recommended = _checked_out_canonical_ref(Path(state.project_root))
+    refs = sorted(CANONICAL_BASE_REFS, key=lambda r: r != recommended)
+    options = [_opt(r, f"{r}{recommended_suffix}", recommended=True) if r == recommended
+               else _opt(r) for r in refs]
     for value, label in _static_options(t):
         options.append(_opt(value=value, label=label))
     return Prompt(

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

@@ -131,7 +131,7 @@ def _build_optional_cached_pick(state: WizardState, spec: _OptionalCachedPickSpe
         if spec.recommend_note:
             label += spec.recommend_note(state, suggestion)
         options.append(_opt(spec.recommend_token, label, recommended=True))
-        setattr(state, spec.cache_attr, suggestion)
+    setattr(state, spec.cache_attr, suggestion)
     options.append(_opt(PICK_SKIP, t["options"][PICK_SKIP]))
     options.append(_opt(PICK_TYPE_CUSTOM, t["options"][PICK_TYPE_CUSTOM]))
     return Prompt(
@@ -151,8 +151,8 @@ def _submit_optional_cached_pick(
             setattr(state, attr, "")
         setattr(state, spec.pending_attr, False)
         return t["echo_suffixes"]["skip"]
-    if value == spec.recommend_token:
-        cached = getattr(state, spec.cache_attr)
+    cached = getattr(state, spec.cache_attr)
+    if value == spec.recommend_token and cached:
         setattr(state, spec.target_attr, cached)
         setattr(state, spec.pending_attr, False)
         echo = t["echo_suffixes"][spec.echo_suffix_key].format(value=cached)
@@ -162,9 +162,10 @@ def _submit_optional_cached_pick(
     if value == PICK_TYPE_CUSTOM:
         setattr(state, spec.pending_attr, True)
         return None
+    offered = ([spec.recommend_token] if cached else []) + [PICK_SKIP, PICK_TYPE_CUSTOM]
     raise WizardError(
         f"unexpected {spec.prompt_key} value: {value!r} "
-        f"(expected {PICK_SKIP!r}, {spec.recommend_token!r}, or {PICK_TYPE_CUSTOM!r})"
+        f"(expected {', '.join(map(repr, offered[:-1]))}, or {offered[-1]!r})"
     )