okstra 0.130.4 → 0.131.1

package/runtime/validators/validate-run.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import argparse
+import hashlib
 import importlib.util
 import json
 import os
@@ -35,6 +36,7 @@ from okstra_project import project_json_path  # noqa: E402
 from okstra_project.dirs import tasks_root as _okstra_tasks_root  # noqa: E402
 
 from okstra_ctl.conformance import (  # noqa: E402
+    CAPABILITY_WHITELIST,
     detect_surfaces,
     evaluate_conformance,
     manifest_required_surfaces,
@@ -68,12 +70,18 @@ from okstra_ctl.design_surfaces import (  # noqa: E402
     detect_design_surfaces,
     expected_prep_plan_item_id,
 )
-from okstra_ctl.plan_items import expected_plan_item_ids  # noqa: E402
+from okstra_ctl.plan_items import (  # noqa: E402
+    expected_plan_item_ids,
+    extract_plan_items,
+)
 from okstra_ctl.worker_prompt_contract import (  # noqa: E402
     PromptRecord,
     validate_initial_prompt_records,
 )
-from okstra_ctl.convergence_engine import validate_final_state  # noqa: E402
+from okstra_ctl.convergence_engine import (  # noqa: E402
+    grouped_input_digest,
+    validate_final_state,
+)
 
 TERMINAL_STATUSES = {"completed", "timeout", "error", "not-run"}
 ATTEMPTED_STATUSES = {"completed", "timeout", "error"}
@@ -82,6 +90,33 @@ WORKER_DISPATCH_MODES = {"cli-wrapper", "mixed", "tmux-pane"}
 
 def utc_now() -> str:
     return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+# Providers dispatched through a CLI wrapper. Their token accounting lives in
+# that CLI, never in the lead's session JSONL, so `usage.source: unavailable`
+# is structural rather than a collection failure.
+_CLI_WRAPPER_AGENTS = frozenset({"codex", "antigravity"})
+
+
+def _cli_wrapper_worker_labels(team_state: dict) -> frozenset[str]:
+    """Token-table row labels whose `--` cells are honest.
+
+    Mirrors `scripts/okstra_token_usage/report.py` `_worker_detail_label`
+    (`"{role} ({agent}, {status})"`) so the match is on the rendered label the
+    scanner actually sees.
+    """
+    labels = set()
+    for worker in team_state.get("workers") or []:
+        if not isinstance(worker, dict):
+            continue
+        agent = str(worker.get("agent") or "").strip()
+        if agent not in _CLI_WRAPPER_AGENTS:
+            continue
+        role = str(worker.get("role") or worker.get("workerId") or "Worker").strip()
+        status = str(worker.get("status") or "").strip()
+        suffix = ", ".join(v for v in (agent, status) if v)
+        labels.add(f"{role} ({suffix})" if suffix else role)
+    return frozenset(labels)
+
+
 def _session_accounting(team_state: dict) -> str:
     adapter = (
         team_state.get("leadAdapter") if isinstance(team_state.get("leadAdapter"), dict) else {}
@@ -847,6 +882,7 @@ def _scan_token_usage_summary(
     failures: list[str],
     *,
     allow_unavailable_tokens: bool = False,
+    unavailable_ok_labels: frozenset[str] = frozenset(),
 ) -> None:
     """Reject sentinel / zero values that workers typed into the Token
     Usage Summary table instead of leaving the `{{...}}` placeholders
@@ -895,13 +931,27 @@ def _scan_token_usage_summary(
         # The CLI row's label always contains the word "CLI" — matching
         # `Codex/Antigravity CLI 추가 비용` regardless of formatting variations.
         is_cli_row = "CLI" in label_cell
+        # A CLI-wrapper worker's tokens are accounted inside its own CLI, not
+        # in the lead's session JSONL, so `--` on that row is the honest
+        # value — not a skipped collection. Gating it made every roster
+        # containing such a worker unable to pass, leaving the lead a choice
+        # between fabricating numbers and shipping `contract-violated`.
+        row_label = label_cell.lstrip("- ").strip()
+        unavailable_ok = allow_unavailable_tokens or row_label in unavailable_ok_labels
+        # One row's three cells carry the same defect, so reporting per cell
+        # turned two broken workers into six failures and made the real count
+        # unreadable. Collapse to one line per (row, sentinel).
+        reported_sentinels: set[str] = set()
         for raw_cell in cells[1:]:
             for value in _TOKEN_USAGE_BACKTICK_CELL_RE.findall(raw_cell):
                 stripped = value.strip()
                 lowered = stripped.lower()
-                if allow_unavailable_tokens and stripped == "--":
+                if unavailable_ok and stripped == "--":
+                    continue
+                if lowered in reported_sentinels:
                     continue
                 if lowered in _TOKEN_USAGE_SENTINEL_VALUES:
+                    reported_sentinels.add(lowered)
                     failures.append(
                         "Token Usage Summary cell contains sentinel value "
                         f"`{stripped}` on row labelled `{label_cell or '<unlabeled>'}` — "
@@ -911,6 +961,7 @@ def _scan_token_usage_summary(
                     )
                     continue
                 if stripped in _TOKEN_USAGE_ZERO_VALUES and not is_cli_row:
+                    reported_sentinels.add(lowered)
                     failures.append(
                         f"Token Usage Summary row `{label_cell or '<unlabeled>'}` has "
                         f"a zero value `{stripped}` — no okstra run consumes zero "
@@ -1020,8 +1071,10 @@ _DEPRECATED_FINAL_REPORT_PATTERNS: tuple[tuple[re.Pattern, str], ...] = (
 
 
 def _load_conformance_results(qa_dir: Path, manifest: dict) -> dict:
-    """매니페스트 각 entry 에 대응하는 `result-<stageKey>.json` 을 로드.
-    파일 부재/파손은 키를 비워 둬 미실행(None→BLOCKING)으로 흐르게 한다."""
+    """Load each entry's `result-<stageKey>.json` sidecar.
+
+    Missing or malformed files leave the key absent so gate evaluation receives None.
+    """
     results: dict = {}
     for entry in manifest.get("entries", []):
         key = entry.get("stageKey") if isinstance(entry, dict) else None
@@ -1033,7 +1086,7 @@ def _load_conformance_results(qa_dir: Path, manifest: dict) -> dict:
         try:
             results[key] = qa_result_from_dict(json.loads(sidecar.read_text()))
         except (OSError, json.JSONDecodeError):
-            results[key] = qa_result_from_dict(None)  # → MISSING → BLOCKING
+            results[key] = qa_result_from_dict(None)  # → MISSING → conformance verdict
     return results
 
 
@@ -1052,11 +1105,12 @@ def _parse_diff_summary_files(content: str) -> list[str]:
 _STAGE_RUN_DIR_RE = re.compile(r"^stage-\d+$")
 
 
-def _implementation_stage_name(run_dir: Path) -> str | None:
-    """implementation stage 격리 run(`runs/implementation/stage-<N>`)이면
-    `stage-<N>` 을 반환. 그 외(final-verification 등 task-type 레벨 run)는
-    None — whole-task 스코프."""
-    if run_dir.parent.name == "implementation" and _STAGE_RUN_DIR_RE.match(run_dir.name):
+def _stage_isolated_name(run_dir: Path) -> str | None:
+    """Return stage-<N> for implementation or final-verification stage runs."""
+    if (
+        run_dir.parent.name in ("implementation", "final-verification")
+        and _STAGE_RUN_DIR_RE.match(run_dir.name)
+    ):
         return run_dir.name
     return None
 
@@ -1093,6 +1147,308 @@ def _task_root_from_run_dir(run_dir: Path) -> Path:
     return run_dir.parent.parent
 
 
+def _read_run_inputs_payload(
+    inputs_path: Path,
+    failures: list[str],
+) -> dict | None:
+    """Read the exact run-inputs payload, failing closed on malformed evidence."""
+    if not inputs_path.is_file():
+        failures.append(
+            f"conformance gate BLOCKING: approved plan evidence run inputs missing "
+            f"at {inputs_path}"
+        )
+        return None
+    try:
+        payload = json.loads(inputs_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        failures.append(
+            f"conformance gate BLOCKING: approved plan evidence run inputs "
+            f"unreadable at {inputs_path}: {exc}"
+        )
+        return None
+    if not isinstance(payload, dict):
+        failures.append(
+            "conformance gate BLOCKING: approved plan evidence run inputs "
+            f"payload malformed at {inputs_path}"
+        )
+        return None
+    return payload
+
+
+def _approved_plan_path_from_run_inputs(
+    run_manifest_path: Path,
+    failures: list[str],
+) -> Path | None:
+    """Load an absolute approvedPlanPath from the exact run-inputs sibling."""
+    name = run_manifest_path.name
+    if not name.startswith("run-manifest-") or not name.endswith(".json"):
+        failures.append(
+            "conformance gate BLOCKING: approved plan evidence cannot derive "
+            f"run-inputs sibling from {run_manifest_path}"
+        )
+        return None
+    inputs_path = run_manifest_path.with_name(
+        name.replace("run-manifest-", "run-inputs-", 1)
+    )
+    payload = _read_run_inputs_payload(inputs_path, failures)
+    if payload is None:
+        return None
+    inputs = payload.get("inputs")
+    if not isinstance(inputs, dict):
+        failures.append(
+            "conformance gate BLOCKING: approved plan evidence has malformed "
+            f"inputs object at {inputs_path}"
+        )
+        return None
+    raw_path = inputs.get("approvedPlanPath")
+    if not isinstance(raw_path, str) or not raw_path.strip():
+        failures.append(
+            "conformance gate BLOCKING: approved plan evidence approvedPlanPath "
+            f"missing or malformed at {inputs_path}"
+        )
+        return None
+    path = Path(raw_path)
+    if not path.is_absolute():
+        failures.append(
+            "conformance gate BLOCKING: approved plan evidence approvedPlanPath "
+            f"must be absolute at {inputs_path}: {raw_path}"
+        )
+        return None
+    try:
+        return path.resolve()
+    except (OSError, ValueError) as exc:
+        failures.append(
+            "conformance gate BLOCKING: approved plan evidence approvedPlanPath "
+            f"malformed at {inputs_path}: {exc}"
+        )
+        return None
+
+
+def _approved_plan_stage_entries(
+    stages: object,
+    data_path: Path,
+    failures: list[str],
+) -> list[dict] | None:
+    """Validate approved-plan stages and return conformance declarations."""
+    if not isinstance(stages, list) or not stages:
+        _record_malformed_plan_stages(data_path, failures)
+        return None
+    entries: list[dict] = []
+    seen_stage_numbers: set[int] = set()
+    for stage in stages:
+        valid, entry = _approved_plan_stage_entry(
+            stage,
+            seen_stage_numbers,
+            data_path,
+            failures,
+        )
+        if not valid:
+            return None
+        if entry is not None:
+            entries.append(entry)
+    return entries
+
+
+def _record_malformed_plan_stages(data_path: Path, failures: list[str]) -> None:
+    failures.append(
+        f"conformance gate BLOCKING: approved plan evidence has malformed stages at {data_path}"
+    )
+
+
+def _approved_plan_stage_entry(
+    stage: object,
+    seen_stage_numbers: set[int],
+    data_path: Path,
+    failures: list[str],
+) -> tuple[bool, dict | None]:
+    if not isinstance(stage, dict):
+        _record_malformed_plan_stages(data_path, failures)
+        return False, None
+    stage_number = stage.get("stage")
+    tests = stage.get("conformanceTests")
+    exemption = stage.get("conformanceExemption")
+    tests_present = "conformanceTests" in stage
+    exemption_present = "conformanceExemption" in stage
+    fields_are_strings = all(
+        value is None or isinstance(value, str) for value in (tests, exemption)
+    )
+    has_tests = isinstance(tests, str) and bool(tests.strip())
+    has_exemption = isinstance(exemption, str) and bool(exemption.strip())
+    choice_is_valid = (
+        tests_present != exemption_present
+        and (has_tests if tests_present else has_exemption)
+    )
+    stage_is_valid = (
+        isinstance(stage_number, int)
+        and not isinstance(stage_number, bool)
+        and stage_number >= 1
+        and stage_number not in seen_stage_numbers
+    )
+    if not fields_are_strings or not stage_is_valid or not choice_is_valid:
+        _record_malformed_plan_stages(data_path, failures)
+        return False, None
+    seen_stage_numbers.add(stage_number)
+    if not has_tests:
+        return True, None
+    declaration = _parse_conformance_tests(tests)
+    if declaration is None:
+        failures.append(
+            "conformance gate BLOCKING: approved plan evidence has malformed "
+            f"conformanceTests for stage {stage_number} at {data_path}"
+        )
+        return False, None
+    script, requires = declaration
+    return True, {
+        "stageKey": f"approved-plan-stage-{stage_number}",
+        "script": script,
+        "requires": sorted(requires),
+    }
+
+
+_CONFORMANCE_TESTS_RE = re.compile(
+    r"^(?P<script>\S+)\s+\(requires=\[(?P<requires>[^\]]+)\]\)$"
+)
+
+
+def _normalize_conformance_script(script: str) -> str:
+    prefix = "<task_root>/"
+    return script[len(prefix):] if script.startswith(prefix) else script
+
+
+def _parse_conformance_tests(value: object) -> tuple[str, frozenset[str]] | None:
+    """Parse `<script> (requires=[cap,...])` from a stage declaration."""
+    if not isinstance(value, str):
+        return None
+    match = _CONFORMANCE_TESTS_RE.fullmatch(value.strip())
+    if match is None:
+        return None
+    script = _normalize_conformance_script(match.group("script"))
+    capabilities = [part.strip() for part in match.group("requires").split(",")]
+    if (
+        not script
+        or any(not capability for capability in capabilities)
+        or len(set(capabilities)) != len(capabilities)
+        or any(capability not in CAPABILITY_WHITELIST for capability in capabilities)
+    ):
+        return None
+    return script, frozenset(capabilities)
+
+
+def _approved_plan_conformance_manifest(
+    approved_plan_path: Path,
+    task_root: Path,
+    failures: list[str],
+) -> dict | None:
+    """Represent approved-plan conformance declarations as stage-key entries."""
+    if not approved_plan_path.is_file():
+        failures.append(
+            f"conformance gate BLOCKING: approved plan evidence missing at {approved_plan_path}"
+        )
+        return None
+    data_path = _data_path_for(approved_plan_path)
+    if not data_path.is_file():
+        failures.append(
+            f"conformance gate BLOCKING: approved plan evidence missing at {data_path}"
+        )
+        return None
+    resolved_data_path = data_path.resolve()
+    if not resolved_data_path.is_relative_to(task_root.resolve()):
+        failures.append(
+            "conformance gate BLOCKING: approved plan data evidence resolves "
+            f"outside current task root {task_root}: {resolved_data_path}"
+        )
+        return None
+    data_path = resolved_data_path
+    try:
+        data = json.loads(data_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        failures.append(
+            f"conformance gate BLOCKING: approved plan evidence unreadable at {data_path}: {exc}"
+        )
+        return None
+    planning = data.get("implementationPlanning") if isinstance(data, dict) else None
+    stages = planning.get("stages") if isinstance(planning, dict) else None
+    entries = _approved_plan_stage_entries(stages, data_path, failures)
+    return {"entries": entries} if entries is not None else None
+
+
+def _declared_conformance_errors(
+    declared_manifest: dict,
+    actual_manifest: dict,
+    stage_name: str | None,
+) -> list[str]:
+    """Compare scoped plan declarations with their one actual manifest entry."""
+    declared = _scope_manifest_entries(declared_manifest, stage_name).get("entries", [])
+    actual = _scope_manifest_entries(actual_manifest, stage_name).get("entries", [])
+    errors: list[str] = []
+    declared_stage_numbers = {
+        str(entry.get("stageKey") or "").rsplit("-stage-", 1)[-1]
+        for entry in declared
+        if isinstance(entry, dict)
+    }
+    for declaration in declared:
+        stage_number = str(declaration.get("stageKey") or "").rsplit("-stage-", 1)[-1]
+        matches = [
+            entry for entry in actual
+            if isinstance(entry, dict)
+            and str(entry.get("stageKey") or "").endswith(f"-stage-{stage_number}")
+        ]
+        if not matches:
+            errors.append(f"stage {stage_number} has no matching entry")
+            continue
+        if len(matches) > 1:
+            errors.append(f"stage {stage_number} has multiple matching entries")
+            continue
+        actual_entry = matches[0]
+        actual_script = _normalize_conformance_script(str(actual_entry.get("script") or ""))
+        if actual_script != declaration.get("script"):
+            errors.append(f"stage {stage_number} script mismatch")
+        actual_requires = actual_entry.get("requires")
+        actual_capabilities = (
+            frozenset(actual_requires)
+            if isinstance(actual_requires, list)
+            and all(isinstance(value, str) for value in actual_requires)
+            else None
+        )
+        if actual_capabilities != frozenset(declaration.get("requires") or []):
+            errors.append(f"stage {stage_number} requires mismatch")
+    for actual_entry in actual:
+        if not isinstance(actual_entry, dict):
+            continue
+        stage_number = str(actual_entry.get("stageKey") or "").rsplit("-stage-", 1)[-1]
+        if stage_number not in declared_stage_numbers:
+            errors.append(
+                f"stage {stage_number} actual manifest entry is not declared by approved plan"
+            )
+    return errors
+
+
+def _planning_conformance_declarations(
+    stages: object,
+    failures: list[str],
+) -> list[dict]:
+    declarations: list[dict] = []
+    for stage in stages if isinstance(stages, list) else []:
+        if not isinstance(stage, dict) or not str(stage.get("conformanceTests") or "").strip():
+            continue
+        parsed = _parse_conformance_tests(stage.get("conformanceTests"))
+        if parsed is None:
+            failures.append(
+                "final-report data.json: stage "
+                f"{stage.get('stage')} has malformed conformanceTests declaration."
+            )
+            continue
+        script, requires = parsed
+        declarations.append(
+            {
+                "stageKey": f"approved-plan-stage-{stage.get('stage')}",
+                "script": script,
+                "requires": sorted(requires),
+            }
+        )
+    return declarations
+
+
 def _validate_planning_conformance_declared(report_path: Path, failures: list[str]) -> None:
     """H4-c — at planning time, every stage that DECLARES `Conformance tests:`
     must already carry a matching entry in the shared task-level
@@ -1113,52 +1469,72 @@ def _validate_planning_conformance_declared(report_path: Path, failures: list[st
     ip = data.get("implementationPlanning")
     if not isinstance(ip, dict):
         return
-    declaring_stages = [
-        s.get("stage")
-        for s in (ip.get("stages") or [])
-        if isinstance(s, dict) and str(s.get("conformanceTests") or "").strip()
-    ]
-    if not declaring_stages:
+    declarations = _planning_conformance_declarations(ip.get("stages"), failures)
+    if not declarations:
         return
     task_root = _task_root_from_run_dir(report_path.parent.parent)
     manifest_path = task_root / "qa" / "conformance-manifest.json"
     entries = []
     if manifest_path.is_file():
         try:
-            entries = json.loads(manifest_path.read_text()).get("entries") or []
+            manifest = json.loads(manifest_path.read_text())
+            entries = manifest.get("entries") or [] if isinstance(manifest, dict) else []
         except (OSError, json.JSONDecodeError):
             entries = []
-    for stage_number in declaring_stages:
-        suffix = f"-stage-{stage_number}"
-        has_entry = any(
-            isinstance(e, dict) and str(e.get("stageKey") or "").endswith(suffix)
-            for e in entries
+    for error in _declared_conformance_errors(
+        {"entries": declarations},
+        {"entries": entries},
+        None,
+    ):
+        failures.append(
+            f"final-report data.json: conformance declaration {error} in "
+            f"{manifest_path}. Emitting `Conformance tests:` MUST also write "
+            "one matching manifest entry (implementation-planning.md §Conformance)."
+        )
+
+
+def _validate_conformance_surfaces(
+    report_path: Path,
+    scoped_manifest: dict,
+    surface_patterns: object,
+    failures: list[str],
+) -> None:
+    changed_files = _parse_diff_summary_files(report_path.read_text(encoding="utf-8"))
+    if not changed_files:
+        return
+    uncovered = (
+        detect_surfaces(changed_files, surface_patterns)
+        - manifest_required_surfaces(scoped_manifest)
+    )
+    if uncovered:
+        failures.append(
+            "conformance gate BLOCKING: implementation diff touches undeclared "
+            f"surface(s) {sorted(uncovered)} — no in-scope stage declares "
+            "`requires` for them. Declare a conformance entry (requires=[...]) "
+            "for the touching stage. "
+            "(silent mock-green 방지 — DEV-9184)"
         )
-        if not has_entry:
-            failures.append(
-                f"final-report data.json: stage {stage_number} declares "
-                "`Conformance tests:` but no matching entry exists in "
-                f"{manifest_path} (stageKey ending `{suffix}`). Emitting the "
-                "declaration MUST also write the manifest entry + script "
-                "(implementation-planning.md §Conformance)."
-            )
 
 
-def _validate_conformance(report_path: Path, failures: list[str],
-                          surface_patterns: object = None) -> None:
+def _validate_conformance(
+    report_path: Path,
+    failures: list[str],
+    surface_patterns: object = None,
+    approved_plan_path: Path | None = None,
+) -> list[str]:
     """Tier 3 conformance 게이트(implementation / final-verification).
 
-    `<task_root>/qa/conformance-manifest.json` 이 없으면 inert(선언된 conformance
-    가 없다는 뜻 — 선언을 강제하는 것은 planning 계약(Phase 4)의 몫). 매니페스트가
-    있으면 결과 사이드카와 함께 evaluate_conformance 로 판정하고 BLOCKING verdict
-    를 run 검증 실패로 승격한다. WAIVED(conditional)/EXEMPT 는 통과시킨다.
+    A missing task-level manifest is inert only without approved-plan evidence.
+    When a recorded approved plan declares conformance for the in-scope stage,
+    disappearance of that manifest is a blocking structural failure. Otherwise,
+    evaluate the manifest and result sidecars normally: BLOCKING verdicts fail
+    validation, ADVISORY verdicts become user follow-up warnings, and permitted
+    WAIVED/EXEMPT verdicts pass.
 
-    게이트 스코프: implementation stage 격리 run 은 자기 stage entry 만(결과
-    게이트·diff-surface 교차검증 모두 — 미래 stage 의 미실행이 현재 run 을
-    막으면 안 된다), final-verification 등 task-type 레벨 run 은 전 entry
-    (whole-task). prompts/profiles/_implementation-verifier.md §Tier 3 /
-    final-verification.md 의 스코프 계약과 동형.
+    Stage-isolated implementation and final-verification runs evaluate only their
+    own stage suffix. Whole-task runs evaluate every entry.
     """
+    warnings: list[str] = []
     # conformance 산출물은 task-level(<task_root>/qa)에 있어 planning/
     # implementation/final-verification 가 공유한다. report_path 는
     # task_root/runs/<task-type>/reports/final-report.md (implementation 은
@@ -1169,38 +1545,106 @@ def _validate_conformance(report_path: Path, failures: list[str],
     task_root = _task_root_from_run_dir(run_dir)
     qa_dir = task_root / "qa"
     manifest_path = qa_dir / "conformance-manifest.json"
+    stage_name = _stage_isolated_name(run_dir)
+    declared_manifest = None
+    if approved_plan_path is not None:
+        resolved_plan_path = approved_plan_path.resolve()
+        if not resolved_plan_path.is_relative_to(task_root.resolve()):
+            failures.append(
+                "conformance gate BLOCKING: approved plan evidence resolves "
+                f"outside current task root {task_root}: {resolved_plan_path}"
+            )
+            return warnings
+        declared_manifest = _approved_plan_conformance_manifest(
+            resolved_plan_path,
+            task_root,
+            failures,
+        )
+        if declared_manifest is None:
+            return warnings
     if not manifest_path.is_file():
-        return
+        empty_scoped_manifest = {"entries": []}
+        if declared_manifest is not None:
+            for error in _declared_conformance_errors(
+                declared_manifest,
+                empty_scoped_manifest,
+                stage_name,
+            ):
+                failures.append(
+                    f"conformance gate BLOCKING: approved plan {error}; "
+                    f"{manifest_path} is absent"
+                )
+        _validate_conformance_surfaces(
+            report_path,
+            empty_scoped_manifest,
+            surface_patterns,
+            failures,
+        )
+        return warnings
     try:
         manifest = json.loads(manifest_path.read_text())
     except (OSError, json.JSONDecodeError) as exc:
         failures.append(f"conformance manifest unreadable at {manifest_path}: {exc}")
-        return
+        return warnings
     schema_errors = validate_conformance_manifest(manifest)
     if schema_errors:
         failures.extend(f"conformance manifest: {e}" for e in schema_errors)
-        return
-    scoped = _scope_manifest_entries(manifest, _implementation_stage_name(run_dir))
+        return warnings
+    if declared_manifest is not None:
+        for error in _declared_conformance_errors(
+            declared_manifest,
+            manifest,
+            stage_name,
+        ):
+            failures.append(
+                f"conformance gate BLOCKING: approved plan {error} "
+                f"in {manifest_path}"
+            )
+    scoped = _scope_manifest_entries(manifest, stage_name)
+    entries_by_key = {
+        entry.get("stageKey"): entry
+        for entry in scoped.get("entries", [])
+        if isinstance(entry, dict) and isinstance(entry.get("stageKey"), str)
+    }
+    for stage_key, entry in entries_by_key.items():
+        if entry.get("requires") == [] and entry.get("waiver"):
+            failures.append(
+                f"conformance gate BLOCKING for stage {stage_key}: "
+                "requires=[] is declaration/contract trouble and cannot be waived"
+            )
+        if entry.get("requires") and entry.get("exemption"):
+            failures.append(
+                f"conformance gate BLOCKING for stage {stage_key}: "
+                f"a stage that declares a gated surface (requires="
+                f"{entry.get('requires')}) cannot be exempted — submit a real "
+                "conformance result or record a user-acknowledged waiver. See "
+                "docs/superpowers/specs/2026-06-07-stage-conformance-qa-design.md §7.1."
+            )
     results = _load_conformance_results(qa_dir, scoped)
     for verdict in evaluate_conformance(scoped, results):
-        if not verdict.ok:
+        if verdict.status == "ADVISORY":
+            entry = entries_by_key.get(verdict.stage_key, {})
+            warnings.append(
+                f"conformance advisory for stage {verdict.stage_key}: "
+                f"{verdict.message}; requires={entry.get('requires') or []}; "
+                f"user-owned follow-up command: "
+                f"{entry.get('runCommand') or '(missing)'}; "
+                f"manifest: {manifest_path}"
+            )
+        elif not verdict.ok:
             failures.append(
                 f"conformance gate BLOCKING for stage {verdict.stage_key}: "
                 f"{verdict.message}. Run the stage's conformance script (or declare "
                 f"an exemption / user waiver) — see "
                 f"docs/superpowers/specs/2026-06-07-stage-conformance-qa-design.md."
             )
-    changed_files = _parse_diff_summary_files(report_path.read_text(encoding="utf-8"))
-    if changed_files:
-        uncovered = detect_surfaces(changed_files, surface_patterns) - manifest_required_surfaces(scoped)
-        if uncovered:
-            failures.append(
-                "conformance gate BLOCKING: implementation diff touches undeclared "
-                f"surface(s) {sorted(uncovered)} — no in-scope stage declares "
-                "`requires` for them. Declare a conformance entry (requires=[...]) "
-                "for the touching stage, or an explicit exemption. "
-                "(silent mock-green 방지 — DEV-9184)"
-            )
+    _validate_conformance_surfaces(
+        report_path,
+        scoped,
+        surface_patterns,
+        failures,
+    )
+    return warnings
 
 
 def _check_incremental_audit_block(
@@ -1247,6 +1691,7 @@ def validate_report(
     failures: list[str],
     *,
     allow_unavailable_token_usage: bool = False,
+    unavailable_ok_labels: frozenset[str] = frozenset(),
 ) -> None:
     if not report_path.exists():
         failures.append(f"final report is missing: {report_path}")
@@ -1272,6 +1717,7 @@ def validate_report(
         content,
         failures,
         allow_unavailable_tokens=allow_unavailable_token_usage,
+        unavailable_ok_labels=unavailable_ok_labels,
     )
 
     # Verdict Card is mandatory in every final-report (introduced with the
@@ -1355,14 +1801,24 @@ _WORKER_RESULT_BASENAME_RE = re.compile(
     r"^(?P<worker>[a-z][a-z0-9-]*-worker)-(?P<task_type>[a-z][a-z-]*?)-(?P<seq>\d{3})\.md$"
 )
 
+_REPORT_BASENAME_SEQ_RE = re.compile(r"-(?P<seq>\d{3})(?:\.data)?\.(?:md|json)$")
+
+
+def _report_run_seq(report_path: Path) -> str | None:
+    """This run's seq, read off `final-report-<task-type>-<seq>.md`. ``None``
+    when the name does not carry one, so callers fall back to not filtering
+    rather than silently checking nothing."""
+    match = _REPORT_BASENAME_SEQ_RE.search(report_path.name)
+    return match.group("seq") if match else None
+
 
 def validate_worker_results_audit(
     report_path: Path, task_type: str, failures: list[str]
 ) -> None:
     """Enforce the worker audit sidecar contract.
 
-    For every `worker-results/<worker>-<task-type>-<seq>.md` produced by a
-    worker (skipping the audit sidecar itself), the validator checks:
+    For every `worker-results/<worker>-<task-type>-<seq>.md` **this run**
+    produced (skipping the audit sidecar itself), the validator checks:
 
     1. The main worker-results file does NOT contain a `## 0. Reading
        Confirmation` heading. That block moved to the audit sidecar with
@@ -1370,6 +1826,13 @@ def validate_worker_results_audit(
     2. The matching audit sidecar exists at
        `<worker>-audit-<task-type>-<seq>.md`. Missing sidecar means the
        worker silently skipped the reading-confirmation step.
+
+    Scoped to this run's seq. `worker-results/` accumulates every run's
+    artifacts, so scanning the whole directory judged a run by files it did
+    not produce: a task that once opted a worker in and later dropped it from
+    the roster failed forever on that worker's old sidecar, with no legitimate
+    remedy — the lead can neither fabricate a sidecar for a worker it never
+    dispatched nor delete a prior run's audit record.
     """
     # `report_path` is `runs/<task-type>/reports/final-report-...md`; the
     # sibling `worker-results/` directory holds every worker artifact.
@@ -1379,6 +1842,8 @@ def validate_worker_results_audit(
         # `release-handoff` which is single-lead). Nothing to enforce.
         return
 
+    run_seq = _report_run_seq(report_path)
+
     for path in sorted(worker_results_dir.glob("*.md")):
         name = path.name
         if "-audit-" in name:
@@ -1392,6 +1857,9 @@ def validate_worker_results_audit(
             # Cross-phase artifacts shouldn't appear here; skip rather
             # than fail to keep the check focused on the current phase.
             continue
+        if run_seq is not None and match.group("seq") != run_seq:
+            # A prior run's artifact. Its contract was judged when it ran.
+            continue
 
         worker_role = match.group("worker")
         seq = match.group("seq")
@@ -1847,13 +2315,25 @@ def validate_final_report_data(
     _validate_unverified_critic_gaps_recorded(data, failures)
 
     task_type = (data.get("header") or {}).get("taskType")
+    _validate_verifier_fail_blocks_verdict(data, failures)
+    if task_type == "implementation":
+        _validate_stage_carry_sidecar_exists(data, report_path, failures)
     if task_type == "final-verification":
         _validate_final_verification_consistency(data, failures)
+        _validate_verified_row_recorded(data, report_path, failures)
     elif task_type == "implementation-planning":
         active_report_contracts = report_contracts or set()
         _validate_implementation_planning_cross_project(data, failures)
         _validate_implementation_planning_decision_drafts(data, failures)
         _validate_plan_body_gate_recompute(data, failures)
+        _validate_gate_blocked_by(data, failures)
+        _validate_supersession_ledger(data, failures)
+        _validate_self_fix_grouping(data, failures)
+        _validate_clarification_evidence_note(data, failures)
+        _validate_plan_body_verdict_provenance(data, report_path, failures)
+        _validate_aborted_gate_has_clarification(data, failures)
+        _validate_round_recorded_verdicts(data, failures)
+        _validate_verdicts_match_current_subjects(data, failures)
         _validate_plan_item_extraction_completeness(data, failures)
         _validate_plan_item_subject_substance(data, failures)
         _validate_plan_body_clarification_matching(data, failures)
@@ -2041,6 +2521,11 @@ _PLAN_GATE_RANK = {
 # is prone to planning-vs-implementation environment false positives.
 _SINGLE_VOTE_BLOCKING_KINDS = {"a", "d"}
 
+# Stop reasons that justify promoting a still-broken planner-fixable item to the
+# user: the self-fix budget ran out, or a round produced no net resolution so
+# further rounds would repeat themselves.
+_SELF_FIX_EXHAUSTED_REASONS = frozenset({"max-rounds-reached", "no-progress"})
+
 
 def _classify_plan_item_gate(item: dict) -> str:
     """Recompute one plan item's gate class from its per-worker verdicts,
@@ -2089,12 +2574,74 @@ def _classify_plan_item_gate(item: dict) -> str:
     return "has-dissent"
 
 
+def _disagree_breakage_kinds(item: dict) -> set[str]:
+    return {
+        str(v.get("breakageKind") or "").strip().lower()
+        for v in (item.get("verdicts") or [])
+        if isinstance(v, dict)
+        and str(v.get("verdict") or "").strip().upper() == "DISAGREE"
+        and str(v.get("breakageKind") or "").strip()
+    }
+
+
+def _has_planner_fixable_majority(item: dict) -> bool:
+    disagrees = [
+        v
+        for v in (item.get("verdicts") or [])
+        if isinstance(v, dict) and str(v.get("verdict") or "").upper() == "DISAGREE"
+    ]
+    fixable = [v for v in disagrees if v.get("fixability") == "planner-fixable"]
+    return bool(disagrees) and len(fixable) * 2 > len(disagrees)
+
+
+def _is_correctness_critical(item: dict) -> bool:
+    """Whether this item's defect would make `implementation` produce wrong or
+    unsafe code — the single-vote-blocking kinds `a` (cited path/symbol
+    mismatch) and `d` (rollback violates commit order) on any item, or `f`
+    (requirement-coverage mismatch) on a `P-Req-*` item. Kinds `b`/`c`/`e` are
+    plan-prose defects: they degrade the document, not the resulting code.
+    """
+    kinds = _disagree_breakage_kinds(item)
+    is_req = str(item.get("id") or "").upper().startswith("P-REQ")
+    return bool(kinds & _SINGLE_VOTE_BLOCKING_KINDS) or (is_req and "f" in kinds)
+
+
+def _self_fix_budget_exhausted(pbv: dict) -> bool:
+    rounds_applied = pbv.get("selfFixRoundsApplied")
+    return (
+        isinstance(rounds_applied, int)
+        and rounds_applied >= 1
+        and pbv.get("selfFixStopReason") in _SELF_FIX_EXHAUSTED_REASONS
+    )
+
+
+def _is_dissent_downgraded(item: dict, pbv: dict) -> bool:
+    """Whether a surviving `majority-disagree` item stops blocking approval.
+
+    A planner-fixable defect the planner failed to fix is still a *planner*
+    defect; promoting it to a `Blocks=approval` row asks the user to proofread
+    the plan document. Once the self-fix budget is exhausted, such an item is
+    recorded as a Working Assumption in `## 5. Missing Information and Risks`
+    instead of blocking the gate. Defects that would make the implementation
+    itself wrong or unsafe (`_is_correctness_critical`) are excluded and keep
+    blocking, so correctness never trades away for throughput.
+    """
+    return (
+        _classify_plan_item_gate(item) == "majority-disagree"
+        and not _is_correctness_critical(item)
+        and _has_planner_fixable_majority(item)
+        and _self_fix_budget_exhausted(pbv)
+    )
+
+
 def _recompute_plan_body_gate(pbv: dict) -> str | None:
     """Recompute the whole §5.5.9 gate value from ``planItems[].verdicts``.
     Returns a value in ``PLAN_VERIFY_GATE_VALUES`` or ``None`` when there are
     no plan items to judge (disabled / empty round)."""
     classes = [
-        _classify_plan_item_gate(it)
+        "has-dissent"
+        if _is_dissent_downgraded(it, pbv)
+        else _classify_plan_item_gate(it)
         for it in (pbv.get("planItems") or [])
         if isinstance(it, dict)
     ]
@@ -2137,11 +2684,80 @@ def _validate_plan_body_gate_recompute(data: dict, failures: list[str]) -> None:
         )
 
 
-def _validate_plan_item_extraction_completeness(
-    data: dict,
-    failures: list[str],
-) -> None:
-    """Require the exact deterministic P-* extraction when a round ran."""
+def _cited_clarification_id(row: dict) -> str | None:
+    """The `C-NNN` a coverage row's `status` / `approvalDisposition` cites."""
+    for field in ("status", "approvalDisposition"):
+        value = str(row.get(field) or "").strip()
+        if value.startswith("blocked "):
+            return value.split(" ", 1)[1].strip()
+    return None
+
+
+def _blocks_approval(row: dict) -> bool:
+    """Whether one Requirement Coverage row blocks approval on its face, per
+    `prompts/profiles/implementation-planning.md` §"Requirement Coverage": a
+    `gap`, a plain `blocked C-NNN`, or a deviation whose approval disposition
+    is blocked.
+    """
+    status = str(row.get("status") or "").strip()
+    if status == "gap" or status.startswith("blocked C-"):
+        return True
+    disposition = str(row.get("approvalDisposition") or "").strip()
+    return status == "documented-deviation" and disposition.startswith("blocked C-")
+
+
+def _plan_body_promoted_clarification_ids(pbv: dict) -> set[str]:
+    """`C-NNN` ids this run's own plan-body round created by promoting a
+    majority-disagree item (step 8). Used to break the Requirement Coverage
+    ↔ Clarification cycle: a coverage row citing one of these echoes a blocker
+    the gate already counted, rather than contributing an independent one.
+    """
+    return {
+        item["clarificationId"].strip()
+        for item in (pbv.get("planItems") or [])
+        if isinstance(item, dict)
+        and isinstance(item.get("clarificationId"), str)
+        and item["clarificationId"].strip()
+    }
+
+
+def _independent_coverage_blockers(ip: dict, pbv: dict) -> list[str]:
+    """Coverage rows that block the gate on their own — excluding rows whose
+    blocker is a `C-NNN` this same run's plan-body round promoted."""
+    promoted = _plan_body_promoted_clarification_ids(pbv)
+    return [
+        str(row.get("id") or "<unknown>")
+        for row in (ip.get("requirementCoverage") or [])
+        if isinstance(row, dict)
+        and _blocks_approval(row)
+        and _cited_clarification_id(row) not in promoted
+    ]
+
+
+def _gate_blocking_causes(pbv: dict, coverage_blockers: list[str]) -> set[str]:
+    """Which inputs actually block approval, as `gateBlockedBy` enum values."""
+    causes = set()
+    recomputed = _recompute_plan_body_gate(pbv)
+    if recomputed == "blocked-by-disagreement":
+        causes.add("majority-disagree")
+    elif recomputed == "aborted-non-result":
+        causes.add("non-result")
+    if coverage_blockers:
+        causes.add("coverage-gap")
+    return causes
+
+
+def _validate_gate_blocked_by(data: dict, failures: list[str]) -> None:
+    """The gate value names an *outcome*; `gateBlockedBy` names the *cause*.
+
+    Two independent inputs can block approval — a `majority-disagree` plan item
+    and a Requirement Coverage `gap` / `blocked C-NNN` row — and before this
+    check both surfaced as the single value `blocked-by-disagreement`. A
+    coverage-only block therefore asserted a worker disagreement that never
+    happened, sending the reader hunting for a dissent that does not exist.
+    `gateBlockedBy` records which input actually fired, and this check makes the
+    coverage rule enforceable rather than prose-only.
+    """
     ip = data.get("implementationPlanning")
     if not isinstance(ip, dict):
         return
@@ -2151,20 +2767,975 @@ def _validate_plan_item_extraction_completeness(
     round_count = pbv.get("roundCount")
     if not isinstance(round_count, int) or round_count < 1:
         return
-    try:
-        expected_sequence = expected_plan_item_ids(ip)
-    except Exception as exc:  # noqa: BLE001
+
+    declared_gate = str(pbv.get("gateResult") or "").strip().lower()
+    declared_causes = {
+        str(c).strip()
+        for c in (pbv.get("gateBlockedBy") or [])
+        if isinstance(c, str) and str(c).strip()
+    }
+    coverage_blockers = _independent_coverage_blockers(ip, pbv)
+    actual_causes = _gate_blocking_causes(pbv, coverage_blockers)
+
+    if actual_causes and declared_gate in ("passed", "passed-with-dissent"):
         failures.append(
-            "final-report data.json: deterministic plan-item extraction failed: "
-            f"{exc}"
+            "final-report data.json: implementationPlanning.planBodyVerification "
+            f"`gateResult` is `{declared_gate}` but "
+            f"{sorted(actual_causes)} blocks approval "
+            f"(coverage rows: {coverage_blockers or 'none'}). A Requirement "
+            "Coverage `gap` / `blocked C-NNN` row blocks the gate independently "
+            "of the worker verdicts (implementation-planning.md "
+            '§"Requirement Coverage").'
         )
         return
 
-    actual_sequence = [
-        str(item.get("id") or "").strip()
-        for item in (pbv.get("planItems") or [])
-        if isinstance(item, dict)
-    ]
+    if declared_causes != actual_causes:
+        failures.append(
+            "final-report data.json: implementationPlanning.planBodyVerification "
+            f"`gateBlockedBy` is {sorted(declared_causes)} but the recorded "
+            f"inputs support {sorted(actual_causes)} (coverage rows blocking "
+            f"independently: {coverage_blockers or 'none'}). Every blocking "
+            "input must be named so the reader is not sent looking for a "
+            "worker disagreement that never happened "
+            '(plan-body-verification.md §"Round protocol" step 5).'
+        )
+
+
+_EVIDENCE_NOTE_RE = re.compile(r"Evidence checked:\s*(?P<body>.+?)(?:\.\s|\.$|$)", re.S)
+_EVIDENCE_NONE_RE = re.compile(r"^none\s*[—-]\s*\S")
+# `path/to/file.ext:123`, the form the codebase-first rule asks the row to cite.
+_EVIDENCE_PATH_LINE_RE = re.compile(r"\S+\.\w+:\d+")
+
+
+def _validate_clarification_evidence_note(data: dict, failures: list[str]) -> None:
+    """Every clarification row must show its codebase-first work.
+
+    The profile requires any ambiguity answerable by `Read` / `Grep` to be
+    resolved that way, and calls a row for something the code already answers a
+    defect of the phase — but nothing checked it, so rows the codebase could
+    have settled reached the user as approval blockers. Requiring the
+    `Evidence checked:` note to exist and be well-formed does not prove the
+    lookup happened; it makes its absence a failure and a false `none` an
+    attributable claim rather than a silent omission.
+    """
+    if (data.get("header") or {}).get("taskType") != "implementation-planning":
+        return
+    for row in data.get("clarificationItems") or []:
+        if not isinstance(row, dict):
+            continue
+        row_id = str(row.get("id") or "<unknown>")
+        statement = str(row.get("statement") or "")
+        match = _EVIDENCE_NOTE_RE.search(statement)
+        if not match:
+            failures.append(
+                f"final-report data.json: clarification `{row_id}` has no "
+                "`Evidence checked:` note in its `statement`. Every row must "
+                "record the codebase lookup that failed to settle it — either "
+                "`Evidence checked: <path:line>` or `Evidence checked: none — "
+                "<human-only reason>` (implementation-planning.md "
+                '§"Evidence note required inside `Statement`").'
+            )
+            continue
+        body = match.group("body").strip()
+        if _EVIDENCE_NONE_RE.match(body) or _EVIDENCE_PATH_LINE_RE.search(body):
+            continue
+        failures.append(
+            f"final-report data.json: clarification `{row_id}` has a malformed "
+            f"`Evidence checked:` note ({body[:60]!r}). It must cite a concrete "
+            "`<path>:<line>` or use the form `none — <human-only reason>`; a "
+            "bare assertion records no lookup."
+        )
+
+
+def _validate_self_fix_grouping(data: dict, failures: list[str]) -> None:
+    """A self-fix round must be instructed by cause, not as a flat item list.
+
+    Blocked items are usually several derivatives of one defect. Instructed
+    item-by-item, each patch corrects its own section and leaves the sibling
+    sections still asserting the old value, so the next round re-finds the same
+    family and the budget drains without converging. Recording the grouping
+    makes the lead commit to a diagnosis and makes a one-group-per-item
+    non-diagnosis visible in the artifact rather than invisible in a prompt.
+
+    Recording rounds here also ties `selfFixRoundsApplied` to work that exists
+    in the data: it was a free-floating self-reported integer, yet
+    `_validate_self_fix_before_clarification` gates promotion on its value.
+    """
+    ip = data.get("implementationPlanning")
+    if not isinstance(ip, dict):
+        return
+    pbv = ip.get("planBodyVerification")
+    if not isinstance(pbv, dict):
+        return
+    rounds_applied = pbv.get("selfFixRoundsApplied")
+    if not isinstance(rounds_applied, int) or rounds_applied < 1:
+        return
+
+    groups = [g for g in (pbv.get("selfFixGroups") or []) if isinstance(g, dict)]
+    if not groups:
+        failures.append(
+            "final-report data.json: planBodyVerification declares "
+            f"`selfFixRoundsApplied`={rounds_applied} but records no "
+            "`selfFixGroups`. Each round's targets MUST be grouped by common "
+            "cause before being handed to report-writer — a flat item list "
+            "makes every patch leave its siblings' contradictions standing "
+            '(plan-body-verification.md §"Round protocol" step 7).'
+        )
+        return
+
+    rounds = [g.get("round") for g in groups if isinstance(g.get("round"), int)]
+    if rounds and max(rounds) != rounds_applied:
+        failures.append(
+            "final-report data.json: planBodyVerification "
+            f"`selfFixRoundsApplied`={rounds_applied} does not match the highest "
+            f"round recorded in `selfFixGroups` ({max(rounds)}). The round count "
+            "must be derivable from recorded work, not asserted independently of "
+            "it — promotion eligibility is gated on this number."
+        )
+
+    known_ids = {
+        str(item.get("id")).strip()
+        for item in (pbv.get("planItems") or [])
+        if isinstance(item, dict) and str(item.get("id") or "").strip()
+    }
+    grouped_ids = [
+        str(item_id).strip()
+        for group in groups
+        for item_id in (group.get("itemIds") or [])
+        if str(item_id or "").strip()
+    ]
+    unknown = sorted({i for i in grouped_ids if i not in known_ids})
+    if unknown:
+        failures.append(
+            "final-report data.json: planBodyVerification.selfFixGroups targets "
+            f"plan item(s) {unknown} that do not exist in `planItems`."
+        )
+
+    fixed_ids = {
+        str(item.get("id")).strip()
+        for item in (pbv.get("planItems") or [])
+        if isinstance(item, dict)
+        and str(item.get("selfFixNote") or "").strip()
+        and str(item.get("id") or "").strip()
+    }
+    ungrouped = sorted(fixed_ids - set(grouped_ids))
+    if ungrouped:
+        failures.append(
+            "final-report data.json: plan item(s) "
+            f"{ungrouped} carry a `selfFixNote` but appear in no "
+            "`selfFixGroups` entry. Every item a round corrected must be "
+            "attributable to the cause group it was instructed under."
+        )
+
+
+_ANSWERED_CLARIFICATION_STATUSES = frozenset({"answered", "resolved"})
+
+
+def _answered_clarification_ids(data: dict) -> list[str]:
+    """Clarifications this run incorporated an answer for — the rows whose
+    answers can invalidate statements the previous run wrote."""
+    return [
+        str(row.get("id")).strip()
+        for row in (data.get("clarificationItems") or [])
+        if isinstance(row, dict)
+        and str(row.get("status") or "").strip() in _ANSWERED_CLARIFICATION_STATUSES
+        and str(row.get("userInput") or "").strip()
+        and str(row.get("id") or "").strip()
+    ]
+
+
+def _validate_supersession_ledger(data: dict, failures: list[str]) -> None:
+    """Incorporating an answer means retiring what it invalidates, not only
+    adding what it decides.
+
+    A re-run reconciles each `C-*` row's `Status` and writes the new decision
+    into the plan, but nothing required it to remove the sentences the answer
+    made false. The result is one plan carrying two opposite instructions for
+    the same symbol — the implementer then has to guess which one is live, and
+    the §5.5.9 round correctly blocks on it. This check makes the writer state,
+    per answered clarification, what it retired or why nothing was contingent
+    on that answer. The claim's *truth* is what the §5.5.9 adversarial round
+    tests; this only forces the claim to exist and be attributable.
+    """
+    ip = data.get("implementationPlanning")
+    if not isinstance(ip, dict):
+        return
+    answered = _answered_clarification_ids(data)
+    if not answered:
+        return
+    ledger = [e for e in (ip.get("supersessionLedger") or []) if isinstance(e, dict)]
+    covered = {
+        str(entry.get("clarificationId") or "").strip()
+        for entry in ledger
+        if str(entry.get("clarificationId") or "").strip()
+    }
+    missing = [cid for cid in answered if cid not in covered]
+    if missing:
+        failures.append(
+            "final-report data.json: implementationPlanning.supersessionLedger has "
+            f"no entry for answered clarification(s) {sorted(missing)}. Every "
+            "answer this run incorporated MUST record what it superseded "
+            "(`disposition: superseded` with the retired statement and the "
+            "sections revised) or state that no plan statement was contingent "
+            "on it (`disposition: no-dependent-statement` with a rationale). "
+            "Adding the new decision while leaving the contradicting sentence "
+            "in place is what puts two opposite instructions in one plan "
+            '(_common-contract.md §"clarification response carry-in").'
+        )
+    stale = sorted(covered - set(answered))
+    if stale:
+        failures.append(
+            "final-report data.json: implementationPlanning.supersessionLedger "
+            f"cites {stale}, which this run did not answer. A ledger entry must "
+            "correspond 1:1 to a clarification whose answer this run "
+            "incorporated."
+        )
+
+
+def _safe_resolve(path: Path) -> Path | None:
+    """``path.resolve()`` that returns None instead of raising, so a
+    malformed recorded path degrades to "no match" rather than a crash."""
+    try:
+        return path.resolve()
+    except (OSError, ValueError):
+        return None
+
+
+def _carry_in_source_for_run(run_manifest_path: Path) -> str:
+    """The carry-in source path THIS run was launched with, read off the
+    per-run ``run-inputs-<task-type>-<seq>.json`` sibling. Empty string when
+    the run had no carry-in or the evidence is unreadable.
+
+    File existence is NOT a usable signal here: ``instruction-set/`` lives at
+    the task root and is shared by every run of the task-key, and
+    ``run.py:_write_instruction_set_sources`` only mkdirs and overwrites — it
+    never clears the directory. So a ``clarification-response.md`` on disk may
+    have been staged by an earlier run, and keying off the file alone would
+    fail every later run of a task that ever used ``--clarification-response``.
+    The run-inputs record is the only per-run evidence.
+    """
+    name = run_manifest_path.name
+    if not name.startswith("run-manifest-") or not name.endswith(".json"):
+        return ""
+    inputs_path = run_manifest_path.with_name(
+        name.replace("run-manifest-", "run-inputs-", 1)
+    )
+    # Absent/malformed run-inputs has its own reporting path
+    # (`_approved_plan_path_from_run_inputs`); discard the reader's
+    # conformance-gate failures so this check stays silent on that input.
+    payload = _read_run_inputs_payload(inputs_path, [])
+    if payload is None:
+        return ""
+    inputs = payload.get("inputs")
+    if not isinstance(inputs, dict):
+        return ""
+    raw = inputs.get("clarificationResponsePath")
+    return raw.strip() if isinstance(raw, str) else ""
+
+
+def _validate_clarification_carry_in_recorded(
+    data: dict,
+    report_path: Path,
+    run_manifest_path: Path,
+    project_root: Path,
+    failures: list[str],
+) -> None:
+    """A clarification response carried into this run must be recorded in §0.
+
+    Enforcement ran in one direction only: `_EMPTY_CARRY_IN_RE` fails a report
+    that emits an empty `## 0.` stub when nothing was carried in. Nothing
+    failed the opposite — a run launched with `--clarification-response` whose
+    report never records `clarificationCarryIn.sourceFile`. The template gates
+    the whole `## 0.` section on that field, so an unrecorded carry-in makes
+    the section vanish and the user's answers leave no audit trace at all.
+    `_validate_supersession_ledger` covers a slice of this but returns unless
+    `implementationPlanning` is a dict, so it is inert for `implementation`
+    and every other non-planning phase.
+
+    Two spellings of `sourceFile` are accepted because two shipped contracts
+    disagree: `_implementation-deliverable.md` and `launch.template.md` name
+    the staged copy, while `report-writer.md` and the schema description name
+    the source the run was launched with. Both identify a real file this run
+    consumed, so failing either one would be a false accusation.
+    """
+    source = _carry_in_source_for_run(run_manifest_path)
+    if not source:
+        return
+    task_root = _task_root_from_run_dir(report_path.parent.parent)
+    staged = task_root / "instruction-set" / "clarification-response.md"
+    if not staged.is_file():
+        return
+
+    carry_in = data.get("clarificationCarryIn")
+    recorded = (
+        str(carry_in.get("sourceFile") or "").strip()
+        if isinstance(carry_in, dict)
+        else ""
+    )
+    if not recorded:
+        failures.append(
+            "final report does not record the clarification response this run "
+            f"was launched with (`{source}`, staged at `{staged}`). "
+            "`clarificationCarryIn.sourceFile` is missing from the data.json, "
+            "so the renderer omits `## 0. Clarification Response Carried In "
+            "From Previous Run` entirely and nothing in the report shows which "
+            "user answers it incorporated. Set `clarificationCarryIn."
+            "sourceFile` to the staged carry-in path."
+        )
+        return
+
+    accepted = {p for p in (_safe_resolve(staged),) if p is not None}
+    source_path = Path(source)
+    if source_path.is_absolute():
+        resolved_source = _safe_resolve(source_path)
+        if resolved_source is not None:
+            accepted.add(resolved_source)
+
+    recorded_path = Path(recorded)
+    # A recorded relative value may be project-root-relative (schema wording)
+    # or task-root-relative (`instruction-set/clarification-response.md`, the
+    # deliverable profile's wording); accept whichever lands on a real target.
+    bases = (
+        (recorded_path,)
+        if recorded_path.is_absolute()
+        else (project_root / recorded_path, task_root / recorded_path)
+    )
+    candidates = {p for p in (_safe_resolve(b) for b in bases) if p is not None}
+    if candidates & accepted:
+        return
+
+    failures.append(
+        f"final report records `clarificationCarryIn.sourceFile` as "
+        f"`{recorded}`, which resolves to neither the carry-in this run staged "
+        f"(`{staged}`) nor the source it was launched with (`{source}`). "
+        "`## 0.` must name the file whose answers this run actually "
+        "incorporated — pointing it at some other file makes the section "
+        "unauditable."
+    )
+
+
+_PASSING_VERDICT_TOKENS = frozenset({"accepted", "conditional-accept"})
+
+
+def _consumers_rows(report_path: Path) -> list[dict] | None:
+    """`runs/implementation-planning/consumers.jsonl` rows for this task.
+
+    The final-verification report sits at `runs/final-verification/[stage-N/]
+    reports/...`, so walk up to the `runs/` directory rather than guessing a
+    fixed depth. ``None`` when the file is absent, so the caller does not turn
+    a missing artifact into a false accusation.
+    """
+    runs_dir = None
+    for parent in report_path.parents:
+        if parent.name == "runs":
+            runs_dir = parent
+            break
+    if runs_dir is None:
+        return None
+    path = runs_dir / "implementation-planning" / "consumers.jsonl"
+    if not path.is_file():
+        return None
+    rows = []
+    try:
+        for line in path.read_text(encoding="utf-8").splitlines():
+            line = line.strip()
+            if line:
+                rows.append(json.loads(line))
+    except (OSError, json.JSONDecodeError):
+        return None
+    return rows
+
+
+_TARGET_FIELD_RES = {
+    "scope": re.compile(r"\*\*Verification scope:\*\*\s*`([^`]*)`"),
+    "worktree": re.compile(r"\*\*Worktree:\*\*\s*`([^`]*)`"),
+    "base": re.compile(r"\*\*Verification base ref:\*\*\s*`([^`]*)`"),
+    "head": re.compile(r"\*\*Verification head ref:\*\*\s*`([^`]*)`"),
+}
+_TARGET_STAGES_RE = re.compile(r"\*\*Stages under verification:\*\*\s*\[([^\]]*)\]")
+# Anchored at the line start so the cut excludes the `- ` list marker; the
+# digest covers the snapshot body only, so leaving the marker in shifts the
+# hash and makes every well-formed target look tampered with.
+_TARGET_DIGEST_RE = re.compile(
+    r"^- \*\*Verification target digest:\*\*\s*`([^`]*)`", re.M
+)
+
+
+def _read_verification_target(project_root: Path, relative: str) -> dict | None:
+    """The prepared target snapshot, but only when its digest still checks out.
+
+    The digest covers the snapshot body (everything before the digest line, as
+    `write_verification_target_snapshot` normalizes it). A file that no longer
+    matches its own digest is not evidence of anything, so return ``None``
+    rather than compare against text someone edited after prep.
+    """
+    path = project_root / relative
+    if not path.is_file():
+        return None
+    try:
+        content = path.read_text(encoding="utf-8")
+    except OSError:
+        return None
+    digest_match = _TARGET_DIGEST_RE.search(content)
+    if digest_match is None:
+        return None
+    body = content[: digest_match.start()]
+    body = body.replace("\r\n", "\n").replace("\r", "\n").rstrip() + "\n"
+    recomputed = "sha256:" + hashlib.sha256(body.encode("utf-8")).hexdigest()
+    if recomputed != digest_match.group(1).strip():
+        return None
+    parsed = {
+        key: (match.group(1).strip() if (match := pattern.search(body)) else "")
+        for key, pattern in _TARGET_FIELD_RES.items()
+    }
+    stages_match = _TARGET_STAGES_RE.search(body)
+    parsed["stages"] = (
+        {int(v) for v in re.findall(r"\d+", stages_match.group(1))}
+        if stages_match
+        else set()
+    )
+    return parsed
+
+
+def _validate_plan_body_state_file(
+    data: dict,
+    report_path: Path,
+    failures: list[str],
+) -> None:
+    """The per-round state file must exist once a round has run.
+
+    Nothing read this file, so its documented schema was dead contract — yet
+    it is the only record of *superseded* rounds. `planItems[].verdicts` in
+    data.json is overwritten by each self-fix re-verification, so after the
+    loop the report shows the final votes and no trace of what the earlier
+    rounds found. Both defect investigations of this phase depended on the
+    sidecar to recover that history.
+
+    Deliberately does NOT cross-check `gateResult` against data.json: the two
+    are different views by design (per-round history vs. final state), and
+    demanding equality would fail every run whose self-fix loop worked.
+    """
+    ip = data.get("implementationPlanning")
+    if not isinstance(ip, dict):
+        return
+    pbv = ip.get("planBodyVerification")
+    if not isinstance(pbv, dict):
+        return
+    round_count = pbv.get("roundCount")
+    if not isinstance(round_count, int) or round_count < 1:
+        return
+    seq = _report_run_seq(report_path)
+    if seq is None:
+        return
+    state_dir = report_path.parent.parent / "state"
+    expected = state_dir / f"plan-body-verification-implementation-planning-{seq}.json"
+    if not expected.is_file():
+        failures.append(
+            f"plan-body verification ran ({round_count} round(s)) but "
+            f"`state/{expected.name}` was not written. It is the only record "
+            "of superseded rounds — data.json keeps just the final verdicts, "
+            "so without it a self-fixed run leaves no trace of what the "
+            'earlier rounds found (plan-body-verification.md §"schema").'
+        )
+        return
+    try:
+        state = json.loads(expected.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        failures.append(f"plan-body verification state file is unreadable: {exc}")
+        return
+    for key in ("schemaVersion", "gateResult", "planItems"):
+        if key not in state:
+            failures.append(
+                f"plan-body verification state file `{expected.name}` is "
+                f"missing required key `{key}`."
+            )
+
+
+_QA_NOT_CONFIGURED_TEMPLATE = "qa-command not configured: {category}"
+
+
+def _validate_missing_qa_categories_recorded(
+    data: dict,
+    project_root: Path,
+    failures: list[str],
+) -> None:
+    """"lint is clean" and "lint never ran" must not read the same.
+
+    The verifier contract requires one `qa-command not configured: <category>`
+    line per category absent from `project.json.qaCommands`, but the literal
+    appeared nowhere in the codebase — so a category that was never executed
+    was indistinguishable in the report from one that passed. That reads as
+    verification coverage the run does not have.
+    """
+    implementation = data.get("implementation")
+    if not isinstance(implementation, dict):
+        return
+    results = [r for r in (implementation.get("verifierResults") or []) if isinstance(r, dict)]
+    if not results:
+        return
+    # `db-test` is deliberately excluded: the contract requires its note only
+    # when the diff touches DB/IO/SQL, and that condition is not decidable
+    # here. Demanding it unconditionally would fail every project that has no
+    # database — a false positive, which in a blocking validator is worse than
+    # the gap it closes. The DB case keeps its own gate (the blocking finding
+    # `db-test not configured — DB change unverified`).
+    unconditional_categories = ("lint", "format", "typecheck", "test")
+    path = project_json_path(project_root)
+    if not path.is_file():
+        return
+    try:
+        configured = json.loads(path.read_text(encoding="utf-8")).get("qaCommands") or {}
+    except (OSError, json.JSONDecodeError):
+        return
+    if not isinstance(configured, dict):
+        return
+
+    recorded = "\n".join(
+        str(value)
+        for row in results
+        for value in row.values()
+        if isinstance(value, str)
+    )
+    missing = [
+        category
+        for category in unconditional_categories
+        if not configured.get(category)
+        and _QA_NOT_CONFIGURED_TEMPLATE.format(category=category) not in recorded
+    ]
+    if missing:
+        failures.append(
+            "final-report data.json: `project.json.qaCommands` declares no "
+            f"command for {missing}, but no verifier result records "
+            f"`{_QA_NOT_CONFIGURED_TEMPLATE.format(category='<category>')}` for "
+            "them. An unrun category MUST be stated as unrun — otherwise the "
+            "report reads as though it passed "
+            '(_implementation-verifier.md §"Missing-tier handling").'
+        )
+
+
+def _load_report_data(report_path: Path) -> dict | None:
+    """The report's data.json, or ``None`` when it is missing or malformed.
+    Both cases are already reported by `validate_final_report_data`; callers
+    here only need to skip rather than re-report."""
+    data_path = _data_path_for(report_path)
+    if not data_path.is_file():
+        return None
+    try:
+        loaded = json.loads(data_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return None
+    return loaded if isinstance(loaded, dict) else None
+
+
+def _validate_verification_target_match(
+    data: dict,
+    run_manifest: dict,
+    project_root: Path,
+    failures: list[str],
+) -> None:
+    """The verification report must mirror the target it was prepared against.
+
+    `verificationScope`, the worktree, and the base/head refs were entirely
+    self-declared: the schema required the fields to exist but nothing compared
+    them to the digest-verified snapshot written at prep time. That matters
+    because both `handoff.compute_eligibility` and the `release-handoff`
+    routing check read `verificationScope` — a single-stage run that writes
+    `whole-task` passes both, and an `accepted` verdict can be rendered against
+    a worktree or head nobody verified.
+    """
+    instruction_set = run_manifest.get("instructionSet")
+    if not isinstance(instruction_set, dict):
+        return
+    relative = str(instruction_set.get("verificationTargetPath") or "").strip()
+    if not relative:
+        return
+    target = _read_verification_target(project_root, relative)
+    if target is None:
+        return
+
+    source = (data.get("finalVerification") or {}).get("sourceImplementationReport") or {}
+    declared = {
+        "scope": str(data.get("verificationScope") or "").strip(),
+        "worktree": str(source.get("worktreePath") or "").strip(),
+        "base": str(source.get("implementationBaseRef") or "").strip(),
+        "head": str(source.get("capturedHeadSha") or "").strip(),
+    }
+    for key, expected in ((k, target[k]) for k in _TARGET_FIELD_RES):
+        actual = declared[key]
+        if expected and actual and actual != expected:
+            failures.append(
+                f"final-verification report declares {key} `{actual}` but the "
+                f"prepared verification target says `{expected}` "
+                f"(`{relative}`). The report must mirror the target it was "
+                "prepared against — `verificationScope` in particular gates "
+                "both stage-group eligibility and release-handoff routing, so "
+                "a self-declared value lets a run be judged as something it "
+                "was not."
+            )
+
+    declared_stages = {
+        row.get("stage")
+        for row in ((data.get("finalVerification") or {}).get("stageReports") or [])
+        if isinstance(row, dict) and isinstance(row.get("stage"), int)
+    }
+    if target["stages"] and declared_stages and declared_stages != target["stages"]:
+        failures.append(
+            f"final-verification report covers stages {sorted(declared_stages)} "
+            f"but the prepared target names {sorted(target['stages'])} "
+            f"(`{relative}`). A verdict must not be rendered for a stage set "
+            "nobody prepared evidence for."
+        )
+
+
+def _validate_verified_row_recorded(
+    data: dict,
+    report_path: Path,
+    failures: list[str],
+) -> None:
+    """An accepted single-stage verification must leave its `verified` row.
+
+    `okstra handoff record-verified` validates its own inputs, but nothing
+    checked that it ever ran. Skipping it leaves the report saying `accepted`
+    while `consumers.jsonl` says the stage was never verified, so
+    `handoff.compute_eligibility` never offers it for a stage-group PR — and
+    the only recoveries are re-running an expensive phase or hand-editing the
+    registry.
+    """
+    if str(data.get("verificationScope") or "") != "single-stage":
+        return
+    token = str((data.get("finalVerdict") or {}).get("verdictToken") or "").strip()
+    if token.lower() != "accepted":
+        return
+    stages = {
+        row.get("stage")
+        for row in ((data.get("finalVerification") or {}).get("stageReports") or [])
+        if isinstance(row, dict) and isinstance(row.get("stage"), int)
+    }
+    if not stages:
+        return
+    rows = _consumers_rows(report_path)
+    if rows is None:
+        return
+    verified = {
+        row.get("stage")
+        for row in rows
+        if isinstance(row, dict) and row.get("status") == "verified"
+    }
+    missing = sorted(s for s in stages if s not in verified)
+    if missing:
+        failures.append(
+            f"final-verification accepted stage(s) {missing} but "
+            "`runs/implementation-planning/consumers.jsonl` carries no "
+            "`verified` row for them. Run `okstra handoff record-verified` "
+            "before finishing — without that row the report says accepted "
+            "while the registry says unverified, and the stage is never "
+            "offered for a stage-group PR "
+            '(final-verification.md §"Verified-row recording").'
+        )
+
+
+def _validate_verifier_fail_blocks_verdict(data: dict, failures: list[str]) -> None:
+    """A verifier FAIL cannot be dropped during synthesis.
+
+    `implementation.verifierResults[]` was written, read by the stage-fix carry
+    helper, and by nothing else — no check compared a recorded `FAIL` against
+    the verdict the lead published. A FAIL lost in synthesis lets
+    `final-verification` reach `accepted` and `release-handoff` push work a
+    verifier rejected.
+    """
+    implementation = data.get("implementation")
+    if not isinstance(implementation, dict):
+        return
+    failed = sorted({
+        str(row.get("verifier") or "<unknown>")
+        for row in (implementation.get("verifierResults") or [])
+        if isinstance(row, dict) and str(row.get("verdict") or "").strip() == "FAIL"
+    })
+    if not failed:
+        return
+    token = str((data.get("verdictCard") or {}).get("verdictToken") or "").strip()
+    if token in _PASSING_VERDICT_TOKENS:
+        failures.append(
+            f"final-report data.json: verifier(s) {failed} recorded "
+            f"`verdict: FAIL` but `verdictCard.verdictToken` is `{token}`. A "
+            "verifier rejection MUST survive into the published verdict — "
+            "dropping it during synthesis is how rejected work reaches "
+            "`release-handoff`. Either carry the FAIL into a blocking verdict "
+            "or record why the verifier's finding was withdrawn."
+        )
+
+
+def _validate_stage_carry_sidecar_exists(
+    data: dict,
+    report_path: Path,
+    failures: list[str],
+) -> None:
+    """The stage carry sidecar must exist on disk, not only be transcribed.
+
+    `implementation.stageSidecarEvidence` is prose the report quotes, so a
+    report can describe a sidecar that was never written. `consumers` treats
+    the carry file as the source of truth for marking a stage `done`, so a
+    missing file leaves the stage permanently un-done and blocks every
+    dependent stage with a `PrepareError` — while the run that caused it
+    finished reporting success.
+    """
+    implementation = data.get("implementation")
+    if not isinstance(implementation, dict):
+        return
+    evidence = implementation.get("stageSidecarEvidence")
+    if not isinstance(evidence, dict):
+        return
+    stage = evidence.get("stageNumber")
+    if not isinstance(stage, int):
+        return
+    # `report_path` is `runs/implementation/reports/final-report-...md`.
+    carry_path = report_path.parent.parent / "carry" / f"stage-{stage}.json"
+    if not carry_path.exists():
+        failures.append(
+            f"implementation run declares stage-{stage} sidecar evidence but "
+            f"`{carry_path.parent.name}/{carry_path.name}` does not exist. The "
+            "carry file is what marks the stage `done` for dependent stages; "
+            "without it this stage never completes and every successor fails "
+            "to prepare, even though this run reported success "
+            '(_implementation-executor.md §"Sidecar evidence writer").'
+        )
+
+
+def _validate_round_recorded_verdicts(data: dict, failures: list[str]) -> None:
+    """A round that ran must leave the votes it ran on.
+
+    The gate is re-derived from `planItems[].verdicts[]`, so an empty table
+    removes the very evidence the recompute judges. A *healthier* declared gate
+    is already caught — empty verdicts recompute to `aborted-non-result`, which
+    every passing value outranks. What slipped through was the conservative
+    declaration: a lead writing `aborted-non-result` over an empty table
+    produces a gate nothing can audit, indistinguishable from a round that was
+    dispatched and whose results were never transcribed.
+    """
+    ip = data.get("implementationPlanning")
+    if not isinstance(ip, dict):
+        return
+    pbv = ip.get("planBodyVerification")
+    if not isinstance(pbv, dict):
+        return
+    round_count = pbv.get("roundCount")
+    if not isinstance(round_count, int) or round_count < 1:
+        return
+    items = [it for it in (pbv.get("planItems") or []) if isinstance(it, dict)]
+    if not items:
+        return
+    if any(it.get("verdicts") for it in items):
+        return
+    failures.append(
+        "final-report data.json: planBodyVerification declares "
+        f"`roundCount`={round_count} but every one of the {len(items)} "
+        "`planItems[]` carries an empty `verdicts[]`. A round that ran MUST "
+        "record the votes it produced — the gate is re-derived from this "
+        "table, so an empty one leaves the declared `gateResult` unauditable. "
+        "A dispatch that returned nothing is recorded as `verification-error`, "
+        'not omitted (plan-body-verification.md §"Round protocol" step 4).'
+    )
+
+
+def _validate_verdicts_match_current_subjects(
+    data: dict,
+    failures: list[str],
+) -> None:
+    """A verdict must still be attached to the element it was cast on.
+
+    `P-*` ids are positional (`plan_items.py` numbers rows by array index), so
+    when a self-fix round deletes a plan element every later row shifts up one.
+    A dangling id at the tail is already caught by
+    `_validate_plan_item_extraction_completeness`, but the shift itself is not:
+    the id set still matches while each surviving verdict now points at its
+    neighbour. The recorded `subject` is what makes the shift visible — it is a
+    snapshot of the row the worker actually judged.
+    """
+    ip = data.get("implementationPlanning")
+    if not isinstance(ip, dict):
+        return
+    pbv = ip.get("planBodyVerification")
+    if not isinstance(pbv, dict):
+        return
+    round_count = pbv.get("roundCount")
+    if not isinstance(round_count, int) or round_count < 1:
+        return
+    try:
+        current = {
+            str(item["id"]): str(item.get("subject") or "")
+            for item in extract_plan_items(ip)
+        }
+    except Exception:  # noqa: BLE001
+        # Extraction failure is already reported by the completeness check;
+        # do not double-report it here as a spurious subject mismatch.
+        return
+
+    drifted = []
+    for item in pbv.get("planItems") or []:
+        if not isinstance(item, dict):
+            continue
+        item_id = str(item.get("id") or "").strip()
+        recorded = str(item.get("subject") or "").strip()
+        expected = current.get(item_id)
+        if expected is None or not recorded:
+            continue
+        if recorded != expected.strip():
+            drifted.append(item_id)
+    if drifted:
+        failures.append(
+            f"final-report data.json: plan item(s) {sorted(drifted)} carry a "
+            "`subject` that no longer matches the plan element at that "
+            "position. `P-*` ids are positional, so deleting an element during "
+            "self-fix shifts every later row and silently re-points its "
+            "verdicts at a different element — a recorded blocker then refers "
+            "to something the reader cannot find. Re-extract the plan items "
+            "and re-verify the shifted ones instead of carrying the old votes "
+            'forward (plan-body-verification.md §"Round protocol" step 7).'
+        )
+
+
+def _validate_aborted_gate_has_clarification(data: dict, failures: list[str]) -> None:
+    """A gate nobody can act on is a stalled task.
+
+    `aborted-non-result` correctly refuses approval and run-prep fail-closes
+    the `implementation` entry, but the clarification matcher only walks
+    `majority-disagree` items — and an aborted round has none. So the report
+    stated no blocker, `okstra-user-response` had nothing to present, and the
+    run stalled with no remedy until someone read the gate value by hand.
+    """
+    ip = data.get("implementationPlanning")
+    if not isinstance(ip, dict):
+        return
+    pbv = ip.get("planBodyVerification")
+    if not isinstance(pbv, dict):
+        return
+    if str(pbv.get("gateResult") or "").strip() != "aborted-non-result":
+        return
+    has_open_blocker = any(
+        isinstance(row, dict)
+        and row.get("blocks") == "approval"
+        and str(row.get("status") or "").strip() == "open"
+        for row in (data.get("clarificationItems") or [])
+    )
+    if not has_open_blocker:
+        failures.append(
+            "final-report data.json: planBodyVerification `gateResult` is "
+            "`aborted-non-result` but no open `Blocks=approval` clarification "
+            "row explains it. An aborted round blocks approval without "
+            "producing any majority-disagree item, so without this row the "
+            "report names no blocker, `okstra-user-response` has nothing to "
+            "present, and the task stalls with no stated remedy. Add a row "
+            "naming which dispatches returned no result and what re-running "
+            'them requires (plan-body-verification.md §"Round protocol").'
+        )
+
+
+def _plan_verify_result_workers(report_path: Path, task_type: str) -> set[str] | None:
+    """Worker roles that actually returned a plan-body reverify result.
+
+    Result files are named
+    ``<role-slug>-plan-verify-r<N>-<task-type>-<seq>.md`` per
+    `plan-body-verification.md` §"Round protocol" step 3, and the role slug is
+    ``<role>-plan-verify-r<N>``. Returns ``None`` when the directory is absent
+    so the caller can distinguish "no artifacts to check against" from "nobody
+    voted".
+    """
+    worker_results_dir = report_path.parent.parent / "worker-results"
+    if not worker_results_dir.is_dir():
+        return None
+    # Scoped to this run's seq for the same reason the audit check is: the
+    # directory accumulates every run, so an unscoped glob would let a prior
+    # run's result file vouch for a vote this run never collected.
+    seq = _report_run_seq(report_path)
+    pattern = f"*-plan-verify-r*-{task_type}-{seq or '*'}.md"
+    workers = set()
+    for path in worker_results_dir.glob(pattern):
+        role = path.name.split("-plan-verify-r", 1)[0]
+        if role:
+            workers.add(role)
+    return workers
+
+
+def _validate_plan_body_verdict_provenance(
+    data: dict,
+    report_path: Path,
+    failures: list[str],
+) -> None:
+    """A recorded verdict must trace back to a worker that was actually asked.
+
+    Every §5.5.9 gate computation reads `planItems[].verdicts[]` out of the
+    data.json the lead authored, and nothing tied a vote to a dispatch. A lead
+    that skipped the round entirely and wrote `AGREE` for two workers produced
+    `gateResult: passed`, a flippable `approved:`, and a clean validator run —
+    the same self-report weakness `selfFixRoundsApplied` had, but on the votes
+    the whole gate is computed from.
+    """
+    ip = data.get("implementationPlanning")
+    if not isinstance(ip, dict):
+        return
+    pbv = ip.get("planBodyVerification")
+    if not isinstance(pbv, dict):
+        return
+    round_count = pbv.get("roundCount")
+    if not isinstance(round_count, int) or round_count < 1:
+        return
+
+    voters = {
+        str(v.get("worker") or "").strip()
+        for item in (pbv.get("planItems") or [])
+        if isinstance(item, dict)
+        for v in (item.get("verdicts") or [])
+        if isinstance(v, dict) and str(v.get("worker") or "").strip()
+    }
+    if not voters:
+        return
+
+    task_type = str((data.get("header") or {}).get("taskType") or "")
+    dispatched = _plan_verify_result_workers(report_path, task_type)
+    if dispatched is None:
+        return
+    unbacked = sorted(voters - dispatched)
+    if unbacked:
+        failures.append(
+            "final-report data.json: planBodyVerification records verdicts from "
+            f"{unbacked} but no matching plan-body reverify result file exists "
+            f"under `runs/{task_type}/worker-results/` "
+            f"(expected `<worker>-plan-verify-r<N>-{task_type}-<seq>.md`). "
+            "A vote the gate is computed from MUST trace back to a dispatch "
+            "that actually returned — otherwise the round can be skipped and "
+            'the gate still read `passed` (plan-body-verification.md §"Round '
+            'protocol" step 3).'
+        )
+
+
+def _validate_plan_item_extraction_completeness(
+    data: dict,
+    failures: list[str],
+) -> None:
+    """Require the exact deterministic P-* extraction when a round ran."""
+    ip = data.get("implementationPlanning")
+    if not isinstance(ip, dict):
+        return
+    pbv = ip.get("planBodyVerification")
+    if not isinstance(pbv, dict):
+        return
+    round_count = pbv.get("roundCount")
+    if not isinstance(round_count, int) or round_count < 1:
+        return
+    try:
+        expected_sequence = expected_plan_item_ids(ip)
+    except Exception as exc:  # noqa: BLE001
+        failures.append(
+            "final-report data.json: deterministic plan-item extraction failed: "
+            f"{exc}"
+        )
+        return
+
+    actual_sequence = [
+        str(item.get("id") or "").strip()
+        for item in (pbv.get("planItems") or [])
+        if isinstance(item, dict)
+    ]
     expected_ids = set(expected_sequence)
     actual_ids = set(actual_sequence)
     missing = expected_ids - actual_ids
@@ -2575,6 +4146,8 @@ def _validate_plan_body_clarification_matching(data: dict, failures: list[str])
             continue
         if _classify_plan_item_gate(item) != "majority-disagree":
             continue
+        if _is_dissent_downgraded(item, pbv):
+            continue
         item_id = item.get("id") or "<unknown>"
         cid = item.get("clarificationId")
         if not cid:
@@ -2597,12 +4170,6 @@ def _validate_plan_body_clarification_matching(data: dict, failures: list[str])
             )
 
 
-# Stop reasons that justify promoting a still-broken planner-fixable item to the
-# user: the self-fix budget ran out, or a round produced no net resolution so
-# further rounds would repeat themselves.
-_SELF_FIX_EXHAUSTED_REASONS = frozenset({"max-rounds-reached", "no-progress"})
-
-
 def _validate_self_fix_before_clarification(data: dict, failures: list[str]) -> None:
     """A planner-fixable defect MUST exhaust the self-fix budget before it is
     promoted to a `## 1. Clarification Items` row. Closes the hole where the
@@ -2619,26 +4186,16 @@ def _validate_self_fix_before_clarification(data: dict, failures: list[str]) ->
     round_count = pbv.get("roundCount")
     if not isinstance(round_count, int) or round_count < 1:
         return
+    if _self_fix_budget_exhausted(pbv):
+        return
     rounds_applied = pbv.get("selfFixRoundsApplied")
     stop_reason = pbv.get("selfFixStopReason")
-    budget_exhausted = (
-        isinstance(rounds_applied, int)
-        and rounds_applied >= 1
-        and stop_reason in _SELF_FIX_EXHAUSTED_REASONS
-    )
-    if budget_exhausted:
-        return
     for item in pbv.get("planItems") or []:
         if not isinstance(item, dict):
             continue
         if _classify_plan_item_gate(item) != "majority-disagree":
             continue
-        disagrees = [
-            v for v in (item.get("verdicts") or [])
-            if isinstance(v, dict) and str(v.get("verdict") or "").upper() == "DISAGREE"
-        ]
-        fixable = [v for v in disagrees if v.get("fixability") == "planner-fixable"]
-        if disagrees and len(fixable) * 2 > len(disagrees):
+        if _has_planner_fixable_majority(item):
             allowed = " / ".join(sorted(_SELF_FIX_EXHAUSTED_REASONS))
             failures.append(
                 "final-report data.json: plan item "
@@ -3471,6 +5028,47 @@ _CONVERGENCE_INTERMEDIATE_PREFIXES = (
 )
 
 
+def _validate_convergence_rounds_match_manifest(
+    run_dir,
+    run_manifest: dict,
+    failures: list[str],
+) -> None:
+    """The round budget must be the one the run was configured with.
+
+    The engine only checks `effectiveMaxRounds <= maxRounds` *within* the
+    artifact, and the `okstra convergence` CLI never reads the manifest — so
+    both numbers were lead-authored and unlinked to the `convergence.maxRounds`
+    the run was prepared with. Writing `maxRounds: 1` into the artifact when
+    the manifest says 2 legally short-circuits Round 2 via
+    `round2SkippedReason: max-rounds-1` and halves cross-verification depth,
+    with every self-consistency check satisfied.
+    """
+    from pathlib import Path as _Path
+
+    configured = (run_manifest.get("convergence") or {}).get("maxRounds")
+    if not isinstance(configured, int):
+        return
+    state_dir = _Path(run_dir) / "state"
+    if not state_dir.is_dir():
+        return
+    for state_path in sorted(state_dir.glob("convergence-*.json")):
+        if state_path.name.startswith(_CONVERGENCE_INTERMEDIATE_PREFIXES):
+            continue
+        try:
+            state = json.loads(state_path.read_text(encoding="utf-8"))
+        except (OSError, json.JSONDecodeError):
+            continue
+        declared = (state.get("config") or {}).get("maxRounds")
+        if isinstance(declared, int) and declared != configured:
+            failures.append(
+                f"convergence state `{state_path.name}` declares "
+                f"`config.maxRounds`={declared} but the run manifest configured "
+                f"{configured}. The round budget is not the lead's to restate — "
+                "lowering it in the artifact silently halves cross-verification "
+                "depth while every self-consistency check still passes."
+            )
+
+
 def _validate_convergence_states(run_dir, failures) -> None:
     """Replay shared engine invariants for every public final state artifact."""
     from pathlib import Path as _Path
@@ -3494,6 +5092,292 @@ def _validate_convergence_states(run_dir, failures) -> None:
         )
 
 
+def _nonempty_string(value) -> bool:
+    """True for a non-blank string, matching the schema's `\\S` pattern."""
+    return isinstance(value, str) and value.strip() != ""
+
+
+# Round-0 grouping filename: `convergence-groups-<task-type>-<seq>.json`. The
+# `<task-type>-<seq>` suffix is shared verbatim with the worker-result and
+# working-state basenames, so capture it as one token to reconstruct both.
+_CONVERGENCE_GROUPS_BASENAME_RE = re.compile(
+    r"^convergence-groups-(?P<suffix>[a-z][a-z-]*?-\d{3})\.json$"
+)
+
+
+def _convergence_group_claims(document) -> list[tuple[str, str, str]] | None:
+    """Extract `(findingId, worker, itemId)` provenance claims from a grouping.
+
+    Returns ``None`` when the document does not match the convergence-groups
+    schema shape closely enough to read its provenance fields safely — the
+    caller refuses to judge such a file. Otherwise returns the deduplicated
+    claims drawn from every group's ``sourceItems[]`` and ``discoveredBy`` map.
+    """
+    if not isinstance(document, dict) or not isinstance(document.get("groups"), list):
+        return None
+    claims: list[tuple[str, str, str]] = []
+    seen: set[tuple[str, str, str]] = set()
+    for group in document["groups"]:
+        if not isinstance(group, dict):
+            return None
+        finding_id = group.get("findingId")
+        source_items = group.get("sourceItems")
+        discovered_by = group.get("discoveredBy")
+        if (
+            not _nonempty_string(finding_id)
+            or not isinstance(source_items, list)
+            or not isinstance(discovered_by, dict)
+        ):
+            return None
+        pairs: list[tuple[object, object]] = []
+        for item in source_items:
+            if not isinstance(item, dict):
+                return None
+            pairs.append((item.get("worker"), item.get("itemId")))
+        for worker, discovery in discovered_by.items():
+            if not isinstance(discovery, dict):
+                return None
+            pairs.append((worker, discovery.get("itemId")))
+        for worker, item_id in pairs:
+            if not _nonempty_string(worker) or not _nonempty_string(item_id):
+                return None
+            claim = (finding_id, worker, item_id)
+            if claim not in seen:
+                seen.add(claim)
+                claims.append(claim)
+    return claims
+
+
+def _convergence_groups_digest_ok(state_dir, suffix: str, document: dict) -> bool:
+    """False only when a recorded groupsDigest exists and no longer matches.
+
+    ``okstra convergence seed`` pins ``grouped_input_digest`` of the grouping
+    into the working state. When that record is present and disagrees with the
+    on-disk grouping, the file was tampered with or written out of band — not
+    evidence of fabrication — so the caller refuses to judge it. A missing
+    working state or missing digest means judge the file as parsed.
+    """
+    work_path = state_dir / f"convergence-work-{suffix}.json"
+    try:
+        work = json.loads(work_path.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return True
+    recorded = work.get("groupsDigest") if isinstance(work, dict) else None
+    if not _nonempty_string(recorded):
+        return True
+    return grouped_input_digest(document) == recorded
+
+
+def _read_canonical_worker_result(worker_results_dir, worker: str, suffix: str):
+    """Return the `<worker>-<suffix>.md` text, or ``None`` when it is not a
+    resolvable file directly inside ``worker-results/`` (missing, unreadable,
+    or a worker slug that is not a single path component)."""
+    candidate = worker_results_dir / f"{worker}-{suffix}.md"
+    try:
+        if candidate.resolve().parent != worker_results_dir.resolve():
+            return None
+        return candidate.read_text(encoding="utf-8")
+    except (OSError, ValueError):
+        return None
+
+
+def _id_occurs_wordbounded(text: str, item_id: str) -> bool:
+    """True when `item_id` occurs as a literal not flanked by another
+    identifier char, so `F-7` matches neither `F-70` nor `xF-7`."""
+    pattern = r"(?<![0-9A-Za-z_-])" + re.escape(item_id) + r"(?![0-9A-Za-z_-])"
+    return re.search(pattern, text) is not None
+
+
+def _validate_convergence_group_provenance(run_dir, failures) -> None:
+    """Every source item a round-0 grouping cites must exist in the worker file.
+
+    The lead mints its own finding IDs, but each ``sourceItems[].itemId`` and
+    ``discoveredBy.<worker>.itemId`` is copied verbatim from a worker's own
+    result. A grouping that cites ``codex-worker:F-007`` when codex never wrote
+    F-007 is a fabricated provenance link the final report cannot expose. This
+    replays that one claim: the cited item ID must occur, word-boundary
+    anchored, in the worker's canonical result file.
+
+    A validator failure blocks user approval, so unjudgeable input is skipped
+    silently: no groups file, unreadable/malformed JSON, a groups file that
+    fails the schema shape, a missing worker result file (provider-unavailable
+    substitution is legitimate), or a recorded groupsDigest that no longer
+    matches.
+    """
+    from pathlib import Path as _Path
+
+    state_dir = _Path(run_dir) / "state"
+    worker_results_dir = _Path(run_dir) / "worker-results"
+    if not state_dir.is_dir() or not worker_results_dir.is_dir():
+        return
+    for groups_path in sorted(state_dir.glob("convergence-groups-*.json")):
+        match = _CONVERGENCE_GROUPS_BASENAME_RE.match(groups_path.name)
+        if match is None:
+            continue
+        suffix = match.group("suffix")
+        try:
+            document = json.loads(groups_path.read_text(encoding="utf-8"))
+        except (OSError, ValueError):
+            continue
+        claims = _convergence_group_claims(document)
+        if claims is None:
+            continue
+        if not _convergence_groups_digest_ok(state_dir, suffix, document):
+            continue
+        contents: dict[str, str | None] = {}
+        for finding_id, worker, item_id in claims:
+            if worker not in contents:
+                contents[worker] = _read_canonical_worker_result(
+                    worker_results_dir, worker, suffix
+                )
+            text = contents[worker]
+            if text is None or _id_occurs_wordbounded(text, item_id):
+                continue
+            failures.append(
+                f"convergence groups `{groups_path.name}` group {finding_id} "
+                f"cites source item `{worker}:{item_id}`, but that ID does not "
+                f"occur in the worker's result file `{worker}-{suffix}.md` — a "
+                "grouping may not invent a provenance link to an item the "
+                "worker never reported."
+            )
+
+
+# Reverify-prompt basename: `<role-slug>-reverify-r<N>-<task-type>-<seq>.md`.
+# The role slug ends in `-worker` like the worker-result files, but the round
+# plan's `dispatches[].worker` may carry either that full slug or the bare
+# provider token (`claude` vs `claude-worker`), depending on how the roster was
+# seeded — worker resolution below accepts both. `-reverify-r` never occurs
+# inside a slug, so the non-greedy slug capture stops at that literal anchor.
+_REVERIFY_PROMPT_BASENAME_RE = re.compile(
+    r"^(?P<slug>[a-z][a-z0-9-]*?)-reverify-r(?P<round>\d+)"
+    r"-(?P<task_type>[a-z][a-z-]*?)-(?P<seq>\d{3})\.md$"
+)
+
+# The reverify prompt's finding identifier is the lead-minted `### F-NNN` /
+# `### C-NNN` H3 heading inside the `## Findings to verify` block. The older
+# `### VF-N (origin ...)` / `G-NNN` heading shape this token regex deliberately
+# does not match, so historical prompts parse zero ids and are skipped.
+_FINDINGS_TO_VERIFY_HEADING_RE = re.compile(r"^##\s+Findings to verify\s*$")
+_TWO_HASH_HEADING_RE = re.compile(r"^##\s")
+_FINDING_HEADING_TOKEN_RE = re.compile(r"^###\s+(F-\d+|C-\d+)")
+
+
+def _reverify_prompt_finding_ids(content: str) -> set[str] | None:
+    """Distinct `### F-NNN`/`### C-NNN` tokens in the `## Findings to verify`
+    block, or ``None`` when the prompt has no such block.
+
+    The `## Response format` section re-echoes the same headings, so the block
+    is bounded at the next `## ` heading and the tokens are collected into a
+    set — order and re-echoed duplicates are irrelevant because votes are keyed
+    by findingId. An empty set means the block exists but yielded no recognized
+    heading (the historical `VF-N`/`G-NNN` shape); the caller skips both.
+    """
+    lines = content.splitlines()
+    start = None
+    for index, line in enumerate(lines):
+        if _FINDINGS_TO_VERIFY_HEADING_RE.match(line):
+            start = index + 1
+            break
+    if start is None:
+        return None
+    ids: set[str] = set()
+    for line in lines[start:]:
+        if _TWO_HASH_HEADING_RE.match(line):
+            break  # next `## ` section (e.g. `## Response format`) ends the block
+        match = _FINDING_HEADING_TOKEN_RE.match(line)
+        if match:
+            ids.add(match.group(1))
+    return ids
+
+
+def _plan_dispatch_finding_ids(plan, prompt_slug: str) -> set[str] | None:
+    """The `findingIds` set of the single `dispatches[]` row the prompt slug
+    resolves to, or ``None`` when the plan shape is malformed or the slug does
+    not resolve to exactly one row (refuse to judge either way).
+
+    A prompt slug `claude-worker` matches a row whose `worker` is `claude-worker`
+    (exact) or `claude` (bare token, `worker + "-worker" == slug`). The round
+    plan has no JSON schema, so the `dispatches[]` shape is validated defensively.
+    """
+    if not isinstance(plan, dict):
+        return None
+    dispatches = plan.get("dispatches")
+    if not isinstance(dispatches, list):
+        return None
+    matched: list[set[str]] = []
+    for row in dispatches:
+        if not isinstance(row, dict):
+            return None
+        worker = row.get("worker")
+        finding_ids = row.get("findingIds")
+        if not _nonempty_string(worker) or not isinstance(finding_ids, list):
+            return None
+        if any(not _nonempty_string(fid) for fid in finding_ids):
+            return None
+        if worker == prompt_slug or f"{worker}-worker" == prompt_slug:
+            matched.append(set(finding_ids))
+    if len(matched) != 1:
+        return None
+    return matched[0]
+
+
+def _validate_reverify_prompt_matches_plan(run_dir, failures) -> None:
+    """Each reverify prompt must show exactly the findings its plan row assigned.
+
+    `okstra convergence apply-round` checks *who* voted (`votes ⊆ plan`), but
+    nothing checks that the reverify *prompt* carried the findings the plan
+    assigned. A prompt-generation bug or a tampered prompt that drops or adds a
+    `### F-NNN` heading relative to `dispatches[].findingIds` goes undetected,
+    and a vote can be attributed to a finding the worker was never shown. This
+    replays `plan == prompt`, which with the engine's check yields
+    `votes ⊆ what-was-shown`. It stays independent of the engine's own check.
+
+    A validator failure blocks user approval, so any unjudgeable input is
+    skipped silently: no paired plan file for the prompt's (round, task-type,
+    seq) — which also excludes a superseded plan whose seq/task-type differs;
+    no recognizable `## Findings to verify` block or zero headings (guards the
+    historical `VF-N`/`G-NNN` formats); a worker slug that resolves to other
+    than exactly one `dispatches[]` row; and an unreadable/malformed plan.
+    """
+    from pathlib import Path as _Path
+
+    run_dir = _Path(run_dir)
+    prompts_dir = run_dir / "prompts"
+    state_dir = run_dir / "state"
+    if not prompts_dir.is_dir() or not state_dir.is_dir():
+        return
+    for prompt_path in sorted(prompts_dir.glob("*-reverify-r*.md")):
+        match = _REVERIFY_PROMPT_BASENAME_RE.match(prompt_path.name)
+        if match is None:
+            continue
+        round_n = match.group("round")
+        plan_path = state_dir / (
+            f"convergence-round-{round_n}-plan-"
+            f"{match.group('task_type')}-{match.group('seq')}.json"
+        )
+        if not plan_path.is_file():
+            continue  # no paired plan (~96% of artifacts) — never infer from the prompt
+        try:
+            content = prompt_path.read_text(encoding="utf-8")
+            plan = json.loads(plan_path.read_text(encoding="utf-8"))
+        except (OSError, ValueError):
+            continue
+        prompt_ids = _reverify_prompt_finding_ids(content)
+        if not prompt_ids:  # None (no block) or empty set (no F-/C- headings)
+            continue
+        plan_ids = _plan_dispatch_finding_ids(plan, match.group("slug"))
+        if plan_ids is None or prompt_ids == plan_ids:
+            continue
+        failures.append(
+            f"reverify prompt `{prompt_path.name}` (round {round_n}, worker "
+            f"`{match.group('slug')}`) does not show the findings its plan row "
+            f"assigned: in the plan but not the prompt {sorted(plan_ids - prompt_ids)}; "
+            f"in the prompt but not the plan {sorted(prompt_ids - plan_ids)}. The "
+            f"prompt must carry exactly `dispatches[].findingIds` so a vote cannot "
+            f"be attributed to a finding the worker was never shown."
+        )
+
+
 def _validate_requirements_discovery_fanout(run_dir, failures, brief_path=None) -> None:
     """requirements-discovery run 에 fan-out/ 이 있으면 packet+index 를 검증해
     실패를 ``requirements-discovery: `` 접두로 folding 한다. fan-out 이 없으면 no-op.
@@ -3894,6 +5778,7 @@ def main() -> int:
         contract["required_agent_status_entries"],
         failures,
         allow_unavailable_token_usage=_session_accounting(team_state) == "artifact-only",
+        unavailable_ok_labels=_cli_wrapper_worker_labels(team_state),
     )
     validate_team_state_usage(team_state, failures)
 
@@ -3925,7 +5810,17 @@ def main() -> int:
                 _sp = (json.loads(_pj.read_text()).get("qaEnv") or {}).get("surfacePatterns")
             except (OSError, json.JSONDecodeError):
                 _sp = None
-        _validate_conformance(report_path, failures, surface_patterns=_sp)
+        conformance_warnings = _validate_conformance(
+            report_path,
+            failures,
+            surface_patterns=_sp,
+            approved_plan_path=_approved_plan_path_from_run_inputs(
+                run_manifest_path,
+                failures,
+            ),
+        )
+        for warning in conformance_warnings:
+            print(f"validate-run: warning: {warning}", file=sys.stderr)
     if task_type == "implementation-planning":
         _validate_planning_conformance_declared(report_path, failures)
         brief_relative = str(task_manifest.get("taskBriefPath") or "").strip()
@@ -3957,7 +5852,35 @@ def main() -> int:
         _validate_requirements_discovery_fanout(run_dir, failures, brief_path)
     # Phase-agnostic: convergence runs in every finding-producing phase.
     _validate_convergence_states(report_path.parent.parent, failures)
+    _validate_convergence_rounds_match_manifest(
+        report_path.parent.parent, run_manifest, failures
+    )
+    _validate_convergence_group_provenance(report_path.parent.parent, failures)
+    _validate_reverify_prompt_matches_plan(report_path.parent.parent, failures)
     validate_report_views(report_path, failures)
+    if task_type == "implementation":
+        _validate_missing_qa_categories_recorded(
+            _load_report_data(report_path) or {}, project_root, failures
+        )
+    if task_type == "implementation-planning":
+        _validate_plan_body_state_file(
+            _load_report_data(report_path) or {}, report_path, failures
+        )
+    if task_type == "final-verification":
+        _validate_verification_target_match(
+            _load_report_data(report_path) or {},
+            run_manifest,
+            project_root,
+            failures,
+        )
+    # Phase-agnostic: any task-type can be launched with a carry-in.
+    _validate_clarification_carry_in_recorded(
+        _load_report_data(report_path) or {},
+        report_path,
+        run_manifest_path,
+        project_root,
+        failures,
+    )
 
     validation_status = "passed" if not failures else "failed"
     update_validation_metadata(