okstra 0.144.0 → 0.146.0

package/runtime/python/okstra_ctl/wizard.py

@@ -31,13 +31,26 @@ from typing import Any, Callable, Optional
 
 from okstra_ctl.ids import slugify_task_segment
 from okstra_ctl.brief_frontmatter import read_brief_frontmatter
+from okstra_ctl.analysis_inputs import (
+    ANALYSIS_TASK_TYPES,
+    AnalysisInputError,
+    AnalysisReportCandidate,
+    _resolved_within,
+    list_evidence_candidates,
+    load_analysis_report_candidate,
+    resolve_analysis_target,
+    resolve_evidence_inputs,
+)
 from okstra_ctl.models import (
     PROVIDER_MAPPINGS,
     UnknownModelError,
     picker_options,
     resolve_model_metadata,
 )
-from okstra_ctl.clarification_items import scan_approval_gate, user_response_sidecars
+from okstra_ctl.clarification_items import (
+    scan_approval_gate,
+    user_response_sidecars,
+)
 from okstra_ctl.design_prep import (
     DesignPrepError,
     load_design_prep_items,
@@ -100,9 +113,16 @@ from okstra_project.state import (
 
 # ---- Constants -----------------------------------------------------------
 
+_ANALYSIS_TASK_TYPE_DESCRIPTIONS = (
+    "Map project structure and bounded codebase scope (read-only)",
+    "Analyse feature behavior and test coverage scope (read-only)",
+    "Assess change impact and preserved behavior (read-only)",
+)
+
 TASK_TYPES: list[tuple[str, str]] = [
     ("requirements-discovery", "Classify request and route to next safe phase"),
     ("improvement-discovery", "Find improvement candidates within a codebase scope and lens whitelist"),
+    *zip(ANALYSIS_TASK_TYPES, _ANALYSIS_TASK_TYPE_DESCRIPTIONS),
     ("error-analysis", "Evidence-based root-cause analysis (no code changes)"),
     ("implementation-planning", "Plan options + request user approval"),
     ("implementation", "Execute approved plan (requires approved final-report)"),
@@ -131,11 +151,16 @@ _STAGE_SCOPED_TASK_TYPES = ("implementation", "final-verification")
 # downstream phase 는 task manifest 의 taskBriefPath 를 자동 carry-in 하며
 # 위저드에서 brief 를 묻지 않는다 (release-handoff 는 prepare 가 검증 보고서
 # 인용 input 문서를 자동 생성하므로 brief 자체가 없다).
-_BRIEF_ENTRY_TASK_TYPES = ("requirements-discovery", "improvement-discovery",
-                           "error-analysis")
+_BRIEF_ENTRY_TASK_TYPES = (
+    "requirements-discovery",
+    "improvement-discovery",
+    *ANALYSIS_TASK_TYPES,
+    "error-analysis",
+)
 
 CANONICAL_BASE_REFS = ["main", "dev", "staging", "preprod", "prod"]
 BASE_REF_FREE_INPUT_TOKEN = "__free_input__"
+HOST_PICK_OPTION_CAP = 4
 
 CLAUDE_MODEL_OPTIONS = ["default", *picker_options("claude")]
 CODEX_MODEL_OPTIONS = ["default", *picker_options("codex")]
@@ -263,6 +288,12 @@ S_BRIEF_KEEP = "brief_keep"
 S_BRIEF_PATH_PICK = "brief_path_pick"
 S_BRIEF_PATH = "brief_path"
 S_BRIEF_CARRY = "brief_carry"
+S_FEATURE_EVIDENCE_PICK = "feature_evidence_pick"
+S_FEATURE_EVIDENCE = "feature_evidence"
+S_PROJECT_EVIDENCE_PICK = "project_evidence_pick"
+S_PROJECT_EVIDENCE = "project_evidence"
+S_ANALYSIS_TARGET_PICK = "analysis_target_pick"
+S_ANALYSIS_TARGET = "analysis_target"
 S_BASE_REF_PICK = "base_ref_pick"
 S_BASE_REF_TEXT = "base_ref_text"
 S_APPROVED_PLAN_PICK = "approved_plan_pick"
@@ -355,6 +386,14 @@ class WizardState:
     brief_path: str = ""
     brief_path_pending_text: bool = False
 
+    # analysis evidence and target
+    project_evidence_path: str = ""
+    project_evidence_pending_text: bool = False
+    feature_evidence_path: str = ""
+    feature_evidence_pending_text: bool = False
+    analysis_target: str = ""
+    analysis_target_pending_text: bool = False
+
     # worktree
     reuse_worktree: Optional[bool] = None
     base_ref: str = ""
@@ -460,6 +499,8 @@ class Prompt:
             "echoTemplate": self.echo_template,
             "multi": self.multi,
         }
+        if self.kind == "pick" and len(self.options) > HOST_PICK_OPTION_CAP:
+            out["presentation"] = "numbered-text"
         if self.kind == "pick_group":
             out["questions"] = [
                 {"step": q.step, "label": q.label,
@@ -474,6 +515,35 @@ class WizardError(Exception):
     """validation failure surfaced to user."""
 
 
+def _normalize_numbered_pick_item(prompt: Prompt, answer: str) -> str:
+    candidate = (answer or "").strip()
+    exact_values = [option.value for option in prompt.options if option.value == candidate]
+    if exact_values:
+        return exact_values[0]
+
+    if candidate.isdecimal():
+        number = int(candidate)
+        if 1 <= number <= len(prompt.options):
+            return prompt.options[number - 1].value
+        raise WizardError(f"numbered-text answer is out of range: {candidate}")
+
+    label_values = [option.value for option in prompt.options if option.label == candidate]
+    if len(label_values) == 1:
+        return label_values[0]
+    if len(label_values) > 1:
+        raise WizardError(f"numbered-text answer label is ambiguous: {candidate}")
+    raise WizardError(f"numbered-text answer is not an option: {candidate}")
+
+
+def _normalize_numbered_pick_answer(prompt: Prompt, answer: str) -> str:
+    if prompt.multi:
+        return ",".join(
+            _normalize_numbered_pick_item(prompt, item)
+            for item in (answer or "").split(",")
+        )
+    return _normalize_numbered_pick_item(prompt, answer)
+
+
 # ---- Validation helpers --------------------------------------------------
 
 _SLUG_OK = re.compile(r"[a-z0-9]")
@@ -1445,6 +1515,101 @@ def _recent_task_types(state: WizardState) -> list[str]:
     return out
 
 
+def _contained_final_report_data_path(report: Path, task_root: Path) -> Path:
+    _resolved_within(report, task_root, "final report path")
+    return _resolved_within(
+        final_report_data_path(report),
+        task_root,
+        "final report data path",
+    )
+
+
+def _newest_contained_final_report(
+    runs_base: Path,
+    task_root: Path,
+    glob_pattern: str,
+    project_root: Path,
+) -> Path | None:
+    candidates: list[Path] = []
+    for report in runs_base.glob(glob_pattern):
+        if not report.is_file():
+            continue
+        try:
+            _contained_final_report_data_path(report, task_root)
+            if report.parent.parent.name in ANALYSIS_TASK_TYPES:
+                load_analysis_report_candidate(project_root, report)
+        except AnalysisInputError:
+            continue
+        candidates.append(report)
+
+    def mtime_safe(report: Path) -> float:
+        try:
+            return report.stat().st_mtime
+        except OSError:
+            return -1.0
+
+    return max(candidates, key=mtime_safe) if candidates else None
+
+
+def _analysis_revision_candidate(
+    state: WizardState,
+    report: Path,
+    task_root: Path,
+    expected_task_key: str,
+) -> tuple[int, Path] | None:
+    try:
+        _contained_final_report_data_path(report, task_root)
+        candidate = load_analysis_report_candidate(
+            Path(state.project_root), report
+        )
+    except AnalysisInputError:
+        return None
+    if (
+        candidate.task_key != expected_task_key
+        or candidate.task_type != state.task_type
+        or candidate.review_status != "revision-requested"
+    ):
+        return None
+    return int(candidate.run_seq), report
+
+
+def _latest_revision_requested_analysis_report(
+    state: WizardState,
+) -> Path | None:
+    if state.task_type not in ANALYSIS_TASK_TYPES:
+        return None
+    reports = task_runs_dir(
+        Path(state.project_root), state.task_group, state.task_id
+    ) / state.task_type / "reports"
+    try:
+        task_root = _resolved_within(
+            reports.parents[2],
+            Path(state.project_root).resolve(),
+            "analysis task root",
+        )
+    except AnalysisInputError:
+        return None
+    expected_task_key = f"{state.project_id}:{state.task_group}:{state.task_id}"
+    candidates: list[tuple[int, Path]] = []
+    for report in reports.glob("final-report-*.md"):
+        candidate = _analysis_revision_candidate(
+            state,
+            report,
+            task_root,
+            expected_task_key,
+        )
+        if candidate is not None:
+            candidates.append(candidate)
+    if not candidates:
+        return None
+    return max(candidates, key=lambda candidate: candidate[0])[1]
+
+
+def _latest_revision_requested_analysis_type(state: WizardState) -> str:
+    report = _latest_revision_requested_analysis_report(state)
+    return state.task_type if report is not None else ""
+
+
 def _build_task_type(state: WizardState) -> Prompt:
     t = _p(state.workspace_root, "task_type")
     recommended_suffix = t["options"].get("_RECOMMENDED_SUFFIX", "")
@@ -1464,7 +1629,9 @@ def _build_task_type(state: WizardState) -> Prompt:
                             description_by_type[task_type]))
 
     workflow = _existing_task_workflow(state)
-    recommended = state.task_type or workflow.get("nextRecommendedPhase") or ""
+    revision_requested = _latest_revision_requested_analysis_type(state)
+    recommended = (revision_requested or state.task_type
+                   or workflow.get("nextRecommendedPhase") or "")
     if not recommended and not workflow:
         recommended = TASK_TYPE_VALUES[0]
     add(recommended, recommended_suffix)
@@ -1677,6 +1844,225 @@ def _submit_brief_carry(state: WizardState, value: str) -> Optional[str]:
     )
 
 
+def _analysis_current_commit(state: WizardState) -> str:
+    try:
+        return subprocess.check_output(
+            ["git", "-C", state.project_root, "rev-parse", "HEAD"],
+            text=True,
+            stderr=subprocess.DEVNULL,
+        ).strip()
+    except (OSError, subprocess.CalledProcessError) as exc:
+        raise WizardError(
+            f"cannot resolve current project commit for analysis evidence: {state.project_root}"
+        ) from exc
+
+
+def _analysis_evidence_paths(state: WizardState) -> list[Path]:
+    return [
+        Path(path)
+        for path in (state.feature_evidence_path, state.project_evidence_path)
+        if path
+    ]
+
+
+def _resolve_analysis_evidence(state: WizardState):
+    try:
+        return resolve_evidence_inputs(
+            Path(state.project_root),
+            state.task_type,
+            _analysis_evidence_paths(state),
+            _analysis_current_commit(state),
+        )
+    except AnalysisInputError as exc:
+        raise WizardError(str(exc)) from exc
+
+
+def _accept_analysis_evidence(
+    state: WizardState, raw_path: str, field_name: str
+) -> AnalysisReportCandidate:
+    report_path = _resolve_path(raw_path, Path(state.project_root))
+    try:
+        candidate = load_analysis_report_candidate(
+            Path(state.project_root), report_path
+        )
+    except AnalysisInputError as exc:
+        raise WizardError(str(exc)) from exc
+    previous = getattr(state, field_name)
+    setattr(state, field_name, str(candidate.report_path))
+    try:
+        _resolve_analysis_evidence(state)
+    except WizardError:
+        setattr(state, field_name, previous)
+        raise
+    return candidate
+
+
+def _evidence_option_label(candidate: AnalysisReportCandidate) -> str:
+    return f"{candidate.task_key} · {candidate.task_type} · run {candidate.run_seq}"
+
+
+def _build_analysis_evidence_pick(
+    state: WizardState, *, step: str, relation: str
+) -> Prompt:
+    t = _p(state.workspace_root, step)
+    candidates = list_evidence_candidates(
+        Path(state.project_root), state.task_type, relation
+    )[:2]
+    options = [
+        _opt(str(candidate.report_path), _evidence_option_label(candidate))
+        for candidate in candidates
+    ]
+    options.extend([
+        _opt(PICK_SKIP, t["options"][PICK_SKIP]),
+        _opt(PICK_TYPE_CUSTOM, t["options"][PICK_TYPE_CUSTOM]),
+    ])
+    return Prompt(step=step, kind="pick", label=t["label"], options=options,
+                  echo_template=t["echo_template"])
+
+
+def _submit_analysis_evidence_pick(
+    state: WizardState,
+    value: str,
+    *,
+    step: str,
+    field_name: str,
+    pending_name: str,
+    target_after_skip: bool = False,
+) -> Optional[str]:
+    t = _p(state.workspace_root, step)
+    if value == PICK_SKIP:
+        setattr(state, field_name, "")
+        setattr(state, pending_name, False)
+        if target_after_skip:
+            state.analysis_target_pending_text = True
+        return t["echo_variants"]["skip"]
+    if value == PICK_TYPE_CUSTOM:
+        setattr(state, pending_name, True)
+        return None
+    candidate = _accept_analysis_evidence(state, value, field_name)
+    setattr(state, pending_name, False)
+    return t["echo_variants"]["selected"].format(path=candidate.report_path)
+
+
+def _build_feature_evidence_pick(state: WizardState) -> Prompt:
+    return _build_analysis_evidence_pick(
+        state, step=S_FEATURE_EVIDENCE_PICK, relation="feature-baseline"
+    )
+
+
+def _submit_feature_evidence_pick(state: WizardState, value: str) -> Optional[str]:
+    return _submit_analysis_evidence_pick(
+        state, value, step=S_FEATURE_EVIDENCE_PICK,
+        field_name="feature_evidence_path",
+        pending_name="feature_evidence_pending_text",
+    )
+
+
+def _build_feature_evidence(state: WizardState) -> Prompt:
+    t = _p(state.workspace_root, S_FEATURE_EVIDENCE)
+    return Prompt(step=S_FEATURE_EVIDENCE, kind="text", label=t["label"],
+                  echo_template=t["echo_template"])
+
+
+def _submit_feature_evidence(state: WizardState, value: str) -> Optional[str]:
+    candidate = _accept_analysis_evidence(state, value, "feature_evidence_path")
+    state.feature_evidence_pending_text = False
+    return f"feature-evidence: {candidate.report_path}"
+
+
+def _build_project_evidence_pick(state: WizardState) -> Prompt:
+    return _build_analysis_evidence_pick(
+        state, step=S_PROJECT_EVIDENCE_PICK, relation="project-context"
+    )
+
+
+def _submit_project_evidence_pick(state: WizardState, value: str) -> Optional[str]:
+    return _submit_analysis_evidence_pick(
+        state, value, step=S_PROJECT_EVIDENCE_PICK,
+        field_name="project_evidence_path",
+        pending_name="project_evidence_pending_text",
+        target_after_skip=state.task_type == "feature-analysis",
+    )
+
+
+def _build_project_evidence(state: WizardState) -> Prompt:
+    t = _p(state.workspace_root, S_PROJECT_EVIDENCE)
+    return Prompt(step=S_PROJECT_EVIDENCE, kind="text", label=t["label"],
+                  echo_template=t["echo_template"])
+
+
+def _submit_project_evidence(state: WizardState, value: str) -> Optional[str]:
+    candidate = _accept_analysis_evidence(state, value, "project_evidence_path")
+    state.project_evidence_pending_text = False
+    return f"project-evidence: {candidate.report_path}"
+
+
+def _feature_description(feature: dict[object, object]) -> str:
+    name = str(feature.get("name") or "")
+    summary = str(feature.get("summary") or "")
+    entry_point = str(
+        feature.get("entryPoint") or feature.get("entrypoint") or ""
+    )
+    return " · ".join(value for value in (name, summary, entry_point) if value)
+
+
+def _build_analysis_target_pick(state: WizardState) -> Prompt:
+    t = _p(state.workspace_root, S_ANALYSIS_TARGET_PICK)
+    try:
+        candidate = load_analysis_report_candidate(
+            Path(state.project_root), Path(state.project_evidence_path)
+        )
+    except AnalysisInputError as exc:
+        raise WizardError(str(exc)) from exc
+    options = [
+        _opt(str(feature["id"]), str(feature["id"]), _feature_description(feature))
+        for feature in candidate.feature_index
+        if isinstance(feature, dict) and isinstance(feature.get("id"), str)
+    ][:3]
+    options.append(_opt(PICK_TYPE_CUSTOM, t["options"][PICK_TYPE_CUSTOM]))
+    return Prompt(step=S_ANALYSIS_TARGET_PICK, kind="pick", label=t["label"],
+                  options=options, echo_template=t["echo_template"])
+
+
+def _accept_analysis_target(state: WizardState, value: str) -> str:
+    candidates: dict[Path, AnalysisReportCandidate] = {}
+    for path in _analysis_evidence_paths(state):
+        try:
+            candidate = load_analysis_report_candidate(Path(state.project_root), path)
+        except AnalysisInputError as exc:
+            raise WizardError(str(exc)) from exc
+        candidates[candidate.report_path] = candidate
+    try:
+        target = resolve_analysis_target(
+            value, _resolve_analysis_evidence(state), candidates
+        )
+    except AnalysisInputError as exc:
+        raise WizardError(str(exc)) from exc
+    requested_value = target["requestedValue"]
+    if not isinstance(requested_value, str):
+        raise WizardError("analysis target resolver returned an invalid requestedValue")
+    state.analysis_target = requested_value
+    state.analysis_target_pending_text = False
+    return requested_value
+
+
+def _submit_analysis_target_pick(state: WizardState, value: str) -> Optional[str]:
+    if value == PICK_TYPE_CUSTOM:
+        state.analysis_target_pending_text = True
+        return None
+    return f"analysis-target: {_accept_analysis_target(state, value)}"
+
+
+def _build_analysis_target(state: WizardState) -> Prompt:
+    t = _p(state.workspace_root, S_ANALYSIS_TARGET)
+    return Prompt(step=S_ANALYSIS_TARGET, kind="text", label=t["label"],
+                  echo_template=t["echo_template"])
+
+
+def _submit_analysis_target(state: WizardState, value: str) -> Optional[str]:
+    return f"analysis-target: {_accept_analysis_target(state, value)}"
+
+
 def _build_base_ref_pick(state: WizardState) -> Prompt:
     t = _p(state.workspace_root, "base_ref_pick")
     recommended_suffix = t["options"].get("_RECOMMENDED_SUFFIX", "")
@@ -2383,24 +2769,34 @@ def _suggest_latest_final_report(state: WizardState) -> str:
     runs_base = task_runs_dir(state.project_root, state.task_group, state.task_id)
     if not runs_base.is_dir():
         return ""
+    try:
+        task_root = _resolved_within(
+            runs_base.parent,
+            Path(state.project_root).resolve(),
+            "task root",
+        )
+    except AnalysisInputError:
+        return ""
 
-    def _mtime_safe(p: Path) -> float:
-        try:
-            return p.stat().st_mtime
-        except OSError:
-            return -1.0
-
-    def _newest(glob_pattern: str) -> Optional[Path]:
-        cands = [p for p in runs_base.glob(glob_pattern) if p.is_file()]
-        return max(cands, key=_mtime_safe) if cands else None
-
-    # 산출물 구조는 runs/<task-type>/reports/final-report-*.md (1단계).
-    best: Optional[Path] = None
-    if state.task_type:
+    # A revision request outranks ordinary recency. Carry the newest requested
+    # revision for the selected analysis type into that exact rerun.
+    revision = _latest_revision_requested_analysis_report(state)
+    best = revision
+    if best is None and state.task_type:
         seg = slugify_task_segment(state.task_type)
-        best = _newest(f"{seg}/reports/final-report-*.md")
+        best = _newest_contained_final_report(
+            runs_base,
+            task_root,
+            f"{seg}/reports/final-report-*.md",
+            Path(state.project_root),
+        )
     if best is None:
-        best = _newest("*/reports/final-report-*.md")
+        best = _newest_contained_final_report(
+            runs_base,
+            task_root,
+            "*/reports/final-report-*.md",
+            Path(state.project_root),
+        )
     if best is None:
         return ""
     # The approved plan is already wired via --approved-plan. On the first run
@@ -2735,10 +3131,15 @@ def _submit_executor(state: WizardState, value: str) -> Optional[str]:
 # §1 clarification 을 갖는 비-implementation phase 로 한정한다(implementation 은
 # approved-plan/stage 가 매 run 고유라 재사용 대상이 아니다).
 _RESUME_REUSE_PHASES = (
-    "requirements-discovery", "error-analysis", "implementation-planning")
+    "requirements-discovery", "error-analysis", "implementation-planning",
+    *ANALYSIS_TASK_TYPES,
+)
 
 # YES 선택 시 prefill 로 충족되어 다시 묻지 않는 설정 단계들.
 _REUSE_FILLED_STEPS = (
+    S_FEATURE_EVIDENCE_PICK, S_FEATURE_EVIDENCE,
+    S_PROJECT_EVIDENCE_PICK, S_PROJECT_EVIDENCE,
+    S_ANALYSIS_TARGET_PICK, S_ANALYSIS_TARGET,
     S_DEFAULTS_OR_CUSTOM, S_WORKERS_OVERRIDE, S_LEAD_MODEL, S_EXECUTOR_MODEL,
     S_CLAUDE_MODEL, S_CODEX_MODEL, S_ANTIGRAVITY_MODEL, S_REPORT_WRITER_MODEL,
     S_DIRECTIVE_PICK, S_DIRECTIVE, S_RELATED_TASKS_PICK, S_RELATED_TASKS,
@@ -2750,6 +3151,49 @@ def _has_prior_run_inputs(state: WizardState) -> bool:
     return bool(_latest_run_inputs(state, phase_segment=seg))
 
 
+def _analysis_inputs_after_reuse(state: WizardState) -> bool:
+    return (
+        state.reuse_previous is not None
+        or state.task_type not in _RESUME_REUSE_PHASES
+        or not _has_prior_run_inputs(state)
+    )
+
+
+def _restore_analysis_evidence_inputs(
+    state: WizardState, evidence_raw: object
+) -> tuple[tuple[Any, ...], dict[Path, AnalysisReportCandidate]]:
+    if state.task_type not in ANALYSIS_TASK_TYPES or not isinstance(evidence_raw, str):
+        return (), {}
+    report_paths = [
+        _resolve_path(item.strip(), Path(state.project_root))
+        for item in evidence_raw.split(",")
+        if item.strip()
+    ]
+    try:
+        candidates = [
+            load_analysis_report_candidate(Path(state.project_root), path)
+            for path in report_paths
+        ]
+        evidence_inputs = resolve_evidence_inputs(
+            Path(state.project_root),
+            state.task_type,
+            [candidate.report_path for candidate in candidates],
+            _analysis_current_commit(state),
+        )
+    except AnalysisInputError as exc:
+        raise WizardError(str(exc)) from exc
+    state.feature_evidence_path = ""
+    state.project_evidence_path = ""
+    for evidence in evidence_inputs:
+        if evidence.relation == "feature-baseline":
+            state.feature_evidence_path = str(evidence.report_path)
+        elif evidence.relation == "project-context":
+            state.project_evidence_path = str(evidence.report_path)
+    return evidence_inputs, {
+        candidate.report_path: candidate for candidate in candidates
+    }
+
+
 def _safe_model(provider: str, raw: object) -> str:
     """run-inputs 의 모델 display 값을 wizard 필드로 환원. 알 수 없는 값은
     빈 문자열(phase 기본값)로 안전하게 떨어뜨린다."""
@@ -2795,6 +3239,25 @@ def _submit_reuse_previous(state: WizardState, value: str) -> Optional[str]:
     state.directive = directive if isinstance(directive, str) else ""
     related = inputs.get("relatedTasks")
     state.related_tasks_raw = related if isinstance(related, str) else ""
+    evidence_inputs, candidates = _restore_analysis_evidence_inputs(
+        state, inputs.get("evidenceInputs")
+    )
+    target = inputs.get("analysisTarget")
+    if state.task_type == "feature-analysis":
+        try:
+            resolved_target = resolve_analysis_target(
+                target if isinstance(target, str) else "",
+                evidence_inputs,
+                candidates,
+            )
+        except AnalysisInputError as exc:
+            raise WizardError(str(exc)) from exc
+        requested_value = resolved_target.get("requestedValue")
+        if not isinstance(requested_value, str):
+            raise WizardError("analysis target resolver returned an invalid requestedValue")
+        state.analysis_target = requested_value
+    else:
+        state.analysis_target = target if isinstance(target, str) else ""
     # clarification 은 직전 run 의 입력이 아니라 "직전 run 의 산출물(가장 최근
     # final-report)" 을 재실행 입력으로 자동 선택한다 — resume-clarification 의 본질.
     state.clarification_response_path = _suggest_latest_final_report(state)
@@ -3304,6 +3767,63 @@ STEPS: list[Step] = [
                             and s.task_id_pending_text),
          build=_build_task_id_text, submit=_submit_task_id_text,
          owns=("task_id", "task_id_pending_text")),
+    Step(S_REUSE_PREVIOUS,
+         applies=lambda s: (_identity_ready(s)
+                            and s.use_defaults is None
+                            and s.reuse_previous is None
+                            and s.task_type in _RESUME_REUSE_PHASES
+                            and _has_prior_run_inputs(s)),
+         build=_build_reuse_previous, submit=_submit_reuse_previous,
+         owns=("reuse_previous",)),
+    Step(S_FEATURE_EVIDENCE_PICK,
+         applies=lambda s: (s.task_type == "change-impact-analysis"
+                            and not s.feature_evidence_path
+                            and not s.feature_evidence_pending_text
+                            and S_FEATURE_EVIDENCE_PICK not in s.answered
+                            and _brief_resolved(s)
+                            and _analysis_inputs_after_reuse(s)),
+         build=_build_feature_evidence_pick, submit=_submit_feature_evidence_pick,
+         owns=("feature_evidence_path", "feature_evidence_pending_text")),
+    Step(S_FEATURE_EVIDENCE,
+         applies=lambda s: (s.task_type == "change-impact-analysis"
+                            and s.feature_evidence_pending_text
+                            and S_FEATURE_EVIDENCE not in s.answered),
+         build=_build_feature_evidence, submit=_submit_feature_evidence,
+         owns=("feature_evidence_path", "feature_evidence_pending_text")),
+    Step(S_PROJECT_EVIDENCE_PICK,
+         applies=lambda s: (s.task_type in ("feature-analysis", "change-impact-analysis")
+                            and not s.project_evidence_path
+                            and not s.project_evidence_pending_text
+                            and S_PROJECT_EVIDENCE_PICK not in s.answered
+                            and _brief_resolved(s)
+                            and _analysis_inputs_after_reuse(s)
+                            and (s.task_type != "change-impact-analysis"
+                                 or S_FEATURE_EVIDENCE_PICK in s.answered)),
+         build=_build_project_evidence_pick, submit=_submit_project_evidence_pick,
+         owns=("project_evidence_path", "project_evidence_pending_text",
+               "analysis_target", "analysis_target_pending_text")),
+    Step(S_PROJECT_EVIDENCE,
+         applies=lambda s: (s.task_type in ("feature-analysis", "change-impact-analysis")
+                            and s.project_evidence_pending_text
+                            and S_PROJECT_EVIDENCE not in s.answered),
+         build=_build_project_evidence, submit=_submit_project_evidence,
+         owns=("project_evidence_path", "project_evidence_pending_text",
+               "analysis_target", "analysis_target_pending_text")),
+    Step(S_ANALYSIS_TARGET_PICK,
+         applies=lambda s: (s.task_type == "feature-analysis"
+                            and bool(s.project_evidence_path)
+                            and not s.analysis_target
+                            and not s.analysis_target_pending_text
+                            and S_ANALYSIS_TARGET_PICK not in s.answered),
+         build=_build_analysis_target_pick, submit=_submit_analysis_target_pick,
+         owns=("analysis_target", "analysis_target_pending_text")),
+    Step(S_ANALYSIS_TARGET,
+         applies=lambda s: (s.task_type == "feature-analysis"
+                            and not s.analysis_target
+                            and s.analysis_target_pending_text
+                            and S_ANALYSIS_TARGET not in s.answered),
+         build=_build_analysis_target, submit=_submit_analysis_target,
+         owns=("analysis_target", "analysis_target_pending_text")),
     Step(S_BASE_REF_PICK,
          applies=lambda s: (S_TASK_TYPE in s.answered
                             and _base_ref_required(s)
@@ -3395,18 +3915,6 @@ STEPS: list[Step] = [
          applies=lambda s: (s.critic_pending_text and S_CRITIC_TEXT not in s.answered),
          build=_build_critic_text, submit=_submit_critic_text,
          owns=("critic", "critic_pending_text")),
-    # resume: identity 가 모두 정해진 뒤(직전 run 과 같은 task/phase 가 확정),
-    # 모델/워커/directive/related/clarification 설정 단계로 들어가기 직전에
-    # "직전 run 설정 그대로 재사용?" 를 한 번 묻는다. YES 면 그 단계들을 prefill 로
-    # 충족시켜 곧장 confirm 으로 직행하고, NO 면 현행대로 단계별 입력을 받는다.
-    Step(S_REUSE_PREVIOUS,
-         applies=lambda s: (_identity_ready(s)
-                            and s.use_defaults is None
-                            and s.reuse_previous is None
-                            and s.task_type in _RESUME_REUSE_PHASES
-                            and _has_prior_run_inputs(s)),
-         build=_build_reuse_previous, submit=_submit_reuse_previous,
-         owns=("reuse_previous",)),
     Step(S_DEFAULTS_OR_CUSTOM,
          applies=lambda s: (_identity_ready(s)
                             and s.use_defaults is None),
@@ -3609,6 +4117,14 @@ def _reset_from(state: WizardState, target_step: str) -> None:
         for fname in step.owns:
             _reset_field(state, fname)
     state.answered = [a for a in state.answered if a not in cleared_ids]
+    direct_input_pending = {
+        S_FEATURE_EVIDENCE: "feature_evidence_pending_text",
+        S_PROJECT_EVIDENCE: "project_evidence_pending_text",
+        S_ANALYSIS_TARGET: "analysis_target_pending_text",
+    }
+    pending_field = direct_input_pending.get(target_step)
+    if pending_field is not None:
+        setattr(state, pending_field, True)
 
 
 _FIELD_DEFAULTS: dict[str, Any] = {
@@ -3619,6 +4135,9 @@ _FIELD_DEFAULTS: dict[str, Any] = {
     "profile_workers": [], "profile_optional_workers": [],
     "keep_existing_brief": None,
     "brief_path": "", "brief_path_pending_text": False,
+    "project_evidence_path": "", "project_evidence_pending_text": False,
+    "feature_evidence_path": "", "feature_evidence_pending_text": False,
+    "analysis_target": "", "analysis_target_pending_text": False,
     "reuse_worktree": None, "base_ref": "",
     "base_ref_pending_text": False, "approved_plan_path": "",
     "approved_plan_pending_text": False, "approve_plan_candidate": "",
@@ -3841,6 +4360,8 @@ def submit(state: WizardState, value: str) -> dict[str, Any]:
         return {"echo": "", "next": prompt_payload(state, prompt)}
     if prompt.kind == "pick_group":
         return _submit_group(state, prompt, value)
+    if prompt.kind == "pick" and len(prompt.options) > HOST_PICK_OPTION_CAP:
+        value = _normalize_numbered_pick_answer(prompt, value)
     step = STEP_BY_ID[prompt.step]
     echo = step.submit(state, value or "")
     if prompt.step not in state.answered:
@@ -3876,6 +4397,11 @@ def render_args(state: WizardState) -> dict[str, str]:
         if state.task_type == "release-handoff"
         else ""
     )
+    evidence_paths = [
+        path
+        for path in (state.feature_evidence_path, state.project_evidence_path)
+        if path
+    ]
     return {
         "project-root": state.project_root,
         "project-id": state.project_id,
@@ -3883,6 +4409,8 @@ def render_args(state: WizardState) -> dict[str, str]:
         "task-id": state.task_id,
         "task-type": state.task_type,
         "task-brief": state.brief_path,
+        "analysis-target": state.analysis_target,
+        "evidence-inputs": ",".join(evidence_paths),
         "executor": state.executor,
         "critic": state.critic,
         "approved-plan": state.approved_plan_path,
@@ -3911,6 +4439,25 @@ def confirmation_block(state: WizardState) -> str:
     lines.append(f"  task-type     : {state.task_type}")
     lines.append(f"  task-key      : {state.task_group}/{state.task_id}")
     lines.append(f"  brief         : {state.brief_path or '(none)'}")
+    if state.analysis_target:
+        lines.append(f"  analysis-target: {state.analysis_target}")
+    if state.feature_evidence_path or state.project_evidence_path:
+        evidence_status = {
+            str(item.report_path): item.review_status
+            for item in _resolve_analysis_evidence(state)
+        }
+        if state.feature_evidence_path:
+            lines.append(
+                "  feature-evidence: "
+                f"{state.feature_evidence_path} "
+                f"({evidence_status.get(state.feature_evidence_path, 'unknown')})"
+            )
+        if state.project_evidence_path:
+            lines.append(
+                "  project-evidence: "
+                f"{state.project_evidence_path} "
+                f"({evidence_status.get(state.project_evidence_path, 'unknown')})"
+            )
     if state.task_type == "final-verification":
         lines.append("  base-ref      : (selected stage worktree)")
     elif state.task_type == "implementation" and state.reuse_worktree: