okstra 0.66.0 → 0.67.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okstra",
-  "version": "0.66.0",
+  "version": "0.67.0",
   "description": "Multi-agent cross-verification orchestrator runtime + Claude Code skills.",
   "license": "MIT",
   "author": "devonshin",

package/runtime/BUILD.json

@@ -1,5 +1,5 @@
 {
-  "package": "0.66.0",
-  "builtAt": "2026-06-10T09:21:55.603Z",
+  "package": "0.67.0",
+  "builtAt": "2026-06-10T10:33:26.768Z",
   "repoRoot": "/home/runner/work/okstra/okstra"
 }

package/runtime/prompts/wizard/prompts.ko.json

@@ -3,10 +3,10 @@
   "locale": "ko",
   "steps": {
     "task_pick": {
-      "label": "어느 task?",
+      "label": "어느 task? (남은 작업 최신순 추천)",
       "echo_template": "task: {value}",
       "options": {
-        "__new__": "Start a brand-new task",
+        "__new__": "직접 입력 (새 작업 또는 목록에 없는 task)",
         "_LATEST_SUFFIX": "  (latest)"
       }
     },
@@ -80,9 +80,19 @@
       "label": "Task type?",
       "echo_template": "task-type: {value}",
       "options": {
-        "_RECOMMENDED_SUFFIX": " (recommended)"
+        "_RECOMMENDED_SUFFIX": " (recommended)",
+        "_RERUN_SUFFIX": " (현재 phase 재실행)",
+        "_NEXT_SUFFIX": " (다음 단계)",
+        "__free_input__": "직접 입력"
+      },
+      "echo_variants": {
+        "free_input": "task-type: (직접 입력)"
       }
     },
+    "task_type_text": {
+      "label": "Task type? (입력 가능: requirements-discovery, improvement-discovery, error-analysis, implementation-planning, implementation, final-verification, release-handoff)",
+      "echo_template": "task-type: {value}"
+    },
     "brief_keep": {
       "label": "기존 brief 경로 [{existing_brief_path}] 를 유지할까요?",
       "echo_template": "brief: {value}",

package/runtime/python/okstra_ctl/wizard.py

@@ -49,6 +49,7 @@ from okstra_ctl.workers import (
     resolve_profile_workers,
     validate_workers_against_profile,
 )
+from okstra_ctl.workflow import PHASE_SEQUENCE
 from okstra_ctl import worktree_registry
 from okstra_ctl.worktree import (
     is_git_work_tree,
@@ -97,6 +98,11 @@ GEMINI_MODEL_OPTIONS = ["default", "gemini-3-pro-preview", "gemini-3-flash-previ
 # special pick value: start a brand-new task
 TASK_PICK_NEW_TOKEN = "__new__"
 
+# AskUserQuestion renders at most 4 options per question; the last slot is
+# always reserved for the direct-input option, so recommendation lists from
+# dynamic sources (catalog, manifest) are capped at 3.
+_RECOMMENDATION_CAP = 3
+
 # Pick-vs-free-text tokens shared by suggestion-aware prompts.
 PICK_USE_SUGGESTED = "__use_suggested__"
 PICK_TYPE_CUSTOM = "__free_input__"
@@ -220,6 +226,7 @@ S_TASK_GROUP_TEXT = "task_group_text"
 S_TASK_ID = "task_id"
 S_TASK_ID_TEXT = "task_id_text"
 S_TASK_TYPE = "task_type"
+S_TASK_TYPE_TEXT = "task_type_text"
 S_BRIEF_KEEP = "brief_keep"
 S_BRIEF_PATH_PICK = "brief_path_pick"
 S_BRIEF_PATH = "brief_path"
@@ -788,12 +795,15 @@ def _build_task_pick(state: WizardState) -> Prompt:
     latest = read_latest_task(project_root) or {}
     latest_key = latest.get("taskKey") or ""
     latest_suffix = t["options"].get("_LATEST_SUFFIX", "")
+    remaining = [e for e in tasks if (e.get("workStatus") or "") != "done"]
     options: list[Option] = []
-    for entry in tasks[:16]:
+    for entry in remaining[:_RECOMMENDATION_CAP]:
         key = entry.get("taskKey") or ""
         ttype = entry.get("taskType") or ""
-        phase = (entry.get("workflow") or {}).get("currentPhase") or ttype
-        nxt = (entry.get("workflow") or {}).get("nextRecommendedPhase") or ""
+        # catalog entries are flat (render_task_catalog_discovery) — there is
+        # no nested "workflow" object here, unlike task-manifest.json.
+        phase = entry.get("currentPhase") or ttype
+        nxt = entry.get("nextRecommendedPhase") or ""
         suffix = latest_suffix if key == latest_key else ""
         label = f"{key}  ·  {phase}  ·  next: {nxt}{suffix}"
         options.append(_opt(value=key, label=label))
@@ -838,7 +848,9 @@ 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]:
+def _suggest_recent_task_groups(
+    state: WizardState, limit: int = _RECOMMENDATION_CAP
+) -> list[str]:
     """프로젝트 catalog 에서 최근 task-group 후보를 limit 개까지 반환."""
     if not state.project_root:
         return []
@@ -856,7 +868,9 @@ def _suggest_recent_task_groups(state: WizardState, limit: int = 2) -> list[str]
     return seen
 
 
-def _suggest_recent_task_ids(state: WizardState, limit: int = 2) -> list[str]:
+def _suggest_recent_task_ids(
+    state: WizardState, limit: int = _RECOMMENDATION_CAP
+) -> list[str]:
     """현재 task_group 내의 최근 task-id 후보를 limit 개까지 반환."""
     if not state.project_root or not state.task_group:
         return []
@@ -925,7 +939,7 @@ def _build_task_group(state: WizardState) -> Prompt:
             echo_template=t["echo_template"],
         )
     # suggestion 이 없으면 catalog 의 최근 task-group 을 후보로 노출 + 직접 입력
-    recent = _suggest_recent_task_groups(state, limit=2)
+    recent = _suggest_recent_task_groups(state)
     t = _p(state.workspace_root, "task_group_no_suggestion")
     recent_prefix = t.get("recent_label_prefix", "")
     options: list[Option] = []
@@ -999,7 +1013,7 @@ def _build_task_id(state: WizardState) -> Prompt:
             label=t["label"], options=options,
             echo_template=t["echo_template"],
         )
-    recent = _suggest_recent_task_ids(state, limit=2)
+    recent = _suggest_recent_task_ids(state)
     t = _p(state.workspace_root, "task_id_no_suggestion")
     recent_prefix = t.get("recent_label_prefix", "")
     options: list[Option] = []
@@ -1058,48 +1072,88 @@ def _submit_task_id_text(state: WizardState, value: str) -> Optional[str]:
     return f"task-id: {state.task_id}"
 
 
-def _existing_task_next_phase(state: WizardState) -> str:
-    """새 task 로 시작했더라도 입력한 task-key 가 이미 존재하면(=사실상 이어가기)
-    그 기존 manifest 의 nextRecommendedPhase 를 반환한다. 없으면 ''.
+def _existing_task_workflow(state: WizardState) -> dict:
+    """현재 task-key 가 이미 존재하면 그 manifest 의 workflow dict 를 반환한다.
 
-    사용자가 picker 에서 기존 task-key 를 고르지 않고 new-task 흐름으로 같은
-    task-group/task-id 를 다시 입력한 경우에도 직전 phase 의 추천이 끊기지 않게
-    하는 안전장치."""
+    picker 로 기존 task 를 고른 경우뿐 아니라, new-task 흐름으로 같은
+    task-group/task-id 를 다시 입력한 경우(=사실상 이어가기)에도 직전 phase
+    기반 추천이 끊기지 않게 하는 안전장치. 없으면 {}."""
     if not (state.project_id and state.task_group and state.task_id):
-        return ""
+        return {}
     key = f"{state.project_id}:{state.task_group}:{state.task_id}"
     root = find_task_root(Path(state.project_root), key)
     if root is None:
-        return ""
+        return {}
     workflow = (read_task_manifest(root) or {}).get("workflow") or {}
-    nxt = workflow.get("nextRecommendedPhase") or ""
-    return nxt if isinstance(nxt, str) else ""
+    return workflow if isinstance(workflow, dict) else {}
+
+
+def _phase_after(task_type: str) -> str:
+    """라이프사이클(PHASE_SEQUENCE) 상 task_type 바로 다음 단계. 없으면 ''."""
+    try:
+        idx = PHASE_SEQUENCE.index(task_type)
+    except ValueError:
+        return ""
+    return PHASE_SEQUENCE[idx + 1] if idx + 1 < len(PHASE_SEQUENCE) else ""
+
+
+def _recent_task_types(state: WizardState) -> list[str]:
+    """catalog 최신순으로 이 프로젝트에서 최근 사용된 task-type 목록(중복 제거)."""
+    if not state.project_root:
+        return []
+    try:
+        tasks = list_project_tasks(Path(state.project_root))
+    except (OSError, StateError):
+        return []
+    out: list[str] = []
+    for entry in tasks:
+        tt = entry.get("taskType") or ""
+        if tt and tt not in out:
+            out.append(tt)
+    return out
 
 
 def _build_task_type(state: WizardState) -> Prompt:
     t = _p(state.workspace_root, "task_type")
     recommended_suffix = t["options"].get("_RECOMMENDED_SUFFIX", "")
+    rerun_suffix = t["options"].get("_RERUN_SUFFIX", "")
+    next_suffix = t["options"].get("_NEXT_SUFFIX", "")
+    description_by_type = dict(TASK_TYPES)
     options: list[Option] = []
-    recommended = state.task_type if not state.is_new_task else ""
-    if not recommended and state.is_new_task:
-        recommended = _existing_task_next_phase(state)
-    seen: list[str] = []
-    if recommended and recommended in TASK_TYPE_VALUES:
-        d = dict(TASK_TYPES)[recommended]
-        options.append(_opt(recommended, f"{recommended}{recommended_suffix}", d))
-        seen.append(recommended)
-    for tt, desc in TASK_TYPES:
-        if tt in seen:
-            continue
-        options.append(_opt(tt, tt, desc))
+
+    def add(task_type: str, suffix: str = "") -> None:
+        if task_type not in description_by_type:
+            return
+        if any(o.value == task_type for o in options):
+            return
+        if len(options) >= _RECOMMENDATION_CAP:
+            return
+        options.append(_opt(task_type, f"{task_type}{suffix}",
+                            description_by_type[task_type]))
+
+    workflow = _existing_task_workflow(state)
+    recommended = state.task_type or workflow.get("nextRecommendedPhase") or ""
+    if not recommended and not workflow:
+        recommended = TASK_TYPE_VALUES[0]
+    add(recommended, recommended_suffix)
+    add(workflow.get("currentPhase") or "", rerun_suffix)
+    add(_phase_after(recommended), next_suffix)
+    for tt in _recent_task_types(state):
+        add(tt)
+    for tt in TASK_TYPE_VALUES:
+        add(tt)
+    options.append(_opt(PICK_TYPE_CUSTOM, t["options"][PICK_TYPE_CUSTOM]))
     return Prompt(step=S_TASK_TYPE, kind="pick",
                   label=t["label"], options=options,
                   echo_template=t["echo_template"])
 
 
-def _submit_task_type(state: WizardState, value: str) -> Optional[str]:
+def _apply_task_type(state: WizardState, value: str) -> str:
     if value not in TASK_TYPE_VALUES:
-        raise WizardError(f"unknown task-type: {value!r}")
+        raise WizardError(
+            f"unknown task-type: {value!r} "
+            f"(expected one of: {', '.join(TASK_TYPE_VALUES)})"
+        )
     state.task_type = value
     state.profile_workers = _load_profile_workers(
         Path(state.workspace_root), value
@@ -1113,6 +1167,27 @@ def _submit_task_type(state: WizardState, value: str) -> Optional[str]:
     return f"task-type: {value}"
 
 
+def _submit_task_type(state: WizardState, value: str) -> Optional[str]:
+    # PICK_TYPE_CUSTOM leaves task_type empty while S_TASK_TYPE gets marked
+    # answered — that combination is what gates S_TASK_TYPE_TEXT on.
+    if value == PICK_TYPE_CUSTOM:
+        state.task_type = ""
+        t = _p(state.workspace_root, "task_type")
+        return t["echo_variants"]["free_input"]
+    return _apply_task_type(state, value)
+
+
+def _build_task_type_text(state: WizardState) -> Prompt:
+    t = _p(state.workspace_root, "task_type_text")
+    return Prompt(step=S_TASK_TYPE_TEXT, kind="text",
+                  label=t["label"],
+                  echo_template=t["echo_template"])
+
+
+def _submit_task_type_text(state: WizardState, value: str) -> Optional[str]:
+    return _apply_task_type(state, value.strip())
+
+
 def _build_brief_keep(state: WizardState) -> Prompt:
     t = _p(state.workspace_root, "brief_keep",
            existing_brief_path=state.existing_brief_path)
@@ -2216,6 +2291,7 @@ STEPS: list[Step] = [
                  (s.is_new_task is True and bool(s.task_group))
                  or (s.is_new_task is False
                      and S_TASK_TYPE in s.answered
+                     and bool(s.task_type)
                      and (s.keep_existing_brief is False
                           or not s.existing_brief_path))
              )
@@ -2250,11 +2326,19 @@ STEPS: list[Step] = [
          build=_build_task_type, submit=_submit_task_type,
          owns=("task_type", "profile_workers", "profile_optional_workers",
                "reuse_worktree")),
+    Step(S_TASK_TYPE_TEXT,
+         applies=lambda s: (S_TASK_TYPE in s.answered
+                            and not s.task_type
+                            and S_TASK_TYPE_TEXT not in s.answered),
+         build=_build_task_type_text, submit=_submit_task_type_text,
+         owns=("task_type", "profile_workers", "profile_optional_workers",
+               "reuse_worktree")),
     Step(S_BRIEF_KEEP,
          applies=lambda s: (not s.is_new_task
                             and bool(s.existing_brief_path)
                             and s.keep_existing_brief is None
-                            and S_TASK_TYPE in s.answered),
+                            and S_TASK_TYPE in s.answered
+                            and bool(s.task_type)),
          build=_build_brief_keep, submit=_submit_brief_keep,
          owns=("keep_existing_brief",)),
     Step(S_BASE_REF_PICK,

package/runtime/skills/okstra-run/SKILL.md

@@ -118,8 +118,8 @@ Repeat until `next.kind == "done"`:
 
 That is the entire interactive flow. The wizard handles:
 
-- new-vs-existing task split, task-group / task-id slug validation,
-- task-type pick (with `nextRecommendedPhase` surfaced as recommended for existing tasks),
+- new-vs-existing task split (남은 작업 — `workStatus != done` — 최신순 3개 추천 + 직접 입력), task-group / task-id slug validation (각각 최근 후보 3개 추천 + 직접 입력),
+- task-type pick (추천 3개 — `nextRecommendedPhase` recommended / 현재 phase 재실행 / 라이프사이클 다음 단계 — + 직접 입력; 직접 입력은 후속 `text` 단계에서 전체 task-type 화이트리스트로 검증),
 - brief path after task-group selection (same-group `.okstra/briefs/<task-group>/**/*.md` candidates first, direct input last; `유지 / 변경` for existing tasks),
 - base-ref pick + git rev-parse validation (skipped when reusing an active worktree),
 - `implementation`-only sub-flow: approved-plan path (frontmatter `approved: true` check) + stage pick (`auto` = 의존성 충족된 가장 빠른 미완료 stage, 또는 특정 stage 번호) + executor pick,