okstra 0.170.3 → 0.172.0

package/runtime/validators/validate_session_conformance.py

@@ -1,4 +1,4 @@
-"""Post-hoc checks for three BLOCKING neutral lead lifecycle contracts.
+"""Post-hoc checks for neutral lead lifecycle and live-activity contracts.
 
 Design: docs/superpowers/specs/2026-06-10-blocking-contract-posthoc-conformance-design.md
 
@@ -39,6 +39,12 @@ from okstra_ctl.worker_heartbeat import (  # noqa: E402
     IN_STAGE_PREFIX,
     max_gap_seconds_after,
 )
+from okstra_ctl.lead_events import (  # noqa: E402
+    LeadEvent,
+    LeadEventParseError,
+    read_lead_events,
+)
+from okstra_ctl.agent_activity import ACTIVITY_FIELDS  # noqa: E402
 from okstra_ctl.domain.host import HostNotRegistered  # noqa: E402
 from okstra_ctl.registry.host_registry import default_host_registry  # noqa: E402
 from okstra_ctl.wrapper_status import read_wrapper_status  # noqa: E402
@@ -65,6 +71,15 @@ _PROGRESS_LINE_RE = re.compile(
     r"^[ \t]*`*[ \t]*PROGRESS:[ \t]+(?P<phase>[^\s`]+)(?P<rest>[^`\n]*)`*[ \t]*$",
     re.MULTILINE,
 )
+_ACTIVITY_ID_RE = re.compile(r"^A-(\d{3,})$")
+_TARGETED_REVERIFICATION_REF_RE = re.compile(
+    r"^plan-body-verification:round-(\d+)$"
+)
+_CLARIFICATION_ID_RE = re.compile(r"^C-\d{3,}$")
+_WORKER_FIELD_RE = re.compile(
+    r"(?:^|\s)worker=(?P<worker>.+?)(?=\s+[a-zA-Z][a-zA-Z0-9_.-]*=|$)"
+)
+_COMPLETED_STATUS_RE = re.compile(r"(?:^|\s)status=completed(?:\s|$)")
 
 # heartbeat 라인 shape 과 cadence 예산은 okstra_ctl.worker_heartbeat 정본을 쓴다 —
 # `okstra worker-liveness` 가 run 도중 같은 판정을 내리므로 정의가 갈리면 안 된다.
@@ -141,6 +156,7 @@ class SessionConformanceResult:
 class _LeadEvidence:
     progress: list[tuple[str, str, str]] = field(default_factory=list)  # (ts, phase-id, line)
     sidecar_reads: dict[str, list[str]] = field(default_factory=dict)  # basename -> [ts]
+    activities: list[LeadEvent] = field(default_factory=list)
     scanned_files: list[Path] = field(default_factory=list)
     window: tuple[str | None, str | None] = (None, None)
 
@@ -170,17 +186,23 @@ def _is_report_writer(worker: dict) -> bool:
     )
 
 
-def _worker_needles(worker: dict) -> list[str]:
-    """worker 식별 needle — 선언 형식 `worker=<role>` 와 role/workerId 표기를
-    normalize 매칭으로 흡수한다 (`Claude worker` ↔ `claude-worker`)."""
-    needles = []
-    role = _norm(str(worker.get("role", "")))
-    if role:
-        needles.append(role)
-    worker_id = _norm(str(worker.get("workerId", "")))
-    if worker_id:
-        needles.append(worker_id + "worker")
-    return needles
+def _worker_role(value: str) -> str | None:
+    """역할 필드 전체에서 Unicode 대소문자 차이만 제거한다."""
+    return value.casefold() if value else None
+
+
+def _worker_roles(worker: dict) -> set[str]:
+    role = _worker_role(str(worker.get("role") or ""))
+    return {role, role.replace(" ", "-")} if role else set()
+
+
+def _analysis_workers(team_state: Mapping[str, Any]) -> list[dict]:
+    workers = [
+        worker
+        for worker in (team_state.get("workers") or [])
+        if isinstance(worker, dict)
+    ]
+    return [worker for worker in workers if not _is_report_writer(worker)]
 
 
 def _scan_one_jsonl(
@@ -227,7 +249,10 @@ def _scan_one_jsonl(
 def _collect_lead_evidence(
     team_state: dict,
     team_state_path: Path,
+    run_manifest: Mapping[str, Any],
     project_root: Path,
+    task_type: str,
+    suffix: str | None,
     projects_root: Path | None,
 ) -> tuple[_LeadEvidence | None, str | None]:
     """lead 후보 jsonl 을 스캔해 증거를 모은다.
@@ -280,13 +305,24 @@ def _collect_lead_evidence(
     evidence.progress.sort()
     for ts_list in evidence.sidecar_reads.values():
         ts_list.sort()
+    if _is_activity_contract_v1_planning(run_manifest):
+        activities, events_path, error = _read_scoped_lead_activities(
+            team_state, run_manifest, project_root, task_type, suffix
+        )
+        if error:
+            return None, error
+        evidence.activities.extend(activities)
+        if events_path is not None:
+            evidence.scanned_files.append(events_path)
     return evidence, None
 
 
 def _resolve_lead_events_path(
-    team_state: dict, project_root: Path
+    team_state: Mapping[str, Any],
+    run_manifest: Mapping[str, Any],
+    project_root: Path,
 ) -> tuple[Path | None, str | None]:
-    raw = team_state.get("leadEventsPath") or (
+    raw = run_manifest.get("leadEventsPath") or team_state.get("leadEventsPath") or (
         (team_state.get("artifacts") or {}).get("leadEventsPath")
         if isinstance(team_state.get("artifacts"), dict)
         else ""
@@ -308,9 +344,19 @@ def _resolve_lead_events_path(
     return path, None
 
 
-def _event_matches_run(event, team_state: dict, task_type: str, run_seq: str) -> bool:
-    task_key = str(team_state.get("taskKey", ""))
-    expected_runtime = str(team_state.get("leadRuntime", "") or "claude-code")
+def _event_matches_run(
+    event: LeadEvent,
+    team_state: Mapping[str, Any],
+    run_manifest: Mapping[str, Any],
+    task_type: str,
+    run_seq: str,
+) -> bool:
+    task_key = str(run_manifest.get("taskKey") or team_state.get("taskKey") or "")
+    expected_runtime = str(
+        run_manifest.get("leadRuntime")
+        or team_state.get("leadRuntime")
+        or "claude-code"
+    )
     if event.lead_runtime != expected_runtime:
         return False
     if task_key and event.task_key != task_key:
@@ -318,6 +364,53 @@ def _event_matches_run(event, team_state: dict, task_type: str, run_seq: str) ->
     return event.task_type == task_type and event.run_seq == run_seq
 
 
+def _run_sequence(run_manifest: Mapping[str, Any], suffix: str | None) -> str:
+    sequences = run_manifest.get("runSequencesByCategory")
+    if isinstance(sequences, Mapping):
+        value = sequences.get("manifests")
+        if isinstance(value, str) and value:
+            return value
+    if suffix and "-" in suffix:
+        return suffix.rsplit("-", 1)[1]
+    return ""
+
+
+def _read_scoped_lead_activities(
+    team_state: Mapping[str, Any],
+    run_manifest: Mapping[str, Any],
+    project_root: Path,
+    task_type: str,
+    suffix: str | None,
+) -> tuple[list[LeadEvent], Path | None, str | None]:
+    run_seq = _run_sequence(run_manifest, suffix)
+    if not run_seq:
+        return [], None, (
+            "activity contract cannot scope lead events because the run sequence "
+            "is missing from the run manifest and team-state filename."
+        )
+    events_path, error = _resolve_lead_events_path(
+        team_state, run_manifest, project_root
+    )
+    if error:
+        return [], None, error
+    try:
+        events = read_lead_events(events_path)
+    except LeadEventParseError as exc:
+        return [], events_path, (
+            "artifact lead event log is malformed — selected adapter evidence "
+            f"source cannot verify conformance: {exc}"
+        )
+    activities = [
+        event
+        for event in events
+        if event.event_type == "activity"
+        and _event_matches_run(
+            event, team_state, run_manifest, task_type, run_seq
+        )
+    ]
+    return activities, events_path, None
+
+
 def _progress_line_from_event(event) -> tuple[str, str, str] | None:
     details = event.details
     phase = details.get("phase")
@@ -352,6 +445,7 @@ def _sidecar_read_from_event(event) -> tuple[str, str] | None:
 
 def _collect_artifact_lead_evidence(
     team_state: dict,
+    run_manifest: Mapping[str, Any],
     project_root: Path,
     task_type: str,
     suffix: str | None,
@@ -361,15 +455,12 @@ def _collect_artifact_lead_evidence(
             "artifact lead event log cannot be scoped because team-state filename "
             "does not expose a run artifact suffix."
         )
-    events_path, error = _resolve_lead_events_path(team_state, project_root)
+    events_path, error = _resolve_lead_events_path(
+        team_state, run_manifest, project_root
+    )
     if error:
         return None, error
 
-    try:
-        from okstra_ctl.lead_events import LeadEventParseError, read_lead_events
-    except ImportError as exc:
-        return None, f"okstra_ctl.lead_events import failed — {exc}"
-
     try:
         events = read_lead_events(events_path)
     except LeadEventParseError as exc:
@@ -378,12 +469,16 @@ def _collect_artifact_lead_evidence(
             f"source `artifact-only` cannot verify conformance: {exc}"
         )
 
-    run_seq = suffix.rsplit("-", 1)[1]
+    run_seq = _run_sequence(run_manifest, suffix)
     evidence = _LeadEvidence(scanned_files=[events_path])
     for event in events:
-        if not _event_matches_run(event, team_state, task_type, run_seq):
+        if not _event_matches_run(
+            event, team_state, run_manifest, task_type, run_seq
+        ):
             continue
-        if event.event_type in ("progress", "progress-checkpoint"):
+        if event.event_type == "activity":
+            evidence.activities.append(event)
+        elif event.event_type in ("progress", "progress-checkpoint"):
             progress = _progress_line_from_event(event)
             if progress is not None:
                 evidence.progress.append(progress)
@@ -483,6 +578,377 @@ def _ids_reported_as_asked(report_path: Path) -> list[str]:
     return asked
 
 
+def _is_activity_contract_v1_planning(
+    run_manifest: Mapping[str, Any],
+) -> bool:
+    return (
+        run_manifest.get("activityContractVersion") == 1
+        and run_manifest.get("taskType") == "implementation-planning"
+    )
+
+
+def _activity_index(events: list[LeadEvent]) -> dict[str, list[LeadEvent]]:
+    indexed: dict[str, list[LeadEvent]] = {}
+    for event in events:
+        kind = str(event.details.get("kind") or "")
+        indexed.setdefault(kind, []).append(event)
+    return indexed
+
+
+def _read_report_data(report_path: Path) -> Mapping[str, Any]:
+    name = report_path.name
+    if not name.endswith(".md"):
+        return {}
+    data_path = report_path.with_name(name.removesuffix(".md") + ".data.json")
+    try:
+        data = json.loads(data_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return {}
+    return data if isinstance(data, Mapping) else {}
+
+
+def _progress_workers(
+    evidence: _LeadEvidence,
+    phase: str,
+    *,
+    completed_only: bool = False,
+) -> set[str]:
+    workers: set[str] = set()
+    for _timestamp, event_phase, line in evidence.progress:
+        if event_phase != phase:
+            continue
+        if completed_only and _COMPLETED_STATUS_RE.search(line) is None:
+            continue
+        worker = _progress_worker(line)
+        if worker is not None:
+            workers.add(worker)
+    return workers
+
+
+def _progress_worker(line: str) -> str | None:
+    match = _WORKER_FIELD_RE.search(line)
+    return match.group("worker") if match else None
+
+
+def _activity_has_agent(events: list[LeadEvent], roles: set[str]) -> bool:
+    return any(
+        _worker_role(str(event.details.get("agent") or "")) in roles
+        for event in events
+    )
+
+
+def _roster_roles_for_value(value: str, workers: list[dict]) -> set[str]:
+    candidate = _worker_role(value)
+    for worker in workers:
+        roles = _worker_roles(worker)
+        if candidate in roles:
+            return roles
+    return {candidate} if candidate else set()
+
+
+def _check_activity_id_order(events: list[LeadEvent], errors: list[str]) -> None:
+    activity_ids = [str(event.details.get("activityId") or "") for event in events]
+    invalid = [
+        value or "<empty>"
+        for value in activity_ids
+        if not _ACTIVITY_ID_RE.fullmatch(value)
+    ]
+    if invalid:
+        errors.append(
+            "activity contract: activityId values must use A-NNN format; "
+            f"invalid={invalid}."
+        )
+    duplicates = sorted(
+        {value for value in activity_ids if activity_ids.count(value) > 1}
+    )
+    if duplicates:
+        errors.append(
+            "activity contract: activityId values must be unique; "
+            f"duplicates={duplicates}."
+        )
+    if invalid:
+        return
+    numbers = [
+        int(_ACTIVITY_ID_RE.fullmatch(value).group(1))
+        for value in activity_ids
+    ]
+    if any(current <= previous for previous, current in zip(numbers, numbers[1:])):
+        errors.append(
+            "activity contract: activityId values must be in strict A-NNN order; "
+            f"recorded={activity_ids}."
+        )
+
+
+def _check_projected_agent_activity(
+    events: list[LeadEvent],
+    report_data: Mapping[str, Any],
+    errors: list[str],
+) -> None:
+    expected = [
+        {field: event.details.get(field) for field in ACTIVITY_FIELDS}
+        for event in events
+    ]
+    projected = report_data.get("agentActivity")
+    if projected == expected:
+        return
+    mismatch = "length"
+    if isinstance(projected, list) and len(projected) == len(expected):
+        mismatch = next(
+            (
+                f"index {index}"
+                for index, (actual, wanted) in enumerate(zip(projected, expected))
+                if actual != wanted
+            ),
+            "content",
+        )
+    errors.append(
+        "activity contract: final-report data.json agentActivity must exactly "
+        "match canonical activity events in order and core fields; "
+        f"mismatch={mismatch}, expected={len(expected)}, "
+        f"projected={len(projected) if isinstance(projected, list) else '<missing>'}."
+    )
+
+
+def _check_activity_worker_pairs(
+    evidence: _LeadEvidence,
+    indexed: dict[str, list[LeadEvent]],
+    analysis_workers: list[dict],
+    errors: list[str],
+) -> None:
+    expected = (
+        ("phase-4-dispatch", "worker-dispatched", False),
+        ("phase-5-collect", "worker-completed", True),
+    )
+    for phase, kind, completed_only in expected:
+        workers = _progress_workers(
+            evidence, phase, completed_only=completed_only
+        )
+        for worker in sorted(workers):
+            roles = _roster_roles_for_value(worker, analysis_workers)
+            if _activity_has_agent(indexed.get(kind, []), roles):
+                continue
+            errors.append(
+                f"activity contract: missing `{kind}` for worker `{worker}` "
+                f"recorded by `PROGRESS: {phase}`."
+            )
+
+
+def _check_activity_worker_agents(
+    indexed: dict[str, list[LeadEvent]],
+    analysis_workers: list[dict],
+    errors: list[str],
+) -> None:
+    accepted = {
+        role
+        for worker in analysis_workers
+        for role in _worker_roles(worker)
+    }
+    roster = [str(worker.get("role") or "") for worker in analysis_workers]
+    for kind in ("worker-dispatched", "worker-completed"):
+        for event in indexed.get(kind, []):
+            agent = str(event.details.get("agent") or "")
+            if _worker_role(agent) in accepted:
+                continue
+            errors.append(
+                f"activity contract: `{kind}` agent `{agent or '<empty>'}` must "
+                f"match an actual manifest roster role; roster={roster}."
+            )
+
+
+def _self_fix_rounds_applied(report_data: Mapping[str, Any]) -> int:
+    planning = report_data.get("implementationPlanning")
+    plan_verification = (
+        planning.get("planBodyVerification")
+        if isinstance(planning, Mapping)
+        else None
+    )
+    value = (
+        plan_verification.get("selfFixRoundsApplied")
+        if isinstance(plan_verification, Mapping)
+        else 0
+    )
+    return value if isinstance(value, int) and value >= 0 else 0
+
+
+def _matching_user_reverification_round(
+    event: LeadEvent | None,
+    clarification_id: str,
+    plan_item_ids: set[str],
+    verification_rounds: int,
+) -> int | None:
+    if event is None or event.details.get("outcome") != "resolved":
+        return None
+    evidence_refs = {
+        ref
+        for ref in (event.details.get("evidenceRefs") or [])
+        if isinstance(ref, str)
+    }
+    clarification_refs = {
+        ref for ref in evidence_refs if _CLARIFICATION_ID_RE.fullmatch(ref)
+    }
+    event_item_ids = {
+        item_id
+        for item_id in (event.details.get("planItemIds") or [])
+        if isinstance(item_id, str)
+    }
+    round_numbers = {
+        int(match.group(1))
+        for ref in evidence_refs
+        for match in [_TARGETED_REVERIFICATION_REF_RE.fullmatch(ref)]
+        if match is not None
+    }
+    if clarification_refs != {clarification_id} or event_item_ids != plan_item_ids:
+        return None
+    if len(round_numbers) != 1:
+        return None
+    round_number = next(iter(round_numbers))
+    return round_number if round_number <= verification_rounds else None
+
+
+def _resolved_correctness_reverification_rounds(
+    indexed: dict[str, list[LeadEvent]],
+    report_data: Mapping[str, Any],
+    verification_rounds: int,
+) -> set[int]:
+    evaluated_by_id = {
+        str(event.details.get("activityId") or ""): event
+        for event in indexed.get("user-decision-evaluated", [])
+    }
+    rounds: set[int] = set()
+    for row in report_data.get("clarificationItems") or []:
+        if not isinstance(row, Mapping) or row.get("status") != "resolved":
+            continue
+        context = row.get("approvalContext")
+        if not isinstance(context, Mapping):
+            continue
+        if context.get("classification") != "correctness-critical":
+            continue
+        resolution = context.get("resolution")
+        if not isinstance(resolution, Mapping):
+            continue
+        clarification_id = str(row.get("id") or "")
+        plan_item_ids = {
+            item_id
+            for item_id in (context.get("planItemIds") or [])
+            if isinstance(item_id, str)
+        }
+        if not plan_item_ids:
+            continue
+        check_refs = [
+            ref for ref in (resolution.get("checkRefs") or []) if isinstance(ref, str)
+        ]
+        matched_rounds = [
+            _matching_user_reverification_round(
+                evaluated_by_id.get(check_ref),
+                clarification_id,
+                plan_item_ids,
+                verification_rounds,
+            )
+            for check_ref in check_refs
+        ]
+        if matched_rounds and all(
+            round_number is not None for round_number in matched_rounds
+        ):
+            unique_rounds = set(matched_rounds)
+            if len(unique_rounds) == 1:
+                rounds.update(unique_rounds)
+    return rounds
+
+
+def _check_activity_round_counts(
+    indexed: dict[str, list[LeadEvent]],
+    report_data: Mapping[str, Any],
+    run_dir: Path,
+    suffix: str | None,
+    errors: list[str],
+) -> None:
+    verification_rounds = _plan_body_rounds_ran(run_dir, suffix)
+    recorded_verifications = len(indexed.get("verification-round-completed", []))
+    user_reverification_rounds = _resolved_correctness_reverification_rounds(
+        indexed,
+        report_data,
+        verification_rounds,
+    )
+    automatic_rounds = verification_rounds - len(user_reverification_rounds)
+    if automatic_rounds > 2:
+        errors.append(
+            "activity contract: at most two plan verification batches are allowed; "
+            f"roundCount={verification_rounds}, "
+            f"humanReverificationRounds={sorted(user_reverification_rounds)}."
+        )
+    if recorded_verifications != automatic_rounds:
+        errors.append(
+            "activity contract: `verification-round-completed` count must match "
+            f"automatic plan-body rounds={automatic_rounds} from "
+            f"roundCount={verification_rounds}; recorded={recorded_verifications}."
+        )
+    self_fix_rounds = _self_fix_rounds_applied(report_data)
+    recorded_self_fixes = len(indexed.get("self-fix-applied", []))
+    if recorded_self_fixes != self_fix_rounds:
+        errors.append(
+            "activity contract: `self-fix-applied` count must match "
+            f"selfFixRoundsApplied={self_fix_rounds}; recorded={recorded_self_fixes}."
+        )
+
+
+def _activity_references(event: LeadEvent, reference: str) -> bool:
+    refs = event.details.get("evidenceRefs")
+    return isinstance(refs, list) and reference in refs
+
+
+def _check_activity_user_decisions(
+    indexed: dict[str, list[LeadEvent]],
+    report_data: Mapping[str, Any],
+    errors: list[str],
+) -> None:
+    rows = report_data.get("clarificationItems")
+    if not isinstance(rows, list):
+        return
+    required = indexed.get("user-decision-required", [])
+    evaluated = indexed.get("user-decision-evaluated", [])
+    for row in rows:
+        if not isinstance(row, Mapping) or row.get("blocks") != "approval":
+            continue
+        clarification_id = str(row.get("id") or "<unknown>")
+        confirmation = str(row.get("userConfirmation") or "")
+        if confirmation.startswith("asked-") and not any(
+            _activity_references(event, clarification_id) for event in required
+        ):
+            errors.append(
+                "activity contract: missing `user-decision-required` referencing "
+                f"approval clarification `{clarification_id}`."
+            )
+        if row.get("status") == "resolved" and not any(
+            _activity_references(event, clarification_id) for event in evaluated
+        ):
+            errors.append(
+                "activity contract: missing `user-decision-evaluated` referencing "
+                f"resolved approval clarification `{clarification_id}`."
+            )
+
+
+def _check_activity_contract(
+    evidence: _LeadEvidence,
+    team_state: Mapping[str, Any],
+    run_manifest: Mapping[str, Any],
+    report_path: Path,
+    run_dir: Path,
+    suffix: str | None,
+    errors: list[str],
+) -> None:
+    if not _is_activity_contract_v1_planning(run_manifest):
+        return
+    indexed = _activity_index(evidence.activities)
+    analysis_workers = _analysis_workers(team_state)
+    report_data = _read_report_data(report_path)
+    _check_activity_id_order(evidence.activities, errors)
+    _check_projected_agent_activity(evidence.activities, report_data, errors)
+    _check_activity_worker_pairs(evidence, indexed, analysis_workers, errors)
+    _check_activity_worker_agents(indexed, analysis_workers, errors)
+    _check_activity_round_counts(indexed, report_data, run_dir, suffix, errors)
+    _check_activity_user_decisions(indexed, report_data, errors)
+
+
 def _check_user_confirm_checkpoints(
     by_phase: dict[str, list[tuple[str, str]]],
     asked_ids: list[str],
@@ -512,8 +978,14 @@ def _check_user_confirm_checkpoints(
         )
 
 
-def _phase_mentions_worker(lines: list[tuple[str, str]], needles: list[str]) -> bool:
-    return any(needle in _norm(line) for _ts, line in lines for needle in needles)
+def _phase_mentions_worker(
+    lines: list[tuple[str, str]], roles: set[str]
+) -> bool:
+    return any(
+        _worker_role(worker) in roles
+        for _ts, line in lines
+        if (worker := _progress_worker(line)) is not None
+    )
 
 
 def _check_worker_checkpoint_lines(
@@ -525,9 +997,9 @@ def _check_worker_checkpoint_lines(
     for worker in analysis_workers:
         role = str(worker.get("role", "")).strip() or "<unknown role>"
         status = str(worker.get("status", "")).strip()
-        needles = _worker_needles(worker)
+        roles = _worker_roles(worker)
         if status in _ATTEMPTED_STATUSES and not _phase_mentions_worker(
-            by_phase.get("phase-4-dispatch", []), needles
+            by_phase.get("phase-4-dispatch", []), roles
         ):
             errors.append(
                 f"PROGRESS checkpoint missing: no `phase-4-dispatch worker=<role>` "
@@ -535,7 +1007,7 @@ def _check_worker_checkpoint_lines(
                 "prompts/lead/okstra-lead-contract.md 'Progress reporting (BLOCKING)'."
             )
         if status == "completed" and not _phase_mentions_worker(
-            by_phase.get("phase-5-collect", []), needles
+            by_phase.get("phase-5-collect", []), roles
         ):
             errors.append(
                 f"PROGRESS checkpoint missing: no `phase-5-collect worker=<role>` "
@@ -642,7 +1114,7 @@ def _check_progress_checkpoints(
         )
 
     workers = [w for w in (team_state.get("workers") or []) if isinstance(w, dict)]
-    analysis_workers = [w for w in workers if not _is_report_writer(w)]
+    analysis_workers = _analysis_workers(team_state)
     any_dispatched = any(
         str(w.get("status", "")).strip() in _DISPATCHED_STATUSES for w in workers
     )
@@ -896,12 +1368,13 @@ 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: Path | None = None,
 ) -> SessionConformanceResult:
-    """Run three post-hoc checks for the neutral lead lifecycle contract.
+    """Run post-hoc checks for the neutral lead and activity contracts.
 
     `claude_projects_dir` injects the Claude project root for tests and diagnostics.
     Heartbeat validation runs before selecting the adapter evidence source.
@@ -924,11 +1397,17 @@ def validate_session_conformance(
         return result
     if evidence_source == "artifact-only":
         evidence, error = _collect_artifact_lead_evidence(
-            team_state, project_root, task_type, suffix
+            team_state, run_manifest, project_root, task_type, suffix
         )
     else:
         evidence, error = _collect_lead_evidence(
-            team_state, team_state_path, project_root, claude_projects_dir
+            team_state,
+            team_state_path,
+            run_manifest,
+            project_root,
+            task_type,
+            suffix,
+            claude_projects_dir,
         )
     if error:
         result.errors.append(error)
@@ -936,6 +1415,15 @@ def validate_session_conformance(
     _check_progress_checkpoints(
         evidence, team_state, run_dir, suffix, report_path, result.errors
     )
+    _check_activity_contract(
+        evidence,
+        team_state,
+        run_manifest,
+        report_path,
+        run_dir,
+        suffix,
+        result.errors,
+    )
     _check_cmux_adapter_read(evidence, team_state, result.errors)
     if task_type == "implementation":
         _check_implementation_entry_guard(