okstra 0.197.1 → 0.198.1

package/runtime/python/okstra_ctl/verdict_blocks.py

@@ -169,6 +169,33 @@ def parse_finding_votes(text: str, *, adversarial: bool) -> dict[str, FindingVot
     )
 
 
+def finding_vote_defect(text: str) -> str | None:
+    """재검증 결과가 표로 읽히지 않는 이유. 읽히면 ``None``.
+
+    수집(`okstra convergence collect-results`)은 이 파일이 표로 읽혀야 진행한다.
+    읽히지 않는 파일은 산출물이 있어도 표가 없는 것이므로, 디스패치가 그 자리에서
+    "없는 산출물" 로 세어 같은 배치 안에서 재시도한다
+    (`okstra_ctl.dispatch_state.unusable_result_defect`). 그러지 않으면 원장은
+    `ok`, 수집기는 거절이 되어 리드가 손으로 재띄우거나 run 을 닫는 수밖에 없다
+    (2026-09-10 실측, fontsninja-v3-site dev-10631 implementation-option-selection).
+
+    라운드가 adversarial 인지 collaborative 인지는 결과 파일에 적혀 있지 않다. 한쪽
+    어휘로만 읽으면 반대쪽 라운드의 정상 결과를 결함으로 신고하므로, 어느 한쪽으로
+    읽히면 결함이 아니다. 둘 다 실패했을 때만 adversarial 쪽 메시지를 낸다 — 실측된
+    결함(설명 누락)은 두 어휘에서 같은 문장을 낸다.
+    """
+    adversarial_error: str | None = None
+    for adversarial in (True, False):
+        try:
+            parse_finding_votes(text, adversarial=adversarial)
+        except VerdictBlockError as exc:
+            if adversarial:
+                adversarial_error = str(exc)
+            continue
+        return None
+    return adversarial_error
+
+
 def _collect_blocks(blocks: dict[str, dict[str, str]], parse) -> dict:
     """모든 블록을 읽고 결함을 한 번에 보고한다.
 

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

@@ -42,6 +42,7 @@ def main(argv: list[str]) -> int:
     p_init.add_argument("--workspace-root", required=True)
     p_init.add_argument("--project-root", required=True)
     p_init.add_argument("--project-id", required=True)
+    p_init.add_argument("--preferred-task-key", default="")
     p_init.add_argument(
         "--host-runtime",
         default="claude-code",
@@ -81,6 +82,7 @@ def main(argv: list[str]) -> int:
             workspace_root=args.workspace_root,
             project_root=args.project_root,
             project_id=args.project_id,
+            preferred_task_key=args.preferred_task_key,
             host_runtime=args.host_runtime,
             host_entry_mode=args.entry_mode,
             available_functions=args.available_function,

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

@@ -28,6 +28,7 @@ from .ids import (
     S_DESIGN_PREP_OVERRIDES,
     S_DONE,
     S_TASK_PICK,
+    S_REPORT_LANGUAGE,
     TASK_PICK_NEW_TOKEN,
     _STEP_TO_GROUP,
 )
@@ -53,6 +54,7 @@ def init_state(
     host_runtime: str = "claude-code",
     host_entry_mode: str = "current-session",
     available_functions: Optional[list[str]] = None,
+    preferred_task_key: str = "",
 ) -> WizardState:
     """Bootstrap a new wizard state."""
     return WizardState(
@@ -60,6 +62,7 @@ def init_state(
         workspace_root=workspace_root,
         project_root=project_root,
         project_id=project_id,
+        preferred_task_key=preferred_task_key,
         host_runtime=host_runtime,
         host_entry_mode=host_entry_mode,
         available_functions=list(available_functions or []),
@@ -222,6 +225,9 @@ def _sim_answer(prompt: Prompt) -> str:
 def _sim_advance(state: WizardState, prompt: Prompt) -> None:
     """기본답으로 한 화면 전진한다. progress 를 재계산하는 submit()/
     _submit_group() 은 호출하지 않고 step.submit 만 직접 호출해 재귀를 막는다."""
+    if prompt.step == S_REPORT_LANGUAGE:
+        state.answered.append(prompt.step)
+        return
     if is_split_picker(prompt):
         # 조각 질문의 step 은 등록된 step 이 아니다 — 잘리지 않은 원본으로 낸다.
         prompt = _next_prompt_screen(state)

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

@@ -136,6 +136,7 @@ _BRIEF_HEAD_LINES = 60
 
 # ---- Step IDs ------------------------------------------------------------
 
+S_REPORT_LANGUAGE = "report_language"
 S_TASK_PICK = "task_pick"
 
 

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

@@ -50,6 +50,7 @@ from .ids import (
     S_RELATED_TASKS,
     S_RELATED_TASKS_PICK,
     S_REPORT_WRITER_MODEL,
+    S_REPORT_LANGUAGE,
     S_REUSE_PREVIOUS,
     S_REVERIFY_SCOPE_PICK,
     S_REVERIFY_SCOPE_STAGES,
@@ -167,6 +168,9 @@ from .steps_plan import (
     _submit_stage_pick,
 )
 from .steps_options import (
+    _report_language_required,
+    _build_report_language,
+    _submit_report_language,
     _build_clarification,
     _build_clarification_pick,
     _build_directive,
@@ -278,6 +282,10 @@ def _submit_edit_target(state: WizardState, value: str) -> Optional[str]:
 # --- step registry ---
 
 STEPS: list[Step] = [
+    Step(S_REPORT_LANGUAGE,
+         applies=_report_language_required,
+         build=_build_report_language, submit=_submit_report_language,
+         owns=()),
     Step(S_TASK_PICK,
          applies=lambda s: s.is_new_task is None,
          build=_build_task_pick, submit=_submit_task_pick,

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

@@ -39,6 +39,7 @@ class WizardState:
     workspace_root: str = ""
     project_root: str = ""
     project_id: str = ""
+    preferred_task_key: str = ""
     host_runtime: str = "claude-code"
     host_entry_mode: str = "current-session"
     available_functions: list[str] = field(default_factory=list)

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

@@ -129,9 +129,12 @@ def _next_phase_cell(raw: Any) -> str:
     return f"{cell} ({pointer['status']})"
 
 
-def _recommended_task_entry(remaining: list[dict], latest_key: str) -> dict | None:
+def _recommended_task_entry(
+    remaining: list[dict], latest_key: str, preferred_key: str = "",
+) -> dict | None:
     """남은 task 중 이 run 이 권하는 하나.
 
+    현재 대화에서 전달한 task 를 우선한다. 전달값이 없으면
     포인터가 `ready` 인 task 는 지금 바로 다음 phase 를 시작할 수 있는 task 다
     — 그중 최신(카탈로그는 updatedAt 내림차순)을 권한다. `ready` 가 없으면
     마지막으로 만진 task(`latest-task.json`)를, 그것도 목록에 없으면 최신
@@ -139,6 +142,11 @@ def _recommended_task_entry(remaining: list[dict], latest_key: str) -> dict | No
     산문에서 2번을 권했다 — 추천이 여럿이면 라벨은 아무것도 고르지 않은
     것이다.
     """
+    if preferred_key:
+        for entry in remaining:
+            if entry.get("taskKey") == preferred_key:
+                return entry
+        raise WizardError(f"preferred task not found in project catalog: {preferred_key}")
     if not remaining:
         return None
     for entry in remaining:
@@ -158,9 +166,10 @@ def _build_task_pick(state: WizardState) -> Prompt:
     latest = read_latest_task(project_root) or {}
     latest_key = latest.get("taskKey") or ""
     latest_suffix = t["options"].get("_LATEST_SUFFIX", "")
-    remaining = [e for e in tasks if (e.get("workStatus") or "") != "done"]
+    remaining = [e for e in tasks if (e.get("workStatus") or "") != "done"
+                 or e.get("taskKey") == state.preferred_task_key]
     # 추천은 하나이고 1번이다. 나머지는 최신순 그대로.
-    recommended = _recommended_task_entry(remaining, latest_key)
+    recommended = _recommended_task_entry(remaining, latest_key, state.preferred_task_key)
     ordered = (
         [recommended, *(e for e in remaining if e is not recommended)]
         if recommended is not None else remaining
@@ -187,6 +196,7 @@ def _build_task_pick(state: WizardState) -> Prompt:
 def _submit_task_pick(state: WizardState, value: str) -> Optional[str]:
     value = value.strip()
     if value == TASK_PICK_NEW_TOKEN:
+        state.preferred_task_key = ""
         state.is_new_task = True
         state.task_group = ""
         state.task_id = ""
@@ -207,6 +217,7 @@ def _submit_task_pick(state: WizardState, value: str) -> Optional[str]:
     state.is_new_task = False
     state.task_group = tg
     state.task_id = tid
+    state.preferred_task_key = value
     state.existing_brief_path = _existing_task_brief(
         Path(state.project_root), value
     )

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

@@ -6,7 +6,8 @@ from pathlib import Path
 from typing import Callable, Optional
 
 from okstra_ctl.clarification_items import user_response_sidecars
-from okstra_ctl.json_boundary import JsonBoundaryError, load_owned_object
+from okstra_ctl.json_boundary import JsonBoundaryError, load_owned_object, write_owned_object_atomic
+from okstra_ctl.report_language import is_language_tag
 from okstra_ctl.pr_template import PrTemplateError, resolve_pr_template_path
 from okstra_project.dirs import project_json_path
 from okstra_project.state import StateError, list_project_tasks
@@ -23,6 +24,7 @@ from .ids import (
     S_PR_TEMPLATE_SCOPE,
     S_RELATED_TASKS,
     S_RELATED_TASKS_PICK,
+    S_REPORT_LANGUAGE,
     _LATEST_REPORT_TOKEN,
     _PROJECT_DEFAULT_TOKEN,
     _REUSE_LAST_TOKEN,
@@ -33,6 +35,40 @@ from .prompts import _opt, _p, _pick_snippet
 from .sources import _latest_run_inputs, _require_file, _suggest_latest_final_report
 
 
+def _report_language_required(state: WizardState) -> bool:
+    path = project_json_path(Path(state.project_root))
+    if not path.is_file():
+        return False
+    try:
+        data = load_owned_object(path, artifact="project config")
+    except JsonBoundaryError as exc:
+        raise WizardError(str(exc)) from exc
+    return data.get("reportLanguage") in (None, "")
+
+
+def _build_report_language(state: WizardState) -> Prompt:
+    text = _p(state.workspace_root, "report_language")
+    return Prompt(
+        step=S_REPORT_LANGUAGE, kind="text",
+        label=text["label"], echo_template=text["echo_template"],
+    )
+
+
+def _submit_report_language(state: WizardState, value: str) -> Optional[str]:
+    language = value.strip()
+    if not is_language_tag(language):
+        raise WizardError("보고서 언어 태그를 입력하세요: en, ko, fr, pt-BR")
+    path = project_json_path(Path(state.project_root))
+    try:
+        data = load_owned_object(path, artifact="project config")
+        if data.get("reportLanguage") in (None, ""):
+            data["reportLanguage"] = language
+            write_owned_object_atomic(path, data, artifact="project config")
+    except (OSError, JsonBoundaryError) as exc:
+        raise WizardError(str(exc)) from exc
+    return f"report-language: {data['reportLanguage']}"
+
+
 def _clarification_sidecar_note(state: WizardState, suggestion: str) -> str:
     """추천 final-report 와 함께 carry-in 될 ``user-responses/`` 사이드카 현황 문구.
 

package/runtime/python/okstra_ctl/worker_audit_check.py

@@ -31,12 +31,16 @@ _CLI_EPILOG = r"""Usage:
     --seq <nnn> [--worker <id>]
 
   --run-dir    the run directory; worker-results/ and prompts/ hang off it
+  --seq        this run's seq; a bare number is zero-padded to three digits
   --worker     check only this worker (default: every worker in the run)
 
 Emits one JSON object — `{ok, inspected, inspectedFiles[], failures[],
 blocking[], advisory[], runImpact}` — and exits 2 when failures[] is
 non-empty, 0 otherwise. `failures` is `blocking` followed by `advisory`.
 
+A selector that matches no result file also exits 2, carrying `selectorError`
+instead of failures: nothing was checked, which is not a pass.
+
 Runs the Phase 7 audit-sidecar rules now, while the worker session is still
 alive: that every result file carries no `## 0. Reading Confirmation` heading,
 that its audit sidecar exists (blocking), and that every backticked `path:line`
@@ -49,6 +53,15 @@ row alone.
 """
 
 
+# 결과 파일명은 seq 를 3자리로 적고, 선택은 그 문자열과의 동등 비교다
+# (`worker_audit_ledger.worker_result_files`). `--seq 1` 은 `001` 과 같지 않아
+# 전건이 걸러지고, 검사 0건은 실패 0건이므로 통과로 읽혔다 — 2026-09-10
+# dev-10642-15 final-verification 001 실측.
+def _normalized_seq(value: str) -> str:
+    text = value.strip()
+    return text.zfill(3) if text.isdigit() else text
+
+
 def _parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(
         epilog=_CLI_EPILOG,
@@ -59,8 +72,9 @@ def _parser() -> argparse.ArgumentParser:
     parser.add_argument("--run-dir", type=Path, required=True,
                         help="runs/<task-type>/ for this run")
     parser.add_argument("--task-type", required=True)
-    parser.add_argument("--seq", required=True,
-                        help="this run's 3-digit seq")
+    parser.add_argument("--seq", required=True, type=_normalized_seq,
+                        help="this run's seq; a bare number is zero-padded to "
+                             "three digits")
     parser.add_argument("--worker", default=None,
                         help="check only this worker id, with or without the "
                              "`-worker` suffix (default: every worker)")
@@ -83,20 +97,28 @@ def main(argv: list[str] | None = None) -> int:
             args.run_dir, args.task_type, args.seq, args.worker
         )
     ]
-    print(json.dumps(
-        {
-            "ok": not failures,
-            "inspected": len(inspected),
-            "inspectedFiles": inspected,
-            "failures": failures,
-            "blocking": blocking,
-            "advisory": advisory,
-            "runImpact": RUN_IMPACT,
-        },
-        ensure_ascii=False,
-        indent=2,
-    ))
-    return 2 if failures else 0
+    # 검사한 파일이 없다는 것과 위반이 없다는 것은 다른 사실이고, `ok` 는 둘을
+    # 구분하지 못한다. 선택자가 아무것도 고르지 못했으면 판정 자체가 없었으므로
+    # 통과로 보고하지 않는다.
+    selector_error = "" if inspected else (
+        f"no worker-results file matched task-type={args.task_type} "
+        f"seq={args.seq}"
+        + (f" worker={args.worker}" if args.worker else "")
+        + f" under {args.run_dir}"
+    )
+    payload = {
+        "ok": bool(not failures and inspected),
+        "inspected": len(inspected),
+        "inspectedFiles": inspected,
+        "failures": failures,
+        "blocking": blocking,
+        "advisory": advisory,
+        "runImpact": RUN_IMPACT,
+    }
+    if selector_error:
+        payload["selectorError"] = selector_error
+    print(json.dumps(payload, ensure_ascii=False, indent=2))
+    return 2 if failures or selector_error else 0
 
 
 if __name__ == "__main__":

package/runtime/python/okstra_ctl/worker_liveness.py

@@ -32,10 +32,11 @@ import argparse
 import json
 import sys
 import time
-from collections.abc import Callable
+from collections.abc import Callable, Mapping
 from dataclasses import dataclass
 from datetime import datetime, timezone
 from pathlib import Path
+from typing import Any
 
 from .wrapper_status import log_path_for_prompt
 
@@ -353,7 +354,47 @@ _ARTIFACT_FIELD_BY_MODE = {
 }
 
 
+def _dispatch_worker_id(record: Mapping[str, Any]) -> str:
+    """이 디스패치 행이 말하는 워커 id.
+
+    execution-identity v2 행에는 `workerId` 가 실리지 않는다
+    (`dispatch_core._dispatch_record`). 그 경우 `assignmentRef` 의 마지막 마디가
+    워커 id 이므로 — `initial/codex-verifier`, `critic/acceptance` — 거기서 읽는다.
+    """
+    worker_id = record.get("workerId")
+    if isinstance(worker_id, str) and worker_id.strip():
+        return worker_id.strip()
+    assignment_ref = record.get("assignmentRef")
+    if isinstance(assignment_ref, str) and assignment_ref.strip():
+        return assignment_ref.strip().rsplit("/", 1)[-1]
+    return ""
+
+
+def _dispatch_fallback(state: Mapping[str, Any], worker_id: str) -> dict:
+    """같은 워커의 디스패치 행 중 마지막 것.
+
+    로스터 행에 없는 키를 여기서 보충한다. 재디스패치는 같은 워커의 행을 뒤에
+    덧붙이므로 마지막 행이 이번 시도다.
+    """
+    records = state.get("workerDispatches")
+    if not isinstance(records, list):
+        return {}
+    matches = [
+        row for row in records
+        if isinstance(row, Mapping) and _dispatch_worker_id(row) == worker_id
+    ]
+    return dict(matches[-1]) if matches else {}
+
+
 def _worker_row(team_state_path: Path, worker_id: str) -> dict:
+    """이 워커의 프로브 입력 — 로스터 행에 디스패치 행을 덧댄 것.
+
+    `livenessMode` 는 디스패치 행에만 실린다(`dispatch_core._dispatch_record`);
+    로스터 행은 그 키를 갖지 않는다. 로스터만 읽으면 cmux 백엔드의 모든 run 에서
+    프로브가 전면 거부되고, 리드는 계약이 금지한 자체 폴링으로 밀려난다.
+    보충은 로스터에 없거나 빈 키에만 적용한다 — `startedAt` 처럼 로스터가 정본인
+    값을 디스패치 행이 덮어쓰면 grace 앵커가 이번 시도에서 어긋난다.
+    """
     state = load_json_object(team_state_path, "team-state")
     workers = state.get("workers")
     if not isinstance(workers, list):
@@ -367,7 +408,12 @@ def _worker_row(team_state_path: Path, worker_id: str) -> dict:
     )
     if worker is None:
         raise DispatchError(f"team-state has no workerId={worker_id}: {team_state_path}")
-    return worker
+    merged = dict(worker)
+    for key, value in _dispatch_fallback(state, worker_id).items():
+        current = merged.get(key)
+        if key not in merged or (isinstance(current, str) and not current.strip()):
+            merged[key] = value
+    return merged
 
 
 def probe_target(team_state_value: str, worker_id: str) -> ProbeTarget:

package/runtime/python/okstra_ctl/workflow.py

@@ -88,7 +88,7 @@ PHASE_RULES: dict[str, dict[str, str]] = {
     "implementation-option-selection": {
         "allowed": (
             "  - candidate-comparison evidence for up to three options per worker\n"
-            "  - preselected-validation that re-evaluates the merged candidate set\n"
+            "  - preselected-validation of exactly ONE candidate: every analyser returns its own feasibility verdict on that one direction, `candidateAudit` stays empty, and no analyser generates an alternative. It is not a re-evaluation of the merged set — `okstra_ctl.implementation_options._validate_mode` rejects a preselected-validation report carrying more than one option or a non-empty audit\n"
             "  - a ranked display of at most three options with requirement mappings\n"
             "  - an audit record for every rejected candidate\n"
             "  - one endStateCoverage row per brief end-state id (this phase authors no goal of its own)"

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

@@ -149,7 +149,13 @@ okstra wizard new-state-file
 
 This prints one absolute path on stdout (e.g. `/var/folders/.../okstra-wizard.AbCd.json`). Read that path from the tool output and **paste it literally** into every subsequent `--state-file` argument.
 
-Then initialize the wizard with the literal `projectRoot` / `projectId` you parsed from Step 1 and the literal state-file path from above:
+Then initialize the wizard with the literal `projectRoot` / `projectId` you parsed from Step 1 and the literal state-file path from above.
+
+For task continuity, pass `--preferred-task-key <project-id:task-group:task-id>` on every initialization when this conversation has a known task. Use the task explicitly requested in the current message first; otherwise use the last task the user selected in this conversation's wizard. Resolve abbreviated task IDs against the project catalog before passing the full key. If the ID is ambiguous, ask which matching task the user means. Never infer this conversation's selection from project-wide `latest-task.json`, catalog recency, or another session. With neither an explicit task nor a prior selection in this conversation, omit the flag. The runtime puts the preferred task first, including a completed task when explicitly carried in, and rejects a key absent from the catalog instead of substituting another task; ordering is covered by `tests/domain/wizard/test_task_selection.py`. The task picker still lets the user change tasks.
+
+After a successful task selection, retain the returned full task key in this conversation as its task context, including in continuation summaries, and carry it into the next initialization. A different selection replaces it. Selecting a brand-new task clears the previous selection; retain the new full key once its project, group, and task ID are resolved. This conversation carry-forward is a lead instruction, not automatic host-session discovery by the runtime.
+
+Initialize with the optional preferred key resolved above:
 
 ```bash
 okstra wizard init \
@@ -191,6 +197,7 @@ Repeat until `next.kind == "done"` (or `"aborted"` — terminal cancel, see "How
 
 That is the entire interactive flow. The wizard handles:
 
+- project report language before task selection: when `.okstra/project.json` has no `reportLanguage` value, ask for a language tag and save the answer to that file. An existing value skips this question. Prompt rendering and progress estimation do not save a language,
 - new-vs-existing task split (remaining work — `workStatus != done` — top-3 newest recommendations + Enter directly), task-group / task-id slug validation (task-group offers the top-3 newest candidates combining recent task use + recent `.okstra/briefs/<group>/` creation activity + Enter directly; task-id offers the top-3 recent candidates from the same group + Enter directly),
 - task-type pick (3 options + Enter directly; Enter directly is validated against the full task-type whitelist in a follow-up `text` step). **For a brand-new task the brief is asked first** and the three options are entry phases only (`requirements-discovery` / `improvement-discovery` / `project-analysis` / `feature-analysis` / `change-impact-analysis` / `error-analysis`) — a new task-key has no approved plan, no implementation and no commits, so `implementation`, `final-verification` and `release-handoff` cannot be entered there; the recommended slot comes from the selected brief's `Recommended next phase:` line and falls back to `requirements-discovery` when the brief carries none. For an existing task-key what fills those three depends on `workflow.nextRecommendedPhase` — an object `{phase, status, rationale}`, not a phase-name string. `status: ready` gives the classic trio: its `phase` marked recommended, re-run the current phase, the lifecycle's next step. Any other status contributes nothing at all, since both the recommended slot and the next-step slot derive from that phase — re-run the current phase becomes the first option and the remaining slots fill unlabelled from recently used task-types and then the whitelist. Never recover a phase name from a non-`ready` pointer and propose it yourself: prepare deliberately lowers the pointer to `pending` while its run is unfinished, and the missing recommendation is that signal,
 - brief path — **for a new task it is asked right after task-group, before the task-type** (it is the only input that says what the task is, and the task-type recommendation reads it); for an existing task it is **asked only for entry task-types (requirements-discovery / error-analysis / improvement-discovery / project-analysis / feature-analysis / change-impact-analysis)** (same-group `.okstra/briefs/<task-group>/**/*.md` candidates first, sorted by the newer of file-created/modified time and latest task-catalog use; direct input last; `Keep / Change` for existing entry tasks). `project-analysis`, `feature-analysis`, and `change-impact-analysis` are brief entry task types. On an existing task a downstream lifecycle task-type auto carries in the manifest's brief, and when no registered brief exists a `brief_carry` 3-option prompt appears (recommend switching to entry / Enter directly / Abort). `release-handoff` has no brief step of its own — a new-task run answers the brief before the type is known, and the brief is dropped at render time, so prepare always generates the input document that cites the verification report,

package/runtime/templates/reports/html/base.template.html

@@ -77,7 +77,6 @@
       </table>
     </section>
     {% endif %}
-    {{ clarification_responses(clarificationItems) }}
     {% if evidenceIndex %}
     <section data-report-section="evidence-ledger" data-reader-kind="audit">
       <h2>{{ t('base.evidence-ledger') }}</h2>
@@ -139,6 +138,7 @@
       </table>
     </section>
     {% endif %}
+    {{ clarification_responses(clarificationItems) }}
   </main>
   {% if approval is not defined or not (approval and approval.reentry_command) %}<footer class="human-report-footer">
     <button type="button" data-action="export-user-response">{{ t('base.export-my-answers') }}</button>
@@ -147,8 +147,9 @@
     <p class="user-response-hint">{{ t('base.export-downloads') }} <code>user-response-{{ runMeta.task_type }}-{{ runMeta.seq }}.md</code>{{ t('base.drop-that-file-into') }} <code>{{ userResponseDir }}</code> {{ t('base.and-the-next-run-picks-your-answers-up-on-it') }}</p>
     <pre id="user-response-output" aria-live="polite"></pre>
   </footer>{% endif %}
+  <div id="bottom"></div>
   <div class="back-to-top-wrap">
-    <nav class="back-to-top-index" id="back-to-top-index" aria-label="{{ t('base.contents') }}"><!--report-index-items--></nav>
+    <nav class="back-to-top-index" id="back-to-top-index" aria-label="{{ t('base.contents') }}"><!--report-index-items--><a href="#bottom">{{ t('base.go-to-bottom') }}</a></nav>
     <a class="back-to-top" href="#top">{{ t('base.back-to-top') }}</a>
   </div>
   <script id="run-meta" type="application/json">{{ {

package/runtime/templates/reports/html/i18n/en.json

@@ -164,6 +164,7 @@
   "base": {
     "skip-to-report-content": "Skip to report content",
     "back-to-top": "Back to top",
+    "go-to-bottom": "Go to bottom",
     "contents": "Contents",
     "task": "Task",
     "execution-roles": "Execution roles",

package/runtime/templates/reports/html/i18n/ko.json

@@ -164,6 +164,7 @@
   "base": {
     "skip-to-report-content": "리포트 본문으로 건너뛰기",
     "back-to-top": "맨 위로",
+    "go-to-bottom": "맨 아래로",
     "contents": "목차",
     "task": "태스크",
     "execution-roles": "실행 역할",

package/runtime/validators/validate-run.py

@@ -115,6 +115,7 @@ from okstra_ctl.final_report_paths import (  # noqa: E402
 )
 from okstra_token_usage.report import _match_worker_index  # noqa: E402
 from okstra_ctl.implementation_options import (  # noqa: E402
+    validate_blocked_answer_channel,
     validate_implementation_option_selection,
 )
 from okstra_ctl.implementation_direction import (  # noqa: E402
@@ -149,6 +150,7 @@ from okstra_ctl.agent.invocation import (  # noqa: E402
     AgentInvocationError,
     agent_model_assignment_from_payload,
     invocation_execution_identity_from_manifest,
+    invocation_input_digest,
     verify_agent_invocation,
 )
 from okstra_ctl.execution_identity import ExecutionManifestError  # noqa: E402
@@ -253,6 +255,39 @@ def _result_link_attempt_status_failure(
     )
 
 
+def _dispatch_input_digest(
+    project_root: Path, row: Mapping[str, Any]
+) -> tuple[str | None, str]:
+    """이 디스패치의 예약 입력 해시, 예약이 계산한 것과 같은 방법으로.
+
+    `inputDigest` 와 `promptDigest` 는 서로 다른 대상이다. 전달 계약
+    `execution-identity-v1` 부터 예약은 **논리 작업**을 해시한다 — 시도별 전달값과
+    prompt history 경로를 뺀 본문(`agent_prompt_task_bytes`) — 반면 `promptDigest`
+    는 프롬프트 파일 전체 바이트다. 둘을 동등 비교하면 그 계약을 쓰는 run 은
+    통과할 수 있는 값이 하나도 없다(2026-09-08 f56ec08 이후 전부, 2026-09-10
+    dev-10642-15 final-verification 001 에서 7/7 디스패치가 이 규칙에 걸렸다).
+
+    그래서 재구현하지 않고 예약이 쓰는 함수를 그대로 부른다. 메타데이터 경로가
+    없는 구형 행만 `promptDigest` 로 돌아간다 — 그 계약에서는 두 값이 같다.
+    """
+    metadata_value = row.get("promptMetadataPath")
+    if not isinstance(metadata_value, str) or not metadata_value.strip():
+        return row.get("promptDigest"), ""
+    try:
+        metadata = json.loads(
+            _resolve_prompt_record_path(project_root, metadata_value)
+            .read_text(encoding="utf-8")
+        )
+    except (OSError, json.JSONDecodeError):
+        return None, "prompt metadata is missing or invalid"
+    if not isinstance(metadata, Mapping):
+        return None, "prompt metadata is not an object"
+    try:
+        return invocation_input_digest(metadata, project_root), ""
+    except (AgentInvocationError, KeyError, OSError, ValueError) as exc:
+        return None, f"input digest cannot be recomputed: {exc}"
+
+
 def _validate_agent_dispatch_contract(
     *,
     project_root: Path,
@@ -399,12 +434,16 @@ def _validate_agent_dispatch_contract(
                 )
                 continue
             invocation = canonical_invocations.get(row.get("invocationRef"))
+            input_digest, digest_error = _dispatch_input_digest(project_root, row)
+            if digest_error:
+                failures.append(f"agent dispatch {dispatch_id}: {digest_error}")
+                continue
             if not isinstance(invocation, Mapping) or any((
                 invocation.get("participantRef") != row.get("participantRef"),
                 invocation.get("roleExecutionRef") != row.get("roleExecutionRef"),
                 invocation.get("dutyId") != row.get("dutyId"),
                 invocation.get("dispatchKind") != dispatch_kind,
-                invocation.get("inputDigest") != row.get("promptDigest"),
+                invocation.get("inputDigest") != input_digest,
                 )):
                 failures.append(
                     f"agent dispatch {dispatch_id}: does not match canonical invocation"
@@ -1531,7 +1570,12 @@ def validate_team_state(
         by_role[role] = worker
 
     expected_workers: dict[str, dict] = {}
-    for worker in contract["required_worker_roles"]:
+    # 선택은 배정 전의 선택이다. 배정된 비평 역할도 결과 또는 생략 사유가
+    # 있어야 하므로 필수 역할과 같은 상태 검사를 거친다.
+    for worker in [
+        *contract["required_worker_roles"],
+        *contract.get("optional_worker_roles", []),
+    ]:
         if not isinstance(worker, dict):
             failures.append("requiredWorkerRoles contains a non-object entry")
             continue
@@ -1607,15 +1651,7 @@ def validate_team_state(
         if status != "completed" and not reason:
             failures.append(f"{role} with status `{status}` must include a reason")
 
-    # A declared optional role may appear in the roster and may equally be
-    # absent: the run states which ones it can dispatch (today, the critics),
-    # and running one is not a contract violation.
-    optional_roles = {
-        str(worker.get("role", "")).strip()
-        for worker in contract.get("optional_worker_roles", [])
-        if isinstance(worker, dict) and str(worker.get("role", "")).strip()
-    }
-    unexpected_roles = set(by_role) - set(expected_workers) - optional_roles
+    unexpected_roles = set(by_role) - set(expected_workers)
     for role in sorted(unexpected_roles):
         failures.append(f"unexpected worker role detected: {role}")
 
@@ -3273,6 +3309,10 @@ def validate_final_report_data(
                 participating_analysers,
             )
         )
+        failures.extend(
+            f"implementation-option-selection: {error}"
+            for error in validate_blocked_answer_channel(data)
+        )
     elif task_type == "implementation":
         _validate_stage_carry_sidecar_exists(data, report_path, failures)
     _validate_lead_authored_report(data, report_path, failures)