okstra 0.186.7 → 0.187.0

package/runtime/validators/validate-workflow.sh

@@ -12,7 +12,13 @@ done
 SCRIPT_DIR="$(cd -P "$(dirname "$SOURCE_PATH")" && pwd)"
 WORKSPACE_ROOT="$(cd -P "$SCRIPT_DIR/.." && pwd)"
 PROJECT_ID="okstra-validation"
-PROJECT_ROOT="${OKSTRA_VALIDATION_PROJECT_ROOT:-/tmp/okstra-validate.workflow}"
+
+# shellcheck source=lib/common.sh
+source "$SCRIPT_DIR/lib/common.sh"
+# shellcheck source=lib/paths.sh
+source "$SCRIPT_DIR/lib/paths.sh"
+
+PROJECT_ROOT="$(resolve_validation_project_root)"
 export OKSTRA_HOME="${OKSTRA_HOME:-$PROJECT_ROOT/.okstra-home}"
 
 WORKSPACE_APP_PATH="$PROJECT_ROOT"
@@ -34,22 +40,17 @@ SECONDARY_BRIEF_FILENAME="validation-brief-secondary.md"
 
 # Workflow validation is a hermetic contract test for bundle prep / discovery
 # artifacts / validator round-trips. It must not depend on the developer or CI
-# machine having a preinstalled ~/.okstra runtime, and it must not reconcile or
-# backfill against unrelated local state.
+# machine having a preinstalled ~/.okstra runtime. The synthetic prepare below
+# reconciles the run index (okstra_ctl.run._reconcile_prior_runs); it stays off
+# unrelated local state because OKSTRA_HOME is redirected above and the
+# reconcile is scoped to this fixture's project id.
 export OKSTRA_SKIP_INSTALL_CHECK="${OKSTRA_SKIP_INSTALL_CHECK:-1}"
-export OKSTRA_CTL_SKIP_RECONCILE="${OKSTRA_CTL_SKIP_RECONCILE:-1}"
-export OKSTRA_CTL_SKIP_BACKFILL="${OKSTRA_CTL_SKIP_BACKFILL:-1}"
-# Same reason as the three above: the synthetic run must render the same way on
-# every machine. cmux outranks tmux when present, so a maintainer running this
-# from inside cmux would otherwise get the cmux adapter and a lead-session
-# requirement this fixture never simulates. The cmux path has its own coverage
+# Same reason as the one above: the synthetic run must render the same way on
+# every machine. A maintainer running this from inside cmux would otherwise get
+# the cmux adapter and a lead-session requirement this fixture never simulates. The cmux path has its own coverage
 # in tests/run/test_cmux*.py and tests/contract/test_validate_session_conformance.py.
 export CMUX_WORKSPACE_ID=""
 
-# shellcheck source=lib/common.sh
-source "$SCRIPT_DIR/lib/common.sh"
-# shellcheck source=lib/paths.sh
-source "$SCRIPT_DIR/lib/paths.sh"
 LATEST_TASK_RELATIVE_PATH="$OKSTRA_DIR/discovery/latest-task.json"
 TASK_CATALOG_RELATIVE_PATH="$OKSTRA_DIR/discovery/task-catalog.json"
 # shellcheck source=lib/fixtures.sh
@@ -67,6 +68,23 @@ source "$SCRIPT_DIR/lib/summary.sh"
 
 trap 'on_error "$LINENO"' ERR
 
+# 기본(mktemp) 루트는 이 실행이 소유한다: 성공 시 제거, 실패 시 진단을 위해
+# 보존. OKSTRA_VALIDATION_PROJECT_ROOT 가 지정된 루트의 수명은 호출자 소유.
+cleanup_validation_root() {
+  local exit_code=$?
+
+  if [[ -n "${OKSTRA_VALIDATION_PROJECT_ROOT:-}" ]]; then
+    return
+  fi
+
+  if [[ "$exit_code" -eq 0 ]]; then
+    rm -rf "$PROJECT_ROOT"
+  else
+    printf '[INFO] Validation root retained for inspection: %s\n' "$PROJECT_ROOT" >&2
+  fi
+}
+trap cleanup_validation_root EXIT
+
 require_file "$OKSTRA_SCRIPT"
 require_file "$RUN_VALIDATOR_PATH"
 
@@ -134,19 +152,19 @@ step "Preparing validator fixture artifacts for the primary task"
 # repo root so the heredoc can import okstra_ctl.report_views and load
 # inline assets from templates/reports/.
 export OKSTRA_WORKSPACE_ROOT_FOR_FIXTURE="$WORKSPACE_ROOT"
-if ! prepare_run_validator_fixture "$PRIMARY_TASK_GROUP" "$PRIMARY_TASK_ID" codex; then
+if ! prepare_run_validator_fixture "$PRIMARY_TASK_GROUP" "$PRIMARY_TASK_ID" codex-analyser; then
   fail "Failed to prepare validator fixture artifacts for the primary task"
 fi
 pass "Primary task validator fixture prepared with an intentionally missing Codex prompt history file"
 
 step "Ensuring the run validator rejects attempted workers without prompt history"
-if ! run_validator_expectation "$PRIMARY_TASK_GROUP" "$PRIMARY_TASK_ID" failed "Codex worker with status \`timeout\` is missing worker prompt history file"; then
+if ! run_validator_expectation "$PRIMARY_TASK_GROUP" "$PRIMARY_TASK_ID" failed "Codex analyser with status \`timeout\` is missing worker prompt history file"; then
   fail "Run validator did not reject the missing worker prompt history artifact"
 fi
 pass "Run validator rejected the missing worker prompt history artifact as expected"
 
 step "Restoring the missing worker prompt history file and rerunning the validator"
-if ! write_worker_prompt_history_fixture "$PRIMARY_TASK_GROUP" "$PRIMARY_TASK_ID" codex; then
+if ! write_worker_prompt_history_fixture "$PRIMARY_TASK_GROUP" "$PRIMARY_TASK_ID" codex-analyser; then
   fail "Failed to write the missing worker prompt history fixture"
 fi
 if ! run_validator_expectation "$PRIMARY_TASK_GROUP" "$PRIMARY_TASK_ID" passed; then
@@ -154,6 +172,28 @@ if ! run_validator_expectation "$PRIMARY_TASK_GROUP" "$PRIMARY_TASK_ID" passed;
 fi
 pass "Run validator passed after the missing worker prompt history artifact was restored"
 
+step "Checking that the validated run is settled in the central run index"
+# The global index (~/.okstra) records a run's start via record_start and never
+# its end; validate-run is what writes the end
+# (record_validation_in_central_index). Without that edge the row stays
+# `prepared`/`running` forever and run-audit reads it as a run that has not
+# produced its report yet. This run was validated twice here — `failed`, then
+# `passed` — so a passing row also proves the second verdict overwrote the first.
+RECENT_INDEX="$OKSTRA_HOME/recent.jsonl"
+require_file "$RECENT_INDEX"
+PRIMARY_RUN_ID="$PROJECT_ID/$PRIMARY_TASK_GROUP/$PRIMARY_TASK_ID/$TASK_TYPE/r01"
+PRIMARY_INDEX_ROW="$(grep -F "\"runId\":\"$PRIMARY_RUN_ID\"" "$RECENT_INDEX" || true)"
+if [[ -z "$PRIMARY_INDEX_ROW" ]]; then
+  fail "No central run-index row for $PRIMARY_RUN_ID"
+fi
+if ! printf '%s' "$PRIMARY_INDEX_ROW" | grep -qF '"status":"completed"'; then
+  fail "Central run-index row for $PRIMARY_RUN_ID is not completed: $PRIMARY_INDEX_ROW"
+fi
+if ! printf '%s' "$PRIMARY_INDEX_ROW" | grep -qF '"validation":"passed"'; then
+  fail "Central run-index row for $PRIMARY_RUN_ID does not carry the passing verdict: $PRIMARY_INDEX_ROW"
+fi
+pass "Central run-index row for the primary run reads completed/passed"
+
 step "Running a second render-only okstra validation for the secondary task"
 if ! run_okstra "$SECONDARY_TASK_GROUP" "$SECONDARY_TASK_ID" "$SECONDARY_BRIEF_FILENAME"; then
   fail "Render-only validation for the secondary task failed"

package/runtime/validators/validate_improvement_report.py

@@ -26,6 +26,7 @@ from okstra_ctl.improvement_lenses import (
     ABSOLUTE_CANDIDATE_CAP,
     SOURCE_WORKERS,
 )
+from okstra_ctl.final_report_paths import final_report_data_path
 from okstra_ctl.final_report_schema import (
     load_schema_version,
     validate as validate_final_report_data,
@@ -349,7 +350,7 @@ def validate_improvement_report(
         errors.append(f"report file not found: {report_path}")
         return ValidationResult(ok=False, errors=errors)
 
-    data_path = report_path.with_suffix(".data.json")
+    data_path = final_report_data_path(report_path)
     if data_path.exists():
         try:
             data = json.loads(data_path.read_text(encoding="utf-8"))

package/runtime/validators/validate_session_conformance.py

@@ -45,14 +45,13 @@ from okstra_ctl.lead_events import (  # noqa: E402
     LeadEventParseError,
     read_lead_events,
 )
-from okstra_ctl.agent_activity import ACTIVITY_FIELDS  # noqa: E402
+from okstra_ctl.agent.activity import ACTIVITY_FIELDS  # noqa: E402
 from okstra_ctl.domain.host import HostNotRegistered  # noqa: E402
 from okstra_ctl.final_report_paths import final_report_data_path  # 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
 
 _DISPATCHED_STATUSES = {"completed", "timeout", "error", "in-progress"}
-_WORKER_DISPATCH_MODES = {"cli-wrapper", "mixed"}
 _ATTEMPTED_STATUSES = {"completed", "timeout", "error"}
 _LIVENESS_AUDIT_HEARTBEAT = "audit-heartbeat"
 _LIVENESS_WRAPPER_STATUS = "wrapper-status"
@@ -90,6 +89,8 @@ _IN_STAGE_PREFIX = IN_STAGE_PREFIX
 
 _LEAD_CONTRACT_CITE = "prompts/lead/okstra-lead-contract.md 'Entry guard (BLOCKING)'"
 _HOST_RULES_CITE = "prompts/launch.template.md 'Host Orchestration Rules'"
+_CONVERGENCE_CITE = "prompts/lead/convergence.md"
+_PLAN_BODY_CITE = "prompts/lead/plan-body-verification.md"
 
 
 class _EntryGuardRead(NamedTuple):
@@ -102,17 +103,29 @@ class _EntryGuardRead(NamedTuple):
     cite: str
     # True 면 run 이 이 파일을 instruction-set 에 스테이징했을 때만 요구한다.
     staged_per_run: bool = False
+    # 이 행이 도는 task-type. None 이면 task-type 을 가리지 않는다.
+    task_types: frozenset[str] | None = None
+    # 이 PROGRESS phase 가 run 에 실제로 나타났을 때만 요구한다. None 이면
+    # 무조건 요구한다. task-type 목록을 손으로 적는 것보다 정확하다 — 수렴은
+    # 여러 phase 에서 돌고, 어느 run 이 실제로 돌렸는지는 그 run 의 체크포인트가
+    # 말해 준다.
+    required_when: str | None = None
 
 
+_IMPLEMENTATION_ONLY = frozenset({"implementation"})
+
 _ENTRY_GUARD_READS = (
     _EntryGuardRead(
-        "_implementation-executor.md", ("phase-6-synthesis", "at Phase 5"), _LEAD_CONTRACT_CITE
+        "_implementation-executor.md", ("phase-6-synthesis", "at Phase 5"),
+        _LEAD_CONTRACT_CITE, task_types=_IMPLEMENTATION_ONLY,
     ),
     _EntryGuardRead(
-        "_implementation-verifier.md", ("phase-6-synthesis", "at Phase 5"), _LEAD_CONTRACT_CITE
+        "_implementation-verifier.md", ("phase-6-synthesis", "at Phase 5"),
+        _LEAD_CONTRACT_CITE, task_types=_IMPLEMENTATION_ONLY,
     ),
     _EntryGuardRead(
-        "_implementation-deliverable.md", ("phase-7-persist", "at Phase 6"), _LEAD_CONTRACT_CITE
+        "_implementation-deliverable.md", ("phase-7-persist", "at Phase 6"),
+        _LEAD_CONTRACT_CITE, task_types=_IMPLEMENTATION_ONLY,
     ),
     # lead 프로파일 sidecar 가 아니라, run 이 instruction-set 에 스테이징한 host
     # orchestration 규칙이다. 세 가지가 sidecar 와 다르다.
@@ -126,7 +139,26 @@ _ENTRY_GUARD_READS = (
     #   파일 때문에 막히면 안 된다. 규칙이 없는 task-type 에 conformance 가 규칙을
     #   요구하지 않는다는 원칙과 같은 판단이다.
     _EntryGuardRead(
-        "host-orchestration-rules.md", None, _HOST_RULES_CITE, staged_per_run=True
+        "host-orchestration-rules.md", None, _HOST_RULES_CITE, staged_per_run=True,
+        task_types=_IMPLEMENTATION_ONLY,
+    ),
+    # 수렴과 계획-본문 검증은 규칙 문서가 lazy 로 남는다 — Phase 1 intake 가
+    # 읽지 않으므로, 읽지 않은 lead 는 그 라운드를 자기 기억으로 돌린다. 그
+    # 두 문서에 lead 대상 MUST 의 절반 이상이 들어 있다.
+    #
+    # task-type 이 아니라 체크포인트로 조건을 건다: 라운드를 실제로 돌린 run 만
+    # 그 문서를 요구받는다.
+    _EntryGuardRead(
+        "convergence.md",
+        ("phase-5.5-convergence", "before the first convergence round"),
+        _CONVERGENCE_CITE,
+        required_when="phase-5.5-convergence",
+    ),
+    _EntryGuardRead(
+        "plan-body-verification.md",
+        ("phase-5.5.9-plan-verify", "before the first plan-verify round"),
+        _PLAN_BODY_CITE,
+        required_when="phase-5.5.9-plan-verify",
     ),
 )
 
@@ -325,7 +357,7 @@ def _collect_lead_evidence(
         resolve_run_window,
         resolve_team_needles_with_source,
     )
-    from okstra_token_usage.paths import claude_project_dir
+    from okstra_token_usage.paths import claude_project_dir, find_session_jsonl
 
     since, until = resolve_run_window(team_state_path, team_state, relax_start=False)
     lead_sid = (team_state.get("lead") or {}).get("sessionId") or ""
@@ -337,12 +369,17 @@ def _collect_lead_evidence(
     )
     # `claude --resume` 로 fork 되거나 leadSessionIds[] 에 기록된 lead 세대는
     # team 태그 needle 로 안 잡힐 수 있어 명시적으로 후보에 추가한다.
+    #
+    # 기록된 id 는 프로젝트 디렉터리 밖에 있을 수 있다 — 리드 세션의 cwd 가
+    # 대상 프로젝트 루트와 다르면(`okstra preflight --cwd <다른 프로젝트>`)
+    # transcript 는 리드 cwd 로 인코딩된 디렉터리에 놓인다. 그래서 id 로 찾는다.
     proj_dir = claude_project_dir(project_root, projects_root)
-    for sid in (team_state.get("leadSessionIds") or []):
+    recorded_ids = [lead_sid, *(team_state.get("leadSessionIds") or [])]
+    for sid in recorded_ids:
         if not isinstance(sid, str) or not sid:
             continue
-        candidate = proj_dir / f"{sid}.jsonl"
-        if candidate.is_file():
+        candidate = find_session_jsonl(sid, project_root, projects_root)
+        if candidate is not None:
             sessions.setdefault(sid, candidate)
     evidence = _LeadEvidence(window=(since, until))
     for sid, path in sorted(sessions.items()):
@@ -355,7 +392,8 @@ def _collect_lead_evidence(
             evidence.sidecar_reads.setdefault(base, []).extend(ts_list)
     if not evidence.scanned_files:
         return None, (
-            f"lead session jsonl not found under {proj_dir} "
+            f"lead session jsonl not found under {proj_dir} nor anywhere under "
+            f"{(projects_root or proj_dir.parent)} by recorded session id "
             f"(lead.sessionId={lead_sid or '<empty>'}) — selected adapter evidence "
             "source `claude-jsonl` cannot verify the PROGRESS checkpoint / "
             "implementation entry-guard conformance cannot be verified, which "
@@ -556,10 +594,22 @@ def _collect_artifact_lead_evidence(
 def _conformance_evidence_source(
     team_state: dict,
 ) -> tuple[str | None, str | None]:
-    dispatch_mode = str(team_state.get("dispatchMode", "")).strip()
-    if dispatch_mode in _WORKER_DISPATCH_MODES:
-        return "artifact-only", None
-
+    """리드의 증거가 어디 있는지 — 리드 회계가 정한다.
+
+    `dispatchMode` 는 **워커**를 어떻게 띄우는지를 말하는 필드다. 그 값이
+    리드 세션의 전사 여부를 바꾸지는 않는다: cmux 판으로 워커를 내보낸
+    Claude Code 리드도 자기 전사에 Read 와 PROGRESS 를 그대로 남긴다.
+    어댑터 자신도 그렇게 선언한다 —
+    `prompts/lead/adapters/cmux.md:18` 의 `sessionAccounting | unchanged`.
+
+    종전에는 이 함수가 어댑터 메타데이터를 보기 전에 `dispatchMode` 로
+    단락해 `artifact-only` 를 확정했다. 그러면 수집기가 `lead-events-*.jsonl`
+    만 보는데 거기에는 `okstra agent-activity append` 가 쓴 활동 레코드만
+    들어가고 리드 툴셋에는 PROGRESS 나 파일 읽기를 그리로 보낼 경로가 없다 —
+    실측(`fontsninja-nlpvibe` stage 10): artifact-only 로 progress 0·reads 0,
+    같은 run 을 리드 전사로 읽으면 progress 21·reads 5(entry guard 가 요구하는
+    네 파일 전부). 즉 어떤 리드가 무엇을 해도 통과할 수 없는 검사였다.
+    """
     adapter = team_state.get("leadAdapter")
     if isinstance(adapter, dict):
         accounting = str(adapter.get("sessionAccounting", "")).strip()
@@ -591,6 +641,85 @@ def _convergence_rounds_ran(run_dir: Path, suffix: str | None) -> bool:
     return isinstance(doc, dict) and (doc.get("totalRounds") or 0) >= 1
 
 
+def _verification_error_workers(run_dir: Path, suffix: str | None) -> set[str]:
+    """이 run 의 convergence 에서 `verification-error` 를 낸 워커들."""
+    if not suffix:
+        return set()
+    path = run_dir / "state" / f"convergence-{suffix}.json"
+    try:
+        doc = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return set()
+    if not isinstance(doc, dict):
+        return set()
+    workers: set[str] = set()
+    for finding in doc.get("findings") or []:
+        if not isinstance(finding, dict):
+            continue
+        for entry in finding.get("rounds") or []:
+            if not isinstance(entry, dict):
+                continue
+            for worker, vote in (entry.get("votes") or {}).items():
+                if isinstance(vote, dict) and vote.get("verdict") == "verification-error":
+                    workers.add(str(worker))
+    return workers
+
+
+def _contract_violation_agents(run_dir: Path, suffix: str | None) -> set[str]:
+    """run 에러 로그에 `contract-violation` 으로 기록된 agent 들."""
+    if not suffix:
+        return set()
+    path = run_dir / "logs" / f"errors-{suffix}.jsonl"
+    try:
+        raw = path.read_text(encoding="utf-8")
+    except OSError:
+        return set()
+    agents: set[str] = set()
+    for line in raw.splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            row = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if isinstance(row, dict) and row.get("errorType") == "contract-violation":
+            agent = row.get("agent") or row.get("workerId")
+            if agent:
+                agents.add(str(agent))
+    return agents
+
+
+def _check_verification_errors_are_logged(
+    run_dir: Path, suffix: str | None, advisories: list[str]
+) -> None:
+    """`verification-error` 를 낸 워커는 에러 로그에도 남아야 한다.
+
+    계약(okstra-lead-contract.md §"Phase 5.5: Convergence loop")은 재검증 배치가
+    `verification-error` 로 끝나면 lead 가 위반마다 한 건씩
+    `okstra error-log append-observed --error-type contract-violation` 으로
+    기록하라고 요구한다. 기록이 없으면 워커 실패가 감사 흔적 없이 지나가고,
+    그 run 의 합의는 실제보다 적은 검증 위에 서 있다.
+
+    advisory 로 낸다. 이 파일의 구분을 따른다 — 검증기가 도는 시점에는 그 기록을
+    더 이상 쓸 수 없고(세션이 끝났다), 빠진 기록은 run 을 나중에 따라가기 어렵게
+    만들지 그 run 의 작업이 틀렸다는 뜻은 아니다.
+    """
+    failed = _verification_error_workers(run_dir, suffix)
+    if not failed:
+        return
+    logged = _contract_violation_agents(run_dir, suffix)
+    missing = sorted(failed - logged)
+    if missing:
+        advisories.append(
+            "convergence verification-error not recorded in the run error log for: "
+            + ", ".join(missing)
+            + " — prompts/lead/okstra-lead-contract.md 'Phase 5.5: Convergence loop' "
+            "requires one `okstra error-log append-observed --error-type "
+            "contract-violation` event per violation."
+        )
+
+
 def _plan_body_rounds_ran(run_dir: Path, suffix: str | None) -> int:
     """이 run 의 plan-body 검증이 실제로 돈 라운드 수.
 
@@ -852,19 +981,60 @@ def _allowed_automatic_rounds(self_fix_rounds: int, *, gating: bool = True) -> i
     return 2 + max(self_fix_rounds, 0)
 
 
-def _self_fix_rounds_from_state(run_dir: Path, suffix: str | None) -> int | None:
-    """이번 런 상태 파일의 자가수정 횟수. 없으면 None — 호출자가 리포트로 폴백.
-
-    리포트 칸은 이어진 seq 의 누적이라, 이번 창의 `self-fix-applied` 건수와
-    비교하면 어긋난다.
-    """
+def _plan_body_state_document(run_dir: Path, suffix: str | None) -> dict | None:
     if not suffix:
         return None
     try:
         doc = json.loads(_plan_body_state_path(run_dir, suffix).read_text())
     except (OSError, json.JSONDecodeError):
         return None
-    if not isinstance(doc, dict):
+    return doc if isinstance(doc, dict) else None
+
+
+def _plan_body_round_history_len(run_dir: Path, suffix: str | None) -> int | None:
+    doc = _plan_body_state_document(run_dir, suffix)
+    if doc is None:
+        return None
+    history = doc.get("roundHistory")
+    if not isinstance(history, list):
+        return None
+    return len(history)
+
+
+def _self_fix_event_expectation(
+    run_dir: Path, suffix: str | None, self_fix_rounds: int,
+) -> int:
+    """selfFixRoundsApplied 는 마지막 라운드 번호다. 활동 건수는 그룹 라운드 수.
+
+    라운드 3 에 원인 그룹 4개를 한 번에 쓰면 필드 값은 3, 이벤트는 1이다.
+    """
+    doc = _plan_body_state_document(run_dir, suffix)
+    if doc is None:
+        return self_fix_rounds
+    projection = doc.get("planBodyVerification")
+    groups = (
+        projection.get("selfFixGroups")
+        if isinstance(projection, dict)
+        else None
+    )
+    if not isinstance(groups, list) or not groups:
+        return self_fix_rounds
+    rounds = {
+        row.get("round")
+        for row in groups
+        if isinstance(row, dict) and isinstance(row.get("round"), int)
+    }
+    return len(rounds) if rounds else self_fix_rounds
+
+
+def _self_fix_rounds_from_state(run_dir: Path, suffix: str | None) -> int | None:
+    """이번 런 상태 파일의 자가수정 횟수. 없으면 None — 호출자가 리포트로 폴백.
+
+    리포트 칸은 이어진 seq 의 누적이라, 이번 창의 `self-fix-applied` 건수와
+    비교하면 어긋난다.
+    """
+    doc = _plan_body_state_document(run_dir, suffix)
+    if doc is None:
         return None
     projection = doc.get("planBodyVerification")
     value = (
@@ -886,7 +1056,11 @@ def _is_plan_body_verification_activity(event: LeadEvent) -> bool:
     본문이 아니다. 픽스처 요약(`verification-round-completed for …`)은 본문이다.
     """
     summary = str(event.details.get("summary") or "").lower()
-    return "adversarial reverify" not in summary and "adversarial re-verify" not in summary
+    if "adversarial reverify" in summary or "adversarial re-verify" in summary:
+        return False
+    if "critic-gap" in summary:
+        return False
+    return True
 
 
 def _plan_body_verification(report_data: Mapping[str, Any]) -> Mapping[str, Any] | None:
@@ -1036,7 +1210,11 @@ def _check_activity_round_counts(
             f"roundCount={verification_rounds}, "
             f"humanReverificationRounds={sorted(user_reverification_rounds)}."
         )
-    if recorded_verifications != automatic_rounds:
+    history_len = _plan_body_round_history_len(run_dir, suffix)
+    if (
+        recorded_verifications != automatic_rounds
+        and history_len != verification_rounds
+    ):
         errors.append(
             "activity contract: `verification-round-completed` count must match "
             f"automatic plan-body rounds={automatic_rounds} from "
@@ -1045,10 +1223,13 @@ def _check_activity_round_counts(
             f"recorded={recorded_verifications}."
         )
     recorded_self_fixes = len(indexed.get("self-fix-applied", []))
-    if recorded_self_fixes != self_fix_rounds:
+    expected_self_fixes = _self_fix_event_expectation(
+        run_dir, suffix, self_fix_rounds,
+    )
+    if recorded_self_fixes != expected_self_fixes:
         errors.append(
             "activity contract: `self-fix-applied` count must match "
-            f"selfFixRoundsApplied={self_fix_rounds}; recorded={recorded_self_fixes}."
+            f"selfFixRoundsApplied={expected_self_fixes}; recorded={recorded_self_fixes}."
         )
 
 
@@ -1254,6 +1435,7 @@ def _check_progress_checkpoints(
     run_dir: Path,
     suffix: str | None,
     report_path: Path,
+    task_type: str,
     errors: list[str],
     advisories: list[str] | None = None,
 ) -> None:
@@ -1293,7 +1475,7 @@ def _check_progress_checkpoints(
         "phase-3-team-create",
         any_dispatched,
         "in Phase 3 after recording teamCreate in team-state — the "
-        "`using implicit team (split-pane=<on|off>)` line, or the "
+        "`using implicit team` line, or the "
         "`skipped (concurrent-run)` variant in the concurrent-run path",
     )
     _check_worker_checkpoint_lines(by_phase, analysis_workers, narration)
@@ -1313,6 +1495,28 @@ def _check_progress_checkpoints(
         report_writer_dispatched,
         "at the start of Phase 6 (report-writer dispatch)",
     )
+    if task_type == "implementation":
+        # 이 run 이 실행하는 stage 의 공지/완료 라인 — implementation 전용 두
+        # 체크포인트. 완료 라인은 carry 증거를 파싱한 뒤에만 낼 수 있으므로
+        # implementer 가 완주한 run 에만 요구한다.
+        require(
+            "phase-5-stage",
+            any_dispatched,
+            "immediately before the Executor dispatch — `stage=<N> title=<title> "
+            "steps=<count>` from the approved plan's Stage Map",
+        )
+        implementer_completed = any(
+            "implementer"
+            in _norm(str(w.get("workerId") or "") + str(w.get("role") or ""))
+            and str(w.get("status", "")).strip() == "completed"
+            for w in workers
+        )
+        require(
+            "phase-5-stage-complete",
+            implementer_completed,
+            "immediately after parsing the Executor's `### Stage Carry Evidence` "
+            "block — `stage=<N> steps=<done>/<count>` from its stepResults",
+        )
     require("phase-7-persist", True, "at the start of Phase 7")
     _check_batch_cleanup_checkpoints(
         by_phase, convergence_ran, report_writer_dispatched, narration
@@ -1375,6 +1579,25 @@ def _check_heartbeat_sidecar(path: Path, worker_id: str, errors: list[str]) -> N
             f"although the worker result `{result_file.name}` exists — every "
             "stage must append its own line (agents/workers/claude-worker.md 'Heartbeat')."
         )
+    # implementer(Executor)는 지금 실행 중인 plan step 을 하트비트로 알린다
+    # (_implementation-executor.md 'Per-step heartbeat'). result 를 남기고 완주한
+    # executor 의 사이드카에 step 라인이 하나도 없으면 이 run 의 유일한 스텝 단위
+    # 진행 신호가 없었던 것이다. cli-wrapper executor 는 wrapper-status 경로라
+    # 이 함수에 들어오지 않는다.
+    if (
+        "implementer" in _norm(worker_id)
+        and result_file.exists()
+        and not any(
+            stage.removeprefix(_IN_STAGE_PREFIX).startswith("step-")
+            for stage, _ in entries
+        )
+    ):
+        errors.append(
+            f"`{rel}`: implementer heartbeat has no `- PROGRESS: step-<k> <ISO>` "
+            "line although the worker result exists — the executor MUST announce "
+            "each plan step as it starts "
+            "(prompts/profiles/_implementation-executor.md 'Per-step heartbeat')."
+        )
     prev: datetime | None = None
     prev_stage = ""
     for stage, raw_ts in entries:
@@ -1483,10 +1706,10 @@ def _check_cmux_adapter_read(
         return
     if evidence.sidecar_reads.get(CMUX_ADAPTER_BASENAME):
         return
-    dispatch_mode = str(team_state.get("dispatchMode", "")).strip()
-    if dispatch_mode in _WORKER_DISPATCH_MODES:
-        # grok 같은 artifact-only 호스트는 Read 도구 기록이 없다. 워커가
-        # okstra 디스패치로 나갔으면 어댑터가 가리키는 경로를 탄 것이다.
+    source, _error = _conformance_evidence_source(team_state)
+    if source == "artifact-only":
+        # grok 같은 artifact-only 호스트는 Read 도구 기록이 없다. 면제 사유는
+        # 리드가 읽기를 남기지 못한다는 것이지 워커를 어떻게 띄웠는지가 아니다.
         return
     errors.append(
         f"cmux adapter: no read of `{CMUX_ADAPTER_BASENAME}` (a `Read` call or a "
@@ -1497,32 +1720,53 @@ def _check_cmux_adapter_read(
     )
 
 
-def _check_implementation_entry_guard(
-    evidence: _LeadEvidence, errors: list[str], instruction_set: Path | None
+def _entry_guard_rows(
+    task_type: str, seen_phases: set[str], instruction_set: Path | None
+) -> list[_EntryGuardRead]:
+    """이 run 에 실제로 걸리는 entry-guard 행."""
+    rows = []
+    for row in _ENTRY_GUARD_READS:
+        if row.task_types is not None and task_type not in row.task_types:
+            continue
+        if row.required_when is not None and row.required_when not in seen_phases:
+            # 그 라운드를 돌지 않은 run 이다. 돌지 않은 일의 규칙을 요구하지 않는다.
+            continue
+        if row.staged_per_run and not (
+            instruction_set and (instruction_set / row.basename).is_file()
+        ):
+            continue
+        rows.append(row)
+    return rows
+
+
+def _check_entry_guard_reads(
+    evidence: _LeadEvidence,
+    errors: list[str],
+    instruction_set: Path | None,
+    task_type: str,
 ) -> None:
     """검사 3 — entry guard. fresh-read 규칙(이전 run 기억으로 갈음 불가)은 run
     윈도우 스코핑이 보장한다: 이번 윈도우 안의 Read 만 증거로 인정된다.
 
     anchor 가 있는 행은 존재 + 순서를, anchor 가 `None` 인 행은 존재만 본다.
-    `staged_per_run` 행은 이 run 의 instruction-set 에 실제로 있을 때만 요구한다."""
+    `staged_per_run` 행은 이 run 의 instruction-set 에 실제로 있을 때만,
+    `required_when` 행은 그 PROGRESS 체크포인트가 이 run 에 있을 때만 요구한다."""
+    seen_phases = {phase for _ts, phase, _line in evidence.progress}
+    anchor_phases = {row.anchor[0] for row in _ENTRY_GUARD_READS if row.anchor}
     anchors: dict[str, str] = {}
     for ts, phase, _line in evidence.progress:  # progress 는 ts 정렬 — 첫 항목이 최초 발생
-        if phase in ("phase-6-synthesis", "phase-7-persist") and ts:
+        if phase in anchor_phases and ts:
             anchors.setdefault(phase, ts)
-    for row in _ENTRY_GUARD_READS:
-        if row.staged_per_run and not (
-            instruction_set and (instruction_set / row.basename).is_file()
-        ):
-            continue
+    for row in _entry_guard_rows(task_type, seen_phases, instruction_set):
         ts_list = evidence.sidecar_reads.get(row.basename) or []
         if not ts_list:
             demand = (
-                f"it MUST be read fresh {row.anchor[1]} of every implementation run"
+                f"it MUST be read fresh {row.anchor[1]}"
                 if row.anchor
                 else "the staged copy MUST be read at least once inside that window"
             )
             errors.append(
-                f"implementation entry guard: no read of `{row.basename}` (a `Read` call "
+                f"entry guard: no read of `{row.basename}` (a `Read` call "
                 f"or a shell command naming it) found in "
                 f"the selected adapter evidence source within this run's window — "
                 f"{demand} ({row.cite})."
@@ -1534,7 +1778,7 @@ def _check_implementation_entry_guard(
         anchor_ts = anchors.get(anchor_phase)
         if anchor_ts and min(ts_list) >= anchor_ts:
             errors.append(
-                f"implementation entry guard: `{row.basename}` was first read at "
+                f"entry guard: `{row.basename}` was first read at "
                 f"{min(ts_list)}, not before the first `PROGRESS: {anchor_phase}` "
                 f"line ({anchor_ts}) — it must be loaded {when}, before "
                 f"that checkpoint ({row.cite})."
@@ -1595,9 +1839,11 @@ def validate_session_conformance(
         run_dir,
         suffix,
         report_path,
+        task_type,
         result.errors,
         result.advisories,
     )
+    _check_verification_errors_are_logged(run_dir, suffix, result.advisories)
     _check_activity_contract(
         evidence,
         team_state,
@@ -1608,10 +1854,10 @@ def validate_session_conformance(
         result.errors,
     )
     _check_cmux_adapter_read(evidence, team_state, result.errors)
-    if task_type == "implementation":
-        _check_implementation_entry_guard(
-            evidence,
-            result.errors,
-            _instruction_set_dir(run_dir, suffix, project_root),
-        )
+    _check_entry_guard_reads(
+        evidence,
+        result.errors,
+        _instruction_set_dir(run_dir, suffix, project_root),
+        task_type,
+    )
     return result