okstra 0.170.3 → 0.172.0

package/runtime/validators/validate-run.py

@@ -113,6 +113,7 @@ from okstra_ctl.agent_invocation import (  # noqa: E402
     agent_model_assignment_from_payload,
     verify_agent_invocation,
 )
+from okstra_ctl.lead_events import LeadEventParseError, read_lead_events  # noqa: E402
 from okstra_ctl.worker_audit_ledger import (  # noqa: E402
     READING_CONFIRMATION_HEADING_RE,
     check_worker_results_audit,
@@ -3343,11 +3344,15 @@ def validate_final_report_data(
     if errors:
         return data
 
+    manifest = run_manifest or {}
+    _validate_approval_context(data, manifest, failures, report_path)
+    _validate_activity_contract_plan_limits(data, manifest, failures)
+
     analysis_result = validate_analysis_report(
         data=data,
         report_path=report_path,
         project_root=project_root or report_path.parent,
-        run_manifest=run_manifest or {},
+        run_manifest=manifest,
         clarification_text=clarification_text,
     )
     manifest_task_type = str((run_manifest or {}).get("taskType") or "")
@@ -3750,32 +3755,66 @@ def _state_classification(item: dict, gate_class: str) -> str:
     return "dissent-isolated" if dissenting == 1 else "partial-consensus"
 
 
-def _is_dissent_downgraded(item: dict, pbv: dict) -> bool:
+def _resolved_noncritical_dissent_ids(data: dict) -> set[str]:
+    """Plan items whose remaining dissent the user explicitly accepted."""
+    accepted: set[str] = set()
+    for row in data.get("clarificationItems") or []:
+        if not isinstance(row, dict) or row.get("blocks") != "approval":
+            continue
+        context = row.get("approvalContext")
+        if not isinstance(context, dict):
+            continue
+        resolution = context.get("resolution")
+        if (
+            row.get("status") == "resolved"
+            and context.get("classification") == "noncritical-dissent"
+            and isinstance(resolution, dict)
+            and resolution.get("disposition") == "accept-risk"
+            and str(resolution.get("userText") or "").strip()
+            and _approval_context_activity_refs_exist(
+                data, str(row.get("id") or ""), context, resolution
+            )
+        ):
+            accepted.update(
+                item_id
+                for item_id in context.get("planItemIds") or []
+                if isinstance(item_id, str)
+            )
+    return accepted
+
+
+def _is_dissent_downgraded(
+    item: dict,
+    pbv: dict,
+    accepted_item_ids: set[str],
+) -> 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.
+    Exhausting the automatic self-fix budget records the unresolved dissent but
+    does not accept it. Only an explicit, resolved noncritical risk-acceptance
+    row can lower the item to `has-dissent`. Correctness-critical defects remain
+    blocking regardless of the user's selected disposition.
     """
     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)
+        and str(item.get("id") or "") in accepted_item_ids
     )
 
 
-def _recompute_plan_body_gate(pbv: dict) -> str | None:
+def _recompute_plan_body_gate(
+    pbv: dict,
+    accepted_item_ids: set[str] | None = None,
+) -> 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)."""
+    accepted = accepted_item_ids or set()
     classes = [
         "has-dissent"
-        if _is_dissent_downgraded(it, pbv)
+        if _is_dissent_downgraded(it, pbv, accepted)
         else _classify_plan_item_gate(it)
         for it in (pbv.get("planItems") or [])
         if isinstance(it, dict)
@@ -3791,7 +3830,11 @@ def _recompute_plan_body_gate(pbv: dict) -> str | None:
     return "passed"
 
 
-def _validate_plan_body_gate_recompute(data: dict, failures: list[str]) -> None:
+def _validate_plan_body_gate_recompute(
+    data: dict,
+    failures: list[str],
+    accepted_item_ids: set[str] | None = None,
+) -> None:
     """H1 — the declared `Gate result` must not claim a healthier outcome than
     the recorded per-worker verdicts support. Closes the forgery hole where a
     lead writes `gateResult: passed` while workers actually voted DISAGREE:
@@ -3805,7 +3848,12 @@ def _validate_plan_body_gate_recompute(data: dict, failures: list[str]) -> None:
     if not isinstance(pbv, dict):
         return
     declared = str(pbv.get("gateResult") or "").strip().lower()
-    recomputed = _recompute_plan_body_gate(pbv)
+    accepted = (
+        _resolved_noncritical_dissent_ids(data)
+        if accepted_item_ids is None
+        else accepted_item_ids
+    )
+    recomputed = _recompute_plan_body_gate(pbv, accepted)
     if recomputed is None or declared not in _PLAN_GATE_RANK:
         return
     if _PLAN_GATE_RANK[declared] > _PLAN_GATE_RANK[recomputed]:
@@ -3869,10 +3917,14 @@ def _independent_coverage_blockers(ip: dict, pbv: dict) -> list[str]:
     ]
 
 
-def _gate_blocking_causes(pbv: dict, coverage_blockers: list[str]) -> set[str]:
+def _gate_blocking_causes(
+    pbv: dict,
+    coverage_blockers: list[str],
+    accepted_item_ids: set[str] | None = None,
+) -> set[str]:
     """Which inputs actually block approval, as `gateBlockedBy` enum values."""
     causes = set()
-    recomputed = _recompute_plan_body_gate(pbv)
+    recomputed = _recompute_plan_body_gate(pbv, accepted_item_ids)
     if recomputed == "blocked-by-disagreement":
         causes.add("majority-disagree")
     elif recomputed == "aborted-non-result":
@@ -3882,6 +3934,885 @@ def _gate_blocking_causes(pbv: dict, coverage_blockers: list[str]) -> set[str]:
     return causes
 
 
+_APPROVAL_DISPOSITIONS_BY_CLASSIFICATION = {
+    "user-decision": frozenset({"select", "request-revision", "reject"}),
+    "noncritical-dissent": frozenset(
+        {"accept-risk", "request-revision", "reject"}
+    ),
+    "correctness-critical": frozenset({"request-revision", "reject"}),
+}
+
+
+def _is_activity_contract_v1_planning(run_manifest: dict) -> bool:
+    return (
+        run_manifest.get("activityContractVersion") == 1
+        and run_manifest.get("taskType") == "implementation-planning"
+    )
+
+
+def _independent_coverage_clarification_ids(ip: dict, pbv: dict) -> set[str]:
+    promoted = _plan_body_promoted_clarification_ids(pbv)
+    return {
+        clarification_id
+        for row in (ip.get("requirementCoverage") or [])
+        if isinstance(row, dict) and _blocks_approval(row)
+        for clarification_id in [_cited_clarification_id(row)]
+        if clarification_id and clarification_id not in promoted
+    }
+
+
+def _expected_approval_classification(
+    row: dict,
+    plan_items_by_id: dict[str, dict],
+    independent_coverage_clarification_ids: set[str],
+) -> str:
+    linked = [
+        plan_items_by_id[item_id]
+        for item_id in (row.get("approvalContext") or {}).get("planItemIds") or []
+        if item_id in plan_items_by_id
+    ]
+    if any(_is_correctness_critical(item) for item in linked):
+        return "correctness-critical"
+    if str(row.get("id") or "") in independent_coverage_clarification_ids:
+        return "correctness-critical"
+    for item in linked:
+        disagree_votes = [
+            verdict
+            for verdict in (item.get("verdicts") or [])
+            if isinstance(verdict, dict)
+            and str(verdict.get("verdict") or "").upper() == "DISAGREE"
+        ]
+        needs_user_input = sum(
+            verdict.get("fixability") == "needs-user-input"
+            for verdict in disagree_votes
+        )
+        if disagree_votes and needs_user_input * 2 > len(disagree_votes):
+            return "user-decision"
+    if any(_classify_plan_item_gate(item) == "majority-disagree" for item in linked):
+        return "noncritical-dissent"
+    return "user-decision"
+
+
+_STATE_DISAGREE_VOTE_RE = re.compile(r"^DISAGREE\(([a-f])\)$")
+_APPROVAL_CLARIFICATION_ID_RE = re.compile(r"^C-\d{3,}$")
+
+
+def _state_round_as_plan_item(item_id: str, round_row: dict) -> dict:
+    verdicts = []
+    votes = round_row.get("votes")
+    for worker, raw_vote in (votes.items() if isinstance(votes, dict) else ()):
+        vote = str(raw_vote or "").strip()
+        match = _STATE_DISAGREE_VOTE_RE.fullmatch(vote)
+        if match:
+            verdicts.append(
+                {"worker": worker, "verdict": "DISAGREE", "breakageKind": match.group(1)}
+            )
+        elif vote in {"AGREE", "SUPPLEMENT", "verification-error"}:
+            verdicts.append({"worker": worker, "verdict": vote})
+    return {"id": item_id, "verdicts": verdicts}
+
+
+def _historical_plan_item_evidence(state: dict) -> tuple[dict[str, str], set[str]]:
+    classifications: dict[str, str] = {}
+    item_ids: set[str] = set()
+    for item in state.get("planItems") or []:
+        if not isinstance(item, dict):
+            continue
+        item_id = str(item.get("id") or "").strip()
+        if not item_id:
+            continue
+        item_ids.add(item_id)
+        for round_row in item.get("rounds") or []:
+            if not isinstance(round_row, dict):
+                continue
+            historical = _state_round_as_plan_item(item_id, round_row)
+            if _is_correctness_critical(historical):
+                classifications[item_id] = "correctness-critical"
+                break
+            if _classify_plan_item_gate(historical) == "majority-disagree":
+                classifications.setdefault(item_id, "noncritical-dissent")
+    return classifications, item_ids
+
+
+def _historical_coverage_clarification_ids(
+    state: dict,
+    plan_classifications: dict[str, str],
+) -> set[str]:
+    coverage_gap_rounds = {
+        round_row.get("round")
+        for round_row in (state.get("roundHistory") or [])
+        if isinstance(round_row, dict)
+        and isinstance(round_row.get("round"), int)
+        and "coverage-gap" in (round_row.get("gateBlockedBy") or [])
+    }
+    return {
+        clarification_id
+        for item in (state.get("planItems") or [])
+        if isinstance(item, dict)
+        for item_id in [str(item.get("id") or "").strip()]
+        for clarification_id in [str(item.get("clarificationId") or "").strip()]
+        if item_id
+        and item_id not in plan_classifications
+        and _APPROVAL_CLARIFICATION_ID_RE.fullmatch(clarification_id)
+        and any(
+            isinstance(round_row, dict)
+            and round_row.get("round") in coverage_gap_rounds
+            for round_row in (item.get("rounds") or [])
+        )
+    }
+
+
+def _read_approval_history(
+    report_path: Path | None,
+) -> tuple[dict[str, str], set[str], set[str], dict, Path | None]:
+    if report_path is None or (seq := _report_run_seq(report_path)) is None:
+        return {}, set(), set(), {}, None
+    state_path = (
+        report_path.parent.parent
+        / "state"
+        / f"plan-body-verification-implementation-planning-{seq}.json"
+    )
+    try:
+        state = json.loads(state_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return {}, set(), set(), {}, None
+    if not isinstance(state, dict):
+        return {}, set(), set(), {}, None
+    classifications, item_ids = _historical_plan_item_evidence(state)
+    coverage_ids = _historical_coverage_clarification_ids(
+        state,
+        classifications,
+    )
+    return classifications, item_ids, coverage_ids, state, state_path
+
+
+def _nonblocking_coverage_clarification_ids(ip: dict) -> set[str]:
+    return {
+        ref
+        for row in (ip.get("requirementCoverage") or [])
+        if isinstance(row, dict) and not _blocks_approval(row)
+        for ref in (row.get("decisionRefs") or [])
+        if isinstance(ref, str) and _APPROVAL_CLARIFICATION_ID_RE.fullmatch(ref)
+    }
+
+
+def _historical_approval_classification(
+    row_id: str,
+    linked_ids: list[str],
+    historical_plan_classifications: dict[str, str],
+    historical_coverage_ids: set[str],
+) -> str | None:
+    if row_id in historical_coverage_ids:
+        return "correctness-critical"
+    classes = {
+        historical_plan_classifications[item_id]
+        for item_id in linked_ids
+        if item_id in historical_plan_classifications
+    }
+    if "correctness-critical" in classes:
+        return "correctness-critical"
+    if "noncritical-dissent" in classes:
+        return "noncritical-dissent"
+    return None
+
+
+def _approval_activities_by_id(data: dict) -> dict[str, dict]:
+    return {
+        activity_id: activity
+        for activity in (data.get("agentActivity") or [])
+        if isinstance(activity, dict)
+        for activity_id in [activity.get("activityId")]
+        if isinstance(activity_id, str) and activity_id
+    }
+
+
+def _canonical_activity_timestamps(
+    run_manifest: Mapping[str, Any],
+    report_path: Path | None,
+) -> dict[str, str]:
+    raw_path = run_manifest.get("leadEventsPath")
+    if not isinstance(raw_path, str) or not raw_path.strip():
+        return {}
+    path = Path(raw_path)
+    if not path.is_absolute() and report_path is not None:
+        path = _project_root_from_report(report_path) / path
+    try:
+        events = read_lead_events(path)
+    except (LeadEventParseError, OSError):
+        return {}
+    return {
+        str(event.details.get("activityId")): event.timestamp
+        for event in events
+        if event.event_type == "activity"
+        and isinstance(event.details.get("activityId"), str)
+    }
+
+
+def _is_decision_required_activity(activity: dict | None) -> bool:
+    return bool(
+        activity
+        and activity.get("kind") == "user-decision-required"
+        and activity.get("outcome") == "blocked"
+    )
+
+
+def _is_applied_decision_check(activity: dict | None) -> bool:
+    commands = (activity or {}).get("commands")
+    return bool(
+        activity
+        and activity.get("kind") == "user-decision-evaluated"
+        and activity.get("outcome") == "resolved"
+        and str(activity.get("resultPath") or "").strip()
+        and isinstance(commands, list)
+        and bool(commands)
+        and all(
+            isinstance(command, dict) and command.get("exitCode") == 0
+            for command in commands
+        )
+    )
+
+
+def _activity_matches_approval_context(
+    activity: dict | None,
+    row_id: str,
+    context: dict,
+) -> bool:
+    if not activity:
+        return False
+    evidence_refs = {
+        ref
+        for ref in (activity.get("evidenceRefs") or [])
+        if isinstance(ref, str)
+    }
+    activity_item_ids = {
+        item_id
+        for item_id in (activity.get("planItemIds") or [])
+        if isinstance(item_id, str)
+    }
+    context_item_ids = {
+        item_id
+        for item_id in (context.get("planItemIds") or [])
+        if isinstance(item_id, str)
+    }
+    clarification_refs = {
+        ref for ref in evidence_refs if _APPROVAL_CLARIFICATION_ID_RE.fullmatch(ref)
+    }
+    return clarification_refs == {row_id} and context_item_ids == activity_item_ids
+
+
+_TARGETED_REVERIFICATION_REF_RE = re.compile(
+    r"^plan-body-verification:round-(?P<round>\d+)$"
+)
+
+
+def _targeted_reverification_round(activity: dict | None) -> int | None:
+    rounds = {
+        int(match.group("round"))
+        for ref in ((activity or {}).get("evidenceRefs") or [])
+        if isinstance(ref, str)
+        for match in [_TARGETED_REVERIFICATION_REF_RE.fullmatch(ref)]
+        if match is not None
+    }
+    if len(rounds) != 1:
+        return None
+    return next(iter(rounds))
+
+
+def _approval_context_activity_refs_exist(
+    data: dict,
+    row_id: str,
+    context: dict,
+    resolution: dict,
+) -> bool:
+    activities = _approval_activities_by_id(data)
+    activity_ids = {
+        value for value in (context.get("activityIds") or []) if isinstance(value, str)
+    }
+    check_refs = {
+        value for value in (resolution.get("checkRefs") or []) if isinstance(value, str)
+    }
+    activity_order = {
+        activity.get("activityId"): index
+        for index, activity in enumerate(data.get("agentActivity") or [])
+        if isinstance(activity, dict)
+    }
+    ordered = bool(activity_ids and check_refs) and max(
+        activity_order.get(ref, -1) for ref in activity_ids
+    ) < min(activity_order.get(ref, -1) for ref in check_refs)
+    return (
+        bool(activity_ids)
+        and bool(check_refs)
+        and all(
+            _is_decision_required_activity(activities.get(ref))
+            and _activity_matches_approval_context(
+                activities.get(ref), row_id, context
+            )
+            for ref in activity_ids
+        )
+        and all(
+            _is_applied_decision_check(activities.get(ref))
+            and _targeted_reverification_round(activities.get(ref)) is not None
+            and _activity_matches_approval_context(
+                activities.get(ref), row_id, context
+            )
+            for ref in check_refs
+        )
+        and ordered
+    )
+
+
+def _validate_approval_activity_refs(
+    row_id: str,
+    context: dict,
+    activities: dict[str, dict],
+    failures: list[str],
+) -> None:
+    activity_ids = {
+        value for value in (context.get("activityIds") or []) if isinstance(value, str)
+    }
+    unknown_activity_ids = sorted(activity_ids - set(activities))
+    if not activity_ids or unknown_activity_ids:
+        failures.append(
+            f"final-report data.json: approval clarification `{row_id}` activityIds "
+            f"must reference agentActivity[].activityId values; unknown="
+            f"{unknown_activity_ids or 'none'}, recorded={sorted(activity_ids)}."
+        )
+    elif not all(
+        _is_decision_required_activity(activities.get(ref)) for ref in activity_ids
+    ):
+        failures.append(
+            f"final-report data.json: approval clarification `{row_id}` activityIds "
+            "must reference blocked user-decision-required activities."
+        )
+    elif not all(
+        _activity_matches_approval_context(activities.get(ref), row_id, context)
+        for ref in activity_ids
+    ):
+        failures.append(
+            f"final-report data.json: approval clarification `{row_id}` activityIds "
+            f"must cite exactly one clarification (`{row_id}`) in evidenceRefs "
+            "and exactly match approvalContext.planItemIds."
+        )
+    resolution = context.get("resolution")
+    if not isinstance(resolution, dict):
+        return
+    check_refs = {
+        value for value in (resolution.get("checkRefs") or []) if isinstance(value, str)
+    }
+    unknown_check_refs = sorted(check_refs - set(activities))
+    if check_refs and unknown_check_refs:
+        failures.append(
+            f"final-report data.json: approval clarification `{row_id}` resolution."
+            f"checkRefs must reference agentActivity[].activityId values; unknown="
+            f"{unknown_check_refs}."
+        )
+    elif check_refs and not all(
+        _is_applied_decision_check(activities.get(ref))
+        and _targeted_reverification_round(activities.get(ref)) is not None
+        for ref in check_refs
+    ):
+        failures.append(
+            f"final-report data.json: approval clarification `{row_id}` resolution."
+            "checkRefs must reference resolved user-decision-evaluated activities "
+            "with successful check evidence and one "
+            "`plan-body-verification:round-N` evidenceRef."
+        )
+    elif check_refs and not all(
+        _activity_matches_approval_context(activities.get(ref), row_id, context)
+        for ref in check_refs
+    ):
+        failures.append(
+            f"final-report data.json: approval clarification `{row_id}` resolution."
+            f"checkRefs must cite exactly one clarification (`{row_id}`) in "
+            "evidenceRefs and exactly match approvalContext.planItemIds."
+        )
+    elif check_refs:
+        order = {
+            activity.get("activityId"): index
+            for index, activity in enumerate(activities.values())
+        }
+        if activity_ids and max(order.get(ref, -1) for ref in activity_ids) >= min(
+            order.get(ref, -1) for ref in check_refs
+        ):
+            failures.append(
+                f"final-report data.json: approval clarification `{row_id}` "
+                "user-decision-evaluated activity must occur after every "
+                "user-decision-required activity."
+            )
+
+
+def _validate_approval_dispositions(
+    row: dict,
+    context: dict,
+    failures: list[str],
+) -> None:
+    row_id = str(row.get("id") or "<unknown>")
+    classification = str(context.get("classification") or "")
+    allowed = _APPROVAL_DISPOSITIONS_BY_CLASSIFICATION.get(classification, frozenset())
+    candidates = [("recommendedDisposition", context.get("recommendedDisposition"))]
+    candidates.extend(
+        (f"options[{index}].disposition", option.get("disposition"))
+        for index, option in enumerate(row.get("options") or [])
+        if isinstance(option, dict)
+    )
+    resolution = context.get("resolution")
+    if isinstance(resolution, dict):
+        candidates.append(("resolution.disposition", resolution.get("disposition")))
+    for field, disposition in candidates:
+        if disposition not in allowed:
+            failures.append(
+                f"final-report data.json: approval clarification `{row_id}` "
+                f"classification `{classification}` does not allow `{disposition}` "
+                f"in {field}; allowed dispositions are {sorted(allowed)}."
+            )
+
+
+def _validate_resolved_approval(
+    row: dict,
+    context: dict,
+    failures: list[str],
+) -> None:
+    if row.get("status") != "resolved":
+        return
+    row_id = str(row.get("id") or "<unknown>")
+    resolution = context.get("resolution")
+    if not isinstance(resolution, dict):
+        failures.append(
+            f"final-report data.json: resolved approval clarification `{row_id}` "
+            "requires resolution.userText and non-empty resolution.checkRefs."
+        )
+        return
+    if not str(resolution.get("userText") or "").strip():
+        failures.append(
+            f"final-report data.json: resolved approval clarification `{row_id}` "
+            "requires non-empty resolution.userText."
+        )
+    check_refs = resolution.get("checkRefs")
+    if not isinstance(check_refs, list) or not any(
+        isinstance(value, str) and value for value in check_refs
+    ):
+        failures.append(
+            f"final-report data.json: resolved approval clarification `{row_id}` "
+            "requires non-empty resolution.checkRefs."
+        )
+    if (
+        context.get("classification") == "noncritical-dissent"
+        and resolution.get("disposition") != "accept-risk"
+    ):
+        failures.append(
+            f"final-report data.json: resolved noncritical-dissent `{row_id}` "
+            "requires an explicit accept-risk disposition."
+        )
+
+
+def _has_successful_targeted_reverification(item: dict) -> bool:
+    verdicts = [
+        str(verdict.get("verdict") or "").strip().upper()
+        for verdict in (item.get("verdicts") or [])
+        if isinstance(verdict, dict)
+    ]
+    return bool(verdicts) and all(
+        verdict in {"AGREE", "SUPPLEMENT"} for verdict in verdicts
+    )
+
+
+def _parse_approval_timestamp(value: Any) -> datetime | None:
+    if not isinstance(value, str) or not value.strip():
+        return None
+    try:
+        parsed = datetime.fromisoformat(value.strip().replace("Z", "+00:00"))
+    except ValueError:
+        return None
+    if parsed.tzinfo is None or parsed.utcoffset() != timezone.utc.utcoffset(parsed):
+        return None
+    return parsed
+
+
+def _referenced_approval_timestamps(
+    refs: Any,
+    activity_timestamps: dict[str, str],
+) -> list[datetime | None]:
+    return [
+        _parse_approval_timestamp(activity_timestamps.get(ref))
+        for ref in (refs or [])
+        if isinstance(ref, str)
+    ]
+
+
+def _target_round_completed_at(
+    approval_state: dict,
+    target_round: int,
+) -> datetime | None:
+    matching_rounds = [
+        row
+        for row in (approval_state.get("roundHistory") or [])
+        if isinstance(row, dict) and row.get("round") == target_round
+    ]
+    if len(matching_rounds) != 1:
+        return None
+    return _parse_approval_timestamp(matching_rounds[0].get("completedAt"))
+
+
+def _validate_target_round_causality(
+    row_id: str,
+    target_round: int,
+    approval_state: dict,
+    context: dict,
+    resolution: dict,
+    activity_timestamps: dict[str, str],
+    failures: list[str],
+) -> None:
+    completed_at = _target_round_completed_at(approval_state, target_round)
+    required_at = _referenced_approval_timestamps(
+        context.get("activityIds"),
+        activity_timestamps,
+    )
+    evaluated_at = _referenced_approval_timestamps(
+        resolution.get("checkRefs"),
+        activity_timestamps,
+    )
+    if (
+        completed_at is None
+        or not required_at
+        or not evaluated_at
+        or None in required_at
+        or None in evaluated_at
+    ):
+        failures.append(
+            f"final-report data.json: correctness-critical clarification `{row_id}` "
+            f"state round {target_round} requires one UTC completedAt plus canonical "
+            "timestamps for every required and evaluated activity."
+        )
+        return
+    if completed_at <= max(required_at):
+        failures.append(
+            f"final-report data.json: correctness-critical clarification `{row_id}` "
+            f"state round {target_round} completedAt must be after every referenced "
+            "user-decision-required activity."
+        )
+    if completed_at > min(evaluated_at):
+        failures.append(
+            f"final-report data.json: correctness-critical clarification `{row_id}` "
+            f"state round {target_round} completedAt must be no later than every "
+            "referenced user-decision-evaluated activity."
+        )
+
+
+def _required_activity_plan_item_ids(
+    context: dict,
+    activities: dict[str, dict],
+) -> set[str]:
+    return {
+        item_id
+        for ref in (context.get("activityIds") or [])
+        if isinstance(ref, str) and _is_decision_required_activity(activities.get(ref))
+        for item_id in (activities[ref].get("planItemIds") or [])
+        if isinstance(item_id, str)
+    }
+
+
+def _terminal_unknown_plan_items_are_historical(
+    row: dict,
+    context: dict,
+    unknown_ids: set[str],
+    historical_item_ids: set[str],
+    historical_coverage_ids: set[str],
+    activities: dict[str, dict],
+) -> bool:
+    status = row.get("status")
+    if status not in {"resolved", "obsolete"}:
+        return False
+    if status == "resolved" and str(row.get("id") or "") not in historical_coverage_ids:
+        return False
+    required_item_ids = _required_activity_plan_item_ids(context, activities)
+    return bool(unknown_ids) and unknown_ids <= historical_item_ids & required_item_ids
+
+
+def _validate_correctness_resolution(
+    row: dict,
+    linked_ids: list[str],
+    linked_items: list[dict],
+    independent_coverage_clarification_ids: set[str],
+    activities: dict[str, dict],
+    approval_state: dict,
+    approval_state_path: Path | None,
+    activity_timestamps: dict[str, str],
+    failures: list[str],
+) -> None:
+    context = row.get("approvalContext") or {}
+    if (
+        context.get("classification") != "correctness-critical"
+        or row.get("status") != "resolved"
+    ):
+        return
+    row_id = str(row.get("id") or "<unknown>")
+    resolution = context.get("resolution") or {}
+    target_rounds = {
+        round_number
+        for ref in (resolution.get("checkRefs") or [])
+        if isinstance(ref, str)
+        for round_number in [_targeted_reverification_round(activities.get(ref))]
+        if round_number is not None
+    }
+    if len(target_rounds) != 1:
+        failures.append(
+            f"final-report data.json: correctness-critical clarification `{row_id}` "
+            "requires exactly one evidenced targeted reverification state round."
+        )
+        return
+    target_round = next(iter(target_rounds))
+    _validate_target_round_causality(
+        row_id,
+        target_round,
+        approval_state,
+        context,
+        resolution,
+        activity_timestamps,
+        failures,
+    )
+    state_name = approval_state_path.name if approval_state_path is not None else ""
+    result_paths_match = bool(state_name) and all(
+        tuple(
+            Path(str(activities[ref].get("resultPath") or "")).parts[-2:]
+        ) == ("state", state_name)
+        for ref in (resolution.get("checkRefs") or [])
+        if isinstance(ref, str) and ref in activities
+    )
+    if not result_paths_match:
+        failures.append(
+            f"final-report data.json: correctness-critical clarification `{row_id}` "
+            "evaluation resultPath must reference the matching plan-body "
+            "verification state artifact."
+        )
+    state_items = {
+        str(item.get("id") or ""): item
+        for item in (approval_state.get("planItems") or [])
+        if isinstance(item, dict) and str(item.get("id") or "")
+    }
+    state_failures: dict[str, str] = {}
+    current_by_id = {str(item.get("id") or ""): item for item in linked_items}
+    for item_id in linked_ids:
+        state_item = state_items.get(item_id)
+        rounds = state_item.get("rounds") if isinstance(state_item, dict) else None
+        target_state_round = next(
+            (
+                round_row
+                for round_row in (rounds or [])
+                if isinstance(round_row, dict)
+                and round_row.get("round") == target_round
+            ),
+            None,
+        )
+        blocking_rounds = [
+            round_row.get("round")
+            for round_row in (rounds or [])
+            if isinstance(round_row, dict)
+            and isinstance(round_row.get("round"), int)
+            and round_row.get("round") < target_round
+            and (
+                _is_correctness_critical(
+                    _state_round_as_plan_item(item_id, round_row)
+                )
+                or _classify_plan_item_gate(
+                    _state_round_as_plan_item(item_id, round_row)
+                )
+                == "majority-disagree"
+            )
+        ]
+        if (
+            isinstance(state_item, dict)
+            and state_item.get("clarificationId") == row_id
+        ):
+            blocking_rounds.extend(
+                round_row.get("round")
+                for round_row in (approval_state.get("roundHistory") or [])
+                if isinstance(round_row, dict)
+                and isinstance(round_row.get("round"), int)
+                and round_row.get("round") < target_round
+                and "coverage-gap" in (round_row.get("gateBlockedBy") or [])
+            )
+        target_votes = (
+            target_state_round.get("votes")
+            if isinstance(target_state_round, dict)
+            else None
+        )
+        successful = bool(target_votes) and all(
+            vote in {"AGREE", "SUPPLEMENT"} for vote in target_votes.values()
+        )
+        if not blocking_rounds or not successful:
+            state_failures[item_id] = (
+                f"state round {target_round} is not a successful post-blocker round"
+            )
+            continue
+        current = current_by_id.get(item_id)
+        if current is not None:
+            report_votes = {
+                str(verdict.get("worker") or ""): str(verdict.get("verdict") or "")
+                for verdict in (current.get("verdicts") or [])
+                if isinstance(verdict, dict)
+            }
+            if report_votes != target_votes:
+                state_failures[item_id] = (
+                    f"state round {target_round} votes do not match final report verdicts"
+                )
+    if state_failures:
+        failures.append(
+            f"final-report data.json: correctness-critical clarification `{row_id}` "
+            f"targeted reverification state round {target_round} is not bound to "
+            f"the resolved evidence; failures={state_failures}."
+        )
+    unresolved = {
+        str(item.get("id") or "<unknown>"): [
+            str(verdict.get("verdict") or "")
+            for verdict in (item.get("verdicts") or [])
+            if isinstance(verdict, dict)
+        ]
+        for item in linked_items
+        if not _has_successful_targeted_reverification(item)
+    }
+    if unresolved:
+        failures.append(
+            f"final-report data.json: correctness-critical clarification `{row_id}` "
+            "cannot resolve until targeted reverification records only AGREE or "
+            f"acceptable SUPPLEMENT verdicts; unresolved plan items={unresolved}."
+        )
+    if row_id in independent_coverage_clarification_ids:
+        failures.append(
+            f"final-report data.json: correctness-critical clarification `{row_id}` "
+            "cannot resolve while an independent requirement coverage blocker remains."
+        )
+
+
+def _validate_approval_context(
+    data: dict,
+    run_manifest: dict,
+    failures: list[str],
+    report_path: Path | None = None,
+) -> None:
+    if not _is_activity_contract_v1_planning(run_manifest):
+        return
+    ip = data.get("implementationPlanning") or {}
+    pbv = ip.get("planBodyVerification") or {}
+    plan_items_by_id = {
+        str(item.get("id")): item
+        for item in (pbv.get("planItems") or [])
+        if isinstance(item, dict) and str(item.get("id") or "")
+    }
+    coverage_ids = _independent_coverage_clarification_ids(ip, pbv)
+    (
+        historical_classes,
+        historical_item_ids,
+        historical_coverage_ids,
+        approval_state,
+        approval_state_path,
+    ) = _read_approval_history(report_path)
+    historical_coverage_ids &= _nonblocking_coverage_clarification_ids(
+        ip
+    )
+    activities = _approval_activities_by_id(data)
+    activity_timestamps = _canonical_activity_timestamps(run_manifest, report_path)
+    report_approved = (data.get("frontmatter") or {}).get("approved") is True
+    for row in data.get("clarificationItems") or []:
+        if not isinstance(row, dict) or row.get("blocks") != "approval":
+            continue
+        row_id = str(row.get("id") or "<unknown>")
+        context = row.get("approvalContext")
+        if not isinstance(context, dict):
+            failures.append(
+                f"final-report data.json: approval clarification `{row_id}` requires "
+                "approvalContext under activity contract v1."
+            )
+            continue
+        linked_ids = [
+            value
+            for value in context.get("planItemIds") or []
+            if isinstance(value, str)
+        ]
+        unknown_ids = set(linked_ids) - set(plan_items_by_id)
+        if unknown_ids and not _terminal_unknown_plan_items_are_historical(
+            row,
+            context,
+            unknown_ids,
+            historical_item_ids,
+            historical_coverage_ids,
+            activities,
+        ):
+            failures.append(
+                f"final-report data.json: approval clarification `{row_id}` planItemIds "
+                f"reference unknown plan items {sorted(unknown_ids)}."
+            )
+        linked_items = [
+            plan_items_by_id[item_id]
+            for item_id in linked_ids
+            if item_id in plan_items_by_id
+        ]
+        current_expected = _expected_approval_classification(
+            row, plan_items_by_id, coverage_ids
+        )
+        historical_expected = _historical_approval_classification(
+            row_id, linked_ids, historical_classes, historical_coverage_ids
+        )
+        expected = (
+            historical_expected
+            if row.get("status") in {"resolved", "obsolete"} and historical_expected
+            else current_expected
+        )
+        if context.get("classification") != expected:
+            failures.append(
+                f"final-report data.json: approval clarification `{row_id}` classification "
+                f"is `{context.get('classification')}` but plan evidence requires `{expected}`."
+            )
+        obsolete_has_active_cause = current_expected != "user-decision" or any(
+            item_id in plan_items_by_id for item_id in linked_ids
+        )
+        if row.get("status") == "obsolete" and obsolete_has_active_cause:
+            failures.append(
+                f"final-report data.json: obsolete approval clarification `{row_id}` "
+                f"still has an active `{current_expected}` cause in the current plan."
+            )
+        _validate_approval_activity_refs(row_id, context, activities, failures)
+        _validate_approval_dispositions(row, context, failures)
+        _validate_resolved_approval(row, context, failures)
+        _validate_correctness_resolution(
+            row,
+            linked_ids,
+            linked_items,
+            coverage_ids,
+            activities,
+            approval_state,
+            approval_state_path,
+            activity_timestamps,
+            failures,
+        )
+        if report_approved and row.get("status") in {"open", "answered"}:
+            failures.append(
+                f"final-report data.json: approval is true while clarification `{row_id}` "
+                f"has status `{row.get('status')}`; open and answered approval "
+                "rows remain blocking."
+            )
+
+
+def _validate_activity_contract_plan_limits(
+    data: dict,
+    run_manifest: dict,
+    failures: list[str],
+) -> None:
+    if not _is_activity_contract_v1_planning(run_manifest):
+        return
+    pbv = (data.get("implementationPlanning") or {}).get("planBodyVerification") or {}
+    rounds_applied = pbv.get("selfFixRoundsApplied", 0)
+    if isinstance(rounds_applied, int) and rounds_applied > 1:
+        failures.append(
+            "final-report data.json: activity contract v1 selfFixRoundsApplied "
+            "must be at most one automatic self-fix round"
+        )
+    if pbv.get("selfFixStopReason") == "cause-group-recurrence":
+        failures.append(
+            "final-report data.json: activity contract v1 cannot newly emit "
+            "cause-group-recurrence"
+        )
+
+
 _CHECKLIST_REF_RE = re.compile(r"VC-\d+")
 
 
@@ -4172,7 +5103,11 @@ def _validate_participating_analysers(data: dict, failures: list[str]) -> None:
         )
 
 
-def _validate_gate_blocked_by(data: dict, failures: list[str]) -> None:
+def _validate_gate_blocked_by(
+    data: dict,
+    failures: list[str],
+    accepted_item_ids: set[str] | None = None,
+) -> None:
     """The gate value names an *outcome*; `gateBlockedBy` names the *cause*.
 
     Two independent inputs can block approval — a `majority-disagree` plan item
@@ -4200,7 +5135,12 @@ def _validate_gate_blocked_by(data: dict, failures: list[str]) -> None:
         if isinstance(c, str) and str(c).strip()
     }
     coverage_blockers = _independent_coverage_blockers(ip, pbv)
-    actual_causes = _gate_blocking_causes(pbv, coverage_blockers)
+    accepted = (
+        _resolved_noncritical_dissent_ids(data)
+        if accepted_item_ids is None
+        else accepted_item_ids
+    )
+    actual_causes = _gate_blocking_causes(pbv, coverage_blockers, accepted)
 
     if actual_causes and declared_gate in ("passed", "passed-with-dissent"):
         failures.append(
@@ -6227,7 +7167,11 @@ def _validate_plan_item_subject_substance(data: dict, failures: list[str]) -> No
             )
 
 
-def _validate_plan_body_clarification_matching(data: dict, failures: list[str]) -> None:
+def _validate_plan_body_clarification_matching(
+    data: dict,
+    failures: list[str],
+    accepted_item_ids: set[str] | None = None,
+) -> None:
     """H5 — every plan item that the recorded verdicts make `majority-disagree`
     must point (via `clarificationId`) at an existing `blocks: approval`
     clarification row. Closes the hole where a majority-disagree item blocks the
@@ -6243,6 +7187,11 @@ def _validate_plan_body_clarification_matching(data: dict, failures: list[str])
     round_count = pbv.get("roundCount")
     if not isinstance(round_count, int) or round_count < 1:
         return
+    accepted = (
+        _resolved_noncritical_dissent_ids(data)
+        if accepted_item_ids is None
+        else accepted_item_ids
+    )
     clar_rows = [r for r in (data.get("clarificationItems") or []) if isinstance(r, dict)]
     all_ids = {r.get("id") for r in clar_rows if r.get("id")}
     approval_ids = {r.get("id") for r in clar_rows if r.get("blocks") == "approval" and r.get("id")}
@@ -6251,7 +7200,7 @@ 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):
+        if _is_dissent_downgraded(item, pbv, accepted):
             continue
         item_id = item.get("id") or "<unknown>"
         cid = item.get("clarificationId")
@@ -6427,8 +7376,9 @@ def validate_plan_body_section(
     spent against a mis-scored gate.
     """
     pbv = (data.get("implementationPlanning") or {}).get("planBodyVerification") or {}
-    _validate_plan_body_gate_recompute(data, failures)
-    _validate_gate_blocked_by(data, failures)
+    accepted_item_ids = _resolved_noncritical_dissent_ids(data)
+    _validate_plan_body_gate_recompute(data, failures, accepted_item_ids)
+    _validate_gate_blocked_by(data, failures, accepted_item_ids)
     _validate_participating_analysers(data, failures)
     _validate_self_fix_rewrite_scope(data, failures)
     _validate_self_fix_grouping(data, failures)
@@ -6440,17 +7390,21 @@ def validate_plan_body_section(
     _validate_verdict_rounds_outlive_self_fix(data, failures)
     _validate_plan_item_extraction_completeness(data, failures)
     _validate_plan_item_subject_substance(data, failures)
-    _validate_plan_body_clarification_matching(data, failures)
+    _validate_plan_body_clarification_matching(data, failures, accepted_item_ids)
     _validate_disagree_has_fixability(data, failures)
     _validate_self_fix_before_clarification(data, failures)
     return [*_detect_self_fix_recurrence(pbv), *_detect_uniform_verifier(pbv)]
 
 
-def _gate_summary_item(item: dict, pbv: dict) -> dict:
+def _gate_summary_item(
+    item: dict,
+    pbv: dict,
+    accepted_item_ids: set[str],
+) -> dict:
     """One `gate.items[]` row: the gate class plus its state-file counterpart."""
     classification = (
         "has-dissent"
-        if _is_dissent_downgraded(item, pbv)
+        if _is_dissent_downgraded(item, pbv, accepted_item_ids)
         else _classify_plan_item_gate(item)
     )
     return {
@@ -6478,11 +7432,12 @@ def plan_body_gate_summary(data: dict) -> dict | None:
     pbv = ip.get("planBodyVerification")
     if not isinstance(pbv, dict):
         return None
-    recomputed = _recompute_plan_body_gate(pbv)
+    accepted_item_ids = _resolved_noncritical_dissent_ids(data)
+    recomputed = _recompute_plan_body_gate(pbv, accepted_item_ids)
     if recomputed is None:
         return None
     items = [
-        _gate_summary_item(item, pbv)
+        _gate_summary_item(item, pbv, accepted_item_ids)
         for item in (pbv.get("planItems") or [])
         if isinstance(item, dict)
     ]
@@ -6493,7 +7448,9 @@ def plan_body_gate_summary(data: dict) -> dict | None:
         "declaredBlockedBy": sorted(
             str(c) for c in (pbv.get("gateBlockedBy") or []) if isinstance(c, str)
         ),
-        "blockedBy": sorted(_gate_blocking_causes(pbv, coverage_blockers)),
+        "blockedBy": sorted(
+            _gate_blocking_causes(pbv, coverage_blockers, accepted_item_ids)
+        ),
         "coverageBlockers": coverage_blockers,
         "blockingItems": [
             item["id"] for item in items if item["classification"] == "majority-disagree"
@@ -7290,14 +8247,15 @@ def _validate_fix_cycle(run_manifest: dict, data: dict, failures: list[str]) ->
 def _validate_session_conformance(
     team_state: dict,
     team_state_path: Path,
+    run_manifest: Mapping[str, Any],
     project_root: Path,
     report_path: Path,
     task_type: str,
     claude_projects_dir: str | None,
     failures: list[str],
 ) -> None:
-    """prompts/lead/okstra-lead-contract.md BLOCKING 계약 3종(PROGRESS 체크포인트 / claude-worker
-    heartbeat / implementation entry guard)의 post-hoc 검사를 위임하고 실패를
+    """prompts/lead/okstra-lead-contract.md의 PROGRESS / activity / heartbeat /
+    implementation entry guard 사후 검사를 위임하고 실패를
     ``session-conformance: `` 접두로 folding 한다. 설계:
     docs/superpowers/specs/2026-06-10-blocking-contract-posthoc-conformance-design.md
     """
@@ -7314,6 +8272,7 @@ def _validate_session_conformance(
     result = validate_session_conformance(
         team_state=team_state,
         team_state_path=team_state_path,
+        run_manifest=run_manifest,
         project_root=project_root,
         report_path=report_path,
         task_type=task_type,
@@ -8149,6 +9108,7 @@ def main() -> int:
         _validate_session_conformance(
             team_state,
             team_state_path,
+            run_manifest,
             project_root,
             report_path,
             task_type,