okstra 0.209.0 → 0.209.2

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,

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

@@ -278,7 +278,7 @@ def _single_model_options(
     """고정 단일 역할의 후보를 제공자별로 묶고 기존 추천을 유지한다."""
     pool = context.pool
     requirement = next(row for row in profile.roles if row.role == role)
-    defaults, everything = _available_role_models(
+    _defaults, everything = _available_role_models(
         state, profile, requirement, context, scopes,
     )
     prompt = _p(state.workspace_root, "role_model", role=role)
@@ -297,13 +297,7 @@ def _single_model_options(
         options.append(_opt(
             model_ref,
             prompt["options"]["model"].format(
-                model_ref=model_ref,
-                display=model.display_name,
-                default_suffix=(
-                    prompt["options"].get("default_suffix", "")
-                    if model_ref in defaults
-                    else ""
-                ),
+                model_ref=model_ref, display=model.display_name,
             ),
             recommended=not options,
         ))

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

@@ -27,6 +27,7 @@ from okstra_project.state import (
 )
 
 from .ids import (
+    BRIEF_CARRY_SWITCH_ENTRY,
     BASE_REF_FREE_INPUT_TOKEN,
     CANONICAL_BASE_REFS,
     PICK_TYPE_CUSTOM,
@@ -559,7 +560,7 @@ def _implementation_needs_approval(
 
 def _build_task_type(state: WizardState) -> Prompt:
     t = _p(state.workspace_root, "task_type")
-    recommended_suffix = t["options"].get("_RECOMMENDED_SUFFIX", "")
+    recommended_suffix = ""
     rerun_suffix = t["options"].get("_RERUN_SUFFIX", "")
     next_suffix = t["options"].get("_NEXT_SUFFIX", "")
     approve_suffix = t["options"].get("_APPROVE_SUFFIX", recommended_suffix)
@@ -826,7 +827,10 @@ def _build_brief_carry(state: WizardState) -> Prompt:
     return Prompt(
         step=S_BRIEF_CARRY, kind="pick",
         label=t["label"],
-        options=[_opt(k, v) for k, v in t["options"].items()],
+        options=[
+            _opt(k, v, recommended=k == BRIEF_CARRY_SWITCH_ENTRY)
+            for k, v in t["options"].items()
+        ],
         echo_template=t["echo_template"],
     )
 
@@ -851,11 +855,9 @@ def _checked_out_canonical_ref(project_root: Path) -> str:
 
 def _build_base_ref_pick(state: WizardState) -> Prompt:
     t = _p(state.workspace_root, "base_ref_pick")
-    recommended_suffix = t["options"].get("_RECOMMENDED_SUFFIX", "")
     recommended = _checked_out_canonical_ref(Path(state.project_root))
     refs = sorted(CANONICAL_BASE_REFS, key=lambda r: r != recommended)
-    options = [_opt(r, f"{r}{recommended_suffix}", recommended=True) if r == recommended
-               else _opt(r) for r in refs]
+    options = [_opt(r, recommended=r == recommended) for r in refs]
     for value, label in _static_options(t):
         options.append(_opt(value=value, label=label))
     return Prompt(

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

@@ -689,7 +689,7 @@ def _build_fix_cycle_confirm(state: WizardState) -> Prompt:
     return Prompt(
         step=S_FIX_CYCLE_CONFIRM, kind="pick", label=t["label"],
         options=[
-            _opt("yes", opts["yes"]),
+            _opt("yes", opts["yes"], recommended=True),
             _opt("no", opts["no"]),
             _opt("abort", opts["abort"]),
         ],

package/runtime/python/okstra_ctl/worker_audit_ledger.py

@@ -344,6 +344,36 @@ def worker_result_files(
         yield path, match.worker_role, match.seq
 
 
+def result_file_audit_failures(result_path: Path, audit_path: Path) -> list[str]:
+    """The blocking audit-sidecar findings for one worker result and its sidecar."""
+    rel = result_path.name
+    try:
+        content = result_path.read_text()
+    except OSError as exc:
+        return [f"worker-results file unreadable: {rel} ({exc})"]
+    failures: list[str] = []
+    if READING_CONFIRMATION_HEADING_RE.search(content) is not None:
+        failures.append(
+            f"worker-results file `{rel}` contains a `## 0. Reading "
+            f"Confirmation` heading — that block moved to the audit "
+            f"sidecar (`{audit_path.name}`). "
+            f"Remove the §0 heading + body from the main file and "
+            f"write a fresh sidecar."
+        )
+    if not audit_path.exists():
+        worker_role = rel.partition("-worker-")[0] + "-worker"
+        failures.append(
+            f"worker `{worker_role}` produced `{rel}` but no audit sidecar "
+            f"at `{audit_path.name}` — the sidecar must carry the Reading "
+            f"Confirmation block (one short line per input file). Workers "
+            f"write this in the same step as the main worker-results file."
+        )
+        return failures
+    _, command_failures = read_evidence_commands(audit_path)
+    failures.extend(command_failures)
+    return failures
+
+
 def check_worker_results_audit(
     run_dir: Path,
     task_type: str,
@@ -399,36 +429,17 @@ def worker_results_audit_findings(
 
     for path, worker_role, result_seq in worker_result_files(run_dir, task_type, seq, worker):
         rel = path.name
-        try:
-            content = path.read_text()
-        except OSError as exc:
-            failures.append(f"worker-results file unreadable: {rel} ({exc})")
-            continue
-
-        if READING_CONFIRMATION_HEADING_RE.search(content) is not None:
-            failures.append(
-                f"worker-results file `{rel}` contains a `## 0. Reading "
-                f"Confirmation` heading — that block moved to the audit "
-                f"sidecar (`{worker_role}-audit-{task_type}-{result_seq}.md`). "
-                f"Remove the §0 heading + body from the main file and "
-                f"write a fresh sidecar."
-            )
-
         audit_path = (
             run_dir / "worker-results"
             / f"{worker_role}-audit-{task_type}-{result_seq}.md"
         )
+        failures.extend(result_file_audit_failures(path, audit_path))
+        try:
+            content = path.read_text()
+        except OSError:
+            continue
         if not audit_path.exists():
-            failures.append(
-                f"worker `{worker_role}` produced `{rel}` but no audit sidecar "
-                f"at `{audit_path.name}` — the sidecar must carry the Reading "
-                f"Confirmation block (one short line per input file). Workers "
-                f"write this in the same step as the main worker-results file."
-            )
             continue
-
-        _, command_failures = read_evidence_commands(audit_path)
-        failures.extend(command_failures)
         advisories.extend(_evidence_read_ledger_failures(
             run_dir=run_dir,
             worker_role=worker_role,

package/runtime/python/okstra_ctl/worker_prompt_body.py

@@ -23,6 +23,7 @@ def analysis_prompt_body(
     model: str,
     plan: PromptPlan,
     approved_plan_path: str = "",
+    selected_direction_path: str = "",
 ) -> list[str]:
     """Render the provider-neutral body for an initial analysis audience."""
     label = analysis_worker_label(worker_id)
@@ -41,7 +42,9 @@ def analysis_prompt_body(
         f"- Task type: `{_require_string(manifest, 'taskType')}`",
         "",
         "## Inputs",
-        *analysis_input_lines(manifest, active_context, plan, approved_plan_path),
+        *analysis_input_lines(
+            manifest, active_context, plan, approved_plan_path, selected_direction_path
+        ),
         "",
         mcp_pointer_line(),
         "",
@@ -56,6 +59,7 @@ def analysis_input_lines(
     active_context: Mapping[str, Any],
     plan: PromptPlan,
     approved_plan_path: str = "",
+    selected_direction_path: str = "",
 ) -> list[str]:
     if plan.packet_only:
         packet_path = instruction_path(manifest, active_context, "analysisPacketPath")
@@ -70,6 +74,7 @@ def analysis_input_lines(
         return existing_input_lines((
             ("Primary analysis packet", packet_path),
             ("Approved plan", approved_plan_path),
+            ("Selected direction snapshot", selected_direction_path),
         ))
     inputs = [
         ("Primary analysis packet", instruction_path(manifest, active_context, "analysisPacketPath")),

package/runtime/python/okstra_ctl/worker_prompt_policy.py

@@ -170,6 +170,9 @@ class PromptPlan:
     # 기준으로 판정하라고 요구하는 phase 만 참이다 — 없는 phase 에 실으면
     # 열거만 되고 열 파일이 없는 줄이 된다.
     include_approved_plan: bool = False
+    # 계획 워커 직무는 `selected-direction.json` 을 먼저 읽으라고 하는데, 읽기
+    # 범위는 `## Inputs` 에 열거된 경로뿐이다. 그래서 계획 phase 는 스냅샷을 연다.
+    include_selected_direction: bool = False
 
 
 def resolve_prompt_plan(
@@ -261,6 +264,14 @@ def resolve_prompt_plan(
             packet_only=True,
             required_headers=(GRILLING_LOG_HEADER,),
         )
+    if task_type == "implementation-planning":
+        return _plan(
+            "analysis",
+            duty_audience=analysis_duty,
+            equality_group=analysis_equality_group,
+            packet_only=True,
+            include_selected_direction=True,
+        )
     return _plan(
         "analysis",
         duty_audience=analysis_duty,
@@ -328,6 +339,7 @@ def _plan(
     equality_group: str | None = None,
     packet_only: bool = False,
     include_approved_plan: bool = False,
+    include_selected_direction: bool = False,
     allow_coding_preflight: bool = False,
     required_headers: tuple[str, ...] = (),
     max_body_lines: int | None = None,
@@ -339,6 +351,7 @@ def _plan(
         equality_group=equality_group,
         packet_only=packet_only,
         include_approved_plan=include_approved_plan,
+        include_selected_direction=include_selected_direction,
         allow_coding_preflight=allow_coding_preflight,
         required_headers=_worker_facing_headers(audience, required_headers),
         max_body_lines=max_body_lines,

package/runtime/python/okstra_ctl/write_policy.py

@@ -31,6 +31,7 @@ from .final_report_paths import final_report_data_path
 from .json_boundary import JsonBoundaryError, load_owned_object
 from .path_hints import hydrate_active_run_context
 from .paths import task_conformance_manifest_file, task_qa_dir
+from okstra_project.dirs import OKSTRA_RELATIVE
 
 def build_write_policy(
     invocation: Mapping[str, Any],
@@ -130,6 +131,20 @@ def _role_qa_artifact_paths(role: str, task_root: Path | None) -> tuple[Path, ..
     return ()
 
 
+def _role_project_memory_paths(role: str, project_root: Path) -> tuple[Path, ...]:
+    """The project-memory files an approved plan step orders the executor to write.
+
+    The implementation-planning profile makes every decision draft a step that
+    creates `.okstra/decisions/<NNNN>-<slug>.md`, and a glossary proposal a step
+    that updates `.okstra/glossary.md`. Both sit outside the task root, so no
+    other grant reaches them and `_planned_source_paths` refused the dispatch.
+    """
+    if role != "implementer":
+        return ()
+    okstra = project_root / OKSTRA_RELATIVE
+    return (okstra / "decisions", okstra / "glossary.md")
+
+
 def _inherited_qa_evidence(
     role: str, task_type: str, task_root: Path | None,
 ) -> tuple[Path, ...]:
@@ -212,6 +227,7 @@ def build_invocation_write_contract(
                 *artifact_paths,
                 *_technical_experiment_paths(artifact_paths, task_root),
                 *_role_qa_artifact_paths(role, task_root),
+                *_role_project_memory_paths(role, root),
             )
         )
     )

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

@@ -59,9 +59,9 @@ Submit the answer shape required by `interaction.answerProtocol`; do not add nor
 
 The final `confirm` step is a normal `pick` step with three options — `Proceed` / `Edit` / `Abort`(abort) — and is rendered the same way (no special handling). `Edit` rewinds to any earlier step (including `base-ref`); `Abort` terminally cancels the wizard. The branch/worktree decision the run will actually use (for `implementation`, the **stage worktree** — not the task-key directory) is folded into the Step 4 confirmation summary block as a `worktree` line, so there is no separate branch-confirm prompt.
 
-Never invent additional questions. **Never drop, hide, merge, reorder, or truncate** a `pick` / `pick_group` option — relay every `options[]` entry, including entries that carry a `(default)` / `(recommended)` suffix. Do not collapse a multi-option pick into a "recommended + Enter directly / Other" shortlist. The wizard's arrays are the complete authoritative choice sets, regardless of the current host UI's usual option limit. The run-prompt recommendation rule (1–2 recommendations + Enter directly) shapes the **option set** only for prompts this skill authors itself, never for wizard-provided options — you may not add, drop, or reorder a wizard option to produce a shortlist. It does not excuse you from recommending: before relaying a wizard step whose answer turns on something readable (the carried report, the sidecar the user already wrote, the prior Stage Map), read it, put what you found in the question body, and name which of the wizard's own options you recommend and why. Relaying a step with no context and no recommendation hands the whole question back to the user — see the lifecycle core contract "Asking the user (BLOCKING)".
+Never invent additional questions. **Never drop, hide, merge, reorder, or truncate** a `pick` / `pick_group` option — relay every `options[]` entry, including the flagged recommendation. Do not collapse a multi-option pick into a "recommended + Enter directly / Other" shortlist. The wizard's arrays are the complete authoritative choice sets, regardless of the current host UI's usual option limit. The run-prompt recommendation rule (1–2 recommendations + Enter directly) shapes the **option set** only for prompts this skill authors itself, never for wizard-provided options — you may not add, drop, or reorder a wizard option to produce a shortlist. It does not excuse you from recommending: before relaying a wizard step whose answer turns on something readable (the carried report, the sidecar the user already wrote, the prior Stage Map), read it, put what you found in the question body, and name which of the wizard's own options you recommend and why. Relaying a step with no context and no recommendation hands the whole question back to the user — see the lifecycle core contract "Asking the user (BLOCKING)".
 
-**One recommendation, shown in one place, and it is option 1.** The option carrying `recommended: true` is what this run computed, and the wizard already placed it first — except on model-selection steps (`role-models:*`, `role-model:*`), which keep provider display order, so the flagged model may sit anywhere in the list. Append ` (추천)` to that option's label when you render it, and to no other. A checkbox step (`multi: true`) may flag several leading options: they are the recommended set, rendered the same way. Your prose recommendation names one of the flagged options. If you believe a different option is right, do not quietly recommend it in prose while the flagged one still reads as recommended on screen: say you disagree, name both, and let the user pick. When no option carries the flag, the run computed nothing for this step — recommend one from what you read and mark that one, and do not present the first option as a default just because it is first. **Enforced:** `scripts/okstra_ctl/wizard/state.py` `Prompt.__post_init__` refuses a step whose free-input option is not last, whose single-select recommendation is not exactly one option, whose recommendation is not placed first on a single-select step or is not the leading run on a checkbox step (both position checks are skipped on `role-models:*` / `role-model:*` steps), or that marks the free-input / abort escape as a recommendation.
+**One recommendation, shown in one place, and it is option 1.** Wizard labels carry no recommendation marker of their own. The option carrying `recommended: true` is what this run computed, and the wizard already placed it first — except on model-selection steps (`role-models:*`, `role-model:*`), which keep provider display order, so the flagged model may sit anywhere in the list. Append ` (추천)` to that option's label when you render it, and to no other. A checkbox step (`multi: true`) may flag several leading options: they are the recommended set, rendered the same way. Your prose recommendation names one of the flagged options. If you believe a different option is right, do not quietly recommend it in prose while the flagged one still reads as recommended on screen: say you disagree, name both, and let the user pick. When no option carries the flag, the run computed nothing for this step — recommend one from what you read and mark that one, and do not present the first option as a default just because it is first. **Enforced:** `scripts/okstra_ctl/wizard/state.py` `Prompt.__post_init__` refuses a step whose free-input option is not last, whose single-select recommendation is not exactly one option, whose recommendation is not placed first on a single-select step or is not the leading run on a checkbox step (both position checks are skipped on `role-models:*` / `role-model:*` steps), or that marks the free-input / abort escape as a recommendation.
 
 ## Step 1: Preflight
 
@@ -470,7 +470,7 @@ When the user has to choose an implementation direction — a finished `implemen
 ~/.okstra/bin/okstra option-comparison --report <final-report-implementation-option-selection-NNN.data.json>
 ```
 
-At `selected_direction_pick` the report path is the option value. The command prints JSON; every number in the reply comes from it. Use the recorded `weightedScore` as printed; do not recompute it. Write the reply in the user's language, in this order:
+At `selected_direction_pick` the option value is the report path, or `<report path>#<option id>` for a report still awaiting a direction — pass the part before `#` to `--report`. Picking a `#` value records that direction in the report's `user-responses/` sidecar. The command prints JSON; every number in the reply comes from it. Use the recorded `weightedScore` as printed; do not recompute it. Write the reply in the user's language, in this order:
 
 1. **Lead-in** — one or two sentences on what the directions share and the axes they split on, drawn from `narrative.comparisonOverview` and each option's `coreMechanism`.
 2. **Score table** — a Markdown table: one row per `criteria[]` entry in order, a weight column, one column per option (`<id> <short name>`), and a last row with each option's `weightedScore`. Write each criterion as its identifier with a translation in the user's language, e.g. `requirement-fit(요구사항 부합)`.

package/runtime/validators/validate-run.py

@@ -5660,14 +5660,21 @@ def run_plan_body_inputs(narrative_path: Path, state_path: Path) -> int:
         print("validate-run: narrative has no implementationPlanning", file=sys.stderr)
         return 2
     data = {**narrative, "schemaVersion": "3.0"}
-    data["implementationPlanning"] = {**planning, "planBodyVerification": verification}
+    data["implementationPlanning"] = {**planning, "planBodyVerification": dict(verification)}
+    gate = plan_body_gate_summary(data)
+    if gate is not None:
+        # 상태의 gate 값은 complete-round 가 같은 재계산으로 쓴다. 그 전에 도는
+        # plan-verify 에서 선언값을 대조하면 seed 값과의 시차만 잡힌다.
+        data["implementationPlanning"]["planBodyVerification"].update(
+            gateResult=gate["recomputed"], gateBlockedBy=gate["blockedBy"]
+        )
     failures: list[str] = []
     warnings = validate_plan_body_section(data, _report_path_for_state(state_path), failures)
     failures, advisories = _partition_round_failures(failures)
     payload = {
         "ok": not failures,
         "section": SECTION_PLAN_BODY,
-        "gate": plan_body_gate_summary(data),
+        "gate": gate,
         "failures": failures,
         "advisories": advisories,
         "warnings": warnings,