okstra 0.209.0 → 0.209.1

package/runtime/python/okstra_ctl/phases/implementation_planning/instructions/plan-body-verification.md

@@ -275,6 +275,8 @@ The hexagonal rule that an extracted point must declare `interfaceKind: "port"`
 
 `P-Dir-1` carries the same YAGNI judgement as the legacy option item, but its comparison source is the selected-direction snapshot rather than a trade-off matrix. A new abstraction, configuration knob, widened interface, file, or stage with no original-requirement link is a hidden direction change and receives `DISAGREE(e)` on `P-Dir-1`.
 
+Four `P-Dir-1` payload fields — `coreMechanism`, `architectureBoundaries`, `planningInvariants`, `userConstraints` — are verbatim copies of the selected-direction snapshot: report assembly overwrites them from the snapshot (`scripts/okstra_ctl/report_assembly.py`), and `scripts/okstra_ctl/phases/implementation_planning/validation.py` `_direction_realization_errors` rejects any other value. The planner cannot change them, so a mismatch between one of them and a later user decision (an answered clarification) is not a planner-fixable defect in those fields. Judge it against the writer-owned realization fields and the narrative's `supersessionLedger`: DISAGREE when they fail to carry the decision, and never ask for an edit to the four snapshot fields. The rendered `P-Dir-1` block restates this rule (`_DIR_SNAPSHOT_OWNED_NOTE` in `scripts/okstra_ctl/phases/implementation_planning/authoring.py`).
+
 `P-Opt-<N>` carries the **YAGNI judgement** and is majority-gated for the same reason as `P-Var-*`: whether an abstraction serves the stated requirement or only a forecast is a judgement about the design, not a contradiction between two spelled-out references. Raise it as `DISAGREE(e)` — an option that carries an abstraction, parameter, or configuration knob no Requirement Coverage row demands contradicts the trade-off matrix that scored it, because the complexity the matrix priced is not the complexity the option actually buys. DISAGREE on a `P-Opt-*` item under this rule means one of:
 
 - **an abstraction nobody asked for** — a helper module, strategy / factory, indirection layer, or interface whose only justification in the plan is a caller no requirement names. A second implementation already on the table is `P-Var-*` territory and is the opposite defect: do not raise both on the same behavior;
@@ -320,7 +322,7 @@ Plan-body verification only supports **lightweight mode** (defined in `prompts/l
 
 **Enforced:** `scripts/okstra_ctl/convergence_engine.py` `_parse_config` rejects a `verificationMode` outside `_VERIFICATION_MODES`, and the plan-body round is seeded with `lightweight` rather than the manifest value.
 
-Exception for `P-Req-*`: verifiers still MUST NOT re-open the original task brief for this round, but they MUST compare the requirement text embedded in the `Requirement Coverage` row with the cited Option / Stage / Step in the draft plan. A row is not sound merely because it says `covered`; the cited plan item must actually satisfy the row's stated requirement. A `documented-deviation` never earns automatic `AGREE`: verify all four parts independently — the original requirement, the concrete alternative in `coveredBy`, every `decisionRefs` target, and the `approvalDisposition`. `accepted` requires a referenced user-confirmed clarification; `blocked C-NNN` requires that same-report clarification to be open and block approval.
+Exception for `P-Req-*`: verifiers still MUST NOT re-open the original task brief for this round, but they MUST compare the requirement with the cited Option / Stage / Step in the draft plan. A legacy `Requirement Coverage` row embeds that requirement in its own `requirement` field. A selected-direction row carries only `originalRequirementId` and its `*Refs`, so the requirement is the line for that id in the primary analysis packet the prompt lists under `## Inputs`. A row is not sound merely because it says `covered`; the cited plan item must actually satisfy the requirement. A `documented-deviation` never earns automatic `AGREE`: verify all four parts independently — the original requirement, the concrete alternative in `coveredBy`, every `decisionRefs` target, and the `approvalDisposition`. `accepted` requires a referenced user-confirmed clarification; `blocked C-NNN` requires that same-report clarification to be open and block approval.
 
 For selected-direction `P-Req-*` rows, `status: externally-tracked` explicitly assigns external responsibility through `crossProjectDependencyRefs`. Verify that each reference resolves to a unique, complete `crossProjectDependencies` row and that its required work and verification signal satisfy the requirement. External-only rows need no local stage/step/file references; mixed rows retain their real local references. Do not classify absence of local references as kind `f` when the external mapping is valid. This is planned responsibility, not proof of implementation or deployment. Dangling or incomplete references are rejected by `implementation_direction._coverage_reference_errors`; semantic adequacy remains the verifier judgement.
 
@@ -670,25 +672,25 @@ Required prompt anchor headers are identical to finding convergence (see `prompt
 The `prompts/lead/convergence.md` §"Required reverify output contract"
 applies unchanged: append it verbatim after the response format below.
 
-The prompt-body contract check runs on every `analysis`-audience prompt, not
-just the critic's, so this round needs the same two lines the critic's
-instructions need (`prompts/lead/convergence.md` §"What the critic
-task-instructions file MUST contain"): a `**Prompt Delivery Mode:**` header and,
-under `## Inputs`, exactly one `- Primary analysis packet:` line whose path ends
-in `analysis-packet.md`. The literal label and the backticks are what the check
-matches — a bare path or a reworded label counts as zero. They are in the
-template below; keep them when you fill it in.
+`okstra plan-items prompt` renders the `## Inputs` section itself: a
+`- Primary analysis packet:` line from the run manifest's `analysisPacketPath`
+and a `- Plan narrative:` line from its `reportNarrativePath`. The worker's
+`**Read scope:**` header admits only paths the prompt enumerates, so these lines
+are what let a verifier read the requirement a selected-direction `P-Req-*` row
+names by `originalRequirementId`. The lead does not add them by hand.
 
 Carrying the packet does not license re-analysis. It is there so the verifier
 can resolve a plan item back to the requirement it claims to satisfy; the
 posture in §"Adversarial plan-body posture" still applies, and this round does
 not revisit the requirements themselves.
 
-Omitting either line fails `okstra team dispatch --dispatch-kind
-plan-verify-r<N> ...` before any process starts, reported as `<task-type>
-prompt contract: <worker>: exactly one Primary analysis packet path is required
-(found 0)`. Fix the instructions file and re-materialize with
-`--replace-undispatched` rather than editing the published prompt.
+**Enforced:** only by the renderer — `_render_inputs` in
+`scripts/okstra_ctl/phases/implementation_planning/authoring.py`, asserted by
+`_assert_input_paths` in `tests/run/test_plan_items.py`. No dispatch check counts
+the packet line for this round: the `Primary analysis packet` count in
+`scripts/okstra_ctl/worker_prompt_contract.py` `_validate_prompt_for_plan` runs
+only for the `analysis` audience, and a plan-verify dispatch is a
+reverification.
 
 ````
 Perform plan-body verification for <task-key> (round 1).
@@ -698,6 +700,7 @@ Perform plan-body verification for <task-key> (round 1).
 ## Inputs
 
 - Primary analysis packet: `<path ending in analysis-packet.md>`
+- Plan narrative: `<run manifest reportNarrativePath>`
 
 ## Instructions
 
@@ -757,8 +760,10 @@ Every verdict requires a non-empty explanation.
 
 **Enforced:** `scripts/okstra_ctl/convergence_engine.py` `_parse_vote` rejects a vote whose `explanation` is empty and whose verdict is outside `_VERDICTS`; `classify_collaborative_round` drops `verification-error` votes from both numerator and denominator.
 
-For `P-Req-*` items, compare only the requirement text embedded in the row
-against the cited plan item(s). Do not open the original brief, but do reject
+For `P-Req-*` items, compare the requirement against the cited plan item(s):
+the row's own `requirement` text when it has one, otherwise the primary analysis
+packet's line for the row's `originalRequirementId`. Do not open the original
+brief, but do reject
 coverage rows that cite no concrete option/stage/step or cite a plan item that
 does not satisfy the row's own requirement. For `documented-deviation`, do not
 auto-AGREE based on the status token: separately verify the requirement, the

package/runtime/python/okstra_ctl/phases/implementation_planning/plan_body.py

@@ -67,6 +67,7 @@ from okstra_ctl.design_surfaces import DesignSurfaceError  # noqa: E402
 
 
 from okstra_ctl.plan_items import (  # noqa: E402
+    content_hash,
     expected_plan_item_ids,
     extract_plan_items,
 )
@@ -501,14 +502,14 @@ def _plan_item_decision_authority(item: dict, pbv: dict) -> str | None:
     non_result = any(
         row.get("verdict") not in {"AGREE", "SUPPLEMENT", "DISAGREE"} for row in votes
     )
+    disagrees = [row for row in votes if row.get("verdict") == "DISAGREE"]
     if (
         classification not in {"majority-disagree", "needs-reverify", "all-non-result"}
-        and not non_result
+        and not (non_result and disagrees)
     ):
         return None
     if _stage_scope_bucket(item, pbv) != "in-scope" or item.get("block") == "record":
         return None
-    disagrees = [row for row in votes if row.get("verdict") == "DISAGREE"]
     verified = item.get("contentHash")
     if (
         not self_fix_rounds(pbv)
@@ -1572,10 +1573,7 @@ def _validate_verdicts_match_current_subjects(
     if not isinstance(round_count, int) or round_count < 1:
         return
     try:
-        current = {
-            str(item["id"]): str(item.get("subject") or "")
-            for item in extract_plan_items(ip)
-        }
+        current = {str(item["id"]): item for item in extract_plan_items(ip)}
     except Exception:  # noqa: BLE001
         # Extraction failure is already reported by the completeness check;
         # do not double-report it here as a spurious subject mismatch.
@@ -1587,10 +1585,14 @@ def _validate_verdicts_match_current_subjects(
             continue
         item_id = str(item.get("id") or "").strip()
         recorded = str(item.get("subject") or "").strip()
-        expected = current.get(item_id)
-        if expected is None or not recorded:
+        extracted = current.get(item_id)
+        if extracted is None or not recorded:
+            continue
+        if item.get("verifiedContentHash") == content_hash(extracted):
+            # seed 는 subject 를 갱신하지 않는다. 표가 지금 이 위치의 본문에
+            # 찍혔으면 subject 문구 차이는 위치 이동이 아니다.
             continue
-        if recorded != expected.strip():
+        if recorded != str(extracted.get("subject") or "").strip():
             drifted.append(item_id)
     if drifted:
         failures.append(

package/runtime/python/okstra_ctl/phases/implementation_planning/wizard.py

@@ -15,8 +15,13 @@ from okstra_ctl.implementation_direction import (
 )
 from okstra_ctl.json_boundary import JsonBoundaryError, load_owned_object
 from okstra_ctl.paths import task_dir, task_runs_dir
-from okstra_ctl.wizard.ids import S_SELECTED_DIRECTION_PICK
-from okstra_ctl.wizard.state import Prompt, WizardError, WizardState
+from okstra_ctl.user_response import (
+    UserResponseError,
+    pending_direction_candidates,
+    record_direction_selection,
+)
+from okstra_ctl.wizard.ids import _ABORT_OPTION, S_SELECTED_DIRECTION_PICK
+from okstra_ctl.wizard.state import Option, Prompt, WizardError, WizardState
 from okstra_ctl.wizard.prompts import _opt, _p
 from okstra_ctl.wizard.sources import _project_relative_path
 
@@ -27,6 +32,7 @@ from okstra_ctl.wizard.sources import _project_relative_path
 _SELECTION_REPORT_RE = re.compile(
     r"^final-report-implementation-option-selection-(?P<seq>\d{3,})\.data\.json$"
 )
+_DIRECTION_SEPARATOR = "#"
 
 
 def _selected_direction_candidates(state: WizardState) -> list[str]:
@@ -97,18 +103,67 @@ def _planning_rerun_selected(state: WizardState) -> bool:
     )
 
 
+def _task_key(state: WizardState) -> str:
+    return f"{state.project_id}:{state.task_group}:{state.task_id}"
+
+
+def _pending_directions(
+    state: WizardState, rel_path: str
+) -> tuple[list[dict[str, str]], str]:
+    try:
+        return pending_direction_candidates(
+            Path(state.project_root) / rel_path, _task_key(state)
+        )
+    except UserResponseError:
+        return [], ""
+
+
+def _selected_direction_options(state: WizardState) -> list[Option]:
+    """방향을 아직 고르지 않은 리포트는 후보마다 한 줄로 펼친다.
+
+    리포트 경로만 고르게 하면 실제 결정(어느 방향인가)은 답변 사이드카에 있어야
+    해서, 사이드카가 없는 리포트는 고르는 순간 거절됐다(실측 2026-10-04,
+    dev-11118: 후보 IO-001 하나를 고르자 `sidecar file not found`).
+    """
+    t = _p(state.workspace_root, S_SELECTED_DIRECTION_PICK)
+    options: list[Option] = []
+    recommended_taken = False
+    for path in _selected_direction_candidates(state):
+        candidates, recommended_id = _pending_directions(state, path)
+        if not candidates:
+            options.append(_opt(path, _selection_option_label(state, path, t)))
+            continue
+        match = _SELECTION_REPORT_RE.fullmatch(Path(path).name)
+        seq = match.group("seq") if match else ""
+        for row in candidates:
+            if row["ineligibility"]:
+                continue
+            recommended = not recommended_taken and row["id"] == recommended_id
+            recommended_taken = recommended_taken or recommended
+            options.append(_opt(
+                f"{path}{_DIRECTION_SEPARATOR}{row['id']}",
+                t["labels"]["pending_option"].format(
+                    id=row["id"], name=row["name"], seq=seq
+                ),
+                row["goal"],
+                recommended=recommended,
+            ))
+    return sorted(options, key=lambda option: not option.recommended)
+
+
 def _build_selected_direction_pick(state: WizardState) -> Prompt:
-    candidates = _selected_direction_candidates(state)
+    options = _selected_direction_options(state)
     t = _p(state.workspace_root, S_SELECTED_DIRECTION_PICK)
-    if not candidates:
+    if not options:
         raise WizardError(t["errors"]["none"])
+    # 중단 줄이 있어야 후보가 하나뿐일 때도 사용자의 결정으로 남는다 — 옵션
+    # 1개짜리 화면은 자동 제출되고, 이 단계의 제출은 사용자 답변 파일을 쓴다.
+    options.append(_opt(_ABORT_OPTION, t["labels"]["abort"]))
     return Prompt(
         step=S_SELECTED_DIRECTION_PICK,
         kind="pick",
         label=t["label"],
-        options=[
-            _opt(path, _selection_option_label(state, path, t)) for path in candidates
-        ],
+        options=options,
         echo_template=t["echo_template"],
     )
 
@@ -144,17 +199,24 @@ def _selection_option_label(state: WizardState, rel_path: str, t: dict) -> str:
 
 def _submit_selected_direction_pick(state: WizardState, value: str) -> Optional[str]:
     t = _p(state.workspace_root, S_SELECTED_DIRECTION_PICK)
-    candidates = _selected_direction_candidates(state)
-    if value not in candidates:
+    if value == _ABORT_OPTION:
+        state.aborted = True
+        return t["echo_variants"]["abort"]
+    if value not in {option.value for option in _selected_direction_options(state)}:
         raise WizardError(t["errors"]["unknown"].format(value=value))
+    path, _, option_id = value.partition(_DIRECTION_SEPARATOR)
+    report = Path(state.project_root) / path
+    recorded = ""
     try:
-        resolve_selected_direction(
-            Path(state.project_root) / value,
-            expected_task_key=f"{state.project_id}:{state.task_group}:{state.task_id}",
-        )
-    except DirectionSelectionError as exc:
+        if option_id:
+            recorded = t["echo_variants"]["recorded_direction"].format(
+                id=option_id,
+                sidecar=record_direction_selection(report, _task_key(state), option_id),
+            )
+        resolve_selected_direction(report, expected_task_key=_task_key(state))
+    except (DirectionSelectionError, UserResponseError) as exc:
         raise WizardError(str(exc)) from exc
-    state.selected_direction_path = value
+    state.selected_direction_path = path
     # 두 입력은 상호 배타다 — 방향이 정해진 순간 이 런은 새 계획이고,
     # clarification 자리에 남은 값은 render-bundle 이 거절할 이유일 뿐이다.
     # 거절을 여기서 앞당기는 대신 값을 비우고, 무엇이 비워졌는지 echo 로
@@ -162,5 +224,5 @@ def _submit_selected_direction_pick(state: WizardState, value: str) -> Optional[
     # `--selected-direction` 경로로 계획 런에 첨부된다(`run.py` 참조).
     if state.clarification_response_path:
         state.clarification_response_path = ""
-        return t["echo_variants"]["cleared_clarification"].format(value=value)
-    return f"selected-direction: {value}"
+        return t["echo_variants"]["cleared_clarification"].format(value=path) + recorded
+    return f"selected-direction: {path}{recorded}"

package/runtime/python/okstra_ctl/plan_items.py

@@ -751,8 +751,10 @@ ENVIRONMENT_CORRECTION_PREAMBLE = (
 
 CRITIC_TIE_PREAMBLE = (
     "You are the critic tie-break. Only the items below are in dispute. "
-    "Each item already has one AGREE and one DISAGREE from the two plan-body "
-    "verifiers. Decide the item: AGREE or DISAGREE(<kind>). Your verdict "
+    "Each item's plan-body verifiers split on it; its `Analyser split` block lists "
+    "every analyser vote with the basis that analyser gave, and a "
+    "verification-error vote there counted for neither side. Decide the item: "
+    "AGREE or DISAGREE(<kind>). Your verdict "
     "settles the split, including a prior DISAGREE(a) or DISAGREE(f). "
     "Explain whether the earlier dissent is supported or mistaken; a corrected "
     "dissent remains in the audit history without overriding your decision. "

package/runtime/python/okstra_ctl/render.py

@@ -32,6 +32,7 @@ from okstra_project.dirs import TASK_MANIFEST_FILENAME, OKSTRA_DIR_NAME, project
 # render_task_manifest 가 동일한 리스트/딕셔너리를 로컬에 중복 정의했는데,
 # 이는 silent drift 위험이 있어 SSOT import 로 통합한다.
 from . import fix_cycles
+from .cmux import LEAD_LOCATION_KEY
 from . import next_phase
 from .analysis_inputs import ANALYSIS_TASK_TYPES
 from .application.resolve_assignment import (
@@ -1930,6 +1931,9 @@ def render_run_manifest(run_manifest_path: str, ctx: dict) -> None:
         payload["analysisScopeConfirmation"] = scope_confirmation
     if ctx.get("FIX_CYCLE_ID"):
         payload["fixCycleId"] = ctx["FIX_CYCLE_ID"]
+    cmux_lead = json.loads(ctx.get("CMUX_LEAD_JSON") or "{}")
+    if cmux_lead:
+        payload[LEAD_LOCATION_KEY] = cmux_lead
     if (
         CURRENT_REPORT_SCHEMA_VERSION == "3.0"
         or ctx.get("TASK_TYPE") == "implementation-planning"

package/runtime/python/okstra_ctl/report_finalize.py

@@ -727,13 +727,7 @@ def run_finalize(
         if step["name"] == "business-flow":
             payload["businessProcess"] = step["result"]
             # 선택 단계라 exitCode 는 0 이다. 실패를 중첩 JSON 에만 두면 리드가 못 본다.
-            failed = [
-                {"id": row.get("id", ""), "mode": row.get("mode", ""), "error": row.get("error", "")}
-                for row in step["result"].get("executions") or []
-                if isinstance(row, dict) and row.get("status") == "failed"
-            ]
-            if step["result"].get("error"):
-                failed.append({"id": "", "mode": "", "error": str(step["result"]["error"])})
+            failed = business_flow_warnings(step["result"])
             if failed:
                 payload["businessFlowWarnings"] = failed
     census = _census_summary(ctx)
@@ -742,6 +736,24 @@ def run_finalize(
     return payload
 
 
+def business_flow_warnings(result: dict[str, Any]) -> list[dict[str, str]]:
+    # sidecar 는 task link 이력 전체를 담는다. 같은 mode 가 뒤에서 성공했으면 그 실패는 끝난 일이다.
+    rows = [row for row in result.get("executions") or [] if isinstance(row, dict)]
+    failed = [
+        {"id": row.get("id", ""), "mode": row.get("mode", ""), "error": row.get("error", "")}
+        for index, row in enumerate(rows)
+        if row.get("status") == "failed"
+        and not any(
+            later.get("mode") == row.get("mode")
+            and later.get("status") in {"complete", "partial"}
+            for later in rows[index + 1 :]
+        )
+    ]
+    if result.get("error"):
+        failed.append({"id": "", "mode": "", "error": str(result["error"])})
+    return failed
+
+
 def _census_summary(ctx: FinalizeContext) -> dict[str, Any] | None:
     """Unverdicted census cells per worker, for the lead's completion line."""
     try:

package/runtime/python/okstra_ctl/run.py

@@ -3059,6 +3059,7 @@ def _write_instruction_set_sources(
             json.loads(ctx.get("RELATED_TASKS_JSON", "[]")),
         ),
         coverage_census_text=coverage_census_text,
+        has_selected_direction=(instruction_set / "selected-direction.json").is_file(),
     )
     if inp.task_type == "technical-verification":
         packet += materialize_technical_input_packet(
@@ -3967,7 +3968,7 @@ def _resolve_terminal_backend(project_root: Path, inp: PrepareInputs) -> str:
         return detected
     if _prior_run_backend(project_root, inp) != BACKEND_CMUX_PANE:
         return detected
-    observed, remedy = cmux.unreachable_advice(cmux.unreachable_reason())
+    observed, remedy = cmux.unreachable_advice(cmux.unreachable_reason(None))
     raise PrepareError(" ".join(part for part in (
         f"this task's previous {inp.task_type} run put its workers on cmux "
         f"panes, and now {observed}.",
@@ -3985,6 +3986,18 @@ def lead_pane_title(task_group: str, task_id: str) -> str:
     return f"{task_group}/{task_id}"
 
 
+def _cmux_lead_json(terminal_backend: str) -> str:
+    """prepare 를 실행한 터미널의 cmux 위치. cmux 백엔드가 아니면 빈 객체.
+
+    리드 프로세스의 환경은 이 터미널의 것과 다를 수 있다(`cmux.LEAD_LOCATION_KEY`
+    참조) — 그래서 리드가 뜨기 전인 지금 값을 남긴다.
+    """
+    location = cmux.lead_location_from_env()
+    if terminal_backend != BACKEND_CMUX_PANE or location is None:
+        return "{}"
+    return json.dumps(cmux.lead_location_payload(location))
+
+
 def _title_lead_pane(inp: PrepareInputs) -> None:
     """리드 pane 제목을 `<task-group>/<task-id>` 로 바꾼다 (cmux 백엔드 전용).
 
@@ -4204,6 +4217,7 @@ def prepare_task_bundle(inp: PrepareInputs) -> PrepareOutputs:
 
     ctx.update({
         "TERMINAL_BACKEND": terminal_backend,
+        "CMUX_LEAD_JSON": _cmux_lead_json(terminal_backend),
         "EXECUTOR_WORKTREE_PATH": worktree.path,
         "EXECUTOR_WORKTREE_BRANCH": worktree.branch,
         "EXECUTOR_WORKTREE_BASE_REF": worktree.base_ref,

package/runtime/python/okstra_ctl/team.py

@@ -366,7 +366,7 @@ def _close_panes(manifest: Mapping[str, Any], panes: list[dict[str, str]]) -> No
     from .adapters.runtime.assembly import port_for, runtime_chain
     from .domain.worker_runtime import RuntimeHandle, SURFACE_CMUX_PANE
 
-    chain = runtime_chain(_manifest_backend(manifest))
+    chain = runtime_chain(_manifest_backend(manifest), manifest=manifest)
     # cli-wrapper chains have no cmux port; leftover paneIds must not KeyError.
     if panes and any(port.surface == SURFACE_CMUX_PANE for port in chain):
         closer = port_for(chain, SURFACE_CMUX_PANE)
@@ -466,11 +466,13 @@ def _reclaimable_panes(
             continue
         _append_pane(panes, seen, str(record.get("paneId", "")), "worker")
     if _is_cmux_run(manifest):
-        return _still_open_surfaces(panes)
+        return _still_open_surfaces(panes, cmux.recorded_lead(manifest))
     return panes
 
 
-def _still_open_surfaces(panes: list[dict[str, str]]) -> list[dict[str, str]]:
+def _still_open_surfaces(
+    panes: list[dict[str, str]], recorded: cmux.LeadLocation | None
+) -> list[dict[str, str]]:
     """The recorded surfaces cmux still shows.
 
     Nothing prunes `workerDispatches` — a repeat of one `dispatchId` replaces
@@ -484,7 +486,7 @@ def _still_open_surfaces(panes: list[dict[str, str]]) -> list[dict[str, str]]:
     already went away is a silent no-op, and skipping a live one strands it on
     the user's screen for the rest of the session.
     """
-    workspace = cmux.resolve_lead_workspace()
+    workspace = cmux.resolve_lead_workspace(recorded)
     if not workspace:
         return panes
     try:

package/runtime/python/okstra_ctl/user_response.py

@@ -1602,6 +1602,28 @@ def set_direction_selection(
         _write_transaction(path, payload)
 
 
+def pending_direction_candidates(
+    report_path: Path, task_key: str
+) -> tuple[list[dict[str, str]], str]:
+    """아직 방향을 고르지 않은 후보비교 리포트의 (후보, 추천 id). 고른 뒤면 빈 목록."""
+    context = _validate_owned_report_context(report_path, expected_task_key=task_key)
+    if not _direction_selection_required(context):
+        return [], ""
+    return _direction_candidates(context)
+
+
+def record_direction_selection(report_path: Path, task_key: str, option_id: str) -> Path:
+    """사용자가 고른 방향을 `okstra user-response direction` 과 같은 트랜잭션으로 기록한다."""
+    context = _validate_owned_report_context(report_path, expected_task_key=task_key)
+    candidates, _ = _direction_candidates(context)
+    ids = [row["id"] for row in candidates]
+    if option_id not in ids:
+        raise UserResponseError(f"direction option is not a ranked candidate: {option_id}")
+    transaction_id = begin_response(report_path, task_key)
+    set_direction_selection(transaction_id, ids.index(option_id) + 1, None, None)
+    return finalize_response(transaction_id)
+
+
 def set_legacy_report_authoring(
     transaction_id: str, status: str, reason_file: Path
 ) -> None:

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

@@ -11,7 +11,6 @@ from .state import WizardError
 from .statefile import load_state_file, save_state_file
 from .confirmation import confirmation_block
 from .engine import (
-    _auto_start_new_task_when_it_is_the_only_choice,
     init_state,
     next_prompt,
     prompt_payload,
@@ -87,7 +86,6 @@ def main(argv: list[str]) -> int:
             host_entry_mode=args.entry_mode,
             available_functions=args.available_function,
         )
-        _auto_start_new_task_when_it_is_the_only_choice(state)
         save_state_file(state_path, state)
         first = next_prompt(state)
         print(json.dumps({"ok": True, "next": prompt_payload(state, first)},

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

@@ -19,16 +19,14 @@ from okstra_ctl.run import PrepareError
 from .ids import (
     GROUP_LABELS,
     GROUP_MAX_TABS,
-    PICK_TYPE_CUSTOM,
     PROMPT_GROUPS,
     S_ABORTED,
     S_CONFIRM,
     S_DESIGN_PREP_CONFIRM,
     S_DESIGN_PREP_OVERRIDES,
     S_DONE,
-    S_TASK_PICK,
     S_REPORT_LANGUAGE,
-    TASK_PICK_NEW_TOKEN,
+    _ABORT_OPTION,
     _STEP_TO_GROUP,
 )
 from .state import Prompt, WizardError, WizardState, _is_role_selection_step
@@ -40,7 +38,6 @@ from .picker_navigation import (
     split_picker,
 )
 from .roles import _submit_role_prompt, next_role_prompt
-from .steps_identity import _submit_task_pick
 from .steps_analysis import _advance_design_prep_item
 from .registry import STEPS, STEP_BY_ID, _ROLE_SELECTION_BOUNDARY
 
@@ -66,18 +63,6 @@ def init_state(
     )
 
 
-def _auto_start_new_task_when_it_is_the_only_choice(state: WizardState) -> None:
-    """미완료 task 가 없으면 중복된 새 작업 선택 화면을 건너뛴다."""
-    prompt = next_prompt(state)
-    if (
-        prompt.step != S_TASK_PICK
-        or [option.value for option in prompt.options] != [TASK_PICK_NEW_TOKEN]
-    ):
-        return
-    _submit_task_pick(state, TASK_PICK_NEW_TOKEN)
-    state.answered.append(S_TASK_PICK)
-
-
 def _build_group_prompt(state: WizardState, group_id: str) -> Prompt:
     """그룹의 적용가능·미답변 픽 멤버를 최대 GROUP_MAX_TABS 개 모은다.
 
@@ -102,39 +87,51 @@ def _build_group_prompt(state: WizardState, group_id: str) -> Prompt:
                   label=GROUP_LABELS[group_id], questions=members)
 
 
-def _is_lone_free_input_pick(prompt: Prompt) -> bool:
-    """고를 것이 "직접 입력" 하나뿐인 픽인가.
+def _is_lone_choice_pick(prompt: Prompt) -> bool:
+    """고를 것이 한 줄뿐인 단일 선택 픽인가.
 
-    후보가 0건이면 picker 는 탈출구 한 줄만 남는다. 그 화면은 질문이 아니라
-    빈 목록이고, 호스트 선택기는 옵션 2개 미만을 받지 않아(`nativeLimits`
-    `minOptions`) 번호 1개짜리 목록으로 내려간다 — 사용자는 고를 것이 없는
-    목록에서 1 을 치고 나서야 값을 입력한다. 그런 화면은 건너뛰고 입력 단계로
-    바로 간다.
+    호스트 선택기는 옵션 2개 미만을 받지 않아(`nativeLimits` `minOptions`) 이런
+    화면은 번호 1개짜리 목록으로 내려간다 — 사용자는 고를 것이 없는 목록에서
+    1 을 쳐야 했다(실측 2026-10-04, 방향 보고서가 하나뿐인 계획 run). 그 한 줄이
+    `직접 입력` 이면 입력 단계로, 실제 값이면 그 값으로 바로 간다. 고른 값은
+    확인 화면 요약에 남는다. `중단` 한 줄은 사용자의 결정이 필요하므로 묻는다.
     """
     return (
         prompt.kind == "pick"
+        and not prompt.multi
         and len(prompt.options) == 1
-        and prompt.options[0].value == PICK_TYPE_CUSTOM
+        and prompt.options[0].value != _ABORT_OPTION
     )
 
 
-def _take_free_input_branch(state: WizardState, prompt: Prompt) -> None:
-    """빈 picker 를 사용자 대신 "직접 입력" 으로 답한다 (echo 는 없다)."""
-    STEP_BY_ID[prompt.step].submit(state, PICK_TYPE_CUSTOM)
+def _apply_answer(state: WizardState, prompt: Prompt, value: str) -> str:
+    if _is_role_selection_step(prompt.step):
+        echo = _submit_role_prompt(state, prompt, value)
+        if prompt.step not in state.role_selection_order:
+            state.role_selection_order.append(prompt.step)
+    else:
+        echo = STEP_BY_ID[prompt.step].submit(state, value)
     if prompt.step not in state.answered:
         state.answered.append(prompt.step)
+    return echo or ""
 
 
 def next_prompt(state: WizardState) -> Prompt:
-    # 빈 picker 를 건너뛰면 그 자리에 다음 화면이 온다. 그 다음 화면이 또 빈
-    # picker 일 수 있으므로 반복하되, 자동 전진은 step 당 한 번뿐이라 STEPS
-    # 길이로 상한을 둔다.
-    for _ in range(len(STEPS)):
+    # 한 줄짜리 picker 를 건너뛰면 그 자리에 다음 화면이 온다. 그것도 한 줄짜리일
+    # 수 있어 반복하되, 같은 step 이 다시 오면(반복 가능한 step) 묻는다.
+    taken: set[str] = set()
+    while True:
         prompt = _next_prompt_screen(state)
-        if not _is_lone_free_input_pick(prompt):
+        if prompt.step in taken or not _is_lone_choice_pick(prompt):
             return _native_picker_screen(state, prompt)
-        _take_free_input_branch(state, prompt)
-    return _next_prompt_screen(state)
+        taken.add(prompt.step)
+        attempt = copy.deepcopy(state)
+        try:
+            _apply_answer(attempt, prompt, prompt.options[0].value)
+        except WizardError:
+            # 그 한 줄이 거절되면 사용자에게 보여 거절 사유를 받게 한다.
+            return _native_picker_screen(state, prompt)
+        state.__dict__.update(attempt.__dict__)
 
 
 def _native_picker_screen(state: WizardState, prompt: Prompt) -> Prompt:
@@ -413,16 +410,6 @@ def submit(state: WizardState, value: str) -> dict[str, Any]:
         original = next_role_prompt(state)
         if original is not None and original.step == prompt.step:
             prompt = original
-        echo = _submit_role_prompt(state, prompt, value or "")
-        if prompt.step not in state.answered:
-            state.answered.append(prompt.step)
-        if prompt.step not in state.role_selection_order:
-            state.role_selection_order.append(prompt.step)
-        nxt = next_prompt(state)
-        return {"echo": echo, "next": prompt_payload(state, nxt)}
-    step = STEP_BY_ID[prompt.step]
-    echo = step.submit(state, value or "")
-    if prompt.step not in state.answered:
-        state.answered.append(prompt.step)
+    echo = _apply_answer(state, prompt, value or "")
     nxt = next_prompt(state)
-    return {"echo": echo or "", "next": prompt_payload(state, nxt)}
+    return {"echo": echo, "next": prompt_payload(state, nxt)}

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

@@ -9,7 +9,7 @@ from okstra_ctl.phases.change_impact_analysis.entry import (
 )
 
 from okstra_ctl.phases.implementation_planning.wizard import (
-    _selected_direction_candidates,
+    _selected_direction_options,
     _planning_rerun_selected,
     _build_selected_direction_pick,
     _submit_selected_direction_pick,
@@ -532,7 +532,7 @@ STEPS: list[Step] = [
              # 되돌릴 수 없는 막다른 길이다. 방향 없이 진행한 런은
              # `run._validate_planning_entry_inputs` 가 두 입력을 모두 이름 붙여
              # 거절하므로, 실패는 복구 가능한 자리로 옮겨간다.
-             and bool(_selected_direction_candidates(s))
+             and bool(_selected_direction_options(s))
          ),
          build=_build_selected_direction_pick,
          submit=_submit_selected_direction_pick,