okstra 0.197.0 → 0.198.0

package/runtime/python/okstra_ctl/convergence_reverify_prompt.py

@@ -61,12 +61,17 @@ is wrong, overstated, or unproven. Then respond with exactly one verdict:
   - counter-evidence — you found contradicting evidence (give file:line or log line), OR
   - burden-not-met — you re-inspected the cited evidence and could neither confirm
     nor refute it (the claim has not proven itself).
-- **SURVIVES**: You actively tried to refute it and failed — the claim withstood the attack.
+- **SURVIVES**: You actively tried to refute it and failed — the claim withstood the
+  attack. Name the attack you tried and why it failed.
 - **SURVIVES-WITH-CAVEAT**: It holds, but a scope limit / extra condition / missing
   precondition exists (state it).
 - **UNVERIFIABLE**: Capability, credential, network, or service state prevents you
   from opening or reproducing the cited evidence. Do not use REFUTED as a substitute.
 
+Every verdict carries an `**Explanation**`, SURVIVES included — it is what you did,
+not what the verdict already says. Only `**Basis**` is conditional. A block with a
+verdict and no explanation is not collected and the whole response is refused.
+
 The burden of proof is on the claim. If after inspecting the cited evidence you remain
 uncertain, your verdict is REFUTED with basis = burden-not-met.
 
@@ -82,6 +87,10 @@ For EACH finding, respond with exactly one verdict:
 - **UNVERIFIABLE**: Capability, credential, network, or service state prevents you
   from checking this finding. Explain the unavailable capability; do not substitute DISAGREE.
 
+Every verdict carries an `**Explanation**`, AGREE included — name the evidence you
+checked. A block with a verdict and no explanation is not collected and the whole
+response is refused.
+
 Do NOT re-analyze the original source materials. Judge based on the evidence provided."""
 
 # 근거 접근 규칙. `**Cited evidence**` 는 리드의 요약이고, 완전한 인용은 원 워커의
@@ -98,11 +107,13 @@ the summary line alone."""
 ADVERSARIAL_RESPONSE = """### <finding-id>
 **Verdict**: REFUTED | SURVIVES | SURVIVES-WITH-CAVEAT | UNVERIFIABLE
 **Basis** (only if REFUTED): counter-evidence | burden-not-met
-**Explanation**: <2-3 sentences; for counter-evidence include the file:line you found>"""
+**Explanation** (required for every verdict, SURVIVES included): <2-3 sentences; for
+SURVIVES say what you attacked and why the attack failed; for counter-evidence include
+the file:line you found>"""
 
 _COLLABORATIVE_RESPONSE = """### <finding-id>
 **Verdict**: AGREE | DISAGREE | SUPPLEMENT | UNVERIFIABLE
-**Explanation**: <2-3 sentences>"""
+**Explanation** (required for every verdict, AGREE included): <2-3 sentences>"""
 
 
 def _nonempty_string(value: Any) -> str:

package/runtime/python/okstra_ctl/convergence_store.py

@@ -42,6 +42,38 @@ _CRITIC_BATCH_SCHEMA = {
 }
 
 
+# acceptance 모드는 coverage 의 gap 어휘를 쓰지 않는다 — 후보 하나에 대한 판정이
+# `confirmed`/`downgraded` 둘뿐이고, 회계는 이 배치를 읽는 쪽이 센다.
+_ACCEPTANCE_BATCH_SCHEMA = {
+    "type": "object",
+    "required": [
+        "schemaVersion", "taskKey", "mode", "provider",
+        "modelExecutionValue", "candidates",
+    ],
+    "additionalProperties": False,
+    "properties": {
+        "schemaVersion": {"const": "1.0"},
+        "taskKey": {"type": "string", "pattern": "\\S"},
+        "mode": {"const": "acceptance-devils-advocate"},
+        "provider": {"type": "string", "pattern": "\\S"},
+        "modelExecutionValue": {"type": "string", "pattern": "\\S"},
+        "candidates": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "required": ["candidateId", "verdict"],
+                "additionalProperties": False,
+                "properties": {
+                    "candidateId": {"type": "string", "pattern": "\\S"},
+                    "verdict": {"enum": ["confirmed", "downgraded"]},
+                    "statement": {"type": "string"},
+                },
+            },
+        },
+    },
+}
+
+
 def load_owned_json_object(path: Path) -> dict[str, Any]:
     try:
         return load_owned_object(path, artifact="convergence artifact")
@@ -71,6 +103,10 @@ def load_convergence_critic_batch(path: Path) -> dict[str, Any]:
     return _load_convergence_result(path, schema=_CRITIC_BATCH_SCHEMA)
 
 
+def load_acceptance_critic_batch(path: Path) -> dict[str, Any]:
+    return _load_convergence_result(path, schema=_ACCEPTANCE_BATCH_SCHEMA)
+
+
 def load_json_object(path: Path) -> dict[str, Any]:
     """Compatibility alias for convergence artifacts owned by okstra."""
     return load_owned_json_object(path)

package/runtime/python/okstra_ctl/dispatch_core.py

@@ -1988,7 +1988,9 @@ def _outcome_from_completed(handle: WorkerHandle) -> WorkerOutcome:
 
 
 def _artifact_defects(job: WorkerJob) -> tuple[str, ...]:
-    defect = unusable_result_defect(job.worker_id, job.result_path)
+    defect = unusable_result_defect(
+        job.worker_id, job.result_path, job.dispatch_kind,
+    )
     return (defect,) if defect else ()
 
 
@@ -3228,9 +3230,12 @@ def _record_missing_completion_paths(record: Mapping[str, Any]) -> tuple[Path, .
     worker_result = Path(_string_value(record.get("workerResultPath")))
     missing: list[Path] = []
     worker_id = _dispatch_worker_key(record)
+    dispatch_kind = _string_value(record.get("dispatchKind"))
     for path in _record_completion_paths(record):
         if path.is_file():
-            if path == result_path and unusable_result_defect(worker_id, path):
+            if path == result_path and unusable_result_defect(
+                worker_id, path, dispatch_kind,
+            ):
                 missing.append(path)
             continue
         if path in {result_path, worker_result} and any(alias.is_file() for alias in aliases):
@@ -3241,7 +3246,9 @@ def _record_missing_completion_paths(record: Mapping[str, Any]) -> tuple[Path, .
 
 def _record_artifact_defects(record: Mapping[str, Any]) -> tuple[str, ...]:
     defect = unusable_result_defect(
-        _dispatch_worker_key(record), Path(_string_value(record.get("resultPath")))
+        _dispatch_worker_key(record),
+        Path(_string_value(record.get("resultPath"))),
+        _string_value(record.get("dispatchKind")),
     )
     return (defect,) if defect else ()
 

package/runtime/python/okstra_ctl/dispatch_state.py

@@ -54,6 +54,7 @@ from .execution_mutation_audit import ExecutionMutationAudit, MutationSnapshot
 from .final_report_paths import final_report_data_path
 from .report_inputs import report_narrative_path, uses_report_contract_v3
 from .report_narrative import narrative_structure_defect
+from .verdict_blocks import finding_vote_defect
 from .worker_prompt_body import REPORT_WRITER_WORKER_ID
 from .worker_prompt_contract import (
     PromptRecord,
@@ -1642,16 +1643,39 @@ def dispatch_mode(jobs: Sequence[WorkerJob]) -> str:
     return BACKEND_MIXED
 
 
-def unusable_result_defect(worker_id: str, result_path: Path) -> str | None:
-    """산출물이 있어도 소비자가 읽을 수 없으면 없는 것이다 — 지금은 서사 한 종류.
+def unusable_result_defect(
+    worker_id: str, result_path: Path, dispatch_kind: str = "",
+) -> str | None:
+    """산출물이 있어도 소비자가 읽을 수 없으면 없는 것이다 — 서사와 재검증 표.
 
     report-writer 의 서사가 줄 문법을 어기면(frontmatter·헤딩으로 된 보통
     보고서) 조립이 Phase 7 에서 거절하고, 그때는 배치의 재시도가 이미 지나
     리드가 손으로 재저작을 띄워야 한다 — 실측(2026-09-09, jobs implementation
     stage-2)에서 리드는 그것을 하지 않고 run 을 닫았다. 수집 시점에 "없는
     산출물" 로 세면 `_should_retry` 가 같은 배치 안에서 다시 띄운다.
+
+    재검증(`reverify-r<N>`) 결과도 같은 자리에 있다. `okstra convergence
+    collect-results` 는 표로 읽히지 않는 결과를 거절하는데, 원장은 그 attempt 를
+    `ok` 로 닫아 두므로 그 워커를 빼고 수집하면 `apply-round` 가 "missing vote
+    for completed worker" 로 막는다. 즉 리드에게 남는 수가 없다 — 실측
+    (2026-09-10, fontsninja-v3-site dev-10631 implementation-option-selection):
+    antigravity 가 35건 중 34건의 `**Explanation**` 을 빼먹었고 run 이 그 자리에
+    멈췄다. 여기서 결함으로 세면 재시도가 배치 안에서 돌고, 그마저 실패하면
+    attempt 가 실패로 닫혀 `collect-results` 가 그 워커를 `error` 로 적는다 —
+    엔진은 그 표를 `verification-error` 로 기록하고 라운드는 진행한다.
     """
-    if worker_id != REPORT_WRITER_WORKER_ID or not result_path.is_file():
+    if not result_path.is_file():
+        return None
+    if dispatch_kind.startswith("reverify-r"):
+        try:
+            text = result_path.read_text(encoding="utf-8")
+        except (OSError, UnicodeDecodeError) as exc:
+            return f"reverify result is unreadable: {exc}"
+        defect = finding_vote_defect(text)
+        if defect is None:
+            return None
+        return f"reverify result does not parse: {defect}"
+    if worker_id != REPORT_WRITER_WORKER_ID:
         return None
     try:
         text = result_path.read_text(encoding="utf-8")
@@ -1667,7 +1691,9 @@ def missing_completion_paths(job: WorkerJob) -> tuple[Path, ...]:
     missing: list[Path] = []
     for path in job.completion_paths:
         if path.is_file():
-            if path == job.result_path and unusable_result_defect(job.worker_id, path):
+            if path == job.result_path and unusable_result_defect(
+                job.worker_id, path, job.dispatch_kind,
+            ):
                 missing.append(path)
             continue
         # reports seq 와 workerResults seq 가 갈라지면 워커는 다른 쪽

package/runtime/python/okstra_ctl/group_context.py

@@ -70,7 +70,8 @@ _NONE_MARKERS = {"_(none)_", ""}
 MEMORY_BEGIN = "<!-- okstra:task-memory:begin -->"
 MEMORY_END = "<!-- okstra:task-memory:end -->"
 MEMORY_NOTE = (
-    "<!-- okstra rewrites this region at every report-finalize. "
+    "<!-- okstra redraws this region after every report-finalize, at "
+    "`okstra set-work-status`, and before each run copies this file. "
     "Edit the sections above it, not this one. -->"
 )
 MEMORY_HEADING = "## Task Memory"
@@ -323,6 +324,32 @@ def record_task_memory(
     return target, queue
 
 
+def refresh_group_queue(project_root: Path, task_group: str) -> Path | None:
+    """그룹 문서의 시작 순서만 지금 값으로 다시 그린다. 문서가 없으면 아무것도 안 한다.
+
+    기록된 항목과 사람 절은 바이트 그대로 두고 큐만 다시 계산한다. 이 투영을
+    쓰는 곳은 원래 report-finalize 의 `record-group-memory` 하나뿐이라, 리포트
+    없이 끝난 run 이나 사람이 손으로 바꾼 상태는 다음 finalize 까지 문서에
+    닿지 않았다(2026-09-10 실측, cache 그룹 dev-10635: `workStatus` 를 done 으로
+    적었는데 큐는 `[in progress] — requirements-discovery (blocked)` 그대로).
+    같은 그룹의 finalize 와 겹칠 수 있으므로 같은 flock 아래에서 읽고-쓴다.
+    """
+    target = group_context_file(project_root, task_group)
+    if not target.is_file():
+        return None
+    with dir_flock(target.parent, LOCK_FILENAME):
+        text = target.read_text(encoding="utf-8")
+        before, region, after = split_memory_region(text)
+        if not region:
+            return None
+        entries = parse_memory_entries(region)
+        queue = group_queue(project_root, task_group, entries)
+        updated = before + render_memory_region(entries, queue) + after
+        if updated != text:
+            target.write_text(updated, encoding="utf-8")
+    return target
+
+
 # --- 시작 순서 ----------------------------------------------------------------
 #
 # 그룹의 task 는 순서가 있을 수 있다. 순서는 brief-gen 이 매긴 브리프 순번
@@ -332,6 +359,11 @@ def record_task_memory(
 # 15번 가드 티켓이 1번을 `blocks` 한다고 적었지만 사용자는 1번을 먼저 끝냈다.
 # 큐는 영역 머리에 실리고, 이 task 가 끝나는 closeout 은 큐의 다음 task 를 이름한다.
 
+# `okstra set-work-status` 가 task-manifest 에 적는 값 중 큐 상태를 덮는 것.
+# 나머지(`todo` / `in-progress` / `blocked`)는 큐의 세 상태로 옮길 때 파생값보다
+# 나은 정보가 없어 덮지 않는다.
+WORK_STATUS_DONE = "done"
+
 QUEUE_DONE = "done"
 QUEUE_IN_PROGRESS = "in progress"
 QUEUE_NOT_STARTED = "not started"
@@ -354,6 +386,9 @@ class QueueRow:
     status: str         # QUEUE_*
     progress: str       # "<task-type> #<seq>" for a recorded task, else ""
     waits_for: tuple[str, ...] = ()   # ticket ids the graph says come first and are not done
+    # 같은 `brief-id` 를 가진 다른 브리프 파일들. 하나의 task 를 두 파일이
+    # 주장하는 상태이므로 큐는 정본 한 줄만 싣고 나머지를 여기 이름한다.
+    duplicate_briefs: tuple[str, ...] = ()
 
 
 def group_briefs(project_root: Path, task_group: str) -> list[dict[str, Any]]:
@@ -417,6 +452,15 @@ def catalog_progress(project_root: Path, task_group: str) -> dict[str, tuple[str
         state = str(entry.get("currentPhaseState") or entry.get("latestRunStatus") or "")
         progress = f"{phase} ({state})" if phase and state else phase
         status = QUEUE_DONE if pointer.get("status") == STATUS_TERMINAL else QUEUE_IN_PROGRESS
+        # 사용자가 `okstra set-work-status <task> done` 으로 끝났다고 선언한 task
+        # 는 끝난 것이다. 파생 포인터만 보면 리포트 없이 끝난 run 이 영원히
+        # `[in progress]` 로 남는다 — 실측(2026-09-10, fontsninja-v3-site cache
+        # 그룹 dev-10635): 사람이 AWS 콘솔에서 작업을 마치고 `done` 을 적었는데,
+        # 그 run 이 리포트 조립 실패로 끝나 포인터가 `blocked` 에 멈춰 있었다.
+        # 파생 표기는 지우지 않는다 — 왜 done 인지가 그 차이에 남는다.
+        if str(entry.get("workStatus") or "") == WORK_STATUS_DONE:
+            status = QUEUE_DONE
+            progress = f"{progress} · marked done" if progress else "marked done"
         out[task_id] = (status, progress)
     return out
 
@@ -439,6 +483,7 @@ def group_queue(
     for brief in briefs:
         for ticket, before in brief["waits_for"].items():
             waits.setdefault(ticket, set()).update((before & by_ticket.keys()) - {ticket})
+    briefs, duplicates = _fold_duplicate_briefs(briefs)
     ordered = sorted(briefs, key=lambda b: (b["ordinal"] is None, b["ordinal"] or 0, b["brief_id"]))
     by_task = {entry.task_id: entry for entry in entries}
     recorded = catalog_progress(project_root, task_group)
@@ -464,10 +509,50 @@ def group_queue(
         rows.append(QueueRow(
             slugify_task_segment(brief["brief_id"]), brief["brief_id"], brief["ticket_id"],
             brief["brief"], status, progress, open_waits,
+            duplicates.get(brief["brief_id"], ()),
         ))
     return rows
 
 
+def _fold_duplicate_briefs(
+    briefs: list[dict[str, Any]],
+) -> tuple[list[dict[str, Any]], dict[str, tuple[str, ...]]]:
+    """같은 `brief-id` 를 주장하는 브리프들을 정본 하나로 접는다.
+
+    `brief-id` 는 task 디렉터리 이름(`task_id`)의 출처라, 두 파일이 같은 id 를
+    달면 하나의 task 를 둘이 주장하는 상태다. 접지 않으면 큐가 같은 task 를 두
+    줄로 싣고 번호가 브리프 수보다 커진다 — `next_in_group` 과 closeout 도 같은
+    task 를 두 번 가리킨다(2026-09-10 실측, fontsninja-v3-site `cache` 그룹:
+    개정 전 브리프를 `.superseded-<날짜>.md` 로 같은 디렉터리에 남겨 15개 그룹의
+    큐가 16번까지 갔다).
+
+    정본은 파일 이름이 곧 `brief-id` 인 파일이다 — brief-gen 이 쓰는 이름이고,
+    같은 id 를 단 다른 이름은 사본이다. 그런 파일이 없거나 여럿이면 경로 순서로
+    첫 번째다. 거절하지 않는 이유는 이 큐를 report-finalize 와 위저드가 읽기
+    때문이다: 브리프 디렉터리 정리가 안 됐다고 run 발행을 막을 일은 아니다.
+    대신 남은 사본을 `duplicate_briefs` 로 실어 큐가 그 사실을 말한다.
+    """
+    by_id: dict[str, list[dict[str, Any]]] = {}
+    for brief in briefs:
+        by_id.setdefault(brief["brief_id"], []).append(brief)
+    kept: list[dict[str, Any]] = []
+    duplicates: dict[str, tuple[str, ...]] = {}
+    for brief_id, group in by_id.items():
+        if len(group) == 1:
+            kept.append(group[0])
+            continue
+        ordered_group = sorted(group, key=lambda b: b["brief"])
+        canonical = next(
+            (b for b in ordered_group if Path(b["brief"]).stem == brief_id),
+            ordered_group[0],
+        )
+        kept.append(canonical)
+        duplicates[brief_id] = tuple(
+            b["brief"] for b in ordered_group if b is not canonical
+        )
+    return kept, duplicates
+
+
 def next_in_group(queue: list[QueueRow]) -> QueueRow | None:
     """시작 순서에서 아직 시작하지 않은 첫 task."""
     return next((row for row in queue if row.status == QUEUE_NOT_STARTED), None)
@@ -482,6 +567,13 @@ def render_queue(queue: list[QueueRow]) -> str:
         if row.waits_for:
             tail += f" (waits for {', '.join(row.waits_for)})"
         lines.append(f"{number}. [{row.status}] {row.task_id}{tail}")
+        # 사본을 이름한다. 이 줄이 없으면 큐가 조용히 한 파일을 무시하고, 그
+        # 파일을 고친 사람은 자기 편집이 어디로 갔는지 알 길이 없다.
+        for extra in row.duplicate_briefs:
+            lines.append(
+                f"   - ignored duplicate of this brief-id: `{extra}` — one task, "
+                "two brief files. Move the copy out of the briefs directory."
+            )
     return "\n".join(lines) + "\n"
 
 
@@ -657,8 +749,9 @@ def _init_command(args: argparse.Namespace) -> int:
         "line remains; delete the file if the group needs no context."
     )
     print(
-        f"The trailing `{MEMORY_HEADING}` region is written by okstra at every "
-        "report-finalize; leave it alone."
+        f"The trailing `{MEMORY_HEADING}` region is okstra's — redrawn after every "
+        "report-finalize, at `okstra set-work-status`, and before each run copies "
+        "this file; leave it alone."
     )
     return 0
 

package/runtime/python/okstra_ctl/implementation_options.py

@@ -6,9 +6,14 @@ import hashlib
 import json
 import re
 from collections import Counter
+from dataclasses import dataclass
 from collections.abc import Mapping, Sequence
 from typing import Any
 
+from .clarification_items.dispositions import (
+    USER_INPUT_BLOCKS,
+    progress_blocking_ids,
+)
 from .exact_coverage import ExactCoverageError, calculate_exact_coverage
 
 
@@ -361,6 +366,124 @@ def _validate_option_count_and_routing(
         errors.append("recommendedOptionId must name the first ranked option")
 
 
+@dataclass(frozen=True)
+class VoteGap:
+    """전원 투표만 모자란 후보 하나와, 표를 받아야 할 분석자."""
+
+    option_id: str
+    missing: tuple[str, ...]
+    feasible_votes: int
+
+
+def vote_gaps(
+    selection: Mapping[str, object],
+    participating_analysers: Sequence[str],
+) -> list[VoteGap]:
+    """표만 채우면 살아날 후보 — 유효성 규칙을 거꾸로 읽는다.
+
+    1라운드의 설계자들은 병렬로 돌아 서로의 후보를 보지 못한다. 그래서 자기가
+    낸 후보에만 표를 남기고, 병합된 집합에는 분석자마다 다른 구멍이 생긴다.
+    `_validate_option_feasibility` 의 전원 투표 조항은 그 상태를 조립 시점에
+    거절할 뿐 메우지 못한다 — 실측(2026-09-10, dev-10629-4): 설계자 3명 로스터에서
+    IO-001·IO-002·IO-003 이 각각 `feasible` 2표를 받고도 빠진 분석자가 하나씩
+    달라 전부 탈락했고, 그 run 은 후보 0건으로 차단됐다.
+
+    여기서 세는 것은 **표만 모자란** 후보다. `safetyBlockers` 나
+    `unresolvedFeasibilityFacts` 가 있거나 베낀 표가 있으면 표를 더 받아도
+    유효해지지 않으므로 제외한다. 남은 표를 다 받아도 `feasible` 이
+    `MIN_FEASIBLE_VOTES` 에 못 미치는 후보도 제외한다 — 부쳐 봐야 결과가
+    같다.
+    """
+    roster = list(dict.fromkeys(str(name) for name in participating_analysers))
+    gaps: list[VoteGap] = []
+    for candidate in (
+        row
+        for key in ("rankedOptions", "candidateAudit")
+        for row in (selection.get(key) or ())
+        if isinstance(row, Mapping)
+    ):
+        if candidate.get("safetyBlockers") or candidate.get(
+            "unresolvedFeasibilityFacts"
+        ):
+            continue
+        votes = candidate.get("feasibilityVotes") or ()
+        if _copied_votes(votes):
+            continue
+        voted = [str(vote.get("worker")) for vote in votes if isinstance(vote, Mapping)]
+        if len(voted) != len(set(voted)):
+            continue
+        missing = tuple(name for name in roster if name not in set(voted))
+        if not missing or set(voted) - set(roster):
+            continue
+        feasible = sum(
+            isinstance(vote, Mapping) and vote.get("verdict") == "feasible"
+            for vote in votes
+        )
+        if feasible + len(missing) < MIN_FEASIBLE_VOTES:
+            continue
+        gaps.append(
+            VoteGap(
+                option_id=str(candidate.get("id") or "?"),
+                missing=missing,
+                feasible_votes=feasible,
+            )
+        )
+    return gaps
+
+
+def validate_blocked_answer_channel(
+    report_data: Mapping[str, object],
+) -> list[str]:
+    """차단된 run 이 사용자가 답할 자리를 남겼는지.
+
+    `routing: blocked` 는 목적지가 없는 유일한 종료 상태다. 그 차단이
+    `unresolvedFeasibilityFacts` 때문이면 — 값이 미정이다, 계약이 없다,
+    리포터 확인이 필요하다 — 푸는 사람은 사용자인데, 답변 채널은
+    `clarificationItems[]` 하나뿐이다. 조립은 그 배열을 승인 결정 원장에서만
+    읽고(`report_assembly._clarifications`), `okstra user-response` 는 발행된
+    리포트의 그 배열만 읽는다(`user_response._record_clarification_rows`).
+    그래서 미해결 사실이 산문으로만 남으면 run 은 "사용자를 기다림" 상태로
+    발행되고 사용자에게는 답할 항목이 0건으로 보인다(2026-09-10 실측,
+    dev-10630: 후보 5개 전부 미해결 사실을 달고 원장은 빈 배열).
+
+    앞으로 가는 길은 원장에 행을 여는 것이다 —
+    `okstra approval-decision open --ledger <approvalDecisionsPath>` 를 행마다
+    한 번. 미해결 사실이 없는 차단(워커가 결과를 못 냈다 같은 실행 차단)은
+    사용자가 답할 것이 없으므로 이 검사에 걸리지 않는다.
+
+    `clarificationItems[]` 는 리드 소유라 작성자 서사에는 없다. 그래서 이
+    검사는 조립이 끝난 리포트 레코드 전체를 받고
+    `validate_implementation_option_selection`(작성자 소유 의미론) 과 따로
+    선다 — 교정 루프의 semantic validator 에 묶으면 원장에 행이 있어도 매번
+    발화한다.
+    """
+    selection = report_data.get("implementationOptionSelection")
+    if not isinstance(selection, Mapping):
+        return []
+    if selection.get("routing") != NO_VALID_OPTIONS_ROUTING:
+        return []
+    unresolved = [
+        str(candidate.get("id"))
+        for key in ("rankedOptions", "candidateAudit")
+        for candidate in (selection.get(key) or ())
+        if isinstance(candidate, Mapping)
+        and candidate.get("unresolvedFeasibilityFacts")
+    ]
+    if not unresolved:
+        return []
+    if progress_blocking_ids(
+        report_data.get("clarificationItems"), USER_INPUT_BLOCKS
+    ):
+        return []
+    return [
+        "blocked routing leaves the user no answer channel: "
+        f"{', '.join(unresolved)} carry unresolvedFeasibilityFacts and no open "
+        "clarification row asks them — open one decision row per answerable "
+        "fact with `okstra approval-decision open --ledger "
+        "<approvalDecisionsPath>`, then reassemble"
+    ]
+
+
 def _validate_candidate_audit(
     data: Mapping[str, object],
     options: Sequence[Mapping[str, object]],