okstra 0.205.1 → 0.206.1

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

@@ -12,7 +12,6 @@ from okstra_ctl.analysis_inputs import (
     AnalysisReportCandidate,
     list_evidence_candidates,
     load_analysis_report_candidate,
-    resolve_analysis_target,
     resolve_evidence_inputs,
 )
 from okstra_ctl.design_prep import (
@@ -25,13 +24,9 @@ from okstra_ctl.design_prep import (
 from .ids import (
     PICK_SKIP,
     PICK_TYPE_CUSTOM,
-    S_ANALYSIS_TARGET,
-    S_ANALYSIS_TARGET_PICK,
     S_DESIGN_PREP_CONFIRM,
     S_DESIGN_PREP_DECISION,
     S_DESIGN_PREP_OVERRIDES,
-    S_FEATURE_EVIDENCE,
-    S_FEATURE_EVIDENCE_PICK,
     S_PROJECT_EVIDENCE,
     S_PROJECT_EVIDENCE_PICK,
     _RESUME_REUSE_PHASES,
@@ -128,32 +123,6 @@ def _submit_analysis_evidence_pick(
     return t["echo_variants"]["selected"].format(path=candidate.report_path)
 
 
-def _build_feature_evidence_pick(state: WizardState) -> Prompt:
-    return _build_analysis_evidence_pick(
-        state, step=S_FEATURE_EVIDENCE_PICK, relation="feature-baseline"
-    )
-
-
-def _submit_feature_evidence_pick(state: WizardState, value: str) -> Optional[str]:
-    return _submit_analysis_evidence_pick(
-        state, value, step=S_FEATURE_EVIDENCE_PICK,
-        field_name="feature_evidence_path",
-        pending_name="feature_evidence_pending_text",
-    )
-
-
-def _build_feature_evidence(state: WizardState) -> Prompt:
-    t = _p(state.workspace_root, S_FEATURE_EVIDENCE)
-    return Prompt(step=S_FEATURE_EVIDENCE, kind="text", label=t["label"],
-                  echo_template=t["echo_template"])
-
-
-def _submit_feature_evidence(state: WizardState, value: str) -> Optional[str]:
-    candidate = _accept_analysis_evidence(state, value, "feature_evidence_path")
-    state.feature_evidence_pending_text = False
-    return f"feature-evidence: {candidate.report_path}"
-
-
 def _build_project_evidence_pick(state: WizardState) -> Prompt:
     return _build_analysis_evidence_pick(
         state, step=S_PROJECT_EVIDENCE_PICK, relation="project-context"
@@ -181,72 +150,6 @@ def _submit_project_evidence(state: WizardState, value: str) -> Optional[str]:
     return f"project-evidence: {candidate.report_path}"
 
 
-def _feature_description(feature: dict[object, object]) -> str:
-    name = str(feature.get("name") or "")
-    summary = str(feature.get("summary") or "")
-    entry_point = str(
-        feature.get("entryPoint") or feature.get("entrypoint") or ""
-    )
-    return " · ".join(value for value in (name, summary, entry_point) if value)
-
-
-def _build_analysis_target_pick(state: WizardState) -> Prompt:
-    t = _p(state.workspace_root, S_ANALYSIS_TARGET_PICK)
-    try:
-        candidate = load_analysis_report_candidate(
-            Path(state.project_root), Path(state.project_evidence_path)
-        )
-    except AnalysisInputError as exc:
-        raise WizardError(str(exc)) from exc
-    options = [
-        _opt(str(feature["id"]), str(feature["id"]), _feature_description(feature))
-        for feature in candidate.feature_index
-        if isinstance(feature, dict) and isinstance(feature.get("id"), str)
-    ][:3]
-    options.append(_opt(PICK_TYPE_CUSTOM, t["options"][PICK_TYPE_CUSTOM]))
-    return Prompt(step=S_ANALYSIS_TARGET_PICK, kind="pick", label=t["label"],
-                  options=options, echo_template=t["echo_template"])
-
-
-def _accept_analysis_target(state: WizardState, value: str) -> str:
-    candidates: dict[Path, AnalysisReportCandidate] = {}
-    for path in _analysis_evidence_paths(state):
-        try:
-            candidate = load_analysis_report_candidate(Path(state.project_root), path)
-        except AnalysisInputError as exc:
-            raise WizardError(str(exc)) from exc
-        candidates[candidate.report_path] = candidate
-    try:
-        target = resolve_analysis_target(
-            value, _resolve_analysis_evidence(state), candidates
-        )
-    except AnalysisInputError as exc:
-        raise WizardError(str(exc)) from exc
-    requested_value = target["requestedValue"]
-    if not isinstance(requested_value, str):
-        raise WizardError("analysis target resolver returned an invalid requestedValue")
-    state.analysis_target = requested_value
-    state.analysis_target_pending_text = False
-    return requested_value
-
-
-def _submit_analysis_target_pick(state: WizardState, value: str) -> Optional[str]:
-    if value == PICK_TYPE_CUSTOM:
-        state.analysis_target_pending_text = True
-        return None
-    return f"analysis-target: {_accept_analysis_target(state, value)}"
-
-
-def _build_analysis_target(state: WizardState) -> Prompt:
-    t = _p(state.workspace_root, S_ANALYSIS_TARGET)
-    return Prompt(step=S_ANALYSIS_TARGET, kind="text", label=t["label"],
-                  echo_template=t["echo_template"])
-
-
-def _submit_analysis_target(state: WizardState, value: str) -> Optional[str]:
-    return f"analysis-target: {_accept_analysis_target(state, value)}"
-
-
 def _design_prep_items_by_id(state: WizardState) -> dict[str, dict[str, Any]]:
     try:
         items = load_design_prep_items(Path(state.approved_plan_path))

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

@@ -3,18 +3,11 @@ from __future__ import annotations
 
 import re
 from pathlib import Path
-from collections.abc import Mapping
 from typing import Optional
 
 from okstra_ctl.clarification_items import scan_approval_gate
 from okstra_ctl.json_boundary import JsonBoundaryError, load_owned_object
 from okstra_ctl.incremental_scope import CARRY_ALL_SCOPE
-from okstra_ctl.implementation_direction import (
-    DirectionSelectionError,
-    lexical_absolute_path,
-    resolve_selected_direction,
-    validate_task_artifact_path,
-)
 from okstra_ctl.final_report_paths import final_report_data_path
 from okstra_ctl.run import (
     PrepareError,
@@ -24,191 +17,24 @@ from okstra_ctl.run import (
     _reject_blocking_plan_body_gate,
     _set_data_json_approved_true_if_present,
 )
+from okstra_ctl.phases.implementation.wizard import _impl_stage_marker, _impl_chosen_stages
 from okstra_ctl.stage_map import StageMapError, parse_stage_map_file, stage_map_records
 from okstra_ctl.user_response import PlanDecisionRecord, parse_plan_decision
 from okstra_ctl.wizard_stage_intent import WHOLE_TASK_STAGE
 from okstra_ctl import fix_cycles
-from okstra_ctl.paths import task_dir, task_runs_dir
+from okstra_ctl.paths import task_dir
+from okstra_ctl.phases.final_verification.wizard import (
+    StageAnswerError,
+    validate_stage_answer,
+    whole_task_verification_allowed,
+)
 from okstra_project.state import read_task_manifest
 
-from .ids import (
-    ALL_STAGES,
-    PICK_OTHER,
-    PICK_TYPE_CUSTOM,
-    PICK_USE_DEFAULT,
-    SCOPE_SHAPE_LINKED,
-    SCOPE_SHAPE_NO_ANSWERS,
-    SCOPE_SHAPE_UNLINKED,
-    S_APPROVED_PLAN,
-    S_APPROVED_PLAN_PICK,
-    S_APPROVE_PLAN_CONFIRM,
-    S_FIX_CYCLE_CONFIRM,
-    S_HANDOFF_STAGE_PICK,
-    S_REVERIFY_SCOPE_PICK,
-    S_REVERIFY_SCOPE_STAGES,
-    S_SELECTED_DIRECTION_PICK,
-    S_STAGE_PICK,
-    _REPORT_PREFIX,
-)
+from .ids import ALL_STAGES, PICK_OTHER, PICK_TYPE_CUSTOM, PICK_USE_DEFAULT, SCOPE_SHAPE_LINKED, SCOPE_SHAPE_NO_ANSWERS, SCOPE_SHAPE_UNLINKED, S_APPROVED_PLAN, S_APPROVED_PLAN_PICK, S_APPROVE_PLAN_CONFIRM, S_FIX_CYCLE_CONFIRM, S_REVERIFY_SCOPE_PICK, S_REVERIFY_SCOPE_STAGES, S_STAGE_PICK, _REPORT_PREFIX
 from .state import Option, Prompt, WizardError, WizardState
 from .prompts import _opt, _p
-from .sources import (
-    _latest_implementation_planning_report,
-    _list_implementation_planning_reports,
-    _parse_stage_objects,
-    _prior_stage_numbers,
-    _project_relative_path,
-    _require_file,
-    _reserved_stage_numbers,
-    _reverify_scope_pick_required,
-    _reverify_scope_preview,
-    _reverify_scope_shape,
-    _stage_lifecycle_snapshot,
-)
-
-
-# 후보는 리포트 **기록**으로 찾는다. 전체 열람본(`.md`)은 `2bcd575` 이후 완료
-# 산출물이 아니라 요청 시 렌더라, `.md` 를 글롭하는 동안 이 목록은 항상 비었고
-# 방향 선택 단계 자체가 뜨지 않았다 — 비교가 끝나도 계획으로 갈 길이 없었다.
-_SELECTION_REPORT_RE = re.compile(
-    r"^final-report-implementation-option-selection-(?P<seq>\d{3,})\.data\.json$"
-)
-
-
-def _selected_direction_candidates(state: WizardState) -> list[str]:
-    if not state.project_root or not state.task_group or not state.task_id:
-        return []
-    project_root = Path(state.project_root).resolve()
-    task_root = lexical_absolute_path(
-        task_dir(project_root, state.task_group, state.task_id)
-    )
-    reports = (
-        task_runs_dir(project_root, state.task_group, state.task_id)
-        / "implementation-option-selection"
-        / "reports"
-    )
-    candidates: list[tuple[int, Path]] = []
-    for report in reports.glob(
-        "final-report-implementation-option-selection-*.data.json"
-    ):
-        match = _SELECTION_REPORT_RE.fullmatch(report.name)
-        if match is None:
-            continue
-        try:
-            validated = validate_task_artifact_path(
-                report, task_root, "selection report"
-            )
-        except DirectionSelectionError:
-            continue
-        candidates.append((int(match.group("seq")), validated))
-    return [
-        _project_relative_path(path, project_root)
-        for _, path in sorted(candidates, reverse=True)[:3]
-    ]
-
-
-def _planning_rerun_selected(state: WizardState) -> bool:
-    if (
-        not state.clarification_response_path
-        or not state.project_root
-        or not state.task_group
-        or not state.task_id
-    ):
-        return False
-    project_root = Path(state.project_root).resolve()
-    raw_path = Path(state.clarification_response_path).expanduser()
-    path = lexical_absolute_path(
-        raw_path if raw_path.is_absolute() else project_root / raw_path
-    )
-    task_root = lexical_absolute_path(
-        task_dir(project_root, state.task_group, state.task_id)
-    )
-    reports = lexical_absolute_path(
-        task_runs_dir(project_root, state.task_group, state.task_id)
-        / "implementation-planning"
-        / "reports"
-    )
-    try:
-        validate_task_artifact_path(path, task_root, "planning report")
-    except DirectionSelectionError:
-        return False
-    return (
-        path.is_file()
-        and not path.is_symlink()
-        and re.fullmatch(
-            r"final-report-implementation-planning-\d{3,}\.(?:md|data\.json)", path.name
-        )
-        is not None
-        and path.parent == reports
-    )
-
-
-def _build_selected_direction_pick(state: WizardState) -> Prompt:
-    candidates = _selected_direction_candidates(state)
-    t = _p(state.workspace_root, S_SELECTED_DIRECTION_PICK)
-    if not candidates:
-        raise WizardError(t["errors"]["none"])
-    return Prompt(
-        step=S_SELECTED_DIRECTION_PICK,
-        kind="pick",
-        label=t["label"],
-        options=[
-            _opt(path, _selection_option_label(state, path, t))
-            for path in candidates
-        ],
-        echo_template=t["echo_template"],
-    )
-
-
-def _selection_option_label(state: WizardState, rel_path: str, t: dict) -> str:
-    """후보 경로에 그 리포트가 실제로 무엇을 담았는지 붙인다.
+from .sources import _latest_implementation_planning_report, _list_implementation_planning_reports, _parse_stage_objects, _prior_stage_numbers, _require_file, _reserved_stage_numbers, _reverify_scope_pick_required, _reverify_scope_preview, _reverify_scope_shape, _stage_lifecycle_snapshot
 
-    목록은 최신순이라 후보가 0건인 최근 재실행이 맨 위에 온다. 경로만 보이면
-    사용자가 그것을 고르고, 방향 없는 리포트로 계획을 열려다 막힌다.
-    """
-    record = Path(state.project_root) / rel_path
-    try:
-        data = load_owned_object(record, artifact="implementation option data")
-    except (OSError, JsonBoundaryError):
-        return rel_path
-    selection = data.get("implementationOptionSelection")
-    if not isinstance(selection, Mapping):
-        return rel_path
-    rows = selection.get("rankedOptions")
-    ids = [
-        str(row.get("id"))
-        for row in rows
-        if isinstance(row, Mapping) and row.get("id")
-    ] if isinstance(rows, list) else []
-    if not ids:
-        return t["labels"]["no_options"].format(path=rel_path)
-    return t["labels"]["options"].format(path=rel_path, ids=", ".join(ids))
-
-
-def _submit_selected_direction_pick(
-    state: WizardState, value: str
-) -> Optional[str]:
-    t = _p(state.workspace_root, S_SELECTED_DIRECTION_PICK)
-    candidates = _selected_direction_candidates(state)
-    if value not in candidates:
-        raise WizardError(t["errors"]["unknown"].format(value=value))
-    try:
-        resolve_selected_direction(
-            Path(state.project_root) / value,
-            expected_task_key=f"{state.project_id}:{state.task_group}:{state.task_id}",
-        )
-    except DirectionSelectionError as exc:
-        raise WizardError(str(exc)) from exc
-    state.selected_direction_path = value
-    # 두 입력은 상호 배타다 — 방향이 정해진 순간 이 런은 새 계획이고,
-    # clarification 자리에 남은 값은 render-bundle 이 거절할 이유일 뿐이다.
-    # 거절을 여기서 앞당기는 대신 값을 비우고, 무엇이 비워졌는지 echo 로
-    # 알린다. 사용자 답변은 손실되지 않는다: 그 사이드카는
-    # `--selected-direction` 경로로 계획 런에 첨부된다(`run.py` 참조).
-    if state.clarification_response_path:
-        state.clarification_response_path = ""
-        return t["echo_variants"]["cleared_clarification"].format(value=value)
-    return f"selected-direction: {value}"
 
 
 def _classify_approved_plan(path_str: str, project_root: Path) -> tuple[Path, bool]:
@@ -422,7 +248,10 @@ def _whole_task_allowed(
         return False
     if done is None:
         done = _stage_lifecycle_snapshot(state, stages).done_stages
-    return all(s.stage_number in done for s in stages)
+    return whole_task_verification_allowed(
+        stage_numbers=tuple(stage.stage_number for stage in stages),
+        done_stages=done,
+    )
 
 
 def _build_approved_plan_pick(state: WizardState) -> Prompt:
@@ -608,35 +437,19 @@ def _build_stage_pick(state: WizardState) -> Prompt:
 # Presentation keys are mapped explicitly rather than interpolated from the
 # status, so renaming a Stage Lifecycle status is a compile-time-visible edit
 # here instead of a KeyError raised while drawing the picker.
-_STAGE_MARKER_KEYS = {
-    "done": "mark_done",
-    "active": "mark_active",
-    "ready": "mark_ready",
-    "blocked": "mark_blocked",
-}
-
-
-def _impl_stage_marker(t, lifecycle) -> str:
-    return t["options"][_STAGE_MARKER_KEYS[lifecycle.status]]
 
 
 def _submit_stage_pick(state: WizardState, answer: str) -> Optional[str]:
     if state.task_type == "implementation":
         return _submit_impl_stage_pick(state, answer)
-    # final-verification: 단일선택 유지 (whole-task 또는 단일 정수; auto 불가)
-    if not answer:
-        raise WizardError("value required")
-    if answer == WHOLE_TASK_STAGE:
-        if not _whole_task_allowed(state):
-            raise WizardError(
-                "whole-task verification requires final-verification "
-                "with all stages done")
-    else:
-        try:
-            int(answer)
-        except ValueError:
-            raise WizardError(
-                f"answer must be whole-task or a stage number, got {answer!r}")
+    try:
+        validate_stage_answer(
+            answer,
+            whole_task_token=WHOLE_TASK_STAGE,
+            whole_task_allowed=answer == WHOLE_TASK_STAGE and _whole_task_allowed(state),
+        )
+    except StageAnswerError as exc:
+        raise WizardError(str(exc)) from exc
     state.selected_stage = answer
     return f"stage: {answer}"
 
@@ -668,34 +481,6 @@ def _submit_impl_stage_pick(state: WizardState, answer: str) -> Optional[str]:
     return t["echo_variants"]["plain"].format(stages=state.selected_stages)
 
 
-def _impl_chosen_stages(t, picks, answer, all_nums, occupied) -> set:
-    if ALL_STAGES in picks:
-        if len(picks) > 1:
-            raise WizardError(t["errors"]["all_exclusive"])
-        chosen = {n for n in all_nums if n not in occupied}
-        if not chosen:
-            raise WizardError(t["errors"]["nothing_selectable"])
-        return chosen
-    try:
-        nums = {int(p) for p in picks}
-    except ValueError:
-        raise WizardError(t["errors"]["bad_number"].format(answer=answer))
-    unknown = sorted(nums - all_nums)
-    if unknown:
-        raise WizardError(t["errors"]["unknown_stage"].format(
-            bad=", ".join(map(str, unknown))))
-    bad = sorted(nums & occupied)
-    if bad:
-        raise WizardError(t["errors"]["occupied"].format(
-            bad=", ".join(map(str, bad))))
-    return nums
-
-
-def _handoff_msgs(state: WizardState) -> dict:
-    """handoff_stage_pick 의 JSON 텍스트 묶음 (label 미사용 조회용)."""
-    return _p(state.workspace_root, "handoff_stage_pick", blocked="")
-
-
 def _resolve_handoff_plan(state: WizardState) -> Path:
     """release-handoff 의 approved plan 을 질문 없이 자동 해소한다.
 
@@ -717,7 +502,7 @@ def _resolve_handoff_plan(state: WizardState) -> Path:
 
 def _handoff_eligibility(state: WizardState) -> list:
     """stage 별 PR 자격 — okstra_ctl.handoff 의 SSOT 판정을 그대로 재사용한다."""
-    from okstra_ctl.handoff import compute_eligibility
+    from okstra_ctl.phases.release_handoff.operations import compute_eligibility
     from okstra_ctl.consumers import read_consumers
     plan = _resolve_handoff_plan(state)
     try:
@@ -731,53 +516,17 @@ def _handoff_eligibility(state: WizardState) -> list:
 # 자격 stage 전체를 한 번에 고르는 값. stage 번호는 숫자뿐이라 충돌하지 않는다.
 # CLI 는 `--stages` 를 비우면 전체를 쓰지만, 위저드 pick 은 빈 선택을 거절하므로
 # 그 뜻을 표현할 값이 따로 필요하다.
-ALL_ELIGIBLE_STAGES = "all"
+from okstra_ctl.phases.release_handoff.wizard import (
+    _handoff_msgs, build_handoff_stage_pick, submit_handoff_stage_pick,
+)
 
 
 def _build_handoff_stage_pick(state: WizardState) -> Prompt:
-    elig = _handoff_eligibility(state)
-    eligible = [e for e in elig if e["eligible"]]
-    blocked = [e for e in elig if not e["eligible"]]
-    msgs = _handoff_msgs(state)
-    blocked_summary = ("; ".join(
-        f"stage {e['stage']} ({', '.join(e['reasons'])})" for e in blocked)
-        or msgs["labels"]["blocked_none"])
-    if not eligible:
-        raise WizardError(
-            msgs["errors"]["nothing_eligible"].format(blocked=blocked_summary))
-    t = _p(state.workspace_root, "handoff_stage_pick", blocked=blocked_summary)
-    stage_label = t["labels"]["stage"]
-    options: list[Option] = []
-    if len(eligible) > 1:
-        options.append(_opt(ALL_ELIGIBLE_STAGES, t["labels"]["all_stages"].format(
-            stages=", ".join(str(e["stage"]) for e in eligible))))
-    for e in eligible:
-        deps = ", ".join(str(d) for d in e["depends_on"]) or "-"
-        options.append(_opt(str(e["stage"]),
-                            stage_label.format(stage=e["stage"], deps=deps)))
-    return Prompt(
-        step=S_HANDOFF_STAGE_PICK, kind="pick", multi=True,
-        label=t["label"], options=options,
-        echo_template=t["echo_template"],
-    )
+    return build_handoff_stage_pick(state, _handoff_eligibility(state))
 
 
 def _submit_handoff_stage_pick(state: WizardState, value: str) -> Optional[str]:
-    t = _handoff_msgs(state)
-    picks = [v.strip() for v in (value or "").split(",") if v.strip()]
-    if not picks:
-        raise WizardError(t["errors"]["none_selected"])
-    eligible = {str(e["stage"]) for e in _handoff_eligibility(state)
-                if e["eligible"]}
-    if ALL_ELIGIBLE_STAGES in picks:
-        picks = sorted(eligible, key=int)
-    bad = [p for p in picks if p not in eligible]
-    if bad:
-        raise WizardError(t["errors"]["not_eligible"].format(
-            bad=", ".join(bad), eligible=", ".join(sorted(eligible))))
-    nums = sorted({int(p) for p in picks})
-    state.handoff_stages = ",".join(str(n) for n in nums)
-    return t["echo_variants"]["stages"].format(stages=state.handoff_stages)
+    return submit_handoff_stage_pick(state, value, lambda: _handoff_eligibility(state))
 
 
 def _reverify_scope_step_pending(state: WizardState) -> bool:

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

@@ -12,7 +12,8 @@ from okstra_ctl.domain.host import (
 from okstra_ctl.registry.host_registry import default_host_registry
 from okstra_ctl.registry.provider_registry import default_provider_registry
 from okstra_ctl.ids import slugify_task_segment
-from okstra_ctl.analysis_inputs import AnalysisInputError, resolve_analysis_target
+from okstra_ctl.analysis_inputs import AnalysisInputError
+from okstra_ctl.phases.feature_analysis.entry import resolve_analysis_target
 from okstra_ctl.models import (
     UnknownModelError,
     UnknownProviderError,

package/runtime/python/okstra_ctl/work_categories.py

@@ -3,7 +3,7 @@
 profile / validators / wizard 는 이 모듈에서 enum 을 import 해야 한다. 다른 곳에서
 재정의하면 single-reference-point 위반이며 tests/test_work_categories.py 가 거부한다.
 
-다섯째 값은 `ops` 가 canonical 이다(`--work-category` CLI help 및 workflow.PHASE_RULES
+다섯째 값은 `ops` 가 canonical 이다(`--work-category` CLI help 및 phases.catalog
 와 일치). 구버전 비표준 철자는 폐기된다.
 """
 from __future__ import annotations

package/runtime/python/okstra_ctl/worker_prompt_contract.py

@@ -23,6 +23,7 @@ from .worker_prompt_policy import (
     PromptPlan,
     is_plan_verify_dispatch_kind,
     resolve_prompt_plan_for_manifest,
+    verification_dispatch_round,
 )
 from .worker_prompt_headers import EVIDENCE_LEDGER_HEADER
 
@@ -367,6 +368,41 @@ def validate_reverify_prompt(
     return errors
 
 
+def validate_plan_verify_dispatch_identity(
+    text: str, *, dispatch_kind: str, result_name: str,
+) -> list[str]:
+    """Tie a plan item queue to the dispatch kind and result name validate-run counts.
+
+    `validate_reverify_prompt` only runs for a verification kind, so a queue
+    rendered by `okstra plan-items prompt` under any other kind skipped every
+    check and dispatched. validate-run then counts plan-body votes only from
+    `plan-verify-r<N>` rows whose result file carries `-plan-verify-r<N>-`
+    (`_plan_verify_dispatched_workers`), so the round's votes surfaced later as
+    unbacked. Observed 2026-09-24 (jobs dev-9065 implementation-planning 001):
+    kinds `plan-body-r1` / `plan-body-r2`, results `*-plan-body-r2-*.md`.
+    """
+    normalized = text.replace("\r\n", "\n").replace("\r", "\n")
+    if not is_plan_verify_dispatch_kind(dispatch_kind):
+        instructions = normalized[_task_instructions_offset(normalized):]
+        if PLAN_VERIFY_RENDERED_BY_LINE not in instructions:
+            return []
+        return [
+            "the instruction is an `okstra plan-items prompt` queue but the "
+            f"dispatch kind is `{dispatch_kind}` — a plan-body round takes "
+            "--dispatch-kind plan-verify-r<N>, matching the round in its result "
+            "file name; validate-run counts no plan-body vote from any other kind"
+        ]
+    token = f"-plan-verify-r{verification_dispatch_round(dispatch_kind)}-"
+    if token in result_name:
+        return []
+    return [
+        f"`{dispatch_kind}` result file `{result_name}` does not carry `{token}` "
+        "— name it <role>-worker-plan-verify-r<N>-<task-type>-<seq>.md with the "
+        "same <N> as the dispatch kind; validate-run counts no plan-body vote "
+        "from another result name"
+    ]
+
+
 def complete_reverify_instruction(
     body: str, *, task_type: str, forbidden_actions: str,
     model: str, output_contract: str,