okstra 0.183.2 → 0.185.0

package/runtime/validators/validate-run.py

@@ -46,6 +46,7 @@ from okstra_ctl.conformance import (  # noqa: E402
     detect_surfaces,
     evaluate_conformance,
     manifest_required_surfaces,
+    missing_declared_scripts,
     normalize_conformance_script as _normalize_conformance_script,
     parse_conformance_tests as _parse_conformance_tests,
     qa_result_from_dict,
@@ -78,6 +79,10 @@ from okstra_ctl.report_translation import (  # noqa: E402
     hangul_share,
 )
 from okstra_ctl.stage_citations import enumerated_stage_numbers  # noqa: E402
+from okstra_ctl.plan_items import (  # noqa: E402
+    advisory_plan_body_gating,
+    stage_scope_bucket as _item_stage_scope_bucket,
+)
 from okstra_ctl.incremental_scope import (  # noqa: E402
     coverage_row_blocked_on,
     stages_for_clarification,
@@ -637,6 +642,35 @@ def write_json(path: Path, payload: dict) -> None:
     path.write_text(json.dumps(payload, indent=2, ensure_ascii=False) + "\n")
 
 
+def _report_already_approved(report_data: Mapping[str, Any] | None) -> bool:
+    if not isinstance(report_data, Mapping):
+        return False
+    frontmatter = report_data.get("frontmatter")
+    return isinstance(frontmatter, Mapping) and frontmatter.get("approved") is True
+
+
+def _derive_awaiting_approval(
+    *,
+    existing: bool,
+    validation_status: str,
+    current_phase: str,
+    pointer: Mapping[str, str],
+    report_data: Mapping[str, Any] | None,
+) -> bool:
+    """planning 이 승인 가능한 plan-ready 를 남기면 올리고, implementation
+    이 그 승인을 소비하면 내린다. 차단 게이트나 열린 Blocks=approval 은
+    포인터가 blocked 라 올리지 않는다."""
+    if validation_status == "passed" and current_phase == "implementation":
+        return False
+    if validation_status == "passed" and current_phase == "implementation-planning":
+        return (
+            pointer.get("phase") == "implementation"
+            and pointer.get("status") == next_phase.STATUS_READY
+            and not _report_already_approved(report_data)
+        )
+    return existing
+
+
 def update_workflow_metadata(
     run_manifest: dict,
     task_manifest: dict,
@@ -688,7 +722,8 @@ def update_workflow_metadata(
             next_recommended_phase = next_phase.make(
                 phase=projected["phase"],
                 status=projected["status"],
-                rationale=(
+                rationale=projected["rationale"]
+                or (
                     "리포트 라우팅에서 투영됨. 리드가 쓴 값과 근거는 "
                     "nextRecommendedPhaseCorrection.authored 에 있다."
                 ),
@@ -708,16 +743,16 @@ def update_workflow_metadata(
             status=next_phase.STATUS_BLOCKED, rationale=authored["rationale"]
         )
 
-    awaiting_approval = workflow.get("awaitingApproval")
-    if not isinstance(awaiting_approval, bool):
-        awaiting_approval = False
-    # 승인 게이트(`frontmatter approved`)는 implementation 진입 직전에 한 번만 의미를 가진다.
-    # implementation run 이 검증을 통과했다는 것은 `_validate_approved_plan` 이 이미 사용자
-    # 승인 플래그(frontmatter `approved: true`)를 소비했다는 뜻이므로, 이 시점에
-    # awaitingApproval 플래그를 명시적으로 내려 다음 phase 의 status 뷰에서 stale 상태로
-    # 남지 않게 한다.
-    if validation_status == "passed" and current_phase == "implementation":
-        awaiting_approval = False
+    awaiting_existing = workflow.get("awaitingApproval")
+    if not isinstance(awaiting_existing, bool):
+        awaiting_existing = False
+    awaiting_approval = _derive_awaiting_approval(
+        existing=awaiting_existing,
+        validation_status=validation_status,
+        current_phase=current_phase,
+        pointer=next_recommended_phase,
+        report_data=report_data,
+    )
 
     last_safe_checkpoint = workflow.get("lastSafeCheckpoint", {})
     if not isinstance(last_safe_checkpoint, dict):
@@ -2167,14 +2202,11 @@ def _planning_conformance_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
-    `qa/conformance-manifest.json`. The profile mandates writing the script +
-    manifest entry as part of emitting that line
-    (implementation-planning.md:83/85); without this check a declaration that
-    was never materialized only surfaces much later at the `implementation`
-    entry gate. Matches by stageKey suffix (`-stage-<N>`) like
-    `_scope_manifest_entries`; skips stages that took a `Conformance exemption:`.
+    """계획 단계는 `Conformance tests:` / `Conformance exemption:` 선언 형식만 본다.
+
+    스크립트 파일과 `runCommand` 는 매칭 implementation stage 가 만든다.
+    선언만 있고 파일이 없는 것은 계획 게이트 실패가 아니다. 형식이 깨진
+    `conformanceTests` 는 여전히 실패한다.
     """
     data_path = report_path.with_suffix(".data.json")
     if not data_path.is_file():
@@ -2186,28 +2218,7 @@ def _validate_planning_conformance_declared(report_path: Path, failures: list[st
     ip = data.get("implementationPlanning")
     if not isinstance(ip, dict):
         return
-    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:
-            manifest = json.loads(manifest_path.read_text())
-            entries = manifest.get("entries") or [] if isinstance(manifest, dict) else []
-        except (OSError, json.JSONDecodeError):
-            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)."
-        )
+    _planning_conformance_declarations(ip.get("stages"), failures)
 
 
 def _validate_conformance_surfaces(
@@ -2280,6 +2291,12 @@ def _validate_conformance(
         )
         if declared_manifest is None:
             return warnings
+    if declared_manifest is not None:
+        scoped_declared = _scope_manifest_entries(declared_manifest, stage_name)
+        for error in missing_declared_scripts(
+            scoped_declared.get("entries"), task_root
+        ):
+            failures.append(f"conformance gate BLOCKING: {error}")
     if not manifest_path.is_file():
         empty_scoped_manifest = {"entries": []}
         if declared_manifest is not None:
@@ -3575,6 +3592,7 @@ def validate_final_report_data(
         _validate_clarification_evidence_note(data, failures)
         _validate_approval_clarification_backtrace(data, failures)
         _validate_rerun_guidance(data, failures)
+        _validate_approval_guidance(data, failures)
         _validate_variation_point_analysis(
             (data.get("implementationPlanning") or {}).get("variationPointAnalysis"),
             resolve_architecture(_project_root_from_report(report_path)),
@@ -3894,9 +3912,11 @@ def _classify_plan_item_gate(item: dict) -> str:
     """Recompute one plan item's gate class from its per-worker verdicts,
     per `prompts/lead/plan-body-verification.md` "Round protocol". Returns one of
     ``majority-disagree`` / ``needs-reverify`` / ``has-dissent`` /
-    ``full-consensus`` / ``all-non-result``. Collapses ``partial-consensus`` and
-    ``dissent-isolated`` into ``has-dissent`` because they resolve to the
-    same gate value; only the majority-disagree boundary changes the gate.
+    ``full-consensus`` / ``all-non-result``. Blocking-kind minority dissent
+    (``dissent-isolated`` / ``partial-consensus`` on ``b``/``c``/``e``) is
+    ``majority-disagree`` so the user gate sees it. ``has-dissent`` remains
+    advisory-only, rollback items, and a single-vote kind that lost its
+    reproduction.
     """
     tokens = [
         (
@@ -3967,6 +3987,18 @@ def _classify_plan_item_gate(item: dict) -> str:
         if _max_verdict_round(item) >= _TIE_SETTLED_ROUND:
             return "majority-disagree"
         return "needs-reverify"
+    if (
+        len(non_error) >= 2
+        and blocking_disagree
+        and (
+            not (blocking_kinds & single_vote_kinds)
+            or _is_variation_point_item(item)
+        )
+    ):
+        # 판단 종류의 소수 반대는 표로 기각하지 않는다. 양쪽이 표를 냈으면
+        # 사용자가 고른다. 재현에 실패한 1표 종류 `a`/`f` 는 위에서 이미
+        # 근거를 잃었으므로 이 분기에 안 들어온다.
+        return "majority-disagree"
     return "has-dissent"
 
 
@@ -4057,11 +4089,10 @@ def _self_fix_budget_exhausted(pbv: dict) -> bool:
 def _state_classification(item: dict, gate_class: str) -> str:
     """This item's `planItems[].rounds[].classification` for the state file.
 
-    The gate classifier deliberately folds `partial-consensus` and
-    `dissent-isolated` into `has-dissent` — only the majority-disagree boundary
-    moves the gate. The state file records the finer label, and the information
-    to recover it is in the same verdicts, so the mapping lives beside the
-    classifier rather than being re-invented by each lead.
+    Blocking-kind `dissent-isolated` / `partial-consensus` is already
+    `majority-disagree` at the gate. `has-dissent` that remains is advisory
+    or a single-vote kind that lost reproduction; the state file then splits
+    that remainder into `dissent-isolated` vs `partial-consensus`.
 
     *gate_class* is passed in rather than recomputed so that the caller's
     effective classification — which may have been downgraded by
@@ -4135,9 +4166,6 @@ def _is_dissent_downgraded(
     )
 
 
-_STARTABLE_STAGE_STATUSES = frozenset({"ready", "active"})
-
-
 def _stage_scope_bucket(item: dict, pbv: dict) -> str:
     """Whether this item has standing to block the stage about to start.
 
@@ -4154,21 +4182,14 @@ def _stage_scope_bucket(item: dict, pbv: dict) -> str:
     `stageScope` belongs to the plan as a whole — `P-Opt-*` and `P-Var-*` live
     there permanently, and scoping them out would stop an unrequested-work
     verdict from blocking a start.
+
+    디스패치 큐와 같은 함수를 쓴다. 검증기가 다른 통을 내면 워커가 안 본
+    항목이 승인을 막거나, 본 항목이 게이트에서 빠진다.
     """
     ledger = pbv.get("stageLedger")
-    if not isinstance(ledger, dict) or not ledger:
-        return "in-scope"
-    scope = item.get("stageScope")
-    stages = [
-        value for value in scope
-        if isinstance(value, int) and not isinstance(value, bool)
-    ] if isinstance(scope, list) else []
-    if not stages:
-        return "in-scope"
-    statuses = {str(ledger.get(str(stage)) or "") for stage in stages}
-    if statuses & _STARTABLE_STAGE_STATUSES:
-        return "in-scope"
-    return "observed" if "done" in statuses else "deferred"
+    return _item_stage_scope_bucket(
+        item, ledger if isinstance(ledger, dict) else None,
+    )
 
 
 def _set_aside_reason(item: dict, pbv: dict, accepted_item_ids: set[str]) -> str | None:
@@ -4244,11 +4265,19 @@ def _recompute_plan_body_gate(
         _plan_item_gate_class(it, pbv, accepted)
         for it in (pbv.get("planItems") or [])
         if isinstance(it, dict)
+        and (
+            _stage_scope_bucket(it, pbv) == "in-scope"
+            or it.get("verdicts")
+        )
     ]
     if not classes:
         return None
     if all(c == "all-non-result" for c in classes):
         return "aborted-non-result"
+    if pbv.get("gating") is False:
+        if any(c in ("majority-disagree", "has-dissent", "needs-reverify", "all-non-result") for c in classes):
+            return "passed-with-dissent"
+        return "passed"
     if any(c == "majority-disagree" for c in classes):
         return "blocked-by-disagreement"
     if any(c in ("has-dissent", "needs-reverify", "all-non-result") for c in classes):
@@ -4433,6 +4462,10 @@ def _gate_blocking_causes(
     """Which inputs actually block approval, as `gateBlockedBy` enum values."""
     causes = set()
     recomputed = _recompute_plan_body_gate(pbv, accepted_item_ids)
+    if pbv.get("gating") is False:
+        if recomputed == "aborted-non-result":
+            causes.add("non-result")
+        return causes
     if recomputed == "blocked-by-disagreement":
         causes.add("majority-disagree")
     elif recomputed == "aborted-non-result":
@@ -6086,16 +6119,16 @@ def _validate_approval_clarification_backtrace(
     direction — a majority-disagree plan item must cite a `blocks: approval`
     row. Nothing walked this way, so a row could withhold approval while
     recording no blast radius at all. The cost lands on the re-run:
-    `incremental-scope` resolves impacted stages from these links and treats an
-    id that traces to no stage as grounds to re-verify everything, so one
-    unlinked blocker turns a narrow re-run into a full one.
+    `incremental-scope` resolves impacted stages from these links and will not
+    silently narrow past an id that traces to no stage, so this report fails
+    rather than forcing a full re-run.
 
     The link must also *resolve to a stage*, which is the thing the re-run
     actually reads. Checking only that a link exists let a row satisfy this
-    gate and still force full: `P-Req-*` and `P-Val-*` ids are numbered by
-    position in their own array, so they carry no stage, and a blocked
-    coverage row whose `coveredBy` is prose cites none either. Both shapes
-    passed while the re-run they were meant to narrow re-verified everything.
+    gate while the next re-run still could not place the answer: `P-Req-*`
+    and `P-Val-*` ids are numbered by position in their own array, so they
+    carry no stage, and a blocked coverage row whose `coveredBy` is prose
+    cites none either.
     """
     if (data.get("header") or {}).get("taskType") != "implementation-planning":
         return
@@ -6117,8 +6150,9 @@ def _validate_approval_clarification_backtrace(
                 "but has no back-trace into the plan — no plan item carries it as "
                 "`clarificationId`, and no requirement-coverage row is `blocked "
                 f"{row_id}` in its `status` or `approvalDisposition`. An item that "
-                "withholds approval without recording what it affects forces the "
-                "next re-run to re-verify everything."
+                "withholds approval without recording what it affects cannot "
+                "place the next re-run's scope; this report fails rather than "
+                "forcing a full re-run."
             )
             continue
         if stages_for_clarification(data, row_id):
@@ -6131,12 +6165,13 @@ def _validate_approval_clarification_backtrace(
             f"blocked coverage row's `coveredBy`. A `P-Req-*` / `P-Val-*` id "
             "carries no stage number, so a row linked only that way must cite "
             "the stage in `coveredBy`. A blocker whose blast radius resolves to "
-            "no stage costs exactly what an unlinked one does — the next re-run "
-            "re-verifies every stage."
+            "no stage cannot auto-narrow the next re-run; this report fails "
+            "rather than forcing a full re-run."
         )
 
 
 _RERUN_FLAG = "--answered-clarifications"
+_APPROVE_HINT = re.compile(r"--approve|\bapprov", re.IGNORECASE)
 
 
 def _next_step_texts(steps: object) -> list[str]:
@@ -6153,6 +6188,24 @@ def _next_step_texts(steps: object) -> list[str]:
     return texts
 
 
+def _has_blocks_approval_row(data: dict) -> bool:
+    return any(
+        isinstance(row, dict) and row.get("blocks") == "approval"
+        for row in data.get("clarificationItems") or []
+    )
+
+
+def _planning_gate_blocks_approval(data: dict) -> bool:
+    planning = data.get("implementationPlanning")
+    if not isinstance(planning, dict):
+        return False
+    verification = planning.get("planBodyVerification")
+    if not isinstance(verification, dict):
+        return False
+    gate = str(verification.get("gateResult") or "").strip().lower()
+    return gate in {"blocked-by-disagreement", "aborted-non-result"}
+
+
 def _validate_rerun_guidance(data: dict, failures: list[str]) -> None:
     """A report that withholds approval must say how to come back from it.
 
@@ -6165,10 +6218,7 @@ def _validate_rerun_guidance(data: dict, failures: list[str]) -> None:
     """
     if (data.get("header") or {}).get("taskType") != "implementation-planning":
         return
-    has_blocker = any(
-        isinstance(row, dict) and row.get("blocks") == "approval"
-        for row in data.get("clarificationItems") or []
-    )
+    has_blocker = _has_blocks_approval_row(data)
     if not has_blocker:
         return
     if any(_RERUN_FLAG in text for text in _next_step_texts(
@@ -6184,6 +6234,34 @@ def _validate_rerun_guidance(data: dict, failures: list[str]) -> None:
     )
 
 
+def _validate_approval_guidance(data: dict, failures: list[str]) -> None:
+    """승인 가능한 plan-ready 는 사용자에게 승인하라고 말해야 한다.
+
+    포인터가 implementation/ready 여도 승인은 사용자만 뒤집는다. 다음 단계
+    안내가 계획 재실행이면 승인 칸을 건너뛰고 같은 단계를 다시 돈다.
+    """
+    if (data.get("header") or {}).get("taskType") != "implementation-planning":
+        return
+    planning = data.get("implementationPlanning")
+    if not isinstance(planning, dict) or planning.get("outcome") != "plan-ready":
+        return
+    if _has_blocks_approval_row(data) or _planning_gate_blocks_approval(data):
+        return
+    if _report_already_approved(data):
+        return
+    if any(_APPROVE_HINT.search(text) for text in _next_step_texts(
+        data.get("recommendedNextSteps")
+    )):
+        return
+    failures.append(
+        "final-report data.json: this plan is ready for the user to approve, "
+        "but no `recommendedNextSteps` entry tells the reader to approve — "
+        "name `--approve` or the in-session wizard in a step's `text` or "
+        "one of its `commands`. Do not recommend another "
+        "implementation-planning run."
+    )
+
+
 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.
 
@@ -7098,7 +7176,10 @@ def _validate_round_recorded_verdicts(data: dict, failures: list[str]) -> None:
     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)]
+    items = [
+        it for it in (pbv.get("planItems") or [])
+        if isinstance(it, dict) and _stage_scope_bucket(it, pbv) == "in-scope"
+    ]
     if not items:
         return
     empty = [str(it.get("id") or "<unnamed>") for it in items if not it.get("verdicts")]
@@ -7178,6 +7259,85 @@ def _validate_unresolved_tie_was_reverified(
     )
 
 
+def _validate_tie_received_extra_vote(
+    data: dict,
+    failures: list[str],
+) -> None:
+    """동수는 같은 둘을 다시 돌리는 것이 아니라 세 번째 표로 가른다."""
+    ip = data.get("implementationPlanning")
+    if not isinstance(ip, dict):
+        return
+    pbv = ip.get("planBodyVerification")
+    if not isinstance(pbv, dict):
+        return
+    missing = sorted({
+        str(item.get("id") or "").strip()
+        for item in pbv.get("planItems") or []
+        if isinstance(item, dict)
+        and not item.get("carriedForwardFromSeq")
+        and _is_even_blocking_split(item)
+        and _distinct_verdict_workers(item) < 3
+    })
+    if not missing:
+        return
+    failures.append(
+        f"final-report data.json: plan item(s) {missing} carry an even split "
+        "on a blocking breakage kind and have no third vote. Re-running the "
+        "original two does not settle a 1-1 split. Dispatch one extra analyser "
+        "whose prompt is those items only (`okstra plan-items prepare "
+        "--tie-vote`) and record the vote with `okstra plan-items "
+        "apply-verdicts --append --round 2`."
+    )
+
+
+def _is_even_blocking_split(item: dict) -> bool:
+    """라운드 승격 없이 차단 kind 의 짝수 분할인지."""
+    forced = {
+        **item,
+        "verdicts": [
+            {**row, "round": 1}
+            for row in (item.get("verdicts") or [])
+            if isinstance(row, dict)
+        ],
+    }
+    return _is_unsettled_tie(forced)
+
+
+def _distinct_verdict_workers(item: dict) -> int:
+    return len({
+        str(row.get("worker") or "")
+        for row in (item.get("verdicts") or [])
+        if isinstance(row, dict) and str(row.get("worker") or "").strip()
+    })
+
+
+def _validate_advisory_plan_body_gating(data: dict, failures: list[str]) -> None:
+    """gating=false 는 검출 표면 0 + 스테이지 1 일 때만 받는다."""
+    ip = data.get("implementationPlanning")
+    if not isinstance(ip, dict):
+        return
+    pbv = ip.get("planBodyVerification")
+    if not isinstance(pbv, dict) or pbv.get("gating") is not False:
+        return
+    facts = ip.get("designPreparation") is not None or ip.get("stageMap") or ip.get("stages")
+    if facts and not advisory_plan_body_gating(ip):
+        failures.append(
+            "final-report data.json: implementationPlanning.planBodyVerification "
+            "`gating` is false, but that is only legal when "
+            "designPreparation.mode is `no-design-inputs` (empty items) and the "
+            "Stage Map has exactly one row. Two-or-more stages, a PREP item, or "
+            "non-empty designPreparation items keep the gating contract."
+        )
+    applied = pbv.get("selfFixRoundsApplied")
+    if isinstance(applied, int) and applied > 0:
+        failures.append(
+            "final-report data.json: implementationPlanning.planBodyVerification "
+            "`gating` is false, so the self-fix loop must not run "
+            f"(`selfFixRoundsApplied`={applied}). Keep extraction and one "
+            "verification round."
+        )
+
+
 def _validate_verdict_rounds_outlive_self_fix(
     data: dict,
     failures: list[str],
@@ -7219,7 +7379,18 @@ def _validate_verdict_rounds_outlive_self_fix(
     for item in pbv.get("planItems") or []:
         if not isinstance(item, dict) or item.get("carriedForwardFromSeq"):
             continue
+        if _stage_scope_bucket(item, pbv) != "in-scope":
+            continue
         item_id = str(item.get("id") or "").strip()
+        verified = item.get("verifiedContentHash")
+        current = item.get("contentHash")
+        if (
+            isinstance(verified, str)
+            and isinstance(current, str)
+            and verified == current
+        ):
+            # 본문이 같으면 라운드 번호가 self-fix 이전이어도 같은 텍스트다.
+            continue
         for verdict in item.get("verdicts") or []:
             if not isinstance(verdict, dict):
                 continue
@@ -8291,6 +8462,8 @@ def validate_plan_body_section(
     _validate_set_aside_register(data, failures, accepted_item_ids)
     _validate_verdict_rounds_outlive_self_fix(data, failures)
     _validate_unresolved_tie_was_reverified(data, failures)
+    _validate_tie_received_extra_vote(data, failures)
+    _validate_advisory_plan_body_gating(data, failures)
     _validate_plan_item_extraction_completeness(data, failures)
     _validate_plan_item_subject_substance(data, failures)
     _validate_plan_body_clarification_matching(data, failures, accepted_item_ids)

package/runtime/validators/validate_session_conformance.py

@@ -809,7 +809,7 @@ def _check_activity_worker_agents(
             )
 
 
-def _allowed_automatic_rounds(self_fix_rounds: int) -> int:
+def _allowed_automatic_rounds(self_fix_rounds: int, *, gating: bool = True) -> int:
     """이 run 이 돌아도 되는 자동 plan-body 라운드 수.
 
     상한이 2 로 고정돼 있던 동안 다른 규칙과 정면으로 충돌했다.
@@ -825,25 +825,42 @@ def _allowed_automatic_rounds(self_fix_rounds: int) -> int:
     로 그 라운드에 실린다. 자가수정은 여기에 배치를 하나씩 더한다. 표적 재검증은
     기준선의 두 번째 배치가 받고, 늘어나는 것은 그 라운드가 덮지 못한 잔여 항목을
     일소하는 배치다.
+
+    ``gating=false`` 자문 경로는 추출과 1라운드만 남긴다. self-fix 와 일소
+    배치는 돌리지 않는다.
     """
+    if not gating:
+        return 1
     return 2 + max(self_fix_rounds, 0)
 
 
-def _self_fix_rounds_applied(report_data: Mapping[str, Any]) -> int:
+def _plan_body_verification(report_data: Mapping[str, Any]) -> Mapping[str, Any] | None:
     planning = report_data.get("implementationPlanning")
-    plan_verification = (
+    verification = (
         planning.get("planBodyVerification")
         if isinstance(planning, Mapping)
         else None
     )
+    return verification if isinstance(verification, Mapping) else None
+
+
+def _self_fix_rounds_applied(report_data: Mapping[str, Any]) -> int:
+    plan_verification = _plan_body_verification(report_data)
     value = (
         plan_verification.get("selfFixRoundsApplied")
-        if isinstance(plan_verification, Mapping)
+        if plan_verification is not None
         else 0
     )
     return value if isinstance(value, int) and value >= 0 else 0
 
 
+def _plan_body_gating(report_data: Mapping[str, Any]) -> bool:
+    plan_verification = _plan_body_verification(report_data)
+    if plan_verification is None:
+        return True
+    return plan_verification.get("gating") is not False
+
+
 def _matching_user_reverification_round(
     event: LeadEvent | None,
     clarification_id: str,
@@ -945,7 +962,9 @@ def _check_activity_round_counts(
     )
     automatic_rounds = verification_rounds - len(user_reverification_rounds)
     self_fix_rounds = _self_fix_rounds_applied(report_data)
-    allowed_rounds = _allowed_automatic_rounds(self_fix_rounds)
+    allowed_rounds = _allowed_automatic_rounds(
+        self_fix_rounds, gating=_plan_body_gating(report_data),
+    )
     if automatic_rounds > allowed_rounds:
         errors.append(
             f"activity contract: at most {allowed_rounds} plan verification "