okstra 0.206.0 → 0.207.0

package/runtime/python/okstra_ctl/run_artifact_prune.py

@@ -0,0 +1,200 @@
+"""run 이 끝난 뒤 읽는 곳이 없는 산출물을 찾고 지운다.
+
+- 의존성·빌드 디렉터리(`node_modules`, `.next`): technical-verification 워커는
+  `experiments/<seq>/<worker-id>/` 에 사이트 복사본을 만들고 그 안에서 설치·빌드한다.
+  증거는 계획·로그·lockfile·diff 이고, 설치·빌드 결과는 lockfile 로 다시 만든다. 태스크
+  하나에 `node_modules` 46개와 `.next` 16개(약 22GB)가 남은 사례가 있다(2026-09-27).
+- dispatch 스냅샷(`*.mutation-audit.json`)과 프롬프트 발행 잠금(`*.publish.lock`): 워커
+  시도의 종결 판정과 같은 run 의 증거 복구만 읽는다. 결과는 시도 기록의 변경 요약에
+  남고, `validate-run` 은 경로 문자열만 본다. 검증을 통과한 run 과, 같은 run 디렉터리에서
+  더 뒤의 run 이 검증을 통과한 run 의 dispatch 기록이 가리키는 것만 지운다 — 가장 최근의
+  실패한 run 은 같은 run 안에서 워커를 다시 보낼 수 있다.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import shutil
+from pathlib import Path
+from typing import Any
+
+from okstra_project import resolve_project_root
+
+from .fixed_text import line
+from .json_boundary import JsonBoundaryError, load_owned_object
+from .paths import task_dir
+
+PRUNED_DIR_NAMES = frozenset({"node_modules", ".next"})
+_DISPATCH_ARRAYS = ("agentDispatches", "workerDispatches")
+_MANIFEST_SEQ = re.compile(r"^run-manifest-.+-(\d{3,})\.json$")
+
+
+def _tree_bytes(root: Path) -> int:
+    total = 0
+    for current, _dirs, files in os.walk(root):
+        for name in files:
+            try:
+                total += os.lstat(os.path.join(current, name)).st_size
+            except OSError:
+                continue
+    return total
+
+
+def find_build_dirs(root: Path) -> list[dict[str, Any]]:
+    """`root` 아래 의존성·빌드 디렉터리. 심볼릭 링크는 따라가지도 지우지도 않는다."""
+    found: list[dict[str, Any]] = []
+    # `.okstra` 아래는 `Path.glob("**")` 이 숨김 디렉터리를 건너뛰므로 os.walk 로 훑는다.
+    for current, dirs, _files in os.walk(root):
+        kept = []
+        for name in dirs:
+            path = Path(current) / name
+            if name in PRUNED_DIR_NAMES and not path.is_symlink():
+                found.append({"path": str(path), "bytes": _tree_bytes(path)})
+            else:
+                kept.append(name)
+        dirs[:] = kept
+    return sorted(found, key=lambda row: row["path"])
+
+
+def _resolve(project_root: Path, value: str) -> Path:
+    path = Path(value)
+    return path if path.is_absolute() else project_root / path
+
+
+def _settled_manifests(manifests_dir: Path, names: list[str]) -> list[dict[str, Any]]:
+    """검증을 통과했거나, 같은 디렉터리의 더 뒤 run 이 통과한 run 매니페스트.
+
+    한 `manifests/` 의 seq 는 한 카운터에서 나오므로 숫자 순서가 실행 순서다.
+    """
+    loaded: list[tuple[int, dict[str, Any]]] = []
+    for name in names:
+        match = _MANIFEST_SEQ.match(name)
+        if match is None:
+            continue
+        try:
+            manifest = load_owned_object(manifests_dir / name, artifact="run manifest")
+        except (OSError, JsonBoundaryError):
+            continue
+        loaded.append((int(match[1]), manifest))
+    passed = [
+        seq for seq, manifest in loaded
+        if (manifest.get("validation") or {}).get("status") == "passed"
+    ]
+    if not passed:
+        return []
+    return [manifest for seq, manifest in loaded if seq <= max(passed)]
+
+
+def find_dispatch_leftovers(project_root: Path, root: Path) -> list[dict[str, Any]]:
+    """`root` 아래 끝난 run(`_settled_manifests`)의 dispatch 스냅샷과 발행 잠금."""
+    found: dict[str, int] = {}
+    for current, dirs, files in os.walk(root):
+        dirs[:] = [name for name in dirs if name not in PRUNED_DIR_NAMES]
+        if Path(current).name != "manifests":
+            continue
+        for manifest in _settled_manifests(Path(current), files):
+            try:
+                team_state = load_owned_object(
+                    _resolve(project_root, str(manifest.get("teamStatePath") or "")),
+                    artifact="team state",
+                )
+            except (OSError, JsonBoundaryError):
+                continue
+            for key in _DISPATCH_ARRAYS:
+                for row in team_state.get(key) or ():
+                    if not isinstance(row, dict):
+                        continue
+                    candidates = [row.get("mutationAuditSnapshotPath")]
+                    if row.get("promptPath"):
+                        candidates.append(f"{row['promptPath']}.publish.lock")
+                    for value in candidates:
+                        if not isinstance(value, str) or not value:
+                            continue
+                        path = _resolve(project_root, value)
+                        if path.is_file() and not path.is_symlink():
+                            found[str(path)] = path.stat().st_size
+    return [{"path": path, "bytes": size} for path, size in sorted(found.items())]
+
+
+def prune_run_artifacts(project_root: Path, root: Path, *, apply: bool) -> dict[str, Any]:
+    dirs = find_build_dirs(root) if root.is_dir() else []
+    files = find_dispatch_leftovers(project_root, root) if root.is_dir() else []
+    if apply:
+        for row in dirs:
+            shutil.rmtree(row["path"])
+        for row in files:
+            Path(row["path"]).unlink(missing_ok=True)
+    return {
+        "root": str(root),
+        "applied": apply,
+        "dirs": dirs,
+        "files": files,
+        "totalBytes": sum(row["bytes"] for row in (*dirs, *files)),
+    }
+
+
+def render_result_text(result: dict[str, Any]) -> str:
+    parts = [
+        "# Okstra Run Artifact Prune\n\n",
+        line("Root", result.get("root")),
+        line("Applied", result.get("applied")),
+        line("Directory count", len(result.get("dirs") or [])),
+        line("File count", len(result.get("files") or [])),
+        line("Total bytes", result.get("totalBytes")),
+    ]
+    for row in result.get("dirs") or []:
+        parts.extend(("\n## Directory\n\n", line("Path", row["path"]), line("Bytes", row["bytes"])))
+    return "".join(parts)
+
+
+_CLI_EPILOG = r"""Usage:
+  okstra prune-run-artifacts [--project-root <dir>] [--cwd <dir>]
+                             [--task-group <group> --task-id <id>] [--apply] [--text]
+
+Lists what no reader needs once a run has ended, under
+<project-root>/.okstra/tasks (or one task root), with sizes and a total:
+  - every node_modules and .next directory (symbolic links are neither
+    followed nor removed);
+  - the dispatch snapshots (*.mutation-audit.json) and prompt publication
+    locks (*.publish.lock) recorded by a run whose validation passed, or by
+    an earlier run in the same run directory as a run that passed.
+Nothing is removed without --apply. Source copies, logs, lockfiles, diffs,
+prompts and results stay. --text lists directories only; files are counted.
+"""
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        epilog=_CLI_EPILOG,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        prog="okstra prune-run-artifacts",
+        description="List, and with --apply remove, run artifacts no reader needs after the run.")
+    parser.add_argument("--project-root", default="")
+    parser.add_argument("--cwd", default=".")
+    parser.add_argument("--task-group", default="")
+    parser.add_argument("--task-id", default="")
+    parser.add_argument("--apply", action="store_true", help="remove the listed paths")
+    parser.add_argument("--text", action="store_true", help="emit fixed text fields")
+    args = parser.parse_args(argv)
+    if bool(args.task_group) != bool(args.task_id):
+        parser.error("--task-group and --task-id go together")
+
+    project_root = resolve_project_root(explicit_root=args.project_root, cwd=args.cwd)
+    root = (
+        task_dir(project_root, args.task_group, args.task_id)
+        if args.task_group else project_root / ".okstra" / "tasks"
+    )
+    result = {
+        "ok": True,
+        "projectRoot": str(project_root),
+        **prune_run_artifacts(project_root, root, apply=args.apply),
+    }
+    output = render_result_text(result) if args.text else json.dumps(result, ensure_ascii=False, indent=2)
+    print(output, end="" if args.text else "\n")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/runtime/python/okstra_ctl/stage_map.py

@@ -641,3 +641,16 @@ def _resolve_plan_path(task_root: Path, value: str) -> Path:
 # 예전에는 okstra_project.state 가 이 어댑터를 들고 okstra_ctl 을 함수 본문에서
 # 지연 import 했다. 하위 계층이 상위를 되짚는 배치였다. 읽는 대상이 okstra_ctl 의
 # Stage Map 과 consumer 상태이므로 소유자를 여기로 옮긴다.
+
+
+def parse_stage_map_for_prepare(plan_path: str) -> list:
+    """Parse the approved plan into context records for execution consumers."""
+    from .prepare_error import PrepareError
+
+    try:
+        return stage_map_records(parse_stage_map_file(Path(plan_path)))
+    except StageMapError as exc:
+        raise PrepareError(
+            "approved-plan 의 Stage Map 을 신뢰할 수 없어 거부합니다 "
+            f"({plan_path}): {exc.reason}. plan 의 Stage Map 을 점검하세요."
+        ) from exc

package/runtime/python/okstra_ctl/team.py

@@ -36,6 +36,12 @@ from .dispatch_core import (
     await_dispatches,
     dispatch_plan,
 )
+from .dispatch_checkpoints import (
+    record_collect_checkpoints,
+    record_dispatch_checkpoints,
+    settled_initial_dispatches,
+)
+from .lead_progress import record_checkpoint, render_progress_line
 from .ports.worker_dispatch import WorkerDispatchPort, WorkerDispatchRequest
 from .registry.host_registry import default_host_registry
 from .registry.provider_registry import default_provider_registry
@@ -44,6 +50,7 @@ from .json_boundary import load_owned_object
 
 
 _SUPPORTED_WRAPPERS = provider_worker_wrappers(default_provider_registry())
+_SOURCE = "okstra team"
 
 
 def main(argv: Sequence[str] | None = None) -> int:
@@ -73,7 +80,7 @@ _CLI_EPILOG = r"""Usage:
     [--poll-interval-seconds <n>] [--timeout-seconds <n>] \
     [--heartbeat-seconds <n>] [--json]
   okstra team reclaim --project-root <dir> --run-manifest <path> \
-    [--dry-run] [--json]
+    [--dry-run] [--gate] [--json]
   okstra team teardown --project-root <dir> --run-manifest <path> \
     [--dry-run] [--json]
 
@@ -84,11 +91,23 @@ descriptor owns the team lifecycle (launch_mode=team) — a worker there is a CL
 wrapper subprocess holding no pane, so there is nothing to close.
 
   reclaim   round boundary: closes the panes of dispatches that have finished and
-            leaves the in-progress ones open. Run it with --dry-run first to
-            count, then again to close.
+            leaves the in-progress ones open, then on a cmux-pane run records
+            `PROGRESS: phase-batch-cleanup panes=<n>`. With --gate it is the
+            cleanup before a user gate and prints
+            `PROGRESS: phase-gate-cleanup panes=<n>` without recording it.
+
   teardown  end of run: closes every recorded pane and writes off any dispatch
             that never reached a terminal status.
 
+  On a cmux-pane run, dispatch records `phase-3-team-create` when it writes the
+  implicit-team marker, `phase-4-dispatch` for each `initial` job and
+  `phase-6-synthesis` on the first report-writer dispatch; await records
+  `phase-5-poll` on entry and again when the counts changed, and
+  `phase-5-collect` for each `initial` dispatch it settled. The lead does not
+  call `okstra lead-progress append` for those checkpoints; each command prints
+  the `PROGRESS:` lines to emit (`progressLines` in JSON output). On any other
+  backend the team commands record nothing.
+
   --workspace-root and --okstra-bin are owned by this command.
 """
 _CLI_DESCRIPTION = "Dispatch, await, and close okstra-owned worker panes."
@@ -148,6 +167,10 @@ def _add_reclaim_parser(sub) -> None:
     )
     _add_run_args(parser)
     parser.add_argument("--dry-run", action="store_true")
+    parser.add_argument(
+        "--gate", action="store_true",
+        help="cleanup before a user gate: print phase-gate-cleanup, record nothing",
+    )
     parser.add_argument("--json", action="store_true")
 
 
@@ -179,11 +202,31 @@ def _dispatch(args) -> int:
     if args.dry_run:
         _print_json(backend_plan.to_payload(dry_run=True))
         return 0
-    result = dispatch_plan(backend_plan, wait=False)
-    _print_json(backend_plan.to_payload(dry_run=False))
+    lines: list[str] = []
+    result = dispatch_plan(
+        backend_plan, wait=False,
+        before_start=lambda prepared: lines.extend(
+            _record_dispatch(args, manifest, prepared)
+        ),
+    )
+    payload = backend_plan.to_payload(dry_run=False)
+    payload["progressLines"] = lines
+    _print_json(payload)
     return result
 
 
+def _record_dispatch(args, manifest: Mapping[str, Any], prepared) -> list[str]:
+    # cmux-pane run 만 체크포인트를 team 명령에 맡긴다. external 리드는 CLI 워커도
+    # `team await` 로 기다리지만 체크포인트는 직접 append 하므로, 여기서 쓰면 행이 둘이 된다.
+    if not _is_cmux_run(manifest):
+        return []
+    return record_dispatch_checkpoints(
+        prepared.project_root, args.run_manifest,
+        _load_json(prepared.team_state_path, "team-state"), prepared.jobs,
+        source=_SOURCE,
+    )
+
+
 def team_dispatch_port(manifest: Mapping[str, Any]) -> WorkerDispatchPort:
     """이 run 의 워커를 띄울 포트. cmux run 이면 pane, 아니면 리드 호스트의 포트.
 
@@ -209,19 +252,59 @@ def _await(args) -> int:
     _validate_team_manifest(manifest)
     _observe_lead_session_from_manifest(Path(args.project_root).resolve(), manifest)
     plan = _plan_for_existing(Path(args.project_root), Path(args.workspace_root), Path(args.run_manifest), manifest)
+    should_record = _is_cmux_run(manifest)
+    entry_state = _load_json(plan.team_state_path, "team-state")
+    entry = _dispatch_counts(entry_state)
+    lines = [_record_poll(args, entry)] if should_record else []
     code = await_dispatches(
         plan,
         poll_interval_seconds=args.poll_interval_seconds,
         timeout_seconds=args.timeout_seconds,
         heartbeat_seconds=0 if args.json else args.heartbeat_seconds,
     )
+    if should_record:
+        exit_state = _load_json(plan.team_state_path, "team-state")
+        lines.extend(record_collect_checkpoints(
+            plan.project_root, args.run_manifest,
+            settled_initial_dispatches(entry_state),
+            settled_initial_dispatches(exit_state),
+            source=_SOURCE,
+        ))
+        exit_counts = _dispatch_counts(exit_state)
+        if exit_counts != entry:
+            lines.append(_record_poll(args, exit_counts))
+    lines = [line for line in lines if line]
     if args.json:
-        _print_json(_await_payload(plan, code == 0))
+        payload = _await_payload(plan, code == 0)
+        payload["progressLines"] = lines
+        _print_json(payload)
     else:
+        for line in lines:
+            print(line)
         print("ALL_WORKERS_DONE" if code == 0 else "POLL_TIMEOUT")
     return code
 
 
+def _dispatch_counts(team_state: Mapping[str, Any]) -> tuple[int, int]:
+    """이 run 의 dispatch 행 기준 (pending, done) — `phase-5-poll` 의 두 값."""
+    statuses = [
+        record.get("status")
+        for record in team_state.get("workerDispatches", [])
+        if isinstance(record, dict)
+    ]
+    done = sum(1 for status in statuses if status in TERMINAL_WORKER_STATUSES)
+    return len(statuses) - done, done
+
+
+def _record_poll(args, counts: tuple[int, int]) -> str | None:
+    pending, done = counts
+    return record_checkpoint(
+        Path(args.project_root), args.run_manifest, "phase-5-poll",
+        source=_SOURCE,
+        fields=(("pending", str(pending)), ("done", str(done))),
+    )
+
+
 def _teardown(args) -> int:
     manifest = _load_manifest(args.project_root, args.run_manifest)
     _validate_team_manifest(manifest)
@@ -259,7 +342,16 @@ def _reclaim(args) -> int:
         _emit_panes(args.json, panes)
         return 0
     _close_panes(manifest, panes)
-    _emit_panes(args.json, panes)
+    count = (("panes", str(len(panes))),)
+    line: str | None = None
+    if args.gate:
+        line = render_progress_line("phase-gate-cleanup", count)
+    elif _is_cmux_run(manifest):
+        line = record_checkpoint(
+            Path(args.project_root), args.run_manifest, "phase-batch-cleanup",
+            source=_SOURCE, fields=count,
+        )
+    _emit_panes(args.json, panes, line)
     return 0
 
 
@@ -434,12 +526,19 @@ def _mark_teardown_errors(team_state_path: Path) -> None:
     mutate_team_state(team_state_path, mark)
 
 
-def _emit_panes(as_json: bool, panes: list[dict[str, str]]) -> None:
+def _emit_panes(
+    as_json: bool, panes: list[dict[str, str]], progress_line: str | None = None
+) -> None:
     if as_json:
-        _print_json({"panes": panes})
+        payload: dict[str, Any] = {"panes": panes}
+        if progress_line:
+            payload["progressLines"] = [progress_line]
+        _print_json(payload)
         return
     for pane in panes:
         print(f"{pane['paneId']}\t{pane['kind']}")
+    if progress_line:
+        print(progress_line)
 
 
 def _manifest_backend(manifest: Mapping[str, Any]) -> str:

package/runtime/python/okstra_ctl/technical_verification_facts.py

@@ -0,0 +1,52 @@
+"""방향 비교와 기술 검증이 함께 읽는 미확정 사실 계약."""
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypedDict
+
+from .clarification_items import USER_INPUT_BLOCKS, progress_blocking_ids
+
+
+class VerificationFact(TypedDict):
+    id: str
+    candidateId: str
+    factIndex: int
+    fact: str
+    whyItMatters: str
+    evidence: list[str]
+
+
+class TechnicalVerificationError(ValueError):
+    """시험 입력 또는 관측 결과가 원본 사실과 일치하지 않는다."""
+
+
+def technical_verification_facts(data: Mapping[str, Any]) -> list[VerificationFact]:
+    """안전 차단이 없는 후보의 명시적인 기술 검증 사실만 추출한다."""
+    blockers = progress_blocking_ids(
+        data.get("clarificationItems"), USER_INPUT_BLOCKS, report_data=data
+    )
+    if blockers:
+        raise TechnicalVerificationError(
+            "unresolved user decisions: " + ", ".join(blockers)
+        )
+    selection = data.get("implementationOptionSelection") or {}
+    facts: list[VerificationFact] = []
+    for candidate in selection.get("candidateAudit") or []:
+        if candidate.get("safetyBlockers"):
+            continue
+        for index, fact in enumerate(candidate.get("unresolvedFeasibilityFacts") or []):
+            if fact.get("resolutionKind") != "technical-verification":
+                continue
+            facts.append(
+                {
+                    "id": f"TV-{len(facts) + 1:03d}",
+                    "candidateId": candidate["id"],
+                    "factIndex": index,
+                    "fact": fact["fact"],
+                    "whyItMatters": fact["whyItMatters"],
+                    "evidence": fact["evidence"],
+                }
+            )
+    if not facts:
+        raise TechnicalVerificationError("no eligible technical-verification facts")
+    return facts

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

@@ -15,11 +15,11 @@ Public surface (re-exported here; the skill calls it through the
 - ``render_args()`` - final args for ``okstra render-bundle`` (``render``).
 - ``wizard_outcome()`` - final args plus persistence actions and confirmation (``render``).
 
-Module order is the import order: ``ids`` → ``state`` → ``prompts`` → ``sources``
-→ ``roles`` → ``statefile`` → ``steps_*`` → ``confirmation`` → ``registry`` →
-``engine`` → ``render`` → ``cli``. A module imports only modules before it;
-``tests/contract/test_no_import_cycles.py`` keeps it that way.
+Package initialization loads identifiers and state types only. Public execution
+functions are composed by ``api`` when requested. Phase modules can import state
+and prompt readers without initializing the registry that imports those phases.
 """
+
 from __future__ import annotations
 
 from .ids import (
@@ -118,31 +118,31 @@ from .state import (
     WizardError,
     WizardState,
 )
-from .roles import (
-    next_role_prompt,
-)
-from .statefile import (
-    load_state_file,
-    save_state_file,
-)
-from .confirmation import (
-    confirmation_block,
-)
-from .registry import (
-    STEPS,
-    STEP_BY_ID,
-)
-from .engine import (
-    init_state,
-    next_prompt,
-    prompt_payload,
-    submit,
-)
-from .render import (
-    render_args,
-    render_role_args,
-)
-from .outcome import wizard_outcome
-from .cli import (
-    main,
+
+_API_EXPORTS = (
+    "next_role_prompt",
+    "load_state_file",
+    "save_state_file",
+    "confirmation_block",
+    "STEPS",
+    "STEP_BY_ID",
+    "init_state",
+    "next_prompt",
+    "prompt_payload",
+    "submit",
+    "render_args",
+    "render_role_args",
+    "wizard_outcome",
+    "main",
 )
+
+__all__ = [name for name in globals() if not name.startswith("_")] + list(_API_EXPORTS)
+
+
+def __getattr__(name: str):
+    """기존 공개 이름을 실행 조립 모듈에 연결한다."""
+    if name not in _API_EXPORTS:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+    from . import api
+
+    return getattr(api, name)

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

@@ -0,0 +1,18 @@
+"""질문 실행기의 공개 조립 지점. 단계의 값·프롬프트 판독에서는 적재하지 않는다."""
+
+from .roles import next_role_prompt as next_role_prompt
+from .statefile import (
+    load_state_file as load_state_file,
+    save_state_file as save_state_file,
+)
+from .confirmation import confirmation_block as confirmation_block
+from .registry import STEPS as STEPS, STEP_BY_ID as STEP_BY_ID
+from .engine import (
+    init_state as init_state,
+    next_prompt as next_prompt,
+    prompt_payload as prompt_payload,
+    submit as submit,
+)
+from .render import render_args as render_args, render_role_args as render_role_args
+from .outcome import wizard_outcome as wizard_outcome
+from .cli import main as main

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

@@ -25,18 +25,9 @@ def _render_argv(rendered: dict[str, Any], *, host_runtime: str) -> list[str]:
 def _wizard_persist_actions(state: WizardState) -> list[dict[str, str]]:
     if state.task_type != "release-handoff":
         return []
-    if not state.pr_template_path:
-        return []
-    if state.pr_template_scope not in ("project", "global"):
-        return []
-    return [
-        {
-            "command": "config.set",
-            "key": "pr-template-path",
-            "scope": state.pr_template_scope,
-            "value": state.pr_template_path,
-        }
-    ]
+    from okstra_ctl.phases.release_handoff.wizard import pr_template_persist_actions
+
+    return pr_template_persist_actions(state)
 
 
 def wizard_outcome(state: WizardState) -> dict[str, Any]:

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

@@ -1,6 +1,20 @@
 """단계 등록표 — 순서가 곧 질문 순서인 `STEPS`, `STEP_BY_ID`, 등록표를 되감는 `_reset_from` 과 되감기를 일으키는 단계(edit target, brief carry)."""
 from __future__ import annotations
 
+from okstra_ctl.phases.change_impact_analysis.entry import (
+    _build_feature_evidence,
+    _build_feature_evidence_pick,
+    _submit_feature_evidence,
+    _submit_feature_evidence_pick,
+)
+
+from okstra_ctl.phases.implementation_planning.wizard import (
+    _selected_direction_candidates,
+    _planning_rerun_selected,
+    _build_selected_direction_pick,
+    _submit_selected_direction_pick,
+)
+
 from typing import Optional
 
 from .ids import (
@@ -119,27 +133,25 @@ from .steps_identity import (
     _submit_task_type,
     _submit_task_type_text,
 )
-from .steps_analysis import (
-    _analysis_inputs_after_reuse,
+from okstra_ctl.phases.feature_analysis.wizard import (
     _build_analysis_target,
     _build_analysis_target_pick,
+    _submit_analysis_target,
+    _submit_analysis_target_pick,
+)
+from .steps_analysis import (
+    _analysis_inputs_after_reuse,
     _build_design_prep_confirm,
     _build_design_prep_decision,
     _build_design_prep_overrides,
-    _build_feature_evidence,
-    _build_feature_evidence_pick,
     _build_project_evidence,
     _build_project_evidence_pick,
     _design_prep_confirm_applies,
     _design_prep_decision_applies,
     _design_prep_overrides_applies,
-    _submit_analysis_target,
-    _submit_analysis_target_pick,
     _submit_design_prep_confirm,
     _submit_design_prep_decision,
     _submit_design_prep_overrides,
-    _submit_feature_evidence,
-    _submit_feature_evidence_pick,
     _submit_project_evidence,
     _submit_project_evidence_pick,
 )
@@ -151,12 +163,9 @@ from .steps_plan import (
     _build_handoff_stage_pick,
     _build_reverify_scope_pick,
     _build_reverify_scope_stages,
-    _build_selected_direction_pick,
     _build_stage_pick,
     _fix_cycle_confirm_required,
-    _planning_rerun_selected,
     _reverify_scope_step_pending,
-    _selected_direction_candidates,
     _submit_approve_plan_confirm,
     _submit_approved_plan,
     _submit_approved_plan_pick,
@@ -164,7 +173,6 @@ from .steps_plan import (
     _submit_handoff_stage_pick,
     _submit_reverify_scope_pick,
     _submit_reverify_scope_stages,
-    _submit_selected_direction_pick,
     _submit_stage_pick,
 )
 from .steps_options import (