okstra 0.36.2 → 0.37.0

package/runtime/python/okstra_ctl/wizard.py

@@ -45,7 +45,9 @@ from okstra_ctl.workers import (
     validate_workers_against_profile,
 )
 from okstra_ctl import worktree_registry
+from okstra_project.dirs import project_json_path, tasks_root
 from okstra_project.state import (
+    StateError,
     list_project_tasks,
     read_latest_task,
     read_task_manifest,
@@ -81,6 +83,8 @@ TASK_PICK_NEW_TOKEN = "__new__"
 # Pick-vs-free-text tokens shared by suggestion-aware prompts.
 PICK_USE_SUGGESTED = "__use_suggested__"
 PICK_TYPE_CUSTOM = "__free_input__"
+_RECENT_PREFIX = "__recent:"
+_REPORT_PREFIX = "__report:"
 
 # Lines of `key: value` we pull from a brief markdown frontmatter. The
 # parser is intentionally lightweight (no yaml dep) and tolerant — a
@@ -167,6 +171,7 @@ S_TASK_ID = "task_id"
 S_TASK_ID_TEXT = "task_id_text"
 S_TASK_TYPE = "task_type"
 S_BRIEF_KEEP = "brief_keep"
+S_BRIEF_PATH_PICK = "brief_path_pick"
 S_BRIEF_PATH = "brief_path"
 S_BASE_REF_PICK = "base_ref_pick"
 S_BASE_REF_TEXT = "base_ref_text"
@@ -226,6 +231,7 @@ class WizardState:
     # brief
     keep_existing_brief: Optional[bool] = None
     brief_path: str = ""
+    brief_path_pending_text: bool = False
 
     # worktree
     reuse_worktree: Optional[bool] = None
@@ -248,13 +254,17 @@ class WizardState:
     report_writer_model: str = ""
     directive: str = ""
     directive_pending_text: bool = False
+    last_directive_cached: str = ""
     related_tasks_raw: str = ""
     related_tasks_pending_text: bool = False
+    last_siblings_cached: str = ""
     clarification_response_path: str = ""
     clarification_pending_text: bool = False
+    last_final_report_cached: str = ""
     pr_template_path: str = ""
     pr_template_pending_text: bool = False
     pr_template_scope: str = ""  # "once" | "project" | "global"
+    last_pr_template_cached: str = ""
 
     # confirm / edit
     confirmed: Optional[bool] = None
@@ -505,6 +515,9 @@ def _p(workspace_root: str, step_id: str, **vars: str) -> dict:
         "options": raw.get("options", {}),
         "echo_variants": raw.get("echo_variants", {}),
         "errors": raw.get("errors", {}),
+        "labels": raw.get("labels", {}),
+        "echo_suffixes": raw.get("echo_suffixes", {}),
+        "recent_label_prefix": raw.get("recent_label_prefix", ""),
     }
 
 
@@ -656,6 +669,45 @@ def _submit_task_pick(state: WizardState, value: str) -> Optional[str]:
     return f"task: {value}"
 
 
+def _suggest_recent_task_groups(state: WizardState, limit: int = 2) -> list[str]:
+    """프로젝트 catalog 에서 최근 task-group 후보를 limit 개까지 반환."""
+    if not state.project_root:
+        return []
+    try:
+        tasks = list_project_tasks(Path(state.project_root))
+    except (OSError, StateError):
+        return []
+    seen: list[str] = []
+    for entry in tasks:
+        tg = entry.get("taskGroup") or ""
+        if tg and tg not in seen:
+            seen.append(tg)
+        if len(seen) >= limit:
+            break
+    return seen
+
+
+def _suggest_recent_task_ids(state: WizardState, limit: int = 2) -> list[str]:
+    """현재 task_group 내의 최근 task-id 후보를 limit 개까지 반환."""
+    if not state.project_root or not state.task_group:
+        return []
+    try:
+        tasks = list_project_tasks(Path(state.project_root))
+    except (OSError, StateError):
+        return []
+    seen: list[str] = []
+    for entry in tasks:
+        tg = entry.get("taskGroup") or ""
+        if tg != state.task_group:
+            continue
+        tid = entry.get("taskId") or ""
+        if tid and tid not in seen:
+            seen.append(tid)
+        if len(seen) >= limit:
+            break
+    return seen
+
+
 def _build_task_group(state: WizardState) -> Prompt:
     sugg = state.task_group_suggestion
     if sugg:
@@ -670,10 +722,19 @@ def _build_task_group(state: WizardState) -> Prompt:
             label=t["label"], options=options,
             echo_template=t["echo_template"],
         )
-    t = _p(state.workspace_root, "task_group")
-    return Prompt(step=S_TASK_GROUP, kind="text",
-                  label=t["label"],
-                  echo_template=t["echo_template"])
+    # suggestion 이 없으면 catalog 의 최근 task-group 을 후보로 노출 + 직접 입력
+    recent = _suggest_recent_task_groups(state, limit=2)
+    t = _p(state.workspace_root, "task_group_no_suggestion")
+    recent_prefix = t.get("recent_label_prefix", "")
+    options: list[Option] = []
+    for tg in recent:
+        options.append(_opt(f"{_RECENT_PREFIX}{tg}", f"{recent_prefix}{tg}"))
+    options.append(_opt(PICK_TYPE_CUSTOM, t["options"][PICK_TYPE_CUSTOM]))
+    return Prompt(
+        step=S_TASK_GROUP, kind="pick",
+        label=t["label"], options=options,
+        echo_template=t["echo_template"],
+    )
 
 
 def _submit_task_group(state: WizardState, value: str) -> Optional[str]:
@@ -686,15 +747,27 @@ def _submit_task_group(state: WizardState, value: str) -> Optional[str]:
             return f"task-group: {state.task_group} (brief)"
         if value == PICK_TYPE_CUSTOM:
             state.task_group_pending_text = True
-            t = _p(state.workspace_root, "task_group")
+            t = _p(state.workspace_root, "task_group_with_suggestion",
+                   suggestion=state.task_group_suggestion)
             return t["echo_variants"]["free_input"]
         raise WizardError(
             f"expected {PICK_USE_SUGGESTED!r} or {PICK_TYPE_CUSTOM!r}, "
             f"got: {value!r}"
         )
-    state.task_group = _slug_or_die(value, "task_group")
-    state.task_group_pending_text = False
-    return f"task-group: {state.task_group}"
+    # suggestion-없음 분기 (Task 2 신규)
+    if value.startswith(_RECENT_PREFIX):
+        tg = value[len(_RECENT_PREFIX):]
+        state.task_group = _slug_or_die(tg, "task_group")
+        state.task_group_pending_text = False
+        return f"task-group: {state.task_group} (recent)"
+    if value == PICK_TYPE_CUSTOM:
+        state.task_group_pending_text = True
+        t = _p(state.workspace_root, "task_group_no_suggestion")
+        return t["echo_variants"]["free_input"]
+    raise WizardError(
+        f"unexpected task-group value: {value!r} "
+        f"(expected {PICK_USE_SUGGESTED!r}, {PICK_TYPE_CUSTOM!r}, or '{_RECENT_PREFIX}<value>')"
+    )
 
 
 def _build_task_group_text(state: WizardState) -> Prompt:
@@ -724,10 +797,18 @@ def _build_task_id(state: WizardState) -> Prompt:
             label=t["label"], options=options,
             echo_template=t["echo_template"],
         )
-    t = _p(state.workspace_root, "task_id")
-    return Prompt(step=S_TASK_ID, kind="text",
-                  label=t["label"],
-                  echo_template=t["echo_template"])
+    recent = _suggest_recent_task_ids(state, limit=2)
+    t = _p(state.workspace_root, "task_id_no_suggestion")
+    recent_prefix = t.get("recent_label_prefix", "")
+    options: list[Option] = []
+    for tid in recent:
+        options.append(_opt(f"{_RECENT_PREFIX}{tid}", f"{recent_prefix}{tid}"))
+    options.append(_opt(PICK_TYPE_CUSTOM, t["options"][PICK_TYPE_CUSTOM]))
+    return Prompt(
+        step=S_TASK_ID, kind="pick",
+        label=t["label"], options=options,
+        echo_template=t["echo_template"],
+    )
 
 
 def _submit_task_id(state: WizardState, value: str) -> Optional[str]:
@@ -738,15 +819,28 @@ def _submit_task_id(state: WizardState, value: str) -> Optional[str]:
             return f"task-id: {state.task_id} (brief)"
         if value == PICK_TYPE_CUSTOM:
             state.task_id_pending_text = True
-            t = _p(state.workspace_root, "task_id")
+            t = _p(state.workspace_root, "task_id_with_suggestion",
+                   suggestion=state.task_id_suggestion)
             return t["echo_variants"]["free_input"]
         raise WizardError(
             f"expected {PICK_USE_SUGGESTED!r} or {PICK_TYPE_CUSTOM!r}, "
             f"got: {value!r}"
         )
-    state.task_id = _slug_or_die(value, "task_id")
-    state.task_id_pending_text = False
-    return f"task-id: {state.task_id}"
+    # suggestion-없음 분기
+    if value.startswith(_RECENT_PREFIX):
+        tid = value[len(_RECENT_PREFIX):]
+        state.task_id = _slug_or_die(tid, "task_id")
+        state.task_id_pending_text = False
+        return f"task-id: {state.task_id} (recent)"
+    if value == PICK_TYPE_CUSTOM:
+        state.task_id_pending_text = True
+        t = _p(state.workspace_root, "task_id_no_suggestion")
+        return t["echo_variants"]["free_input"]
+    raise WizardError(
+        f"unexpected task-id value: {value!r} "
+        f"(expected {PICK_USE_SUGGESTED!r}, {PICK_TYPE_CUSTOM!r}, "
+        f"or '{_RECENT_PREFIX}<value>')"
+    )
 
 
 def _build_task_id_text(state: WizardState) -> Prompt:
@@ -820,6 +914,60 @@ def _submit_brief_keep(state: WizardState, value: str) -> Optional[str]:
     return None  # next prompt is S_BRIEF_PATH
 
 
+def _suggest_brief_path(state: WizardState) -> tuple[str, str]:
+    """Return (existing_brief_relpath_or_empty, standard_relpath).
+    standard_relpath = ".okstra/tasks/<task-group>/<task-id>/brief.md"."""
+    existing = state.existing_brief_path or ""
+    tg = slugify_task_segment(state.task_group) if state.task_group else ""
+    tid = slugify_task_segment(state.task_id) if state.task_id else ""
+    if tg and tid:
+        standard = str(Path(".okstra") / "tasks" / tg / tid / "brief.md")
+    else:
+        standard = ""
+    return existing, standard
+
+
+def _build_brief_path_pick(state: WizardState) -> Prompt:
+    existing, standard = _suggest_brief_path(state)
+    t = _p(state.workspace_root, "brief_path_pick")
+    options: list[Option] = []
+    if existing:
+        options.append(_opt("__existing__",
+                            t["options"]["__existing__"].format(existing=existing)))
+    if standard and standard != existing:
+        options.append(_opt("__standard__",
+                            t["options"]["__standard__"].format(standard=standard)))
+    options.append(_opt(PICK_TYPE_CUSTOM, t["options"][PICK_TYPE_CUSTOM]))
+    return Prompt(step=S_BRIEF_PATH_PICK, kind="pick",
+                  label=t["label"], options=options,
+                  echo_template=t["echo_template"])
+
+
+def _submit_brief_path_pick(state: WizardState, value: str) -> Optional[str]:
+    existing, standard = _suggest_brief_path(state)
+    if value == "__existing__":
+        if not existing:
+            t = _p(state.workspace_root, "brief_path_pick")
+            raise WizardError(t["errors"]["existing_missing"])
+        p = _require_file(existing, Path(state.project_root), "task brief")
+        state.brief_path = str(p)
+        state.brief_path_pending_text = False
+        return f"brief: {p}"
+    if value == "__standard__":
+        p = _require_file(standard, Path(state.project_root), "task brief")
+        state.brief_path = str(p)
+        state.brief_path_pending_text = False
+        return f"brief: {p}"
+    if value == PICK_TYPE_CUSTOM:
+        state.brief_path_pending_text = True
+        state.brief_path = ""
+        return None
+    raise WizardError(
+        f"expected '__existing__', '__standard__', or {PICK_TYPE_CUSTOM!r}, "
+        f"got: {value!r}"
+    )
+
+
 def _build_brief_path(state: WizardState) -> Prompt:
     t = _p(state.workspace_root, "brief_path")
     return Prompt(
@@ -832,6 +980,7 @@ def _build_brief_path(state: WizardState) -> Prompt:
 def _submit_brief_path(state: WizardState, value: str) -> Optional[str]:
     p = _require_file(value, Path(state.project_root), "task brief")
     state.brief_path = str(p)
+    state.brief_path_pending_text = False
     # When the user is starting a brand-new task, pull task-group /
     # task-id candidates from the brief frontmatter so the next two
     # prompts can offer them as a one-click pick instead of forcing a
@@ -888,25 +1037,29 @@ def _submit_base_ref_text(state: WizardState, value: str) -> Optional[str]:
 PICK_USE_DEFAULT = "__use_default__"
 PICK_OTHER = "__other__"
 PICK_SKIP = "__skip__"
-PICK_ENTER = "__enter__"
+_REUSE_LAST_TOKEN = "__reuse_last__"
+_SIBLINGS_TOKEN = "__siblings__"
+_LATEST_REPORT_TOKEN = "__latest_report__"
+_PROJECT_DEFAULT_TOKEN = "__project_default__"
 
 
-def _latest_implementation_planning_report(state: WizardState) -> Optional[Path]:
-    """Find the latest ``final-report-implementation-planning-<seq>.md`` under
-    the current task's runs directory.
+def _list_implementation_planning_reports(
+    state: WizardState, limit: int = 3
+) -> list[Path]:
+    """task 의 implementation-planning runs 디렉토리에서 최신순으로 final-report 경로를 limit 개까지 반환.
 
-    Returns the path relative to ``project_root`` if found, otherwise ``None``.
+    Each path is relative to ``project_root`` when possible.
     """
     if not state.task_group or not state.task_id or not state.project_root:
-        return None
-    base = (Path(state.project_root) / ".project-docs" / "okstra" / "tasks"
+        return []
+    base = (tasks_root(state.project_root)
             / slugify_task_segment(state.task_group)
             / slugify_task_segment(state.task_id)
             / "runs" / "implementation-planning")
     if not base.is_dir():
-        return None
+        return []
     pat = re.compile(r"^final-report-implementation-planning-(\d+)\.md$")
-    best: tuple[int, Path] | None = None
+    found: list[tuple[int, Path]] = []
     for run_dir in base.iterdir():
         reports = run_dir / "reports"
         if not reports.is_dir():
@@ -915,49 +1068,68 @@ def _latest_implementation_planning_report(state: WizardState) -> Optional[Path]
             m = pat.match(child.name)
             if not m:
                 continue
-            n = int(m.group(1))
-            if best is None or n > best[0]:
-                best = (n, child)
-    if best is None:
-        return None
-    try:
-        return best[1].relative_to(Path(state.project_root))
-    except ValueError:
-        return best[1]
+            found.append((int(m.group(1)), child))
+    found.sort(key=lambda x: -x[0])
+    out: list[Path] = []
+    for _, p in found[:limit]:
+        try:
+            out.append(p.relative_to(Path(state.project_root)))
+        except ValueError:
+            out.append(p)
+    return out
+
+
+def _latest_implementation_planning_report(state: WizardState) -> Optional[Path]:
+    """task 의 implementation-planning runs 중 가장 최신 final-report 경로 (relpath where possible)."""
+    reports = _list_implementation_planning_reports(state, limit=1)
+    return reports[0] if reports else None
 
 
 def _build_approved_plan_pick(state: WizardState) -> Prompt:
-    default = _latest_implementation_planning_report(state)
+    reports = _list_implementation_planning_reports(state, limit=3)
+    default = reports[0] if reports else None
     t = _p(state.workspace_root, "approved_plan_pick",
            default=str(default) if default is not None else "")
-    options = [
-        _opt(k, v.format(default=str(default) if default is not None else ""))
-        for k, v in t["options"].items()
-    ]
+    other_report_label = t["labels"]["other_report"]
+    options: list[Option] = []
+    if default is not None:
+        options.append(_opt(PICK_USE_DEFAULT,
+                            t["options"][PICK_USE_DEFAULT].format(default=str(default))))
+    for p in reports[1:]:
+        options.append(_opt(f"{_REPORT_PREFIX}{p}",
+                            other_report_label.format(path=str(p))))
+    options.append(_opt(PICK_OTHER, t["options"][PICK_OTHER]))
     return Prompt(
         step=S_APPROVED_PLAN_PICK, kind="pick",
-        label=t["label"],
-        options=options,
+        label=t["label"], options=options,
         echo_template=t["echo_template"],
     )
 
 
 def _submit_approved_plan_pick(state: WizardState, value: str) -> Optional[str]:
+    t = _p(state.workspace_root, "approved_plan_pick", default="")
     if value == PICK_USE_DEFAULT:
         default = _latest_implementation_planning_report(state)
         if default is None:
-            t = _p(state.workspace_root, "approved_plan_pick", default="")
             raise WizardError(t["errors"]["default_not_found"])
         p = _validate_approved_plan(str(default), Path(state.project_root))
         state.approved_plan_path = str(p)
         state.approved_plan_pending_text = False
         return f"approved-plan: {p}"
+    if value.startswith(_REPORT_PREFIX):
+        rel = value[len(_REPORT_PREFIX):]
+        p = _validate_approved_plan(rel, Path(state.project_root))
+        state.approved_plan_path = str(p)
+        state.approved_plan_pending_text = False
+        suffix = t["echo_suffixes"]["other_report"]
+        return f"approved-plan: {p} {suffix}"
     if value == PICK_OTHER:
         state.approved_plan_pending_text = True
         state.approved_plan_path = ""
         return None
     raise WizardError(
-        f"expected '{PICK_USE_DEFAULT}' or '{PICK_OTHER}', got: {value!r}"
+        f"unexpected approved-plan value: {value!r} "
+        f"(expected {PICK_USE_DEFAULT!r}, {PICK_OTHER!r}, or '{_REPORT_PREFIX}<path>')"
     )
 
 
@@ -1024,89 +1196,250 @@ def _submit_stage_pick(state: WizardState, answer: str) -> Optional[str]:
     return f"stage: {answer}"
 
 
+def _suggest_latest_final_report(state: WizardState) -> str:
+    """task 의 모든 phase runs 디렉토리에서 가장 최근 final-report-*.md 의 relpath 를 반환.
+
+    찾지 못하면 빈 문자열.
+    """
+    if not state.task_group or not state.task_id or not state.project_root:
+        return ""
+    runs_base = (tasks_root(state.project_root)
+                 / slugify_task_segment(state.task_group)
+                 / slugify_task_segment(state.task_id) / "runs")
+    if not runs_base.is_dir():
+        return ""
+    candidates = [
+        p for p in runs_base.glob("*/*/reports/final-report-*.md")
+        if p.is_file()
+    ]
+    if not candidates:
+        return ""
+
+    def _mtime_safe(p: Path) -> float:
+        try:
+            return p.stat().st_mtime
+        except OSError:
+            return -1.0
+
+    best = max(candidates, key=_mtime_safe)
+    try:
+        return str(best.relative_to(Path(state.project_root)))
+    except ValueError:
+        return str(best)
+
+
+def _suggest_last_directive(state: WizardState) -> str:
+    """같은 task 의 가장 최근 run-inputs-*.json 에서 directive 값을 자동 추출."""
+    if not state.task_group or not state.task_id or not state.project_root:
+        return ""
+    runs_base = (tasks_root(state.project_root)
+                 / slugify_task_segment(state.task_group)
+                 / slugify_task_segment(state.task_id) / "runs")
+    if not runs_base.is_dir():
+        return ""
+    candidates: list[tuple[float, Path]] = []
+    for phase_dir in runs_base.iterdir():
+        if not phase_dir.is_dir():
+            continue
+        for run_dir in phase_dir.iterdir():
+            for inp in run_dir.glob("run-inputs-*.json"):
+                try:
+                    candidates.append((inp.stat().st_mtime, inp))
+                except OSError:
+                    continue
+    if not candidates:
+        return ""
+    candidates.sort(key=lambda x: -x[0])
+    try:
+        data = json.loads(candidates[0][1].read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return ""
+    val = data.get("directive") or ""
+    return val if isinstance(val, str) else ""
+
+
 def _build_directive_pick(state: WizardState) -> Prompt:
+    last = _suggest_last_directive(state)
     t = _p(state.workspace_root, "directive_pick")
+    options: list[Option] = []
+    options.append(_opt(PICK_SKIP, t["options"][PICK_SKIP]))
+    if last:
+        snippet = last[:60] + ("…" if len(last) > 60 else "")
+        label_template = t["labels"]["reuse_last"]
+        options.append(_opt(_REUSE_LAST_TOKEN, label_template.format(snippet=snippet)))
+        state.last_directive_cached = last
+    options.append(_opt(PICK_TYPE_CUSTOM, t["options"][PICK_TYPE_CUSTOM]))
     return Prompt(
         step=S_DIRECTIVE_PICK, kind="pick",
-        label=t["label"],
-        options=[_opt(k, v) for k, v in t["options"].items()],
+        label=t["label"], options=options,
         echo_template=t["echo_template"],
     )
 
 
 def _submit_directive_pick(state: WizardState, value: str) -> Optional[str]:
+    t = _p(state.workspace_root, "directive_pick")
     if value == PICK_SKIP:
         state.directive = ""
         state.directive_pending_text = False
-        return "directive: (none)"
-    if value == PICK_ENTER:
+        return t["echo_suffixes"]["skip"]
+    if value == _REUSE_LAST_TOKEN:
+        state.directive = state.last_directive_cached
+        state.directive_pending_text = False
+        return t["echo_suffixes"]["reuse"].format(value=state.directive)
+    if value == PICK_TYPE_CUSTOM:
         state.directive_pending_text = True
         return None
-    raise WizardError(f"expected '{PICK_SKIP}' or '{PICK_ENTER}', got: {value!r}")
+    raise WizardError(
+        f"unexpected directive value: {value!r} "
+        f"(expected {PICK_SKIP!r}, {_REUSE_LAST_TOKEN!r}, or {PICK_TYPE_CUSTOM!r})"
+    )
+
+
+def _suggest_sibling_task_ids(state: WizardState) -> str:
+    """같은 task-group 의 다른 task-id 를 CSV 로 반환 (현재 task 제외, 빈 결과면 '')."""
+    if not state.project_root or not state.task_group:
+        return ""
+    try:
+        tasks = list_project_tasks(Path(state.project_root))
+    except (OSError, StateError):
+        return ""
+    siblings: list[str] = []
+    for entry in tasks:
+        tg = entry.get("taskGroup") or ""
+        if tg != state.task_group:
+            continue
+        tid = entry.get("taskId") or ""
+        if not tid or tid == state.task_id:
+            continue
+        if tid not in siblings:
+            siblings.append(tid)
+    return ",".join(siblings)
 
 
 def _build_related_tasks_pick(state: WizardState) -> Prompt:
+    siblings = _suggest_sibling_task_ids(state)
     t = _p(state.workspace_root, "related_tasks_pick")
-    return Prompt(
-        step=S_RELATED_TASKS_PICK, kind="pick",
-        label=t["label"],
-        options=[_opt(k, v) for k, v in t["options"].items()],
-        echo_template=t["echo_template"],
-    )
+    options: list[Option] = []
+    options.append(_opt(PICK_SKIP, t["options"][PICK_SKIP]))
+    if siblings:
+        snippet = siblings if len(siblings) <= 60 else siblings[:60] + "…"
+        label_template = t["labels"]["siblings"]
+        options.append(_opt(_SIBLINGS_TOKEN, label_template.format(snippet=snippet)))
+        state.last_siblings_cached = siblings
+    options.append(_opt(PICK_TYPE_CUSTOM, t["options"][PICK_TYPE_CUSTOM]))
+    return Prompt(step=S_RELATED_TASKS_PICK, kind="pick",
+                  label=t["label"], options=options,
+                  echo_template=t["echo_template"])
 
 
 def _submit_related_tasks_pick(state: WizardState, value: str) -> Optional[str]:
+    t = _p(state.workspace_root, "related_tasks_pick")
     if value == PICK_SKIP:
         state.related_tasks_raw = ""
         state.related_tasks_pending_text = False
-        return "related-tasks: (none)"
-    if value == PICK_ENTER:
+        return t["echo_suffixes"]["skip"]
+    if value == _SIBLINGS_TOKEN:
+        state.related_tasks_raw = state.last_siblings_cached
+        state.related_tasks_pending_text = False
+        return t["echo_suffixes"]["siblings"].format(value=state.related_tasks_raw)
+    if value == PICK_TYPE_CUSTOM:
         state.related_tasks_pending_text = True
         return None
-    raise WizardError(f"expected '{PICK_SKIP}' or '{PICK_ENTER}', got: {value!r}")
+    raise WizardError(
+        f"unexpected related-tasks value: {value!r} "
+        f"(expected {PICK_SKIP!r}, {_SIBLINGS_TOKEN!r}, or {PICK_TYPE_CUSTOM!r})"
+    )
 
 
 def _build_clarification_pick(state: WizardState) -> Prompt:
+    latest = _suggest_latest_final_report(state)
     t = _p(state.workspace_root, "clarification_pick")
-    return Prompt(
-        step=S_CLARIFICATION_PICK, kind="pick",
-        label=t["label"],
-        options=[_opt(k, v) for k, v in t["options"].items()],
-        echo_template=t["echo_template"],
-    )
+    options: list[Option] = []
+    options.append(_opt(PICK_SKIP, t["options"][PICK_SKIP]))
+    if latest:
+        snippet = latest if len(latest) <= 60 else "…" + latest[-60:]
+        label_template = t["labels"]["latest_report"]
+        options.append(_opt(_LATEST_REPORT_TOKEN, label_template.format(snippet=snippet)))
+        state.last_final_report_cached = latest
+    options.append(_opt(PICK_TYPE_CUSTOM, t["options"][PICK_TYPE_CUSTOM]))
+    return Prompt(step=S_CLARIFICATION_PICK, kind="pick",
+                  label=t["label"], options=options,
+                  echo_template=t["echo_template"])
 
 
 def _submit_clarification_pick(state: WizardState, value: str) -> Optional[str]:
+    t = _p(state.workspace_root, "clarification_pick")
     if value == PICK_SKIP:
         state.clarification_response_path = ""
         state.clarification_pending_text = False
-        return "clarification: (none)"
-    if value == PICK_ENTER:
+        return t["echo_suffixes"]["skip"]
+    if value == _LATEST_REPORT_TOKEN:
+        state.clarification_response_path = state.last_final_report_cached
+        state.clarification_pending_text = False
+        return t["echo_suffixes"]["latest_report"].format(value=state.clarification_response_path)
+    if value == PICK_TYPE_CUSTOM:
         state.clarification_pending_text = True
         return None
-    raise WizardError(f"expected '{PICK_SKIP}' or '{PICK_ENTER}', got: {value!r}")
+    raise WizardError(
+        f"unexpected clarification value: {value!r} "
+        f"(expected {PICK_SKIP!r}, {_LATEST_REPORT_TOKEN!r}, or {PICK_TYPE_CUSTOM!r})"
+    )
+
+
+def _suggest_project_pr_template(state: WizardState) -> str:
+    """project.json 의 prTemplatePath 필드를 읽어 경로 문자열로 반환.
+
+    없거나 읽기 실패 시 빈 문자열.
+    """
+    if not state.project_root:
+        return ""
+    project_json = project_json_path(Path(state.project_root))
+    if not project_json.is_file():
+        return ""
+    try:
+        data = json.loads(project_json.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return ""
+    val = data.get("prTemplatePath") or ""
+    return val if isinstance(val, str) else ""
 
 
 def _build_pr_template_pick(state: WizardState) -> Prompt:
+    project_default = _suggest_project_pr_template(state)
     t = _p(state.workspace_root, "pr_template_pick")
+    options: list[Option] = []
+    options.append(_opt(PICK_SKIP, t["options"][PICK_SKIP]))
+    if project_default:
+        snippet = project_default if len(project_default) <= 60 else "…" + project_default[-60:]
+        label_template = t["labels"]["project_default"]
+        options.append(_opt(_PROJECT_DEFAULT_TOKEN, label_template.format(snippet=snippet)))
+        state.last_pr_template_cached = project_default
+    options.append(_opt(PICK_TYPE_CUSTOM, t["options"][PICK_TYPE_CUSTOM]))
     return Prompt(
         step=S_PR_TEMPLATE_PICK, kind="pick",
-        label=t["label"],
-        options=[_opt(k, v) for k, v in t["options"].items()],
+        label=t["label"], options=options,
         echo_template=t["echo_template"],
     )
 
 
 def _submit_pr_template_pick(state: WizardState, value: str) -> Optional[str]:
+    t = _p(state.workspace_root, "pr_template_pick")
     if value == PICK_SKIP:
         state.pr_template_path = ""
         state.pr_template_scope = ""
         state.pr_template_pending_text = False
-        return "pr-template: (auto-resolve)"
-    if value == PICK_ENTER:
+        return t["echo_suffixes"]["skip"]
+    if value == _PROJECT_DEFAULT_TOKEN:
+        state.pr_template_path = state.last_pr_template_cached
+        state.pr_template_pending_text = False
+        return t["echo_suffixes"]["project_default"].format(value=state.pr_template_path)
+    if value == PICK_TYPE_CUSTOM:
         state.pr_template_pending_text = True
         return None
-    raise WizardError(f"expected '{PICK_SKIP}' or '{PICK_ENTER}', got: {value!r}")
+    raise WizardError(
+        f"unexpected pr-template value: {value!r} "
+        f"(expected {PICK_SKIP!r}, {_PROJECT_DEFAULT_TOKEN!r}, or {PICK_TYPE_CUSTOM!r})"
+    )
 
 
 def _build_executor(state: WizardState) -> Prompt:
@@ -1419,22 +1752,24 @@ STEPS: list[Step] = [
                "profile_optional_workers",
                "task_group_suggestion", "task_id_suggestion",
                "task_group_pending_text", "task_id_pending_text")),
-    Step(S_BRIEF_PATH,
+    Step(S_BRIEF_PATH_PICK,
          applies=lambda s: (
              not s.brief_path
+             and not s.brief_path_pending_text
+             and S_BRIEF_PATH_PICK not in s.answered
              and (
-                 # new-task flow: collect brief FIRST so task-group /
-                 # task-id can be offered as one-click picks from the
-                 # brief's frontmatter.
                  (s.is_new_task is True)
-                 # existing-task flow: brief comes after task-type and
-                 # the optional brief-keep step (unchanged behavior).
                  or (s.is_new_task is False
                      and S_TASK_TYPE in s.answered
                      and (s.keep_existing_brief is False
                           or not s.existing_brief_path))
              )
          ),
+         build=_build_brief_path_pick, submit=_submit_brief_path_pick,
+         owns=("brief_path_pending_text",)),
+    Step(S_BRIEF_PATH,
+         applies=lambda s: s.brief_path_pending_text
+                            and S_BRIEF_PATH not in s.answered,
          build=_build_brief_path, submit=_submit_brief_path,
          owns=("brief_path", "task_group_suggestion", "task_id_suggestion")),
     Step(S_TASK_GROUP,