engineering-platform 2.3.88__tar.gz → 2.3.90__tar.gz

{engineering_platform-2.3.88 → engineering_platform-2.3.90}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: engineering-platform
-Version: 2.3.88
+Version: 2.3.90
 Summary: Local-first Engineering Platform execution operations runtime
 Author: Peter van Tol
 License: MIT

{engineering_platform-2.3.88 → engineering_platform-2.3.90}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "engineering-platform"
-version = "2.3.88"
+version = "2.3.90"
 description = "Local-first Engineering Platform execution operations runtime"
 readme = "README.md"
 requires-python = ">=3.14,<3.15"

{engineering_platform-2.3.88 → engineering_platform-2.3.90}/src/engineering_platform/ENGINEERING_PLATFORM_CONFIG.json

@@ -3,7 +3,7 @@
   "platform": {
     "id": "engineering-platform",
     "name": "Engineering Platform",
-    "version": "2.3.88",
+    "version": "2.3.90",
     "generation": 2,
     "documentation_namespace": "engineering-platform",
     "capability_registry_version": 1

{engineering_platform-2.3.88 → engineering_platform-2.3.90}/src/engineering_platform/ENGINEERING_PLATFORM_VERSION.json

@@ -1,15 +1,15 @@
 {
   "bootstrap_contract": "2026.12",
   "checkpoint_format": 1,
-  "dashboard_version": "2.3.88",
+  "dashboard_version": "2.3.90",
   "handoff_protocol": 1,
   "memory_format": 2,
   "minimum_codex_cli": "0.146.0",
   "inbox_protocol": 1,
-  "platform_version": "2.3.88",
+  "platform_version": "2.3.90",
   "report_format": 2,
-  "runner_version": "2.3.88",
+  "runner_version": "2.3.90",
   "status_model": 1,
   "storage_schema": 45,
-  "watcher_version": "2.3.88"
+  "watcher_version": "2.3.90"
 }

{engineering_platform-2.3.88 → engineering_platform-2.3.90}/src/engineering_platform/central_operational_reset.py

@@ -36,7 +36,7 @@ from .storage import sqlite_connection
 
 PROFILE = "EP_CENTRAL_OPERATIONAL_HISTORY_V1"
 PLAN_VERSION = 2
-SCHEMA_VERSION = 71
+SCHEMA_VERSION = 72
 _OPERATION = re.compile(r"[A-Za-z0-9][A-Za-z0-9._-]{7,127}")
 _INSTANCE_ID = re.compile(
     r"[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}"
@@ -66,6 +66,7 @@ INSTALLATION_AND_CONFIGURATION = frozenset({
     "ep_project_registrations", "ep_repository_registrations",
     "ep_agent_registrations", "ep_agent_repository_attachments",
     "ep_local_repository_bindings", "ep_external_producer_bindings",
+    "ep_assurance_target_selections",
     "execution_migration_provenance",
 })
 SECURITY_AND_AUTHORITY_LEDGER = frozenset({
@@ -222,6 +223,31 @@ def _implementation_digest() -> str:
     })
 
 
+# The published 2.3.89 reset implementation can leave an operation at
+# ARTIFACTS_ARCHIVED when operational engineering_metadata rows are present.
+# Permit only that exact installed implementation to cross the fixed apply
+# boundary; the plan, backup, identity, schema, generation and fences are still
+# verified by apply before any database effect.
+_ARCHIVED_RESET_COMPATIBILITY = frozenset({
+    ("2.3.89", "UNAVAILABLE_IN_INSTALLED_PACKAGE",
+     "sha256:17ec03725e15672ef9511382e0b3d2c72e3f502823a35b89bea170882f4a14b8"),
+})
+
+
+def _implementation_binding_valid(plan: dict[str, object], state: str) -> bool:
+    binding = (
+        plan.get("product_version"), plan.get("implementation_source_revision"),
+        plan.get("implementation_digest"),
+    )
+    current = (
+        CURRENT_PLATFORM_VERSION, _implementation_source_revision(),
+        _implementation_digest(),
+    )
+    return binding == current or (
+        state == "ARTIFACTS_ARCHIVED" and binding in _ARCHIVED_RESET_COMPATIBILITY
+    )
+
+
 def _implementation_source_revision() -> str:
     try:
         module = Path(__file__).resolve()
@@ -2301,11 +2327,7 @@ def apply(data_root: Path, *, operation_id: str, plan_digest: str) -> dict[str,
                     raise OperationalResetError("PRESERVED_BINDINGS_CHANGED")
                 if _schema_objects(connection) != plan["schema_objects"]:
                     raise OperationalResetError("SCHEMA_OBJECTS_CHANGED")
-                if (
-                    plan.get("product_version") != CURRENT_PLATFORM_VERSION
-                    or plan.get("implementation_source_revision") != _implementation_source_revision()
-                    or plan.get("implementation_digest") != _implementation_digest()
-                ):
+                if not _implementation_binding_valid(plan, "ARTIFACTS_ARCHIVED"):
                     raise OperationalResetError("IMPLEMENTATION_PROVENANCE_CHANGED")
                 generation_before = int(connection.execute(
                     "SELECT generation FROM ep_operational_dataset_state WHERE singleton=1"
@@ -2315,11 +2337,15 @@ def apply(data_root: Path, *, operation_id: str, plan_digest: str) -> dict[str,
                 # Immutable-evidence and maintenance-block triggers are removed and
                 # recreated inside this one uncommitted transaction. Other writers
                 # cannot observe an unfenced schema window.
+                reset_trigger_tables = (
+                    OPERATIONAL_HISTORY | DERIVED_CACHE_OR_PROJECTION
+                    | {"engineering_metadata"}
+                )
                 triggers = [
                     (str(name), str(sql)) for name, sql in connection.execute(
                         "SELECT name,sql FROM sqlite_master WHERE type='trigger' AND tbl_name IN ("
-                        + ",".join("?" for _ in (OPERATIONAL_HISTORY | DERIVED_CACHE_OR_PROJECTION)) + ")",
-                        tuple(sorted(OPERATIONAL_HISTORY | DERIVED_CACHE_OR_PROJECTION)),
+                        + ",".join("?" for _ in reset_trigger_tables) + ")",
+                        tuple(sorted(reset_trigger_tables)),
                     ).fetchall() if sql is not None
                 ]
                 for name, _sql in triggers:

{engineering_platform-2.3.88 → engineering_platform-2.3.90}/src/engineering_platform/execution_host.py

@@ -3898,12 +3898,14 @@ First implementation pull-request publication gate:
         try:
             with sqlite_connection(self.store.central_database) as connection:
                 grant = merge_delegation.load(connection, state.merge_delegation_id)
+                selection_current = bool(grant and merge_delegation.target_selection_permits(connection, grant))
         except (EngineeringStorageError, sqlite3.Error):
             return False
-        return bool(grant and grant.assurance_profile_id == "qualification-autonomous-qs"
-                    and grant.assurance_profile_revision == "1"
+        return bool(grant and selection_current and grant.assurance_profile_revision == "1"
                     and grant.github_repository == state.repository
-                    == merge_delegation.AUTONOMOUS_ASSURANCE_REPOSITORY)
+                    and (grant.assurance_profile_id == merge_delegation.REPOSITORY_ASSURANCE_ID
+                         or (grant.assurance_profile_id == "qualification-autonomous-qs"
+                             and state.repository == merge_delegation.AUTONOMOUS_ASSURANCE_REPOSITORY)))
 
     def _recover_autonomous_pr_assurance(
         self, state: TransactionState, candidate: PullRequestEvidence,
@@ -4013,7 +4015,8 @@ First implementation pull-request publication gate:
                     (state.run_id,),
                 ).fetchone()
                 grant = merge_delegation.load(connection, state.merge_delegation_id)
-            if scope is None or grant is None or not isinstance(accepted, dict):
+                selection_current = bool(grant and merge_delegation.target_selection_permits(connection, grant))
+            if scope is None or grant is None or not selection_current or not isinstance(accepted, dict):
                 return None
             if Path(str(scope[2])).resolve() != self.root.resolve():
                 return None
@@ -4057,17 +4060,21 @@ First implementation pull-request publication gate:
             qualifier = getattr(self.github, "delegated_merge_qualification", None)
             if not callable(qualifier):
                 return None
-            autonomous_profile = (
-                grant.assurance_profile_id == "qualification-autonomous-qs"
-                and grant.assurance_profile_revision == "1"
-            )
+            autonomous_profile = (grant.assurance_profile_revision == "1" and
+                                  grant.assurance_profile_id in {
+                                      "qualification-autonomous-qs",
+                                      merge_delegation.REPOSITORY_ASSURANCE_ID})
             if grant.assurance_profile_id or grant.assurance_profile_revision:
                 if (not autonomous_profile
-                        or grant.github_repository != merge_delegation.AUTONOMOUS_ASSURANCE_REPOSITORY
+                        or (grant.assurance_profile_id == "qualification-autonomous-qs"
+                            and grant.github_repository != merge_delegation.AUTONOMOUS_ASSURANCE_REPOSITORY)
                         or not self._autonomous_merge_assurance_passes(state, expected_head)):
                     return None
+            selected_profile = (merge_delegation.REPOSITORY_ASSURANCE_PROFILE
+                                if grant.assurance_profile_id == merge_delegation.REPOSITORY_ASSURANCE_ID
+                                else merge_delegation.AUTONOMOUS_ASSURANCE_PROFILE)
             qualification = (qualifier(fresh.number, expected_head,
-                                      assurance_profile=merge_delegation.AUTONOMOUS_ASSURANCE_PROFILE)
+                                      assurance_profile=selected_profile)
                              if autonomous_profile else qualifier(fresh.number, expected_head))
             if (not isinstance(qualification, dict) or qualification.get("conclusion") != "PASS"
                     or qualification.get("exact_qualified_sha") != expected_head
@@ -4094,7 +4101,8 @@ First implementation pull-request publication gate:
                 return None
             with sqlite_connection(self.store.central_database) as connection:
                 current_grant = merge_delegation.load(connection, state.merge_delegation_id)
-            if (current_grant is None or not current_grant.permits(
+                current_selection = bool(current_grant and merge_delegation.target_selection_permits(connection, current_grant))
+            if (current_grant is None or not current_selection or not current_grant.permits(
                     project_id=str(scope[0]), repository_id=str(scope[1]),
                     mission_id=str(accepted.get("mission_id")), mission_revision=str(mission_revision),
                     role=state.transaction_kind, base_branch="main",
@@ -4108,7 +4116,9 @@ First implementation pull-request publication gate:
                 policy_reader = getattr(self.github, "_autonomous_effective_policy", None)
                 if not callable(policy_reader):
                     return None
-                current_policy = policy_reader()
+                current_policy = (policy_reader(assurance_profile=selected_profile)
+                                  if grant.assurance_profile_id == merge_delegation.REPOSITORY_ASSURANCE_ID
+                                  else policy_reader())
                 if (not isinstance(current_policy, dict)
                         or current_policy.get("digest") != current_grant.assurance_policy_digest):
                     return None
@@ -4118,7 +4128,21 @@ First implementation pull-request publication gate:
             attempted = replace(state, delegated_merge_attempt=attempt,
                                 delegated_merge_actor_reference=None)
             self.store.save(attempted)
-            self.github.merge(fresh.number, expected_head_sha=expected_head)
+            # Linearize revocation against the external merge call. A revoke
+            # committed before this lock is observed; one waiting for this lock
+            # can only commit after the bounded call has returned.
+            with sqlite_connection(self.store.central_database) as authority:
+                authority.execute("BEGIN IMMEDIATE")
+                final_grant = merge_delegation.load(authority, state.merge_delegation_id)
+                if (final_grant is None or not final_grant.permits(
+                        project_id=str(scope[0]), repository_id=str(scope[1]),
+                        mission_id=str(accepted.get("mission_id")),
+                        mission_revision=str(mission_revision),
+                        role=state.transaction_kind, base_branch="main")
+                        or not merge_delegation.target_selection_permits(authority, final_grant)
+                        or final_grant != current_grant):
+                    raise ValueError("merge authority changed before the external call")
+                self.github.merge(fresh.number, expected_head_sha=expected_head)
             merged = self.github.pull_request(fresh.number)
             self.repository.refresh_main_reference(self.root)
             if (merged.state == "MERGED" and merged.head_sha == expected_head

{engineering_platform-2.3.88 → engineering_platform-2.3.90}/src/engineering_platform/execution_repository.py

@@ -360,10 +360,17 @@ class GhCliClient:
         except RuntimeError as error:
             raise RunnerError("Pull request Markdown could not be normalized.") from error
         return True
-    def _autonomous_effective_policy(self) -> dict[str, object]:
+    def _autonomous_effective_policy(self, *, assurance_profile: str = "qualification-autonomous-qs@1") -> dict[str, object]:
         """Read all active main rules and classic protection without inferring zero from errors."""
-        if self.repository != "pcvantol/forge-mission-qualification":
+        if (assurance_profile == "qualification-autonomous-qs@1"
+                and self.repository != "pcvantol/forge-mission-qualification"):
             raise RunnerError("Autonomous assurance profile has a different repository scope.")
+        if assurance_profile not in {"qualification-autonomous-qs@1", "repository-autonomous-qs@1"}:
+            raise RunnerError("Unknown delegated merge assurance profile.")
+        repository_profile = assurance_profile == "repository-autonomous-qs@1"
+        if repository_profile and (not isinstance(self.repository, str)
+                                   or re.fullmatch(r"[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+", self.repository) is None):
+            raise RunnerError("Autonomous assurance requires an exact repository.")
         try:
             raw_rules = json.loads(self._github("api", f"repos/{self.repository}/rules/branches/main?per_page=100"))
         except (RuntimeError, json.JSONDecodeError) as error:
@@ -415,6 +422,13 @@ class GhCliClient:
         required_apps: dict[str, set[int]] = {}
         strict_values: list[bool] = []
         required_approvals: list[int] = []
+        required_thread_resolution = False
+        classic_conversations = classic.get("required_conversation_resolution") if classic else None
+        if repository_profile and classic_conversations is not None:
+            if (not isinstance(classic_conversations, dict)
+                    or not isinstance(classic_conversations.get("enabled"), bool)):
+                raise RunnerError("Classic review-thread policy is incomplete.")
+            required_thread_resolution = classic_conversations["enabled"]
         classic_checks = classic.get("required_status_checks") if classic else None
         if classic_checks is not None:
             if not isinstance(classic_checks, dict) or not isinstance(classic_checks.get("strict"), bool):
@@ -442,9 +456,10 @@ class GhCliClient:
             if (isinstance(count, bool) or not isinstance(count, int) or count < 0
                     or classic_reviews.get("require_code_owner_reviews") is True
                     or classic_reviews.get("require_last_push_approval") is True
-                    or classic_reviews.get("required_review_thread_resolution") is True):
+                    or (classic_reviews.get("required_review_thread_resolution") is True and not repository_profile)):
                 raise RunnerError("Classic review policy requires unsupported or unknown approval evidence.")
             required_approvals.append(count)
+            required_thread_resolution |= classic_reviews.get("required_review_thread_resolution") is True
         supported = {"required_status_checks", "pull_request", "non_fast_forward", "deletion", "required_linear_history"}
         for rule in verified_rules:
             rule_type, parameters = rule.get("type"), rule.get("parameters")
@@ -467,13 +482,28 @@ class GhCliClient:
             elif rule_type == "pull_request":
                 if not isinstance(parameters, dict):
                     raise RunnerError("Ruleset pull-request policy is incomplete.")
+                if repository_profile:
+                    supported_parameters = {
+                        "allowed_merge_methods", "dismiss_stale_reviews_on_push",
+                        "require_code_owner_review", "require_extra_approval_for_unattributed_changes",
+                        "require_last_push_approval", "required_approving_review_count",
+                        "required_review_thread_resolution", "required_reviewers",
+                    }
+                    if (set(parameters) - supported_parameters
+                            or parameters.get("require_extra_approval_for_unattributed_changes") is True
+                            or parameters.get("require_last_push_approval") is True
+                            or ("allowed_merge_methods" in parameters
+                                and (not isinstance(parameters["allowed_merge_methods"], list)
+                                     or "squash" not in parameters["allowed_merge_methods"]))):
+                        raise RunnerError("Ruleset pull-request policy has an unsupported merge condition.")
                 count = parameters.get("required_approving_review_count")
                 if (isinstance(count, bool) or not isinstance(count, int) or count < 0
                         or parameters.get("require_code_owner_review") is True
-                        or parameters.get("required_review_thread_resolution") is True
+                        or (parameters.get("required_review_thread_resolution") is True and not repository_profile)
                         or parameters.get("required_reviewers")):
                     raise RunnerError("Ruleset review policy requires unsupported or unknown approval evidence.")
                 required_approvals.append(count)
+                required_thread_resolution |= parameters.get("required_review_thread_resolution") is True
         if not required_checks or not strict_values or not all(strict_values):
             raise RunnerError("Autonomous assurance requires strict protected status checks.")
         effective_rule_types = {rule.get("type") for rule in verified_rules}
@@ -484,16 +514,74 @@ class GhCliClient:
         policy = {"source": "github-effective-main", "classic": classic,
                   "rulesets": verified_rules, "required_checks": sorted(required_checks),
                   "required_apps": {name: sorted(apps) for name, apps in sorted(required_apps.items())},
-                  "required_approvals": max(required_approvals, default=0), "strict_checks": True}
-        policy["digest"] = "sha256:" + hashlib.sha256(json.dumps(policy, sort_keys=True, separators=(",", ":")).encode()).hexdigest()
+                  "required_approvals": max(required_approvals, default=0), "strict_checks": True,
+                  "required_thread_resolution": required_thread_resolution}
+        if repository_profile:
+            # GitHub embeds observation URLs and other changing metadata in
+            # protection responses. Bind only the effective rule semantics.
+            classic_binding = None
+            if classic is not None:
+                classic_binding = {
+                    "enforce_admins": classic["enforce_admins"]["enabled"],
+                    "allow_force_pushes": classic["allow_force_pushes"]["enabled"],
+                    "allow_deletions": classic["allow_deletions"]["enabled"],
+                    "required_conversation_resolution": None if classic_conversations is None
+                        else classic_conversations["enabled"],
+                    "required_status_checks": None if classic_checks is None else {
+                        "strict": classic_checks["strict"],
+                        "contexts": sorted(classic_checks["contexts"]),
+                        "checks": sorted(({"context": item["context"],
+                                           "app_id": item.get("app_id")}
+                                          for item in classic_checks["checks"]),
+                                         key=lambda item: (item["context"], str(item["app_id"]))),
+                    },
+                    "required_pull_request_reviews": None if classic_reviews is None else {
+                        "required_approving_review_count": classic_reviews["required_approving_review_count"],
+                        "dismiss_stale_reviews": classic_reviews.get("dismiss_stale_reviews", False),
+                        "require_code_owner_reviews": classic_reviews.get("require_code_owner_reviews", False),
+                        "require_last_push_approval": classic_reviews.get("require_last_push_approval", False),
+                        "required_review_thread_resolution": classic_reviews.get("required_review_thread_resolution", False),
+                    },
+                }
+            stable_rules = []
+            for item in verified_rules:
+                parameters = item.get("parameters")
+                if isinstance(parameters, dict):
+                    parameters = dict(parameters)
+                    if item["type"] == "required_status_checks":
+                        parameters["required_status_checks"] = sorted(
+                            parameters["required_status_checks"],
+                            key=lambda check: (check["context"], str(check.get("integration_id"))))
+                    elif item["type"] == "pull_request" and "allowed_merge_methods" in parameters:
+                        parameters["allowed_merge_methods"] = sorted(parameters["allowed_merge_methods"])
+                stable_rules.append({"ruleset_id": item["ruleset_id"],
+                                     "type": item["type"], "parameters": parameters})
+            policy_binding = {
+                "version": "repository-effective-main/v1",
+                "repository": self.repository,
+                "classic": classic_binding,
+                "rulesets": sorted(stable_rules,
+                                    key=lambda item: (item["ruleset_id"], item["type"],
+                                                      json.dumps(item["parameters"], sort_keys=True))),
+                "required_checks": policy["required_checks"],
+                "required_apps": policy["required_apps"],
+                "required_approvals": policy["required_approvals"],
+                "required_thread_resolution": required_thread_resolution,
+                "strict_checks": True,
+            }
+        else:
+            # Preserve the original synthetic profile's immutable digest semantics.
+            policy_binding = {key: value for key, value in policy.items()
+                              if key != "required_thread_resolution"}
+        policy["digest"] = "sha256:" + hashlib.sha256(json.dumps(policy_binding, sort_keys=True, separators=(",", ":")).encode()).hexdigest()
         return policy
 
     def delegated_merge_qualification(self, number: int, head_sha: str, *, assurance_profile: str | None = None) -> dict[str, object]:
         """Fresh protected checks and independent head-bound GitHub reviews."""
-        autonomous = assurance_profile == "qualification-autonomous-qs@1"
+        autonomous = assurance_profile in {"qualification-autonomous-qs@1", "repository-autonomous-qs@1"}
         if assurance_profile is not None and not autonomous:
             raise RunnerError("Unknown delegated merge assurance profile.")
-        policy = self._autonomous_effective_policy() if autonomous else None
+        policy = self._autonomous_effective_policy(assurance_profile=assurance_profile) if autonomous else None
         if policy is None:
             checks = self.qualification_for_exact_head(number, head_sha)
         else:
@@ -506,12 +594,24 @@ class GhCliClient:
             if not isinstance(raw, dict) or raw.get("headRefOid") != head_sha or raw.get("baseRefName") != "main":
                 raise RunnerError("Autonomous PR qualification has a changed head or base.")
             rollup = raw.get("statusCheckRollup")
-            if not isinstance(rollup, list) or not rollup or any(
-                not isinstance(item, dict) or item.get("status") != "COMPLETED"
-                or item.get("conclusion") not in {"SUCCESS", "NEUTRAL", "SKIPPED"} for item in rollup
-            ):
+            if not isinstance(rollup, list) or not rollup:
                 raise RunnerError("Autonomous PR required checks are incomplete or failed.")
-            observed = {item.get("name") for item in rollup}
+            observed: set[str] = set()
+            for item in rollup:
+                if not isinstance(item, dict):
+                    raise RunnerError("Autonomous PR required checks are incomplete or failed.")
+                if item.get("__typename") == "StatusContext" or (
+                    "context" in item and "state" in item and "name" not in item
+                ):
+                    name = item.get("context")
+                    passed = item.get("state") == "SUCCESS"
+                else:
+                    name = item.get("name")
+                    passed = (item.get("status") == "COMPLETED" and
+                              item.get("conclusion") in {"SUCCESS", "NEUTRAL", "SKIPPED"})
+                if not isinstance(name, str) or not name or not passed:
+                    raise RunnerError("Autonomous PR required checks are incomplete or failed.")
+                observed.add(name)
             if not set(policy["required_checks"]) <= observed:
                 raise RunnerError("Autonomous PR is missing effective required checks.")
             if policy["required_apps"]:
@@ -562,17 +662,37 @@ class GhCliClient:
             raise RunnerError("Delegated merge requires protected independent review policy.")
         latest: dict[str, tuple[str, str]] = {}
         for review in reviews:
-            if not isinstance(review, dict):
-                continue
-            reviewer = (review.get("user") or {}).get("login")
-            if isinstance(reviewer, str) and reviewer:
-                latest[reviewer] = (str(review.get("state")), str(review.get("commit_id")))
+            if not isinstance(review, dict) or not isinstance(review.get("user"), dict):
+                raise RunnerError("Delegated merge review evidence is incomplete.")
+            reviewer = review["user"].get("login")
+            decision = review.get("state")
+            if not isinstance(reviewer, str) or not reviewer or not isinstance(decision, str):
+                raise RunnerError("Delegated merge review evidence is incomplete.")
+            latest[reviewer] = (decision, str(review.get("commit_id")))
+        if any(decision == "CHANGES_REQUESTED" for decision, _commit in latest.values()):
+            raise RunnerError("Delegated merge has an unresolved changes-requested review.")
         approvals = sorted(
             reviewer for reviewer, (decision, commit) in latest.items()
             if reviewer != author and decision == "APPROVED" and commit == head_sha
         )
         if len(approvals) < required:
             raise RunnerError("Delegated merge lacks required independent approvals for this exact head.")
+        if policy is not None and policy["required_thread_resolution"]:
+            owner, repository_name = self.repository.split("/", 1)
+            query = ("query { repository(owner:\"" + owner + "\",name:\"" + repository_name
+                     + "\") { pullRequest(number:" + str(number)
+                     + ") { reviewThreads(first:100) { totalCount nodes { isResolved } } } } }")
+            try:
+                response = json.loads(self._github("api", "graphql", "-f", "query=" + query))
+                threads = response["data"]["repository"]["pullRequest"]["reviewThreads"]
+            except (RuntimeError, ValueError, KeyError, TypeError) as error:
+                raise RunnerError("Required review-thread resolution could not be read.") from error
+            nodes = threads.get("nodes") if isinstance(threads, dict) else None
+            if (not isinstance(nodes, list) or not isinstance(threads.get("totalCount"), int)
+                    or threads["totalCount"] != len(nodes) or len(nodes) >= 100
+                    or any(not isinstance(item, dict) or item.get("isResolved") is not True
+                           for item in nodes)):
+                raise RunnerError("Delegated merge has unresolved or unreadable review threads.")
         return {**checks, "reviewers": approvals, "required_approvals": required}
 
     def merge(self, number: int, *, expected_head_sha: str | None = None) -> None: