okstra 0.223.2 → 0.225.0

package/runtime/python/okstra_ctl/team.py

@@ -35,6 +35,7 @@ from .dispatch_core import (
     DispatchPlan,
     await_dispatches,
     dispatch_plan,
+    existing_dispatch_plan as _plan_for_existing,
 )
 from .dispatch_checkpoints import (
     record_collect_checkpoints,
@@ -257,6 +258,11 @@ def _await(args) -> int:
         timeout_seconds=args.timeout_seconds,
         heartbeat_seconds=0 if args.json else args.heartbeat_seconds,
     )
+    from .phases.implementation_planning.round_completion import complete_ready_plan_round
+
+    completion = complete_ready_plan_round(plan) if code == 0 else None
+    if completion and completion["status"] == "failed":
+        code = 2
     if should_record:
         exit_state = _load_json(plan.team_state_path, "team-state")
         lines.extend(record_collect_checkpoints(
@@ -272,11 +278,16 @@ def _await(args) -> int:
     if args.json:
         payload = _await_payload(plan, code == 0)
         payload["progressLines"] = lines
+        if completion:
+            payload["planVerification"] = completion
         _print_json(payload)
     else:
         for line in lines:
             print(line)
-        print("ALL_WORKERS_DONE" if code == 0 else "POLL_TIMEOUT")
+        if completion:
+            print(json.dumps({"planVerification": completion}, ensure_ascii=False))
+        print("PLAN_VERIFICATION_FAILED" if completion and completion["status"] == "failed"
+              else "ALL_WORKERS_DONE" if code == 0 else "POLL_TIMEOUT")
     return code
 
 
@@ -402,23 +413,6 @@ def _observe_lead_session_from_manifest(
     observe_lead_session(project_root, team_state_path)
 
 
-def _plan_for_existing(
-    project_root: Path, workspace_root: Path, run_manifest_path: Path, manifest: Mapping[str, Any]
-) -> DispatchPlan:
-    root = project_root.resolve()
-    manifest_path = _resolve_project_path(root, str(run_manifest_path))
-    return DispatchPlan(
-        project_root=root,
-        workspace_root=workspace_root.resolve(),
-        manifest_path=manifest_path,
-        team_state_path=_resolve_project_path(root, _require_string(manifest, "teamStatePath")),
-        lead_events_path=_resolve_project_path(root, _require_string(manifest, "leadEventsPath")),
-        manifest=manifest,
-        jobs=(),
-        default_backend=_manifest_backend(manifest),
-    )
-
-
 def _await_payload(plan: DispatchPlan, completed: bool) -> dict[str, Any]:
     team_state = _load_json(plan.team_state_path, "team-state")
     dispatches = [d for d in team_state.get("workerDispatches", []) if isinstance(d, dict)]

package/runtime/python/okstra_ctl/verdict_blocks.py

@@ -17,6 +17,7 @@ refusing them costs a dispatch cycle and yields no information. A bare
 from __future__ import annotations
 
 import re
+import json
 from dataclasses import dataclass
 
 VERDICT_TOKENS = frozenset({
@@ -64,7 +65,7 @@ _ITEM_RE = re.compile(r"^###[ \t]+(?P<id>[^\s:]+)[ \t]*:?.*$", re.MULTILINE)
 # `_field_match` enforces that an opening `**` is closed exactly once and that
 # a label without bold carries a bullet.
 _FIELD_KEYS = ("Verdict", "Fixability", "Note", "Explanation", "Prior dissent",
-               "Basis", "Your evidence")
+               "Basis", "Your evidence", "Dependencies")
 _CANONICAL_KEYS = {key.lower(): key for key in _FIELD_KEYS}
 _FIELD_RE = re.compile(
     r"^(?P<bullet>[-*+][ \t]+)?(?P<open>\*\*)?"
@@ -234,6 +235,7 @@ class VerdictBlock:
     note: str
     explanation: str
     prior_dissent: str
+    dependencies: dict | None = None
 
 
 def parse_verdict_blocks(text: str) -> dict[str, VerdictBlock]:
@@ -269,6 +271,19 @@ def _block(item_id: str, fields: dict[str, str]) -> VerdictBlock:
                 f"`{fixability or '(missing)'}` — expected one of "
                 f"{sorted(FIXABILITY_VALUES)}"
             )
+    dependencies = None
+    if fields.get("Dependencies"):
+        try:
+            candidate = json.loads(fields["Dependencies"])
+            if (isinstance(candidate, dict) and isinstance(candidate.get("complete"), bool)
+                    and all(isinstance(candidate.get(key), list)
+                            and all(isinstance(value, str) and value for value in candidate[key])
+                            for key in ("itemIds", "paths"))):
+                dependencies = {key: candidate[key] for key in ("complete", "itemIds", "paths")}
+            else:
+                dependencies = {"complete": False, "itemIds": [], "paths": []}
+        except (ValueError, TypeError):
+            dependencies = {"complete": False, "itemIds": [], "paths": []}
     return VerdictBlock(
         item_id=item_id,
         verdict=token,
@@ -277,4 +292,5 @@ def _block(item_id: str, fields: dict[str, str]) -> VerdictBlock:
         note=fields.get("Note", ""),
         explanation=fields.get("Explanation", ""),
         prior_dissent=fields.get("Prior dissent", ""),
+        dependencies=dependencies,
     )

package/runtime/python/okstra_ctl/wizard/__init__.py

@@ -68,6 +68,7 @@ from .ids import (
     S_HANDOFF_STAGE_PICK,
     S_PROJECT_EVIDENCE,
     S_PROJECT_EVIDENCE_PICK,
+    S_REASONING_EFFORT,
     S_PR_TEMPLATE,
     S_PR_TEMPLATE_PICK,
     S_PR_TEMPLATE_SCOPE,

package/runtime/python/okstra_ctl/wizard/confirmation.py

@@ -333,6 +333,8 @@ def confirmation_block(state: WizardState) -> str:
         lines.append(f"  pr-template   : {state.pr_template_path} ({state.pr_template_scope or 'once'})")
     if state.fix_cycle:
         lines.append(f"  fix-cycle     : {state.fix_cycle}")
+    if state.reasoning_effort:
+        lines.append(f"  reasoning     : {state.reasoning_effort}")
     lines.append(_msg(
         state.workspace_root, "confirmation", "provider_data_scope",
         project_root=state.project_root,

package/runtime/python/okstra_ctl/wizard/engine.py

@@ -123,20 +123,41 @@ def _apply_answer(state: WizardState, prompt: Prompt, value: str) -> str:
     return echo or ""
 
 
+def _automatic_answers(state: WizardState, prompt: Prompt) -> list[tuple[Prompt, str]]:
+    """Answers the wizard takes without showing the screen.
+
+    A one-line pick takes its line. A pick whose builder set `auto_value` takes it
+    unless the user came back to that step through Edit; a group takes each such
+    member and shows the rest.
+    """
+    if _is_lone_choice_pick(prompt):
+        return [(prompt, prompt.options[0].value)]
+    members = prompt.questions if prompt.kind == "pick_group" else [prompt]
+    return [
+        (member, member.auto_value)
+        for member in members
+        if member.kind == "pick"
+        and member.auto_value
+        and member.step not in state.manual_steps
+    ]
+
+
 def next_prompt(state: WizardState) -> Prompt:
-    # 한 줄짜리 picker 를 건너뛰면 그 자리에 다음 화면이 온다. 그것도 한 줄짜리일
-    # 수 있어 반복하되, 같은 step 이 다시 오면(반복 가능한 step) 묻는다.
+    # 자동으로 답한 화면 자리에 다음 화면이 온다. 그것도 자동일 수 있어 반복하되,
+    # 같은 step 이 다시 오면(반복 가능한 step) 묻는다.
     taken: set[str] = set()
     while True:
         prompt = _next_prompt_screen(state)
-        if prompt.step in taken or not _is_lone_choice_pick(prompt):
+        answers = [] if prompt.step in taken else _automatic_answers(state, prompt)
+        if not answers:
             return _native_picker_screen(state, prompt)
         taken.add(prompt.step)
         attempt = copy.deepcopy(state)
         try:
-            _apply_answer(attempt, prompt, prompt.options[0].value)
+            for member, value in answers:
+                _apply_answer(attempt, member, value)
         except WizardError:
-            # 그 한 줄이 거절되면 사용자에게 보여 거절 사유를 받게 한다.
+            # 자동 답이 거절되면 사용자에게 보여 거절 사유를 받게 한다.
             return _native_picker_screen(state, prompt)
         state.__dict__.update(attempt.__dict__)
 

package/runtime/python/okstra_ctl/wizard/ids.py

@@ -238,6 +238,9 @@ S_PR_TEMPLATE_SCOPE = "pr_template_scope"
 S_FIX_CYCLE_CONFIRM = "fix_cycle_confirm"
 
 
+S_REASONING_EFFORT = "reasoning_effort"
+
+
 S_CONFIRM = "confirm"
 
 

package/runtime/python/okstra_ctl/wizard/registry.py

@@ -58,6 +58,7 @@ from .ids import (
     S_PROJECT_EVIDENCE_PICK,
     S_PR_TEMPLATE,
     S_PR_TEMPLATE_PICK,
+    S_REASONING_EFFORT,
     S_PR_TEMPLATE_SCOPE,
     S_RELATED_TASKS,
     S_RELATED_TASKS_PICK,
@@ -169,6 +170,9 @@ from .steps_plan import (
     _submit_stage_pick,
 )
 from .steps_options import (
+    _build_reasoning_effort,
+    _reasoning_effort_required,
+    _submit_reasoning_effort,
     _report_language_required,
     _build_report_language,
     _submit_report_language,
@@ -243,6 +247,8 @@ def _submit_edit_target(state: WizardState, value: str) -> Optional[str]:
         _reset_from(state, value)
     else:
         raise WizardError(f"unknown step: {value!r}")
+    if value not in state.manual_steps:
+        state.manual_steps.append(value)
     state.edit_target = value
     state.confirmed = None
     state.edit_target = ""
@@ -514,6 +520,13 @@ STEPS: list[Step] = [
                             and S_DIRECTIVE not in s.answered),
          build=_build_directive, submit=_submit_directive,
          owns=("directive", "directive_pending_text")),
+    # 역할 화면과 directive 뒤 — 이 run 이 띄울 워커가 정해진 다음에 묻는다.
+    Step(S_REASONING_EFFORT,
+         applies=lambda s: (S_REASONING_EFFORT not in s.answered
+                            and not s.directive_pending_text
+                            and _reasoning_effort_required(s)),
+         build=_build_reasoning_effort, submit=_submit_reasoning_effort,
+         owns=("reasoning_effort",)),
     Step(S_RELATED_TASKS_PICK,
          applies=lambda s: (_identity_ready(s)
                             and S_RELATED_TASKS_PICK not in s.answered),

package/runtime/python/okstra_ctl/wizard/render.py

@@ -118,6 +118,7 @@ def render_args(state: WizardState) -> dict[str, Any]:
         ),
         "pr-template-path": pr_template,
         "fix-cycle": state.fix_cycle,
+        "reasoning-effort": state.reasoning_effort,
         "host-session-context-json": serialize_host_session_context(
             _host_session_context(state)
         ),

package/runtime/python/okstra_ctl/wizard/state.py

@@ -132,6 +132,8 @@ class WizardState:
     # confirm / edit
     # "" | "yes" | "no" — done(release-handoff) task 재진입의 fix-cycle 기록 여부
     fix_cycle: str = ""
+    # `REASONING_EFFORTS` 중 하나. 워커가 정해지기 전에는 비어 있다.
+    reasoning_effort: str = ""
     confirmed: Optional[bool] = None
     confirmation_stages: str = ""
     confirmation_prompt: str = ""
@@ -143,6 +145,8 @@ class WizardState:
 
     # bookkeeping
     answered: list[str] = field(default_factory=list)
+    # Steps the user came back to through Edit; their auto_value no longer applies.
+    manual_steps: list[str] = field(default_factory=list)
 
     def to_json(self) -> dict[str, Any]:
         payload = asdict(self)
@@ -181,6 +185,9 @@ class Prompt:
     multi: bool = False  # only meaningful when kind == "pick"
     # only meaningful when kind == "pick_group": one entry per AskUserQuestion tab
     questions: list["Prompt"] = field(default_factory=list)
+    # The answer the wizard takes without asking, because it comes from a recorded
+    # source; the confirm screen shows it and its Edit menu asks for it again.
+    auto_value: str = ""
 
     def __post_init__(self) -> None:
         """자유 입력 선택지는 언제나 마지막이다.
@@ -622,6 +629,7 @@ _FIELD_DEFAULTS: dict[str, Any] = {
     "pr_template_path": "", "pr_template_pending_text": False,
     "pr_template_scope": "",
     "fix_cycle": "",
+    "reasoning_effort": "",
     "confirmed": None, "edit_target": "", "confirmation_prompt": "", "confirmation_stages": "",
     "confirmation_scope": {}, "user_authorization": {},
 }

package/runtime/python/okstra_ctl/wizard/steps_identity.py

@@ -6,12 +6,15 @@ from pathlib import Path
 from collections.abc import Mapping
 from typing import Any, Optional
 
-from okstra_ctl import next_phase
+from okstra_ctl import next_phase, worktree_registry
+from okstra_ctl.consumers import latest_done_by_stage, read_consumers
 from okstra_ctl.ids import slugify_task_segment
+from okstra_ctl.paths import RunRef
 from okstra_ctl.group_context import (
     QUEUE_DONE,
     QUEUE_IN_PROGRESS,
     QUEUE_NOT_STARTED,
+    group_briefs,
     group_context_file,
     group_queue,
     is_group_context_file,
@@ -79,15 +82,18 @@ def _validate_base_ref(ref: str, project_root: Path) -> str:
     ref = (ref or "").strip()
     if not ref:
         raise WizardError("base ref is empty")
-    main_wt = _git_main_worktree(project_root)
+    if not _ref_resolves(_git_main_worktree(project_root), ref):
+        raise WizardError(f"base ref not found in repository: {ref}")
+    return ref
+
+
+def _ref_resolves(main_wt: Path, ref: str) -> bool:
     rc = subprocess.call(
         ["git", "-C", str(main_wt), "rev-parse",
          "--verify", "--quiet", f"{ref}^{{commit}}"],
         stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
     )
-    if rc != 0:
-        raise WizardError(f"base ref not found in repository: {ref}")
-    return ref
+    return rc == 0
 
 
 # --- builders ---
@@ -605,8 +611,12 @@ def _build_task_type(state: WizardState) -> Prompt:
     brief_phase = _brief_recommended_task_type(state) if fresh_task else ""
     recommended = (revision_requested or state.task_type
                    or _recommended_task_type(state, manifest))
+    # Only a recommendation okstra recorded is taken without asking: the pointer,
+    # a revision request, or the brief's own entry phase.
+    auto_value = recommended
     if not recommended and not workflow:
         recommended = state.requested_task_type or brief_phase or TASK_TYPE_VALUES[0]
+        auto_value = recommended if recommended in (state.requested_task_type, brief_phase) else ""
     if brief_phase and recommended == brief_phase:
         recommended_suffix = t["options"].get("_BRIEF_SUFFIX", recommended_suffix)
     pointer = next_phase.promote(workflow.get("nextRecommendedPhase"))
@@ -638,7 +648,8 @@ def _build_task_type(state: WizardState) -> Prompt:
     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"])
+                  echo_template=t["echo_template"],
+                  auto_value=auto_value)
 
 
 def _carry_in_existing_brief(state: WizardState) -> str:
@@ -835,28 +846,100 @@ def _build_brief_carry(state: WizardState) -> Prompt:
     )
 
 
-def _checked_out_canonical_ref(project_root: Path) -> str:
-    """The main worktree's branch when it is one of the listed base refs, else ''.
+def _checked_out_branch(main_wt: Path) -> str:
+    """The main worktree's branch, or '' when HEAD is detached.
 
     Projects differ in their integration branch (main vs preprod), and nothing in
     okstra records it; the branch the user keeps checked out is the observed hint.
     """
-    try:
-        main_wt = _git_main_worktree(project_root)
-    except WizardError:
-        return ""
     result = subprocess.run(
         ["git", "-C", str(main_wt), "symbolic-ref", "--quiet", "--short", "HEAD"],
         capture_output=True, text=True,
     )
-    branch = result.stdout.strip() if result.returncode == 0 else ""
-    return branch if branch in CANONICAL_BASE_REFS else ""
+    return result.stdout.strip() if result.returncode == 0 else ""
+
+
+def _recorded_stage_branches(state: WizardState, task_id: str) -> list[str]:
+    """A task's stage branches, top of the stack first: PR heads, then done stages.
+
+    release-handoff `record-pr` writes a `pr` row per stage PR; a task that never
+    reached handoff only has `done` rows, whose branch lives in the worktree
+    registry's stage row (kept after the stage is released).
+    """
+    key = f"{state.project_id}:{state.task_group}:{task_id}"
+    task_root = find_task_root(Path(state.project_root), key)
+    if task_root is None:
+        return []
+    rows = read_consumers(RunRef.from_task_root(task_root, "implementation-planning").run_dir)
+    prs = [row for row in rows if row.get("status") == "pr" and row.get("branch")]
+    prs.sort(key=lambda row: max(row.get("stages") or [0]), reverse=True)
+    branches = [str(row["branch"]) for row in prs]
+    for stage in sorted(latest_done_by_stage(rows), reverse=True):
+        stage_row = worktree_registry.get_stage_row(
+            state.project_id, state.task_group, task_id, stage) or {}
+        if stage_row.get("branch"):
+            branches.append(str(stage_row["branch"]))
+    return branches
+
+
+def _predecessor_base_ref(state: WizardState, main_wt: Path) -> tuple[str, bool]:
+    """(branch, succession) from the nearest earlier task in the group's start order.
+
+    A follow-up task in a group usually builds on the previous task's unmerged
+    stage branches. `succession` is True when okstra records that this task
+    follows that one: it is the next row in the start order (what the
+    predecessor's closeout named as `nextInGroup`), or this task's brief waits
+    for that ticket in its Related Task Graph.
+    """
+    if not (state.project_root and state.task_group and state.task_id):
+        return "", False
+    project_root = Path(state.project_root)
+    queue = _group_start_order(project_root, state.task_group)
+    brief = _project_relative_path(Path(state.brief_path), project_root) if state.brief_path else ""
+    current = next(
+        (index for index, row in enumerate(queue)
+         if row.task_id == state.task_id or (brief and row.brief == brief)),
+        None,
+    )
+    if current is None:
+        return "", False
+    waits: set[str] = set()
+    for item in group_briefs(project_root, state.task_group):
+        waits.update(item["waits_for"].get(queue[current].ticket_id, set()))
+    for index in range(current - 1, -1, -1):
+        row = queue[index]
+        branch = next(
+            (b for b in _recorded_stage_branches(state, row.task_id) if _ref_resolves(main_wt, b)),
+            "",
+        )
+        if branch:
+            return branch, index == current - 1 or row.ticket_id in waits
+    return "", False
+
+
+def _base_ref_candidates(state: WizardState) -> tuple[list[str], str]:
+    """(refs in display order, recommended ref or '')."""
+    try:
+        main_wt = _git_main_worktree(Path(state.project_root))
+    except WizardError:
+        return list(CANONICAL_BASE_REFS), ""
+    predecessor, succession = _predecessor_base_ref(state, main_wt)
+    checked_out = _checked_out_branch(main_wt)
+    derived = [predecessor] if predecessor else []
+    if (checked_out and checked_out not in CANONICAL_BASE_REFS
+            and checked_out not in derived and _ref_resolves(main_wt, checked_out)):
+        derived.append(checked_out)
+    if succession:
+        recommended = predecessor
+    else:
+        recommended = checked_out if checked_out in CANONICAL_BASE_REFS else ""
+    refs = derived + [r for r in CANONICAL_BASE_REFS if r not in derived]
+    return sorted(refs, key=lambda r: r != recommended), recommended
 
 
 def _build_base_ref_pick(state: WizardState) -> Prompt:
     t = _p(state.workspace_root, "base_ref_pick")
-    recommended = _checked_out_canonical_ref(Path(state.project_root))
-    refs = sorted(CANONICAL_BASE_REFS, key=lambda r: r != recommended)
+    refs, recommended = _base_ref_candidates(state)
     options = [_opt(r, recommended=r == recommended) for r in refs]
     for value, label in _static_options(t):
         options.append(_opt(value=value, label=label))

package/runtime/python/okstra_ctl/wizard/steps_options.py

@@ -7,6 +7,7 @@ from pathlib import Path
 from typing import Callable, Optional
 
 from okstra_ctl.clarification_items import user_response_sidecars
+from okstra_ctl.domain.worker_exec import REASONING_EFFORTS
 from okstra_ctl.manager_paths import MANAGER_CONTEXT_DIRECTIVE_PREFIX
 from okstra_ctl.json_boundary import JsonBoundaryError, load_owned_object, write_owned_object_atomic
 from okstra_ctl.report_language import is_language_tag
@@ -25,6 +26,7 @@ from .ids import (
     S_PR_TEMPLATE,
     S_PR_TEMPLATE_PICK,
     S_PR_TEMPLATE_SCOPE,
+    S_REASONING_EFFORT,
     S_RELATED_TASKS,
     S_RELATED_TASKS_PICK,
     S_REPORT_LANGUAGE,
@@ -33,7 +35,14 @@ from .ids import (
     _REUSE_LAST_TOKEN,
     _SIBLINGS_TOKEN,
 )
-from .state import Option, Prompt, WizardError, WizardState
+from .state import (
+    Option,
+    Prompt,
+    WizardError,
+    WizardState,
+    _identity_ready,
+    _load_role_profile_for_state,
+)
 from .prompts import _opt, _p, _pick_snippet
 from .sources import _latest_run_inputs, _require_file, _suggest_latest_final_report
 
@@ -120,6 +129,9 @@ class _OptionalCachedPickSpec:
     # 추천 옵션 라벨·echo 뒤에 덧붙일 동적 안내(예: 함께 첨부될 사이드카 개수).
     # (state, 추천 relpath) -> note. 미설정 picker 는 영향 없음.
     recommend_note: Optional[Callable[["WizardState", str], str]] = None
+    # Whether the wizard takes the suggestion without asking. A previous directive
+    # is an instruction written for another run, so reusing it stays a question.
+    auto_take_suggestion: bool = True
 
 
 def _build_optional_cached_pick(state: WizardState, spec: _OptionalCachedPickSpec) -> Prompt:
@@ -137,10 +149,17 @@ def _build_optional_cached_pick(state: WizardState, spec: _OptionalCachedPickSpe
     setattr(state, spec.cache_attr, suggestion)
     options.append(_opt(PICK_SKIP, t["options"][PICK_SKIP]))
     options.append(_opt(PICK_TYPE_CUSTOM, t["options"][PICK_TYPE_CUSTOM]))
+    if not suggestion:
+        auto_value = PICK_SKIP
+    elif spec.auto_take_suggestion:
+        auto_value = spec.recommend_token
+    else:
+        auto_value = ""
     return Prompt(
         step=spec.step, kind="pick",
         label=t["label"], options=options,
         echo_template=t["echo_template"],
+        auto_value=auto_value,
     )
 
 
@@ -199,6 +218,7 @@ _DIRECTIVE_PICK_SPEC = _OptionalCachedPickSpec(
     cache_attr="last_directive_cached", target_attr="directive",
     pending_attr="directive_pending_text",
     recommend_note=_directive_context_note,
+    auto_take_suggestion=False,
 )
 
 
@@ -417,3 +437,34 @@ def _submit_pr_template_scope(state: WizardState, value: str) -> Optional[str]:
         )
     state.pr_template_scope = value
     return f"pr-template-scope: {value}"
+
+
+_RECOMMENDED_REASONING_EFFORT = "high"
+
+
+def _reasoning_effort_required(state: WizardState) -> bool:
+    """워커를 띄우지 않는 프로필(release-handoff)에는 강도를 넘길 CLI 가 없다."""
+    return _identity_ready(state) and bool(_load_role_profile_for_state(state).roles)
+
+
+def _build_reasoning_effort(state: WizardState) -> Prompt:
+    t = _p(state.workspace_root, "reasoning_effort")
+    others = [level for level in REASONING_EFFORTS if level != _RECOMMENDED_REASONING_EFFORT]
+    return Prompt(
+        step=S_REASONING_EFFORT, kind="pick", label=t["label"],
+        options=[
+            _opt(_RECOMMENDED_REASONING_EFFORT,
+                 t["options"][_RECOMMENDED_REASONING_EFFORT], recommended=True),
+            *(_opt(level, t["options"][level]) for level in others),
+        ],
+        echo_template=t["echo_template"])
+
+
+def _submit_reasoning_effort(state: WizardState, value: str) -> Optional[str]:
+    level = value.strip().lower()
+    if level not in REASONING_EFFORTS:
+        raise WizardError(
+            f"expected one of {', '.join(REASONING_EFFORTS)}, got: {value!r}"
+        )
+    state.reasoning_effort = level
+    return f"reasoning-effort: {level}"

package/runtime/python/okstra_ctl/wizard/steps_plan.py

@@ -276,6 +276,7 @@ def _build_approved_plan_pick(state: WizardState) -> Prompt:
         step=S_APPROVED_PLAN_PICK, kind="pick",
         label=label, options=options,
         echo_template=t["echo_template"],
+        auto_value=PICK_USE_DEFAULT if default is not None else "",
     )
 
 
@@ -341,9 +342,22 @@ def _build_approve_plan_confirm(state: WizardState) -> Prompt:
             for k, v in options_map.items()
         ],
         echo_template=t["echo_template"],
+        auto_value="yes" if _already_approved(state) else "",
     )
 
 
+def _already_approved(state: WizardState) -> bool:
+    """An approved plan with no exported approval sidecar leaves nothing to decide."""
+    if state.html_approval_sidecar or not state.approve_plan_candidate:
+        return False
+    try:
+        _, fully_approved = _classify_approved_plan(
+            state.approve_plan_candidate, Path(state.project_root))
+    except (PrepareError, WizardError):
+        return False
+    return fully_approved
+
+
 def _submit_approve_plan_confirm(state: WizardState, value: str) -> Optional[str]:
     allowed = ("yes_apply", "yes", "no") if state.html_approval_sidecar else ("yes", "no")
     if value not in allowed:

package/runtime/python/okstra_ctl/worker_dispatch.py

@@ -45,10 +45,19 @@ def main(argv: Sequence[str] | None = None) -> int:
             _print_json(_backend_payload(backend_plan, dry_run=True))
             return 0
         code, lines = _dispatch_recording_checkpoints(backend_plan)
+        from .phases.implementation_planning.round_completion import complete_ready_plan_round
+        from .worker_prompt_policy import is_plan_verify_dispatch_kind
+
+        completion = complete_ready_plan_round(backend_plan) if code == 0 and any(
+            is_plan_verify_dispatch_kind(job.dispatch_kind) for job in backend_plan.jobs
+        ) else None
+        if completion and completion["status"] == "failed":
+            code = 2
         _print_json({
             **_backend_payload(backend_plan, dry_run=False),
             "exitCode": code,
             "progressLines": lines,
+            **({"planVerification": completion} if completion else {}),
         })
         return code
     except DispatchError as exc:

package/runtime/python/okstra_ctl/worker_request.py

@@ -12,7 +12,11 @@ import os
 import subprocess
 from pathlib import Path
 
-from .domain.worker_exec import ExecutionPolicy, WorkerExecRequest
+from .domain.worker_exec import (
+    REASONING_EFFORTS,
+    ExecutionPolicy,
+    WorkerExecRequest,
+)
 from .domain.worker_role import role_spec
 from .write_policy import WriteEnforcement, WritePolicy
 
@@ -39,6 +43,7 @@ def build_request(
     session_id: str = "",
     write_policy: WritePolicy | None = None,
     write_enforcement: WriteEnforcement | None = None,
+    reasoning_effort: str = "",
 ) -> WorkerExecRequest:
     """One dispatch, with every value the strategies will not re-derive.
 
@@ -46,6 +51,11 @@ def build_request(
     strategies hand what they are given straight to a CLI, so an unresolved
     `..` or symlink would survive into the sandbox boundary itself.
     """
+    if reasoning_effort and reasoning_effort not in REASONING_EFFORTS:
+        raise ValueError(
+            f"reasoning effort must be one of {', '.join(REASONING_EFFORTS)}: "
+            f"{reasoning_effort!r}"
+        )
     root = project_root.resolve()
     worktree = worktree_path.resolve() if worktree_path is not None else None
     return WorkerExecRequest(
@@ -64,6 +74,7 @@ def build_request(
         ),
         idle_timeout_seconds=idle_timeout_seconds,
         session_id=session_id,
+        reasoning_effort=reasoning_effort,
     )
 
 

package/runtime/schemas/execution-manifest-v2.schema.json

@@ -18,6 +18,7 @@
     "schemaVersion": {"const": "2.0"},
     "executionIdentityVersion": {"const": 2},
     "entryMode": {"enum": ["current-session", "new-session"]},
+    "reasoningEffort": {"enum": ["", "low", "medium", "high", "xhigh"]},
     "participantAssignments": {
       "type": "array",
       "items": {"$ref": "#/$defs/ParticipantAssignment"}