okstra 0.197.0 → 0.198.0

package/runtime/python/okstra_ctl/option_votes.py

@@ -0,0 +1,194 @@
+"""전원 투표만 모자란 구현 후보와, 그 표를 받아야 할 분석자를 낸다.
+
+`implementation-option-selection` 의 1라운드는 설계자들이 병렬로 돌아 서로의
+후보를 보지 못한다. 그래서 자기가 낸 후보에만 실현 가능성 표를 남기고, 병합된
+집합에는 분석자마다 다른 구멍이 생긴다. 유효성 규칙은 전원 투표를 요구하므로
+(`implementation_options._validate_option_feasibility`) 그런 후보는 순위표에
+오르지 못하고, 남는 후보가 하나도 없으면 run 이 `routing: blocked` 로 끝난다 —
+실측(2026-09-10, dev-10629-4): 설계자 3명 로스터에서 IO-001·IO-002·IO-003 이
+각각 `feasible` 2표를 받고도 빠진 분석자가 하나씩 달라 전부 탈락했다.
+
+거절은 그 상태를 알려 줄 뿐 메우지 못한다. 이 명령이 앞으로 가는 길이다:
+표만 모자란 후보를 세고, 어느 분석자에게 어떤 후보를 부쳐야 하는지 말한다.
+재검증(reverify) 라운드는 주장을 반박하는 라운드이지 후보에 표를 남기는
+라운드가 아니므로, 그 구멍을 메우는 디스패치는 리드가 이 목록을 보고 연다.
+
+읽는 자리는 두 가지다. 조립 전이면 작성자 서사(`--narrative`), 이미 발행된
+run 이면 리포트 레코드(`--report`). 로스터는 task-manifest 의
+`recommendedWorkers` 에서 `report-writer` 를 뺀 것이고, 그것이 검증기가
+`participating analysers` 로 쓰는 값과 같은 정의다(`validators/validate-run.py`).
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any
+
+from okstra_ctl.final_report_schema import load_schema_version
+from okstra_ctl.implementation_options import VoteGap, vote_gaps
+from okstra_ctl.json_boundary import JsonBoundaryError, load_owned_object
+from okstra_ctl.report_contract import CURRENT_REPORT_SCHEMA_VERSION
+from okstra_ctl.report_narrative import parse_narrative_structure
+
+
+class OptionVotesError(ValueError):
+    """투표 구멍을 셀 입력이 없거나 읽히지 않는다."""
+
+
+def _record_from_report(path: Path) -> dict[str, Any]:
+    try:
+        return load_owned_object(path, artifact="final-report data.json")
+    except (JsonBoundaryError, OSError) as exc:
+        raise OptionVotesError(f"report record is unreadable: {exc}") from exc
+
+
+def _record_from_narrative(path: Path) -> dict[str, Any]:
+    """작성자 서사를 레코드 모양으로 읽는다.
+
+    값 결함은 무시한다 — 교정 원장이 고칠 자리이고, 표 구멍을 세는 데에는
+    후보 id 와 `feasibilityVotes` 만 있으면 된다. 여기서 서사 전체를 거절하면
+    아직 교정 중인 run 은 이 명령을 쓸 수 없다.
+    """
+    try:
+        markdown = path.read_text(encoding="utf-8")
+    except OSError as exc:
+        raise OptionVotesError(f"narrative is unreadable: {exc}") from exc
+    schema = load_schema_version(CURRENT_REPORT_SCHEMA_VERSION)
+    record, _defects = parse_narrative_structure(markdown, schema)
+    return record
+
+
+def participating_analysers(manifest_path: Path) -> tuple[str, ...]:
+    try:
+        manifest = load_owned_object(manifest_path, artifact="task-manifest")
+    except (JsonBoundaryError, OSError) as exc:
+        raise OptionVotesError(f"task manifest is unreadable: {exc}") from exc
+    roster = manifest.get("recommendedWorkers")
+    if not isinstance(roster, list):
+        raise OptionVotesError("task manifest has no recommendedWorkers roster")
+    return tuple(
+        str(worker) for worker in roster if str(worker) != "report-writer"
+    )
+
+
+def _selection(record: Mapping[str, Any]) -> Mapping[str, Any]:
+    selection = record.get("implementationOptionSelection")
+    if not isinstance(selection, Mapping):
+        raise OptionVotesError(
+            "the source has no implementationOptionSelection block — "
+            "this command reads an implementation-option-selection run"
+        )
+    return selection
+
+
+def _dispatch_lines(gaps: list[VoteGap]) -> list[str]:
+    """분석자별로 부칠 후보 목록. 디스패치 단위가 분석자이기 때문이다."""
+    by_analyser: dict[str, list[str]] = {}
+    for gap in gaps:
+        for analyser in gap.missing:
+            by_analyser.setdefault(analyser, []).append(gap.option_id)
+    return [
+        f"  {analyser}: {', '.join(options)}"
+        for analyser, options in sorted(by_analyser.items())
+    ]
+
+
+def _render(gaps: list[VoteGap]) -> str:
+    if not gaps:
+        return (
+            "No candidate is short of votes alone. A blocked run here is "
+            "blocked by something a vote cannot settle — safety blockers, "
+            "unresolved feasibility facts, or too few feasible verdicts."
+        )
+    lines = [
+        f"{len(gaps)} candidate(s) need only the missing feasibility votes:",
+        "",
+    ]
+    lines += [
+        f"  {gap.option_id}: {gap.feasible_votes} feasible so far, "
+        f"missing {', '.join(gap.missing)}"
+        for gap in gaps
+    ]
+    lines += ["", "Dispatch one vote-completion assignment per analyser:"]
+    lines += _dispatch_lines(gaps)
+    lines += [
+        "",
+        "Each assignment asks that analyser for its own feasibility verdict, "
+        "rationale, and counterevidence on the named candidate — nothing else. "
+        "It generates no candidate, so the run stays in `candidate-comparison` "
+        "mode; `preselected-validation` is a whole-run mode that would collapse "
+        "the comparison to one direction.",
+    ]
+    return "\n".join(lines)
+
+
+def _gaps(args: argparse.Namespace) -> int:
+    if bool(args.report) == bool(args.narrative):
+        raise OptionVotesError("pass exactly one of --report or --narrative")
+    record = (
+        _record_from_report(args.report)
+        if args.report
+        else _record_from_narrative(args.narrative)
+    )
+    gaps = vote_gaps(
+        _selection(record), participating_analysers(args.task_manifest)
+    )
+    if args.json:
+        print(json.dumps(
+            {
+                "gaps": [
+                    {
+                        "optionId": gap.option_id,
+                        "missing": list(gap.missing),
+                        "feasibleVotes": gap.feasible_votes,
+                    }
+                    for gap in gaps
+                ]
+            },
+            ensure_ascii=False,
+            indent=2,
+        ))
+    else:
+        print(_render(gaps))
+    return 0
+
+
+_CLI_DESCRIPTION = (
+    "Report the implementation candidates that only lack feasibility votes, "
+    "and which analyser owes each one."
+)
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description=_CLI_DESCRIPTION, prog="okstra option-votes"
+    )
+    subparsers = parser.add_subparsers(dest="command", required=True)
+    gaps_parser = subparsers.add_parser("gaps")
+    gaps_parser.add_argument(
+        "--task-manifest", type=Path, required=True,
+        help="the task's task-manifest.json — its roster names the analysers")
+    gaps_parser.add_argument(
+        "--report", type=Path,
+        help="a published final-report `.data.json`")
+    gaps_parser.add_argument(
+        "--narrative", type=Path,
+        help="the report writer's narrative markdown, before assembly")
+    gaps_parser.add_argument("--json", action="store_true")
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = _parser().parse_args(argv)
+    try:
+        return _gaps(args)
+    except OptionVotesError as exc:
+        print(f"okstra option-votes: {exc}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))

package/runtime/python/okstra_ctl/report_assembly.py

@@ -24,6 +24,7 @@ from .report_synthesis_packet import (
 )
 from .conformance import strip_stage_declaration_label
 from .design_prep import DesignPrepError, materialize_design_prep_requests
+from .implementation_options import validate_blocked_answer_channel
 from .implementation_direction import (
     load_selected_direction_snapshot,
     validate_selected_direction_plan,
@@ -453,6 +454,15 @@ def _compose(
     data["tokenUsage"] = usage
     data["crossVerification"] = convergence_data["crossVerification"]
     data["clarificationItems"] = _clarifications(ledger, activities, inputs["approval-decisions"].path)
+    # 차단된 option-selection 은 발행 전에 답변 채널을 갖춰야 한다. 발행 뒤에는
+    # 이 원장을 다시 읽는 경로가 없어 사용자에게 질문이 0건으로 보인다.
+    for reason in validate_blocked_answer_channel(data):
+        _fail(
+            "lead",
+            inputs["approval-decisions"].path,
+            "activeClarifications",
+            reason,
+        )
     carry_in = _clarification_carry_in(project_root, manifest, manifest_path)
     if carry_in is not None:
         data["clarificationCarryIn"] = carry_in

package/runtime/python/okstra_ctl/run.py

@@ -3631,6 +3631,23 @@ def _stage_or_clear(path: Path, body: str) -> None:
     path.unlink(missing_ok=True)
 
 
+def _refresh_group_context_queue(project_root: Path, task_group: str) -> None:
+    """그룹 문서의 시작 순서를 지금 값으로 다시 그린다. 실패해도 run 은 계속한다.
+
+    파생 표면이라 이것 때문에 run 준비를 멈출 이유가 없다. 대신 삼키지 않고
+    stderr 로 알린다 — 워커가 낡은 형제 상태를 읽었다는 사실을 나중에 설명할
+    근거가 남아야 한다.
+    """
+    try:
+        group_context.refresh_group_queue(project_root, task_group)
+    except (OSError, ValueError) as exc:
+        print(
+            f"prepare: group-context start order for {task_group!r} could not be "
+            f"redrawn before it was copied into the instruction set: {exc}",
+            file=sys.stderr,
+        )
+
+
 def _write_instruction_set_sources(
     inp: PrepareInputs,
     ctx: dict,
@@ -3694,6 +3711,12 @@ def _write_instruction_set_sources(
     (instruction_set / "analysis-material.md").write_text(review_material, encoding="utf-8")
     shutil.copyfile(inp.brief_path, instruction_set / "task-brief.md")
     # 그룹 맥락은 preflight 를 통과한 파일만 여기 온다(`_validate_group_context_preflight`).
+    #
+    # 복사 직전에 시작 순서를 다시 그린다. 이 파일은 그대로 워커의 analysis
+    # packet 에 실리므로, 형제 task 의 상태가 낡은 채로 복사되면 워커는 이미 끝난
+    # task 를 진행 중으로 읽는다. 투영을 쓰는 곳이 report-finalize 뿐이던 동안
+    # 리포트 없이 끝난 run 의 상태는 다음 finalize 까지 문서에 닿지 않았다.
+    _refresh_group_context_queue(Path(inp.project_root), inp.task_group)
     group_context_source = group_context.group_context_file(
         Path(inp.project_root), inp.task_group
     )

package/runtime/python/okstra_ctl/set_work_status.py

@@ -14,6 +14,7 @@ import sys
 from datetime import datetime, timezone
 from pathlib import Path
 
+from okstra_ctl import group_context
 from okstra_ctl.ids import slugify_task_segment
 from okstra_ctl.fixed_text import line, scalar
 from okstra_ctl.paths import task_dir, task_manifest_file
@@ -38,6 +39,7 @@ def _emit(payload: dict, *, text: bool = False) -> None:
         ("taskKey", "Task key"), ("previousWorkStatus", "Previous work status"),
         ("workStatus", "Work status"), ("workStatusUpdatedAt", "Updated at"),
         ("workStatusNote", "Note"), ("taskManifestPath", "Task manifest"),
+        ("groupContextPath", "Group context"),
     ):
         if key in payload:
             lines.append(line(label, payload.get(key)).rstrip("\n"))
@@ -152,6 +154,29 @@ def _updated_payload(manifest_path: Path, manifest: dict, entry: dict, args) ->
     }
 
 
+def _refresh_group_queue(project_root: Path, entry: dict) -> str:
+    """상태를 바꾼 task 가 속한 그룹 문서의 시작 순서를 다시 그린다.
+
+    그 투영을 쓰는 곳이 report-finalize 하나뿐이라, 여기서 갱신하지 않으면
+    사람이 적은 상태가 다음 finalize 까지 그룹 문서에 닿지 않는다. 그룹 문서가
+    없거나 갱신에 실패해도 상태 기록 자체는 성공이다 — 매니페스트는 이미
+    쓰였고, 이것은 파생 표면이다. 실패는 삼키지 않고 stderr 로 알린다.
+    """
+    task_group = str(entry.get("taskGroup") or "")
+    if not task_group:
+        return ""
+    try:
+        target = group_context.refresh_group_queue(project_root, task_group)
+    except (OSError, ValueError) as exc:
+        print(
+            f"set-work-status: work status recorded, but the group-context start "
+            f"order for {task_group!r} could not be redrawn: {exc}",
+            file=sys.stderr,
+        )
+        return ""
+    return str(target) if target is not None else ""
+
+
 def main(argv: list[str] | None = None) -> int:
     args = _parse_args(argv)
     project_root, entry, resolution_exit = _resolve_entry(args)
@@ -184,7 +209,11 @@ def main(argv: list[str] | None = None) -> int:
         )
         return 1
 
-    _emit(_updated_payload(manifest_path, manifest, entry, args), text=args.text)
+    payload = _updated_payload(manifest_path, manifest, entry, args)
+    refreshed = _refresh_group_queue(project_root, entry)
+    if refreshed:
+        payload["groupContextPath"] = refreshed
+    _emit(payload, text=args.text)
     return 0
 
 

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/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,
 )
@@ -222,6 +223,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/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)"