okstra 0.66.0 → 0.68.0

package/runtime/python/okstra_ctl/run.py

@@ -462,12 +462,41 @@ def _commit_is_ancestor(project_root, ancestor: str, descendant: str) -> bool:
     return r.returncode == 0
 
 
+def _check_multi_dep_merged(project_root, plan_run_root, latest,
+                            pred_commits: dict, candidate_base: str,
+                            stage_n: int) -> None:
+    """모든 선행 done commit 이 candidate 에 (내용 기준으로라도) 머지됐는지
+    검증. patch-equivalent 면 보정 row 를 자동 기록(다음 run 은 ancestor 로
+    바로 통과). 아니면 회복 안내를 담아 PrepareError."""
+    from .git_reconcile import content_merged, _record_reconciled
+    for d, head in pred_commits.items():
+        if _commit_is_ancestor(project_root, head, candidate_base):
+            continue
+        match = content_merged(project_root, head, candidate_base)
+        if match.status in ("ancestor", "patch-equivalent"):
+            if plan_run_root is not None:
+                _record_reconciled(
+                    plan_run_root,
+                    impl_task_key=(latest.get(d) or {}).get("impl_task_key", ""),
+                    stage=d, new_commit=match.matched_commit,
+                    replaced=head, reason="auto-patch-id")
+            continue
+        raise PrepareError(
+            f"multi-dependency stage {stage_n}: predecessor stage {d} "
+            f"({head[:8]}) is not merged into the task worktree "
+            f"({candidate_base[:8]}). Merge stage branches "
+            f"(e.g. the `-s{d}` branches) into the task worktree "
+            "(or into main, then refresh the worktree) and retry."
+        )
+
+
 def _resolve_stage_base_commit(
     stage: dict,
     consumer_done_rows: list,
     anchor_base_commit: str,
     candidate_base: str = "",
     project_root=None,
+    plan_run_root=None,
 ) -> str:
     """Pick the git base commit a stage's isolated worktree branches from.
 
@@ -479,18 +508,15 @@ def _resolve_stage_base_commit(
       candidate 를 반환(사용자가 선행을 머지함). 아니면 PrepareError.
 
     Raises PrepareError on missing predecessor / anchor / unmerged predecessor."""
+    from .consumers import latest_done_by_stage
+    latest = latest_done_by_stage(consumer_done_rows)
     deps = stage.get("depends_on") or []
     if len(deps) >= 2:
         n = stage["stage_number"]
         # 1) 모든 선행의 done head_commit 수집
         pred_commits = {}
         for d in deps:
-            head = next(
-                (r.get("head_commit") for r in consumer_done_rows
-                 if r.get("stage") == d and r.get("status") == "done"
-                 and r.get("head_commit")),
-                None,
-            )
+            head = (latest.get(d) or {}).get("head_commit")
             if not head:
                 raise PrepareError(
                     f"predecessor stage {d} has no done row with head_commit "
@@ -503,16 +529,10 @@ def _resolve_stage_base_commit(
                 f"candidate base missing for multi-dependency stage {n}; "
                 "task-key worktree HEAD could not be resolved"
             )
-        # 3) 모든 선행 done 이 candidate 의 ancestor 인지 (=사용자가 머지함)
-        for d, head in pred_commits.items():
-            if not _commit_is_ancestor(project_root, head, candidate_base):
-                raise PrepareError(
-                    f"multi-dependency stage {n}: predecessor stage {d} "
-                    f"({head[:8]}) is not merged into the task worktree "
-                    f"({candidate_base[:8]}). Merge stage branches "
-                    f"(e.g. the `-s{d}` branches) into the task worktree "
-                    "(or into main, then refresh the worktree) and retry."
-                )
+        # 3) 모든 선행 done 이 candidate 에 (ancestor 또는 patch-equivalent 로)
+        #    머지됐는지 — patch-equivalent 면 보정 row 를 자동 기록한다.
+        _check_multi_dep_merged(project_root, plan_run_root, latest,
+                                pred_commits, candidate_base, n)
         return candidate_base
     if not deps:
         if not anchor_base_commit:
@@ -524,11 +544,9 @@ def _resolve_stage_base_commit(
         return anchor_base_commit
     # 단일 의존
     pred = deps[0]
-    for row in consumer_done_rows:
-        if row.get("stage") == pred and row.get("status") == "done":
-            head = row.get("head_commit") or ""
-            if head:
-                return head
+    head = (latest.get(pred) or {}).get("head_commit") or ""
+    if head:
+        return head
     raise PrepareError(
         f"predecessor stage {pred} has no done row with head_commit in "
         "consumers.jsonl; cannot derive base for stage "
@@ -553,7 +571,8 @@ def _resolve_whole_task_target(
 ) -> "_FVTarget":
     """전체-task 검증 target. 모든 Stage Map stage 가 done + HEAD 에 머지 +
     worktree clean 이어야 한다. 위반 시 PrepareError."""
-    done_by_stage = {r["stage"]: r for r in done_rows}
+    from .consumers import latest_done_by_stage
+    done_by_stage = latest_done_by_stage(done_rows)
     for s in stage_map:
         n = s["stage_number"]
         if n not in done_by_stage:
@@ -587,8 +606,9 @@ def _resolve_single_stage_target(
 ) -> "_FVTarget":
     """단독-stage 검증 target. stage N 만 done + stage worktree 존재 + clean.
     다른 stage 의 done/머지 여부와 무관. 위반 시 PrepareError."""
+    from .consumers import latest_done_by_stage
     n = int(requested_stage)
-    done_by_stage = {r["stage"]: r for r in done_rows}
+    done_by_stage = latest_done_by_stage(done_rows)
     if n not in done_by_stage:
         raise PrepareError(
             f"final-verification(single-stage): stage {n} not done — "
@@ -1290,6 +1310,7 @@ class StageSelection:
     worktree_status: str
     worktree_note: str
     started_head_commit: str
+    concurrent_stages: list = field(default_factory=list)
 
 
 def _select_and_provision_implementation_stage(
@@ -1315,6 +1336,7 @@ def _select_and_provision_implementation_stage(
     # carry sidecars are the SSOT for stage completion; recover any `done` rows
     # the lead failed to append before the dependency gate reads them.
     backfill_done_from_carry(plan_run_root)
+    _auto_reconcile_best_effort(inp, plan_run_root)
     consumed = read_consumers(plan_run_root)
     done_stages = {r["stage"] for r in consumed if r.get("status") == "done"}
     started_stages = {r["stage"] for r in consumed if r.get("status") == "started"}
@@ -1327,6 +1349,7 @@ def _select_and_provision_implementation_stage(
         started_stages=started_stages, reserved_stages=reserved_stages,
     )
     selected = batch[0]
+    concurrent_stages = sorted(reserved_stages - {selected})
 
     # spec §2.1 degradation: 주변 흐름이 non-git / nested-worktree 로 skipped 면
     # stage 격리도 동일하게 degrade — worktree 없이 project HEAD 만 기록.
@@ -1340,6 +1363,7 @@ def _select_and_provision_implementation_stage(
             worktree_status=executor_worktree_status,
             worktree_note="",
             started_head_commit=head,
+            concurrent_stages=concurrent_stages,
         )
 
     # anchor base commit 1회 고정 (task-key worktree HEAD 기준)
@@ -1360,6 +1384,7 @@ def _select_and_provision_implementation_stage(
     stage_base = _resolve_stage_base_commit(
         selected_stage, consumer_done_rows, anchor_base_commit=anchor,
         candidate_base=head_sha, project_root=Path(inp.project_root),
+        plan_run_root=plan_run_root,
     )
     try:
         prov = _worktree.provision_stage_worktree(
@@ -1372,7 +1397,12 @@ def _select_and_provision_implementation_stage(
             base_commit=stage_base,
         )
     except RuntimeError as exc:
-        raise PrepareError(f"stage worktree provisioning failed: {exc}") from exc
+        from .git_reconcile import guidance
+        hint = guidance(plan_run_root=plan_run_root, project_id=inp.project_id,
+                        task_group=inp.task_group, task_id=inp.task_id,
+                        work_category=inp.work_category)
+        raise PrepareError(
+            f"stage worktree provisioning failed: {exc}\n{hint}") from exc
 
     return StageSelection(
         stage=selected,
@@ -1382,6 +1412,7 @@ def _select_and_provision_implementation_stage(
         worktree_status=prov.status,
         worktree_note=prov.note,
         started_head_commit=prov.base_ref,
+        concurrent_stages=concurrent_stages,
     )
 
 
@@ -1400,6 +1431,7 @@ def _apply_implementation_stage(
     ctx["effective_stages"] = [sel.stage]
     csv = str(sel.stage)
     ctx["EFFECTIVE_STAGES"] = csv
+    ctx["CONCURRENT_RUN_STAGES"] = ",".join(str(s) for s in sel.concurrent_stages)
     ctx["STAGE_BATCH_DIRECTIVE"] = (
         f"- **Stage for this implementation run:** `{csv}`. "
         "Execute exactly this Stage Map stage — this is the authoritative scope. "
@@ -1436,6 +1468,20 @@ def _git_out(cwd, *args) -> str:
     return r.stdout.strip() if r.returncode == 0 else ""
 
 
+def _auto_reconcile_best_effort(inp: "PrepareInputs", plan_run_root: Path) -> None:
+    try:
+        from .git_reconcile import auto_reconcile
+        for it in auto_reconcile(
+                project_root=Path(inp.project_root), plan_run_root=plan_run_root,
+                project_id=inp.project_id, task_group=inp.task_group,
+                task_id=inp.task_id, work_category=inp.work_category):
+            print(f"git-reconcile: stage {it.stage} done commit "
+                  f"{it.recorded[:8]} -> {it.suggested_commit[:8]} "
+                  "(patch-equivalent)", file=sys.stdout)
+    except Exception as exc:  # 화해는 부가 기능 — 실패 시 기존 gate 가 판정
+        print(f"git-reconcile skipped: {exc}", file=sys.stderr)
+
+
 def _is_ancestor(cwd, commit, head) -> bool:
     if not commit or not head:
         return False
@@ -1464,6 +1510,7 @@ def _reserve_final_verification_target(
     # carry sidecars are the SSOT for stage completion — recover missing `done`
     # rows before the whole-task gate checks every stage.
     backfill_done_from_carry(plan_run_root)
+    _auto_reconcile_best_effort(inp, plan_run_root)
     done_rows = [r for r in read_consumers(plan_run_root)
                  if r.get("status") == "done"]
 
@@ -1485,8 +1532,9 @@ def _reserve_final_verification_target(
         anchor = _reg.get_implementation_base(
             inp.project_id, inp.task_group, inp.task_id) or ""
         head = _git_out(wt_path, "rev-parse", "HEAD")
-        merged = {r["stage"]: _is_ancestor(wt_path, r.get("head_commit", ""), head)
-                  for r in done_rows}
+        from .consumers import latest_done_by_stage
+        merged = {s: _is_ancestor(wt_path, r.get("head_commit", ""), head)
+                  for s, r in latest_done_by_stage(done_rows).items()}
         target = _resolve_whole_task_target(
             stage_map=ctx_stage_map, done_rows=done_rows, anchor_base=anchor,
             task_worktree_path=wt_path, task_head=head,
@@ -1959,10 +2007,19 @@ def prepare_task_bundle(inp: PrepareInputs) -> PrepareOutputs:
     if not inp.render_only:
         _provision_settings_symlink(inp)
 
+    concurrent_run: dict = {}
+    if impl_stage_selection is not None and impl_stage_selection.concurrent_stages:
+        concurrent_run = {
+            "detected": True,
+            "active_stages": impl_stage_selection.concurrent_stages,
+        }
     return PrepareOutputs(
         ctx=ctx,
         prompt_text=prompt_text,
-        extras={"profile_content": profile_content},
+        extras={
+            "profile_content": profile_content,
+            "concurrent_run": concurrent_run,
+        },
     )
 
 
@@ -2132,6 +2189,10 @@ def main(argv: list[str]) -> int:
     print(f"okstra instruction-set: {ctx['INSTRUCTION_SET_PATH']}")
     print(f"okstra reference expectations: {ctx['REFERENCE_EXPECTATIONS_FILE']}")
     print(f"okstra final report template: {ctx['FINAL_REPORT_TEMPLATE_PATH']}")
+    cr = out.extras.get("concurrent_run", {})
+    if cr.get("detected"):
+        stages_csv = ",".join(str(s) for s in cr["active_stages"])
+        print(f"okstra concurrent-run stages: {stages_csv}")
     if inputs.render_only:
         print()
         print(out.prompt_text, end="")

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"
@@ -254,6 +261,7 @@ S_BRANCH_CONFIRM = "branch_confirm"
 S_CONFIRM = "confirm"
 S_EDIT_TARGET = "edit_target"
 S_DONE = "done"
+S_ABORTED = "aborted"
 
 # ---- 멀티탭 배치 프롬프트 그룹 (방출 계층 전용) ----
 # 그룹 id 는 S_* 가 아니므로 prompts JSON SOT / step-id 동기화 검사 대상이 아니다.
@@ -355,6 +363,8 @@ class WizardState:
     branch_confirmed: Optional[bool] = None
     confirmed: Optional[bool] = None
     edit_target: str = ""
+    # terminal: user picked 중단 — no further prompt ever applies
+    aborted: bool = False
 
     # bookkeeping
     answered: list[str] = field(default_factory=list)
@@ -377,7 +387,7 @@ class Option:
 @dataclass
 class Prompt:
     step: str
-    kind: str  # "pick" | "text" | "done"
+    kind: str  # "pick" | "text" | "pick_group" | "done" | "aborted"
     label: str = ""
     options: list[Option] = field(default_factory=list)
     help: str = ""
@@ -788,12 +798,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 +851,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 +871,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 +942,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 +1016,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 +1075,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 +1170,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)
@@ -2126,6 +2204,7 @@ def _build_branch_confirm(state: WizardState) -> Prompt:
     options = [_opt("proceed", opts["proceed"])]
     if decision.status == "new":
         options.append(_opt("edit", opts["edit"]))
+    options.append(_opt("abort", opts["abort"]))
     return Prompt(step=S_BRANCH_CONFIRM, kind="pick", label=label,
                   options=options, echo_template=t["echo_template"])
 
@@ -2135,8 +2214,13 @@ def _submit_branch_confirm(state: WizardState, value: str) -> Optional[str]:
         _reset_from(state, S_BASE_REF_PICK)
         state.branch_confirmed = None
         return "branch-confirm: edit"
+    if value == "abort":
+        state.aborted = True
+        return "branch-confirm: abort"
     if value != "proceed":
-        raise WizardError(f"expected 'proceed' or 'edit', got: {value!r}")
+        raise WizardError(
+            f"expected 'proceed' / 'edit' / 'abort', got: {value!r}"
+        )
     state.branch_confirmed = True
     return "branch-confirm: proceed"
 
@@ -2216,6 +2300,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 +2335,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,
@@ -2601,6 +2694,8 @@ def _build_group_prompt(state: WizardState, group_id: str) -> Prompt:
 
 
 def next_prompt(state: WizardState) -> Prompt:
+    if state.aborted:
+        return Prompt(step=S_ABORTED, kind="aborted")
     if state.confirmed:
         return Prompt(step=S_DONE, kind="done")
     for step in STEPS:
@@ -2647,7 +2742,7 @@ def submit(state: WizardState, value: str) -> dict[str, Any]:
     validation failure (caller may re-prompt).
     """
     prompt = next_prompt(state)
-    if prompt.kind == "done":
+    if prompt.kind in ("done", "aborted"):
         return {"echo": "", "next": prompt.to_json()}
     if prompt.kind == "pick_group":
         return _submit_group(state, prompt, value)
@@ -2661,6 +2756,10 @@ def submit(state: WizardState, value: str) -> dict[str, Any]:
 
 def render_args(state: WizardState) -> dict[str, str]:
     """Convert finalized state into ``okstra render-bundle`` argument map."""
+    if state.aborted:
+        raise WizardError(
+            "wizard was aborted by the user — render-args is unavailable"
+        )
     workers = state.workers_override.strip()
     if state.task_type == "implementation":
         workers = ""  # profile-default roster is mandatory for impl
@@ -2844,7 +2943,13 @@ def _cli(argv: list[str]) -> int:
 
     if args.cmd == "render-args":
         state = load_state_file(state_path)
-        print(json.dumps({"ok": True, "args": render_args(state)},
+        try:
+            rendered = render_args(state)
+        except WizardError as exc:
+            print(json.dumps({"ok": False, "error": str(exc)},
+                             ensure_ascii=False, indent=2))
+            return 0
+        print(json.dumps({"ok": True, "args": rendered},
                          ensure_ascii=False, indent=2))
         return 0
 

package/runtime/python/okstra_ctl/worktree.py

@@ -492,11 +492,14 @@ def compute_worktree_path(
     task_group_segment: str,
     task_id_segment: str,
     stage_number: Optional[int] = None,
+    group_id: Optional[str] = None,
 ) -> Path:
     """Pure path computation. One worktree dir per task-key, or per
     `<task-key>/stage-<N>` when stage_number is given (implementation
     stage isolation). Uses `OKSTRA_HOME` when set (test hook), else
     `~/.okstra`."""
+    if stage_number is not None and group_id is not None:
+        raise ValueError("stage_number and group_id are mutually exclusive")
     okstra_home = os.environ.get("OKSTRA_HOME", "").strip()
     base = Path(okstra_home) if okstra_home else (Path.home() / ".okstra")
     path = (
@@ -507,6 +510,8 @@ def compute_worktree_path(
     )
     if stage_number is not None:
         path = path / f"stage-{stage_number}"
+    if group_id is not None:
+        path = path / f"group-{group_id}"
     return path
 
 
@@ -515,12 +520,17 @@ def compute_branch_name(
     work_category: str,
     task_id_segment: str,
     stage_number: Optional[int] = None,
+    group_id: Optional[str] = None,
 ) -> str:
     """One branch per task-key, or `<prefix>-<task-id>-s<N>` for an
     implementation stage worktree."""
+    if stage_number is not None and group_id is not None:
+        raise ValueError("stage_number and group_id are mutually exclusive")
     name = f"{_work_category_prefix(work_category)}-{_safe_segment(task_id_segment)}"
     if stage_number is not None:
         name = f"{name}-s{stage_number}"
+    if group_id is not None:
+        name = f"{name}-{group_id}"
     return name