okstra 0.56.1 → 0.58.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okstra",
-  "version": "0.56.1",
+  "version": "0.58.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.56.1",
-  "builtAt": "2026-06-08T16:46:40.339Z",
+  "package": "0.58.0",
+  "builtAt": "2026-06-08T17:51:22.479Z",
   "repoRoot": "/home/runner/work/okstra/okstra"
 }

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

@@ -95,13 +95,16 @@
       }
     },
     "brief_path_pick": {
-      "label": "task brief markdown 의 경로를 선택해주세요",
+      "label": "task brief markdown 을 선택해주세요",
       "echo_template": "brief(pick): {value}",
       "options": {
         "__existing__": "기존 brief 사용: {existing}",
         "__standard__": "표준 경로 사용: {standard}",
         "__free_input__": "직접 입력"
       },
+      "labels": {
+        "brief_candidate": "같은 task-group brief: {path}"
+      },
       "errors": {
         "existing_missing": "기존 brief 가 없습니다. 다른 옵션을 선택하세요."
       }
@@ -233,14 +236,20 @@
       "label": "추가 critic 패스를 돌릴까요? (놓친 finding/blocker 를 캐는 검증 패스 — opt-in)",
       "echo_template": "critic: {value}",
       "options": {
-        "off": "사용 안 함 (기본·추천)",
-        "claude": "claude critic (추천)",
-        "__free_input__": "직접 입력 (codex / gemini)"
+        "off": "사용 안 함 (기본·추천)"
+      },
+      "labels": {
+        "provider_recommended": "{provider} critic (추천)",
+        "provider": "{provider} critic"
       }
     },
     "critic_text": {
-      "label": "critic provider 를 직접 입력하세요 (codex / gemini)",
-      "echo_template": "critic: {value}"
+      "label": "critic provider 를 선택하세요",
+      "echo_template": "critic: {value}",
+      "labels": {
+        "provider_recommended": "{provider} critic (추천)",
+        "provider": "{provider} critic"
+      }
     },
     "defaults_or_custom": {
       "label": "역할별로 어떤 모델을 쓸지 정하는 단계입니다 (참여 워커 구성을 바꾸는 게 아닙니다).\n· 기본값으로 진행 — lead·실행자/워커·report-writer 를 모두 추천 모델로 두고 바로 진행합니다.\n· 커스터마이즈 — 역할별 모델을 직접 고르고, 추가 directive·관련 task 도 지정합니다.",

package/runtime/python/okstra_ctl/wizard.py

@@ -99,6 +99,7 @@ PICK_USE_SUGGESTED = "__use_suggested__"
 PICK_TYPE_CUSTOM = "__free_input__"
 _RECENT_PREFIX = "__recent:"
 _REPORT_PREFIX = "__report:"
+_BRIEF_PREFIX = "__brief:"
 
 # Lines of `key: value` we pull from a brief markdown frontmatter. The
 # parser is intentionally lightweight (no yaml dep) and tolerant — a
@@ -176,6 +177,38 @@ def _brief_suggestions(path: Path) -> tuple[str, str]:
     return tg, tid
 
 
+def _project_relative_path(path: Path, project_root: Path) -> str:
+    try:
+        return str(path.relative_to(project_root))
+    except ValueError:
+        return str(path)
+
+
+def _accept_brief_path(state: WizardState, path: Path) -> None:
+    """Record a validated brief and derive safe identity suggestions.
+
+    New-task runs now ask for ``task_group`` before the brief so the wizard
+    can offer same-group brief candidates. If the selected brief carries a
+    conflicting frontmatter ``task-group``, fail fast; otherwise keep using
+    the brief's ``brief-id`` as the task-id suggestion.
+    """
+    tg_suggestion, tid_suggestion = _brief_suggestions(path)
+    if state.task_group and tg_suggestion:
+        suggested_group = _slug_or_die(tg_suggestion, "task_group")
+        if suggested_group != state.task_group:
+            raise WizardError(
+                "brief task-group does not match selected task-group: "
+                f"{tg_suggestion!r} != {state.task_group!r} ({path})"
+            )
+    state.brief_path = str(path)
+    state.brief_path_pending_text = False
+    if state.is_new_task:
+        if not state.task_group:
+            state.task_group_suggestion = tg_suggestion
+        if not state.task_id:
+            state.task_id_suggestion = tid_suggestion
+
+
 # ---- Step IDs ------------------------------------------------------------
 
 S_TASK_PICK = "task_pick"
@@ -771,6 +804,39 @@ def _suggest_recent_task_ids(state: WizardState, limit: int = 2) -> list[str]:
     return seen
 
 
+def _suggest_group_briefs(state: WizardState, limit: int = 6) -> list[str]:
+    """Return recent okstra-brief outputs for the selected task-group.
+
+    ``okstra-brief`` writes to ``.okstra/briefs/<task-group>/**/*.md``. The
+    wizard exposes those paths after task-group selection so users can pick a
+    generated brief instead of typing its path. Paths are project-relative.
+    """
+    if not state.project_root or not state.task_group:
+        return []
+    project_root = Path(state.project_root)
+    root = project_root / ".okstra" / "briefs" / state.task_group
+    if not root.is_dir():
+        return []
+    candidates: list[tuple[float, str]] = []
+    for path in root.rglob("*.md"):
+        if not path.is_file():
+            continue
+        tg_suggestion, _ = _brief_suggestions(path)
+        if tg_suggestion:
+            try:
+                if _slug_or_die(tg_suggestion, "task_group") != state.task_group:
+                    continue
+            except WizardError:
+                continue
+        try:
+            mtime = path.stat().st_mtime
+        except OSError:
+            mtime = 0.0
+        candidates.append((mtime, _project_relative_path(path, project_root)))
+    candidates.sort(key=lambda item: (-item[0], item[1]))
+    return [rel for _, rel in candidates[:limit]]
+
+
 def _build_task_group(state: WizardState) -> Prompt:
     sugg = state.task_group_suggestion
     if sugg:
@@ -1000,6 +1066,12 @@ def _build_brief_path_pick(state: WizardState) -> Prompt:
     if standard and standard != existing:
         options.append(_opt("__standard__",
                             t["options"]["__standard__"].format(standard=standard)))
+    brief_label = t["labels"].get("brief_candidate", "{path}")
+    for relpath in _suggest_group_briefs(state):
+        if relpath in (existing, standard):
+            continue
+        options.append(_opt(f"{_BRIEF_PREFIX}{relpath}",
+                            brief_label.format(path=relpath)))
     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,
@@ -1013,20 +1085,24 @@ def _submit_brief_path_pick(state: WizardState, value: str) -> Optional[str]:
             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
+        _accept_brief_path(state, p)
         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
+        _accept_brief_path(state, p)
+        return f"brief: {p}"
+    if value.startswith(_BRIEF_PREFIX):
+        relpath = value[len(_BRIEF_PREFIX):]
+        p = _require_file(relpath, Path(state.project_root), "task brief")
+        _accept_brief_path(state, p)
         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"expected '__existing__', '__standard__', '{_BRIEF_PREFIX}<path>', "
+        f"or {PICK_TYPE_CUSTOM!r}, "
         f"got: {value!r}"
     )
 
@@ -1042,16 +1118,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
-    # free-text retype of what the brief already declares.
-    if state.is_new_task and not state.task_group and not state.task_id:
-        tg, tid = _brief_suggestions(p)
-        state.task_group_suggestion = tg
-        state.task_id_suggestion = tid
+    _accept_brief_path(state, p)
     return f"brief: {p}"
 
 
@@ -1505,17 +1572,29 @@ def _submit_pr_template_pick(state: WizardState, value: str) -> Optional[str]:
     return _submit_optional_cached_pick(state, value, _PR_TEMPLATE_PICK_SPEC)
 
 
-CRITIC_CHOICES = ["off", "claude", "codex", "gemini"]
+def _critic_provider_choices() -> list[str]:
+    return list(EXECUTORS)
+
+
+def _critic_choices() -> list[str]:
+    return ["off", *_critic_provider_choices()]
+
+
+def _critic_provider_label(provider: str, t: dict) -> str:
+    labels = t.get("labels", {})
+    if provider == "claude":
+        template = labels.get("provider_recommended", "{provider} critic (recommended)")
+    else:
+        template = labels.get("provider", "{provider} critic")
+    return template.format(provider=provider)
 
 
 def _build_critic_pick(state: WizardState) -> Prompt:
     t = _p(state.workspace_root, "critic_pick")
-    options: list[Option] = []
-    for k, v in t["options"].items():
-        if not k.startswith("_"):
-            options.append(_opt(k, v))
-    custom_label = t["options"].get(PICK_TYPE_CUSTOM, PICK_TYPE_CUSTOM)
-    options.append(_opt(PICK_TYPE_CUSTOM, custom_label))
+    off_label = t["options"].get("off", "off")
+    options = [_opt("off", off_label)]
+    for provider in _critic_provider_choices():
+        options.append(_opt(provider, _critic_provider_label(provider, t)))
     return Prompt(
         step=S_CRITIC_PICK, kind="pick",
         label=t["label"],
@@ -1525,12 +1604,10 @@ def _build_critic_pick(state: WizardState) -> Prompt:
 
 
 def _submit_critic_pick(state: WizardState, value: str) -> Optional[str]:
-    if value == PICK_TYPE_CUSTOM:
-        state.critic_pending_text = True
-        return None
     choice = (value or "").strip().lower()
-    if choice not in CRITIC_CHOICES:
-        raise WizardError(f"critic must be one of {CRITIC_CHOICES}, got: {value!r}")
+    choices = _critic_choices()
+    if choice not in choices:
+        raise WizardError(f"critic must be one of {choices}, got: {value!r}")
     state.critic = choice
     state.critic_pending_text = False
     return f"critic: {choice}"
@@ -1538,17 +1615,23 @@ def _submit_critic_pick(state: WizardState, value: str) -> Optional[str]:
 
 def _build_critic_text(state: WizardState) -> Prompt:
     t = _p(state.workspace_root, "critic_text")
+    options = [
+        _opt(provider, _critic_provider_label(provider, t))
+        for provider in _critic_provider_choices()
+    ]
     return Prompt(
-        step=S_CRITIC_TEXT, kind="text",
+        step=S_CRITIC_TEXT, kind="pick",
         label=t["label"],
+        options=options,
         echo_template=t["echo_template"],
     )
 
 
 def _submit_critic_text(state: WizardState, value: str) -> Optional[str]:
     choice = (value or "").strip().lower()
-    if choice not in CRITIC_CHOICES:
-        raise WizardError(f"critic must be one of {CRITIC_CHOICES}, got: {value!r}")
+    providers = _critic_provider_choices()
+    if choice not in providers:
+        raise WizardError(f"critic must be one of {providers}, got: {value!r}")
     state.critic = choice
     state.critic_pending_text = False
     return f"critic: {choice}"
@@ -1907,13 +1990,25 @@ STEPS: list[Step] = [
                "profile_optional_workers",
                "task_group_suggestion", "task_id_suggestion",
                "task_group_pending_text", "task_id_pending_text")),
+    Step(S_TASK_GROUP,
+         applies=lambda s: (bool(s.is_new_task)
+                            and not s.task_group
+                            and not s.task_group_pending_text),
+         build=_build_task_group, submit=_submit_task_group,
+         owns=("task_group", "task_group_pending_text")),
+    Step(S_TASK_GROUP_TEXT,
+         applies=lambda s: (bool(s.is_new_task)
+                            and not s.task_group
+                            and s.task_group_pending_text),
+         build=_build_task_group_text, submit=_submit_task_group_text,
+         owns=("task_group", "task_group_pending_text")),
     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 (
-                 (s.is_new_task is True)
+                 (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 (s.keep_existing_brief is False
@@ -1927,20 +2022,6 @@ STEPS: list[Step] = [
                             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,
-         applies=lambda s: (bool(s.is_new_task)
-                            and bool(s.brief_path)
-                            and not s.task_group
-                            and not s.task_group_pending_text),
-         build=_build_task_group, submit=_submit_task_group,
-         owns=("task_group", "task_group_pending_text")),
-    Step(S_TASK_GROUP_TEXT,
-         applies=lambda s: (bool(s.is_new_task)
-                            and bool(s.brief_path)
-                            and not s.task_group
-                            and s.task_group_pending_text),
-         build=_build_task_group_text, submit=_submit_task_group_text,
-         owns=("task_group", "task_group_pending_text")),
     Step(S_TASK_ID,
          applies=lambda s: (bool(s.is_new_task)
                             and bool(s.brief_path)

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

@@ -120,7 +120,7 @@ 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),
-- brief path (with `유지 / 변경` for existing tasks),
+- 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,
 - `Use defaults / Customize` branch with profile-aware worker/model questions,