okstra 0.209.0 → 0.209.2

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

@@ -718,6 +718,21 @@ _PREP_OWNERSHIP_NOTE = (
     "writer did not produce those fields.\n"
 )
 
+# 이 네 필드는 report assembly 가 선택 방향 스냅샷으로 덮어쓰고 검증기가 다른 값을
+# 거절한다(validation._direction_realization_errors). 계획자가 바꿀 수 없는 값에
+# planner-fixable DISAGREE 를 내면 self-fix 로 풀리지 않는 차단이 된다.
+_DIR_SNAPSHOT_OWNED_NOTE = (
+    "\nSnapshot-owned fields: `coreMechanism`, `architectureBoundaries`, "
+    "`planningInvariants`, and `userConstraints` above are verbatim copies of "
+    "the selected-direction snapshot. Report assembly overwrites them from "
+    "that snapshot and validation rejects any other value, so the planner "
+    "cannot change them. Judge whether the writer-owned realization fields "
+    "honour them. When a later user decision (an answered clarification) "
+    "departs from them, judge whether the writer-owned fields and the plan "
+    "narrative's `supersessionLedger` carry that decision; do not return a "
+    "planner-fixable DISAGREE that asks to edit these four fields.\n"
+)
+
 
 def _step_coordinate(payload: object, field: str) -> int | None:
     if not isinstance(payload, Mapping):
@@ -784,7 +799,9 @@ def _render_analyser_split(verdicts: object) -> str:
             continue
         kind = str(verdict.get("breakageKind") or "").strip()
         label = f"{token}({kind})" if kind else token
-        rows.append(f"- `{worker}`: `{label}`\n")
+        basis = _prior_vote(verdict).get("basis")
+        suffix = f" — `{scalar(basis)}`" if basis else ""
+        rows.append(f"- `{worker}`: `{label}`{suffix}\n")
     if not rows:
         return ""
     return "Analyser split:\n" + "".join(rows)
@@ -944,6 +961,25 @@ def _render_prior_round(entry: object) -> str:
     return "".join(rows)
 
 
+# 검증자의 읽기 범위(`**Read scope:**`)는 `## Inputs` 에 열거된 경로만 허용한다.
+# 이 절이 없으면 P-Req 의 originalRequirementId 를 패킷의 요구 문장으로 되짚을
+# 수 없어 범위를 지킨 검증자는 verification-error 를 낸다.
+_INPUT_FIELDS = (
+    ("Primary analysis packet", "analysisPacketPath"),
+    ("Plan narrative", "reportNarrativePath"),
+)
+
+
+def _render_inputs(run_manifest: Path) -> str:
+    payload = validated_run_authority(run_manifest).payload
+    rows = [
+        f"- {label}: `{payload[field].strip()}`\n"
+        for label, field in _INPUT_FIELDS
+        if isinstance(payload.get(field), str) and payload[field].strip()
+    ]
+    return "\n## Inputs\n\n" + "".join(rows) if rows else ""
+
+
 def _prompt(args: argparse.Namespace) -> str:
     envelope = _load_json_object(
         _prepared_items_path(args.run_manifest, require_regular=True)
@@ -963,7 +999,11 @@ def _prompt(args: argparse.Namespace) -> str:
         if isinstance(envelope.get("priorRounds"), Mapping)
         else {}
     )
-    rows = ["# Plan verification queue\n", line("Item count", len(items))]
+    rows = [
+        "# Plan verification queue\n",
+        line("Item count", len(items)),
+        _render_inputs(args.run_manifest),
+    ]
     for index, item in enumerate(items, 1):
         if not isinstance(item, Mapping):
             continue
@@ -982,6 +1022,8 @@ def _prompt(args: argparse.Namespace) -> str:
         rows.append(_render_prior_steps(item, all_items))
         if item_id.startswith("P-Prep-"):
             rows.append(_PREP_OWNERSHIP_NOTE)
+        if item_id == "P-Dir-1":
+            rows.append(_DIR_SNAPSHOT_OWNED_NOTE)
         split = _render_analyser_split(
             (envelope.get("tieSplits") or {}).get(item_id)
             if isinstance(envelope.get("tieSplits"), Mapping)
@@ -2270,6 +2312,10 @@ def _narrow_dispatch_queue(
             f"queue does not contain — pass the artifact this round dispatched, "
             f"not another round's"
         )
+    if getattr(args, "append", False) and _queue_holds_open_round_votes(
+        verification, assigned - narrowed, args.round_number
+    ):
+        return narrowed
     verification["dispatchQueue"] = [
         item_id
         for item_id in (queue if isinstance(queue, list) else sorted(assigned))
@@ -2278,6 +2324,28 @@ def _narrow_dispatch_queue(
     return narrowed
 
 
+def _queue_holds_open_round_votes(
+    verification: Mapping[str, Any],
+    outside: set[object],
+    round_number: int,
+) -> bool:
+    """critic 의 `--append` 가 아직 열린 분석자 라운드에 얹히는지.
+
+    그 라운드의 큐를 tie 부분집합으로 덮으면 이어지는 `complete-round` 가
+    분석자 표가 있는 나머지 항목을 배정 밖으로 보고 거절한다.
+    """
+    items = verification.get("planItems")
+    return any(
+        isinstance(item, Mapping)
+        and item.get("id") in outside
+        and any(
+            isinstance(vote, Mapping) and vote.get("round") == round_number
+            for vote in item.get("verdicts") or []
+        )
+        for item in (items if isinstance(items, list) else [])
+    )
+
+
 def _incoming_verdict_rows(
     args: argparse.Namespace,
     known: set[object],

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)},