diff --git a/.agents/skills/nemoclaw-maintainer-day/scripts/check-gates.ts b/.agents/skills/nemoclaw-maintainer-day/scripts/check-gates.ts
index 3aeda111c2b..0cec7758bea 100644
--- a/.agents/skills/nemoclaw-maintainer-day/scripts/check-gates.ts
+++ b/.agents/skills/nemoclaw-maintainer-day/scripts/check-gates.ts
@@ -10,6 +10,7 @@
  * Usage: node --experimental-strip-types --no-warnings .agents/skills/nemoclaw-maintainer-day/scripts/check-gates.ts <pr-number> [--repo OWNER/REPO]
  */
 
+import { isDeepStrictEqual } from "node:util";
 import {
   ghJson,
   isRiskyFile,
@@ -316,7 +317,60 @@ interface E2eCoordinationEvidence {
   valid: boolean | null;
   startedAt?: number;
   completedAt?: number;
+  enclosingCoordinatorStartedAt?: number;
+  enclosingCoordinatorCompletedAt?: number;
   trustedCustomCheckId?: number;
+  checkSnapshot?: E2eCoordinationCheckSnapshot;
+  coordinatorSnapshot?: E2eCoordinatorInventorySnapshot;
+  selectedCheckId?: number;
+}
+
+interface E2eCoordinationCheckSnapshot {
+  checkRuns: Array<Record<string, unknown>>;
+}
+
+interface E2eCoordinatorRunMetadata {
+  id: number;
+  attempt: number;
+  createdAt: number;
+  updatedAt: number;
+  event: E2eCoordinatorEvent;
+  displayTitle: string;
+  headSha: string;
+  status: string;
+  conclusion: string | null;
+}
+
+type E2eCoordinatorEvent = "workflow_run" | "workflow_dispatch";
+
+interface E2eCoordinatorRunPartition {
+  startedAt: number;
+  completedAt: number;
+}
+
+interface E2eCoordinatorInventoryRecord {
+  value: Record<string, unknown>;
+  createdAt: number;
+  event: E2eCoordinatorEvent;
+  partitionIndex: number;
+}
+
+interface E2eCoordinatorCandidateSnapshot {
+  listedRun: Record<string, unknown>;
+  firstRun: Record<string, unknown>;
+  jobPages: unknown[];
+  refreshedRun: Record<string, unknown>;
+}
+
+interface E2eCoordinatorInventorySnapshot {
+  candidates: E2eCoordinatorCandidateSnapshot[];
+}
+
+interface E2eCoordinatorEvaluation {
+  valid: boolean | null;
+  snapshot?: E2eCoordinatorInventorySnapshot;
+  coordinateStartedAt?: number;
+  coordinateCompletedAt?: number;
 }
 
 const E2E_RETRYABLE_FAILURE_MARKER_PREFIX = "<!-- nemoclaw-pr-e2e-retry:v1:";
@@ -348,6 +402,541 @@ function parseGitHubTimestamp(value: string | undefined): number {
     : Number.NaN;
 }
 
+const E2E_COORDINATOR_WORKFLOW_PATH = ".github/workflows/pr-e2e-gate.yaml";
+const E2E_COORDINATOR_PARTITION_MS = 12 * 60 * 60 * 1000;
+const E2E_COORDINATOR_INVENTORY_MAX_MS = 14 * 24 * 60 * 60 * 1000;
+const E2E_COORDINATOR_MAX_PARTITIONS = Math.ceil(
+  E2E_COORDINATOR_INVENTORY_MAX_MS / E2E_COORDINATOR_PARTITION_MS,
+);
+const GITHUB_WORKFLOW_RUN_RESULT_CAP = 1000;
+const E2E_COORDINATOR_RUN_PAGE_PROJECTION =
+  "{total_count,workflow_runs:[.workflow_runs[]|{id,run_attempt,event,display_title,path," +
+  "head_branch,head_sha,status,conclusion,repository:{full_name:.repository.full_name}," +
+  "head_repository:{full_name:.head_repository.full_name},created_at,updated_at}]}";
+
+function formatGitHubTimestamp(value: number): string {
+  return new Date(value).toISOString().replace(".000Z", "Z");
+}
+
+function ghJsonPages(args: string[]): unknown[] | null {
+  const output = run("gh", args);
+  if (!output) return null;
+  try {
+    return output.split("\n").map((page) => JSON.parse(page));
+  } catch {
+    process.stderr.write(
+      `[check-gates] The gate checker could not parse a JSON page from this command: gh ${args.join(" ")}\n`,
+    );
+    return null;
+  }
+}
+
+function e2eCoordinatorRunPartitions(
+  historyStartedAt: number,
+  observationAt: number,
+): E2eCoordinatorRunPartition[] | null {
+  if (!Number.isFinite(historyStartedAt) || !Number.isFinite(observationAt)) return null;
+  const checkStart = new Date(historyStartedAt);
+  const inventoryStartedAt = Date.UTC(
+    checkStart.getUTCFullYear(),
+    checkStart.getUTCMonth(),
+    checkStart.getUTCDate() - 1,
+  );
+  const inventoryCompletedAt = Math.ceil(observationAt / 1000) * 1000;
+  const inventorySpan = inventoryCompletedAt - inventoryStartedAt;
+  const partitionCount = Math.ceil(inventorySpan / E2E_COORDINATOR_PARTITION_MS);
+  if (
+    inventorySpan <= 0 ||
+    inventorySpan > E2E_COORDINATOR_INVENTORY_MAX_MS ||
+    !Number.isSafeInteger(partitionCount) ||
+    partitionCount < 1 ||
+    partitionCount > E2E_COORDINATOR_MAX_PARTITIONS
+  ) {
+    return null;
+  }
+  return Array.from({ length: partitionCount }, (_value, index) => {
+    const startedAt = inventoryStartedAt + index * E2E_COORDINATOR_PARTITION_MS;
+    return {
+      startedAt,
+      completedAt: Math.min(startedAt + E2E_COORDINATOR_PARTITION_MS, inventoryCompletedAt),
+    };
+  });
+}
+
+function automaticE2eCoordinatorRunTitle(exactDiff: ExactDiffIdentity): string {
+  return (
+    "E2E Gate coordinate from CI PR #" +
+    exactDiff.number +
+    " head " +
+    exactDiff.headSha +
+    " base " +
+    exactDiff.baseSha +
+    " gate true"
+  );
+}
+
+function manualE2eCoordinatorRunTitle(exactDiff: ExactDiffIdentity): string {
+  return (
+    "E2E Gate approve PR #" +
+    exactDiff.number +
+    " head " +
+    exactDiff.headSha +
+    " base " +
+    exactDiff.baseSha
+  );
+}
+
+function hasRepositoryName(value: unknown, repo: string): boolean {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    !Array.isArray(value) &&
+    (value as Record<string, unknown>).full_name === repo
+  );
+}
+
+function parseE2eCoordinatorRun(
+  value: unknown,
+  repo: string,
+  exactDiff: ExactDiffIdentity,
+  trustedWorkflowSha: string | null,
+): E2eCoordinatorRunMetadata | null {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const record = value as Record<string, unknown>;
+  const createdAt =
+    typeof record.created_at === "string" ? parseGitHubTimestamp(record.created_at) : Number.NaN;
+  const updatedAt =
+    typeof record.updated_at === "string" ? parseGitHubTimestamp(record.updated_at) : Number.NaN;
+  const status = typeof record.status === "string" ? record.status.toUpperCase() : null;
+  const conclusion =
+    typeof record.conclusion === "string" ? record.conclusion.toUpperCase() : record.conclusion;
+  const event =
+    record.event === "workflow_run" || record.event === "workflow_dispatch" ? record.event : null;
+  const expectedTitle =
+    event === "workflow_run"
+      ? automaticE2eCoordinatorRunTitle(exactDiff)
+      : event === "workflow_dispatch"
+        ? manualE2eCoordinatorRunTitle(exactDiff)
+        : null;
+  const headSha = typeof record.head_sha === "string" ? record.head_sha : "";
+  if (
+    !Number.isSafeInteger(record.id) ||
+    (record.id as number) < 1 ||
+    record.run_attempt !== 1 ||
+    !event ||
+    !expectedTitle ||
+    record.display_title !== expectedTitle ||
+    record.path !== E2E_COORDINATOR_WORKFLOW_PATH ||
+    record.head_branch !== "main" ||
+    !/^[0-9a-f]{40}$/u.test(headSha) ||
+    trustedWorkflowSha === null ||
+    headSha !== trustedWorkflowSha ||
+    !status ||
+    !ACTION_STATUSES.has(status) ||
+    (conclusion !== null &&
+      (typeof conclusion !== "string" || !ACTION_CONCLUSIONS.has(conclusion))) ||
+    (status === "COMPLETED" ? conclusion === null : conclusion !== null) ||
+    !hasRepositoryName(record.repository, repo) ||
+    !hasRepositoryName(record.head_repository, repo) ||
+    !Number.isFinite(createdAt) ||
+    !Number.isFinite(updatedAt) ||
+    createdAt > updatedAt
+  ) {
+    return null;
+  }
+  return {
+    id: record.id as number,
+    attempt: 1,
+    createdAt,
+    updatedAt,
+    event,
+    displayTitle: expectedTitle,
+    headSha,
+    status,
+    conclusion,
+  };
+}
+
+function sameE2eCoordinatorRun(
+  left: E2eCoordinatorRunMetadata,
+  right: E2eCoordinatorRunMetadata,
+): boolean {
+  return (
+    left.id === right.id &&
+    left.attempt === right.attempt &&
+    left.createdAt === right.createdAt &&
+    left.updatedAt === right.updatedAt &&
+    left.event === right.event &&
+    left.displayTitle === right.displayTitle &&
+    left.headSha === right.headSha &&
+    left.status === right.status &&
+    left.conclusion === right.conclusion
+  );
+}
+
+type E2eCoordinatorCandidateResult =
+  | "authorization-predecessor"
+  | "enclosing"
+  | "history"
+  | false
+  | null;
+
+interface E2eCoordinatorCandidateEvaluation {
+  result: E2eCoordinatorCandidateResult;
+  snapshot?: E2eCoordinatorCandidateSnapshot;
+  event?: E2eCoordinatorEvent;
+  runCreatedAt?: number;
+  runUpdatedAt?: number;
+  coordinateStartedAt?: number;
+  coordinateCompletedAt?: number;
+}
+
+function evaluateE2eCoordinatorCandidate(
+  listedValue: unknown,
+  repo: string,
+  exactDiff: ExactDiffIdentity,
+  trustedWorkflowSha: string | null,
+  coordinationStartedAt: number,
+  coordinationCompletedAt: number,
+): E2eCoordinatorCandidateEvaluation {
+  const listedRun = parseE2eCoordinatorRun(listedValue, repo, exactDiff, trustedWorkflowSha);
+  if (!listedRun) return { result: false };
+  const firstRunResponse = ghJson(["api", "repos/" + repo + "/actions/runs/" + listedRun.id]);
+  if (firstRunResponse === null) return { result: null };
+  const firstRun = parseE2eCoordinatorRun(firstRunResponse, repo, exactDiff, trustedWorkflowSha);
+  if (!firstRun || !sameE2eCoordinatorRun(listedRun, firstRun)) return { result: false };
+
+  const jobPages = ghJson([
+    "api",
+    "--paginate",
+    "--slurp",
+    "repos/" +
+      repo +
+      "/actions/runs/" +
+      firstRun.id +
+      "/attempts/" +
+      firstRun.attempt +
+      "/jobs?per_page=100",
+  ]);
+  if (!Array.isArray(jobPages) || jobPages.length === 0) return { result: null };
+
+  let expectedJobs: number | null = null;
+  let observedJobs = 0;
+  const jobIds = new Set<number>();
+  const coordinateJobs: Array<Record<string, unknown>> = [];
+  for (const page of jobPages) {
+    if (typeof page !== "object" || page === null || Array.isArray(page)) {
+      return { result: null };
+    }
+    const { total_count: totalCount, jobs } = page as Record<string, unknown>;
+    if (
+      !Number.isSafeInteger(totalCount) ||
+      (totalCount as number) < 0 ||
+      (expectedJobs !== null && totalCount !== expectedJobs) ||
+      !Array.isArray(jobs)
+    ) {
+      return { result: null };
+    }
+    expectedJobs = totalCount as number;
+    observedJobs += jobs.length;
+    for (const value of jobs) {
+      if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return { result: null };
+      }
+      const record = value as Record<string, unknown>;
+      if (
+        !Number.isSafeInteger(record.id) ||
+        (record.id as number) < 1 ||
+        jobIds.has(record.id as number) ||
+        typeof record.name !== "string" ||
+        !record.name
+      ) {
+        return { result: false };
+      }
+      jobIds.add(record.id as number);
+      if (record.name === "coordinate") coordinateJobs.push(record);
+    }
+  }
+
+  const refreshedRunResponse = ghJson(["api", "repos/" + repo + "/actions/runs/" + firstRun.id]);
+  if (refreshedRunResponse === null) return { result: null };
+  const refreshedRun = parseE2eCoordinatorRun(
+    refreshedRunResponse,
+    repo,
+    exactDiff,
+    trustedWorkflowSha,
+  );
+  if (!refreshedRun || !sameE2eCoordinatorRun(firstRun, refreshedRun)) {
+    return { result: false };
+  }
+
+  const snapshot: E2eCoordinatorCandidateSnapshot = {
+    listedRun: listedValue as Record<string, unknown>,
+    firstRun: firstRunResponse as Record<string, unknown>,
+    jobPages,
+    refreshedRun: refreshedRunResponse as Record<string, unknown>,
+  };
+  if (
+    expectedJobs === null ||
+    observedJobs !== expectedJobs ||
+    jobIds.size !== expectedJobs ||
+    coordinateJobs.length !== 1
+  ) {
+    return { result: false, snapshot };
+  }
+
+  const coordinate = coordinateJobs[0];
+  const coordinateStatus =
+    typeof coordinate.status === "string" ? coordinate.status.toUpperCase() : null;
+  const coordinateConclusion =
+    typeof coordinate.conclusion === "string"
+      ? coordinate.conclusion.toUpperCase()
+      : coordinate.conclusion;
+  const coordinateStartedAt =
+    typeof coordinate.started_at === "string"
+      ? parseGitHubTimestamp(coordinate.started_at)
+      : Number.NaN;
+  const coordinateCompletedAt =
+    typeof coordinate.completed_at === "string"
+      ? parseGitHubTimestamp(coordinate.completed_at)
+      : Number.NaN;
+  if (
+    !coordinateStatus ||
+    !ACTION_STATUSES.has(coordinateStatus) ||
+    (coordinateConclusion !== null &&
+      (typeof coordinateConclusion !== "string" ||
+        !ACTION_CONCLUSIONS.has(coordinateConclusion))) ||
+    (coordinateStatus === "COMPLETED"
+      ? coordinateConclusion === null
+      : coordinateConclusion !== null) ||
+    !Number.isFinite(coordinateStartedAt) ||
+    !Number.isFinite(coordinateCompletedAt) ||
+    coordinateStartedAt > coordinateCompletedAt
+  ) {
+    return { result: false, snapshot };
+  }
+
+  const completedSuccessfully =
+    firstRun.status === "COMPLETED" &&
+    firstRun.conclusion === "SUCCESS" &&
+    coordinateStatus === "COMPLETED" &&
+    coordinateConclusion === "SUCCESS";
+  const coordinateWithinRun =
+    firstRun.createdAt <= coordinateStartedAt &&
+    coordinateStartedAt <= coordinateCompletedAt &&
+    coordinateCompletedAt <= firstRun.updatedAt;
+  const candidateEvidence = {
+    snapshot,
+    event: firstRun.event,
+    runCreatedAt: firstRun.createdAt,
+    runUpdatedAt: firstRun.updatedAt,
+    coordinateStartedAt,
+    coordinateCompletedAt,
+  };
+  if (
+    completedSuccessfully &&
+    coordinateWithinRun &&
+    coordinateStartedAt <= coordinationCompletedAt &&
+    coordinationCompletedAt <= coordinateCompletedAt
+  ) {
+    return { result: "enclosing", ...candidateEvidence };
+  }
+
+  const completedHistory =
+    completedSuccessfully && coordinateWithinRun && firstRun.updatedAt <= coordinationStartedAt;
+  if (completedHistory) return { result: "history", ...candidateEvidence };
+
+  const authorizationPredecessor =
+    completedSuccessfully &&
+    coordinateWithinRun &&
+    firstRun.event === "workflow_run" &&
+    coordinationStartedAt <= coordinateStartedAt &&
+    coordinateCompletedAt < coordinationCompletedAt;
+  return {
+    result: authorizationPredecessor ? "authorization-predecessor" : false,
+    ...candidateEvidence,
+  };
+}
+
+function fetchE2eCoordinatorEvidence(
+  repo: string,
+  exactDiff: ExactDiffIdentity,
+  trustedWorkflowSha: string | null,
+  historyStartedAt: number,
+  coordinationStartedAt: number,
+  coordinationCompletedAt: number,
+  observationAt: number,
+): E2eCoordinatorEvaluation {
+  const inventoryById = new Map<number, E2eCoordinatorInventoryRecord>();
+  const partitions = e2eCoordinatorRunPartitions(historyStartedAt, observationAt);
+  if (!partitions) return { valid: null };
+  const events: E2eCoordinatorEvent[] = ["workflow_run", "workflow_dispatch"];
+  for (const event of events) {
+    for (const [partitionIndex, partition] of partitions.entries()) {
+      const createdRange = encodeURIComponent(
+        formatGitHubTimestamp(partition.startedAt) +
+          ".." +
+          formatGitHubTimestamp(partition.completedAt),
+      );
+      const pages = ghJsonPages([
+        "api",
+        "--paginate",
+        "--jq",
+        E2E_COORDINATOR_RUN_PAGE_PROJECTION,
+        "repos/" +
+          repo +
+          "/actions/workflows/pr-e2e-gate.yaml/runs?event=" +
+          event +
+          "&created=" +
+          createdRange +
+          "&per_page=100",
+      ]);
+      if (!Array.isArray(pages) || pages.length === 0) return { valid: null };
+
+      let expectedTotal: number | null = null;
+      let observedTotal = 0;
+      const partitionIds = new Set<number>();
+      const partitionRecords: Array<{ value: Record<string, unknown>; createdAt: number }> = [];
+      for (const page of pages) {
+        if (typeof page !== "object" || page === null || Array.isArray(page)) {
+          return { valid: null };
+        }
+        const { total_count: totalCount, workflow_runs: workflowRuns } = page as Record<
+          string,
+          unknown
+        >;
+        if (
+          !Number.isSafeInteger(totalCount) ||
+          (totalCount as number) < 0 ||
+          (totalCount as number) >= GITHUB_WORKFLOW_RUN_RESULT_CAP ||
+          (expectedTotal !== null && totalCount !== expectedTotal) ||
+          !Array.isArray(workflowRuns)
+        ) {
+          return { valid: null };
+        }
+        expectedTotal = totalCount as number;
+        observedTotal += workflowRuns.length;
+        for (const value of workflowRuns) {
+          if (typeof value !== "object" || value === null || Array.isArray(value)) {
+            return { valid: null };
+          }
+          const record = value as Record<string, unknown>;
+          const createdAt =
+            typeof record.created_at === "string"
+              ? parseGitHubTimestamp(record.created_at)
+              : Number.NaN;
+          if (
+            !Number.isSafeInteger(record.id) ||
+            (record.id as number) < 1 ||
+            partitionIds.has(record.id as number) ||
+            record.event !== event ||
+            !Number.isFinite(createdAt) ||
+            createdAt < partition.startedAt ||
+            createdAt > partition.completedAt
+          ) {
+            return { valid: null };
+          }
+          partitionIds.add(record.id as number);
+          partitionRecords.push({ value: record, createdAt });
+        }
+      }
+      if (
+        expectedTotal === null ||
+        observedTotal !== expectedTotal ||
+        partitionIds.size !== expectedTotal
+      ) {
+        return { valid: null };
+      }
+
+      for (const record of partitionRecords) {
+        const id = record.value.id as number;
+        const existing = inventoryById.get(id);
+        if (!existing) {
+          inventoryById.set(id, {
+            value: record.value,
+            createdAt: record.createdAt,
+            event,
+            partitionIndex,
+          });
+          continue;
+        }
+        const exactBoundaryDuplicate =
+          existing.event === event &&
+          existing.partitionIndex === partitionIndex - 1 &&
+          existing.createdAt === partition.startedAt &&
+          record.createdAt === partition.startedAt &&
+          isDeepStrictEqual(existing.value, record.value);
+        if (!exactBoundaryDuplicate) return { valid: null };
+      }
+    }
+  }
+
+  const expectedTitles = new Set([
+    automaticE2eCoordinatorRunTitle(exactDiff),
+    manualE2eCoordinatorRunTitle(exactDiff),
+  ]);
+  const candidates = [...inventoryById.values()]
+    .map((record) => record.value)
+    .filter((record) => expectedTitles.has(String(record.display_title)));
+  if (candidates.length === 0) return { valid: false };
+
+  const enclosingCandidates: E2eCoordinatorCandidateEvaluation[] = [];
+  const authorizationPredecessors: E2eCoordinatorCandidateEvaluation[] = [];
+  const candidateSnapshots: E2eCoordinatorCandidateSnapshot[] = [];
+  for (const candidate of candidates) {
+    const evaluation = evaluateE2eCoordinatorCandidate(
+      candidate,
+      repo,
+      exactDiff,
+      trustedWorkflowSha,
+      coordinationStartedAt,
+      coordinationCompletedAt,
+    );
+    if (evaluation.result === null) return { valid: null };
+    if (evaluation.result === false || !evaluation.snapshot) return { valid: false };
+    candidateSnapshots.push(evaluation.snapshot);
+    if (evaluation.result === "enclosing") enclosingCandidates.push(evaluation);
+    if (evaluation.result === "authorization-predecessor") {
+      authorizationPredecessors.push(evaluation);
+    }
+  }
+  if (enclosingCandidates.length !== 1) return { valid: false };
+  const encloser = enclosingCandidates[0];
+  if (
+    !encloser ||
+    encloser.coordinateStartedAt === undefined ||
+    encloser.coordinateCompletedAt === undefined
+  ) {
+    return { valid: false };
+  }
+  const automaticLineage =
+    encloser.event === "workflow_run" && authorizationPredecessors.length === 0;
+  const predecessor = authorizationPredecessors[0];
+  const authorizedForkLineage =
+    exactDiff.headRepository !== repo &&
+    encloser.event === "workflow_dispatch" &&
+    authorizationPredecessors.length === 1 &&
+    predecessor?.event === "workflow_run" &&
+    predecessor.runUpdatedAt !== undefined &&
+    encloser.runCreatedAt !== undefined &&
+    predecessor.coordinateCompletedAt !== undefined &&
+    encloser.coordinateStartedAt !== undefined &&
+    predecessor.runUpdatedAt <= encloser.runCreatedAt &&
+    predecessor.coordinateCompletedAt <= encloser.coordinateStartedAt;
+  if (!automaticLineage && !authorizedForkLineage) {
+    return { valid: false };
+  }
+  candidateSnapshots.sort(
+    (left, right) => (left.listedRun.id as number) - (right.listedRun.id as number),
+  );
+  return {
+    valid: true,
+    snapshot: { candidates: candidateSnapshots },
+    coordinateStartedAt: encloser.coordinateStartedAt,
+    coordinateCompletedAt: encloser.coordinateCompletedAt,
+  };
+}
+
 function hasRetryableE2eFailureMarker(check: Record<string, unknown>): boolean {
   if (check.status !== "completed" || check.conclusion !== "failure") return false;
   const output = check.output;
@@ -390,10 +979,11 @@ function currentE2eCoordinationCheck(
   if (active[0] && active[0].id !== current.id) return undefined;
   return current;
 }
-function fetchE2eCoordinationEvidence(
+
+function fetchE2eCoordinationCheckSnapshot(
   repo: string,
   exactDiff: ExactDiffIdentity,
-): E2eCoordinationEvidence {
+): E2eCoordinationCheckSnapshot | null {
   const checkNames = ["E2E / PR Gate", "E2E / PR Gate Coordination"];
   const checkRuns: Array<Record<string, unknown>> = [];
   const ids = new Set<number>();
@@ -404,14 +994,12 @@ function fetchE2eCoordinationEvidence(
       "--slurp",
       `repos/${repo}/commits/${exactDiff.headSha}/check-runs?check_name=${encodeURIComponent(checkName)}&filter=all&per_page=100`,
     ]);
-    if (!Array.isArray(pages) || pages.length === 0) return { valid: null };
+    if (!Array.isArray(pages) || pages.length === 0) return null;
 
     let expectedTotal: number | null = null;
     let observedTotal = 0;
     for (const page of pages) {
-      if (typeof page !== "object" || page === null || Array.isArray(page)) {
-        return { valid: null };
-      }
+      if (typeof page !== "object" || page === null || Array.isArray(page)) return null;
       const { total_count: totalCount, check_runs: pageRuns } = page as Record<string, unknown>;
       if (
         !Number.isSafeInteger(totalCount) ||
@@ -419,14 +1007,12 @@ function fetchE2eCoordinationEvidence(
         (expectedTotal !== null && totalCount !== expectedTotal) ||
         !Array.isArray(pageRuns)
       ) {
-        return { valid: null };
+        return null;
       }
       expectedTotal = totalCount as number;
       observedTotal += pageRuns.length;
       for (const value of pageRuns) {
-        if (typeof value !== "object" || value === null || Array.isArray(value)) {
-          return { valid: null };
-        }
+        if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
         const record = value as Record<string, unknown>;
         if (
           !Number.isSafeInteger(record.id) ||
@@ -434,19 +1020,32 @@ function fetchE2eCoordinationEvidence(
           ids.has(record.id as number) ||
           (typeof record.external_id !== "string" && record.external_id !== null)
         ) {
-          return { valid: null };
+          return null;
         }
         ids.add(record.id as number);
         checkRuns.push(record);
       }
     }
-    if (expectedTotal === null || observedTotal !== expectedTotal) {
-      return { valid: null };
+    if (
+      expectedTotal === null ||
+      observedTotal !== expectedTotal ||
+      ids.size !== checkRuns.length
+    ) {
+      return null;
     }
   }
 
+  checkRuns.sort((left, right) => (left.id as number) - (right.id as number));
+  return { checkRuns };
+}
+
+function selectE2eCoordinationCheck(
+  snapshot: E2eCoordinationCheckSnapshot,
+  exactDiff: ExactDiffIdentity,
+): Record<string, unknown> | undefined {
+  const checkNames = ["E2E / PR Gate", "E2E / PR Gate Coordination"];
   const externalId = `nemoclaw-pr-e2e:v2:${exactDiff.number}:${exactDiff.headSha}:${exactDiff.baseSha}`;
-  const claimedChecks = checkRuns.filter((check) => check.external_id === externalId);
+  const claimedChecks = snapshot.checkRuns.filter((check) => check.external_id === externalId);
   if (
     claimedChecks.some(
       (check) =>
@@ -459,20 +1058,102 @@ function fetchE2eCoordinationEvidence(
         (check.app as Record<string, unknown>).id !== 15368,
     )
   ) {
-    return { valid: false };
+    return undefined;
   }
   const currentNameChecks = claimedChecks.filter((check) => check.name === "E2E / PR Gate");
   const exactChecks =
     currentNameChecks.length > 0
       ? currentNameChecks
       : claimedChecks.filter((check) => check.name === "E2E / PR Gate Coordination");
-  const exact = currentE2eCoordinationCheck(exactChecks);
+  return currentE2eCoordinationCheck(exactChecks);
+}
+
+interface E2eLineageCheckTiming {
+  startedAt: number;
+  completedAt: number;
+}
+
+function selectedE2eLineageTiming(
+  snapshot: E2eCoordinationCheckSnapshot,
+  exactDiff: ExactDiffIdentity,
+  selectedCheckId: number,
+): E2eLineageCheckTiming[] | null {
+  const externalId = `nemoclaw-pr-e2e:v2:${exactDiff.number}:${exactDiff.headSha}:${exactDiff.baseSha}`;
+  const claimedChecks = snapshot.checkRuns.filter((check) => check.external_id === externalId);
+  const currentNameChecks = claimedChecks.filter((check) => check.name === "E2E / PR Gate");
+  const exactChecks =
+    currentNameChecks.length > 0
+      ? currentNameChecks
+      : claimedChecks.filter((check) => check.name === "E2E / PR Gate Coordination");
+  if (currentE2eCoordinationCheck(exactChecks)?.id !== selectedCheckId) return null;
+
+  const ordered = [...exactChecks].sort(
+    (left, right) => (left.id as number) - (right.id as number),
+  );
+  const timing: E2eLineageCheckTiming[] = [];
+  for (const check of ordered) {
+    const startedAt =
+      typeof check.started_at === "string" ? parseGitHubTimestamp(check.started_at) : Number.NaN;
+    const completedAt =
+      typeof check.completed_at === "string"
+        ? parseGitHubTimestamp(check.completed_at)
+        : Number.NaN;
+    if (
+      !Number.isFinite(startedAt) ||
+      !Number.isFinite(completedAt) ||
+      startedAt > completedAt ||
+      (timing.at(-1)?.completedAt ?? Number.NEGATIVE_INFINITY) > startedAt
+    ) {
+      return null;
+    }
+    timing.push({ startedAt, completedAt });
+  }
+  return timing.length > 0 ? timing : null;
+}
+
+function e2eCoordinationHistoryStartedAt(
+  snapshot: E2eCoordinationCheckSnapshot,
+  exactDiff: ExactDiffIdentity,
+): number {
+  const externalId = `nemoclaw-pr-e2e:v2:${exactDiff.number}:${exactDiff.headSha}:${exactDiff.baseSha}`;
+  const claimedChecks = snapshot.checkRuns.filter((check) => check.external_id === externalId);
+  if (claimedChecks.length === 0) return Number.NaN;
+
+  let earliest = Number.POSITIVE_INFINITY;
+  for (const check of claimedChecks) {
+    const startedAt =
+      typeof check.started_at === "string" ? parseGitHubTimestamp(check.started_at) : Number.NaN;
+    const completedAt =
+      typeof check.completed_at === "string"
+        ? parseGitHubTimestamp(check.completed_at)
+        : Number.NaN;
+    if (
+      !Number.isFinite(startedAt) ||
+      (check.status === "completed" && (!Number.isFinite(completedAt) || startedAt > completedAt))
+    ) {
+      return Number.NaN;
+    }
+    earliest = Math.min(earliest, startedAt);
+  }
+  return earliest;
+}
+
+function fetchE2eCoordinationEvidence(
+  repo: string,
+  exactDiff: ExactDiffIdentity,
+  trustedWorkflowSha: string | null,
+): E2eCoordinationEvidence {
+  const checkSnapshot = fetchE2eCoordinationCheckSnapshot(repo, exactDiff);
+  if (!checkSnapshot) return { valid: null };
+  const exact = selectE2eCoordinationCheck(checkSnapshot, exactDiff);
   if (!exact) return { valid: false };
+  const checkNames = ["E2E / PR Gate", "E2E / PR Gate Coordination"];
   const app = exact.app;
   const startedAt =
     typeof exact.started_at === "string" ? parseGitHubTimestamp(exact.started_at) : Number.NaN;
   const completedAt =
     typeof exact.completed_at === "string" ? parseGitHubTimestamp(exact.completed_at) : Number.NaN;
+  const historyStartedAt = e2eCoordinationHistoryStartedAt(checkSnapshot, exactDiff);
   const valid =
     typeof exact.name === "string" &&
     checkNames.includes(exact.name) &&
@@ -485,11 +1166,38 @@ function fetchE2eCoordinationEvidence(
     exact.conclusion === "success" &&
     Number.isFinite(startedAt) &&
     Number.isFinite(completedAt) &&
+    Number.isFinite(historyStartedAt) &&
     startedAt <= completedAt;
+  const coordinator = valid
+    ? fetchE2eCoordinatorEvidence(
+        repo,
+        exactDiff,
+        trustedWorkflowSha,
+        historyStartedAt,
+        startedAt,
+        completedAt,
+        Date.now(),
+      )
+    : { valid: false };
+  const completeEvidence =
+    valid &&
+    coordinator.valid === true &&
+    Boolean(coordinator.snapshot) &&
+    typeof coordinator.coordinateStartedAt === "number" &&
+    typeof coordinator.coordinateCompletedAt === "number";
   return {
-    valid,
-    ...(valid ? { startedAt, completedAt } : {}),
-    ...(valid && exact.name === "E2E / PR Gate"
+    valid: coordinator.valid === null ? null : completeEvidence,
+    ...(completeEvidence ? { startedAt, completedAt } : {}),
+    ...(completeEvidence
+      ? {
+          checkSnapshot,
+          coordinatorSnapshot: coordinator.snapshot,
+          selectedCheckId: exact.id as number,
+          enclosingCoordinatorStartedAt: coordinator.coordinateStartedAt,
+          enclosingCoordinatorCompletedAt: coordinator.coordinateCompletedAt,
+        }
+      : {}),
+    ...(completeEvidence && exact.name === "E2E / PR Gate"
       ? { trustedCustomCheckId: exact.id as number }
       : {}),
   };
@@ -569,6 +1277,20 @@ interface ActionJobMetadata {
   name: string;
   status: string;
   conclusion: string | null;
+  startedAt: number | null;
+  completedAt: number | null;
+}
+
+interface CiActionEvidenceCache {
+  actionRunMetadataById: Map<string, ActionRunMetadata | null>;
+  latestAttemptJobsByRun: Map<string, Map<string, ActionJobMetadata> | null>;
+}
+
+function createCiActionEvidenceCache(): CiActionEvidenceCache {
+  return {
+    actionRunMetadataById: new Map(),
+    latestAttemptJobsByRun: new Map(),
+  };
 }
 
 interface CurrentCheckRollup {
@@ -581,12 +1303,37 @@ function currentCheckRollup(
   repo: string,
   exactDiff: ExactDiffIdentity,
   e2eCoordinationEvidence: E2eCoordinationEvidence,
+  actionEvidence = createCiActionEvidenceCache(),
+  allowActionEvidenceReads = true,
 ): CurrentCheckRollup {
-  const actionRunMetadataById = new Map<string, ActionRunMetadata | null>();
-  const latestAttemptJobsByRun = new Map<string, Map<string, ActionJobMetadata> | null>();
+  const { actionRunMetadataById, latestAttemptJobsByRun } = actionEvidence;
   const incompleteAttemptEvidence = new Set<string>();
+  const observedE2eLineage =
+    e2eCoordinationEvidence.valid === true &&
+    e2eCoordinationEvidence.checkSnapshot &&
+    e2eCoordinationEvidence.selectedCheckId !== undefined
+      ? selectedE2eLineageTiming(
+          e2eCoordinationEvidence.checkSnapshot,
+          exactDiff,
+          e2eCoordinationEvidence.selectedCheckId,
+        )
+      : null;
+  const selectedE2eCheck = observedE2eLineage?.at(-1);
+  const authenticatedE2eLineage =
+    observedE2eLineage &&
+    selectedE2eCheck &&
+    selectedE2eCheck.startedAt === e2eCoordinationEvidence.startedAt &&
+    selectedE2eCheck.completedAt === e2eCoordinationEvidence.completedAt &&
+    (observedE2eLineage.length === 1 ||
+      (typeof e2eCoordinationEvidence.enclosingCoordinatorStartedAt === "number" &&
+        typeof e2eCoordinationEvidence.enclosingCoordinatorCompletedAt === "number" &&
+        e2eCoordinationEvidence.enclosingCoordinatorStartedAt <= selectedE2eCheck.startedAt &&
+        selectedE2eCheck.startedAt <= e2eCoordinationEvidence.enclosingCoordinatorCompletedAt))
+      ? observedE2eLineage
+      : null;
 
   const fetchActionRunMetadata = (runId: string): ActionRunMetadata | null => {
+    if (!allowActionEvidenceReads) return null;
     const runData = ghJson(["api", `repos/${repo}/actions/runs/${runId}`]);
     if (typeof runData !== "object" || runData === null || Array.isArray(runData)) {
       return null;
@@ -734,6 +1481,7 @@ function currentCheckRollup(
 
   const actionRunMetadata = (runId: string): ActionRunMetadata | null => {
     if (actionRunMetadataById.has(runId)) return actionRunMetadataById.get(runId) ?? null;
+    if (!allowActionEvidenceReads) return null;
     const metadata = fetchActionRunMetadata(runId);
     actionRunMetadataById.set(runId, metadata);
     return metadata;
@@ -741,6 +1489,7 @@ function currentCheckRollup(
 
   const latestAttemptJobs = (runId: string): Map<string, ActionJobMetadata> | null => {
     if (latestAttemptJobsByRun.has(runId)) return latestAttemptJobsByRun.get(runId) ?? null;
+    if (!allowActionEvidenceReads) return null;
 
     const metadata = actionRunMetadata(runId);
     if (!metadata) {
@@ -783,10 +1532,21 @@ function currentCheckRollup(
           latestAttemptJobsByRun.set(runId, null);
           return null;
         }
-        const { id, name, status, conclusion } = value as Record<string, unknown>;
+        const {
+          id,
+          name,
+          status,
+          conclusion,
+          started_at: startedAt,
+          completed_at: completedAt,
+        } = value as Record<string, unknown>;
         const normalizedStatus = typeof status === "string" ? status.toUpperCase() : null;
         const normalizedConclusion =
           typeof conclusion === "string" ? conclusion.toUpperCase() : conclusion;
+        const parsedStartedAt =
+          typeof startedAt === "string" ? parseGitHubTimestamp(startedAt) : Number.NaN;
+        const parsedCompletedAt =
+          typeof completedAt === "string" ? parseGitHubTimestamp(completedAt) : Number.NaN;
         if (
           !Number.isSafeInteger(id) ||
           (id as number) < 1 ||
@@ -805,6 +1565,8 @@ function currentCheckRollup(
           name,
           status: normalizedStatus,
           conclusion: normalizedConclusion,
+          startedAt: Number.isFinite(parsedStartedAt) ? parsedStartedAt : null,
+          completedAt: Number.isFinite(parsedCompletedAt) ? parsedCompletedAt : null,
         });
       }
     }
@@ -857,7 +1619,7 @@ function currentCheckRollup(
       run.event !== "pull_request" ||
       run.path !== ".github/workflows/pr.yaml" ||
       run.status !== "COMPLETED" ||
-      run.conclusion !== "SUCCESS"
+      (run.conclusion !== "SUCCESS" && run.conclusion !== "CANCELLED")
     ) {
       return "not_metadata_edit";
     }
@@ -899,19 +1661,70 @@ function currentCheckRollup(
       : "unknown";
   };
 
-  const e2eCoordinationIsEnclosed = (run: ActionRunMetadata): boolean =>
-    e2eControllerHeadBinding(run) === "current" &&
-    run.e2eGateRun === true &&
-    e2eCoordinationEvidence.startedAt !== undefined &&
-    e2eCoordinationEvidence.completedAt !== undefined &&
-    run.createdAt <= e2eCoordinationEvidence.startedAt &&
-    e2eCoordinationEvidence.completedAt <= run.updatedAt;
+  type E2eSeedRunKind = "initial" | "reuse" | "unknown";
+
+  const classifyE2eSeedRun = (runId: string, run: ActionRunMetadata): E2eSeedRunKind => {
+    if (
+      e2eControllerHeadBinding(run) !== "current" ||
+      run.e2eGateRun !== true ||
+      !authenticatedE2eLineage
+    ) {
+      return "unknown";
+    }
+    const initializeJobs = [...(latestAttemptJobs(runId)?.values() ?? [])].filter(
+      (job) => job.name === "initialize",
+    );
+    if (initializeJobs.length !== 1) return "unknown";
+    const [initialize] = initializeJobs;
+    const initializeStartedAt = initialize.startedAt;
+    const initializeCompletedAt = initialize.completedAt;
+    if (
+      initialize.status !== "COMPLETED" ||
+      initialize.conclusion !== "SUCCESS" ||
+      initializeStartedAt === null ||
+      initializeCompletedAt === null ||
+      run.createdAt > initializeStartedAt ||
+      initializeStartedAt > initializeCompletedAt ||
+      initializeCompletedAt > run.updatedAt
+    ) {
+      return "unknown";
+    }
+    const checksStartedDuringInitialize = authenticatedE2eLineage.filter(
+      (check) => initializeStartedAt <= check.startedAt && check.startedAt <= initializeCompletedAt,
+    );
+    if (
+      checksStartedDuringInitialize.length === 1 &&
+      checksStartedDuringInitialize[0] === authenticatedE2eLineage[0]
+    ) {
+      return "initial";
+    }
+    return checksStartedDuringInitialize.length === 0 &&
+      authenticatedE2eLineage.some((check) => check.startedAt < initializeStartedAt)
+      ? "reuse"
+      : "unknown";
+  };
+
+  const isCurrentE2eSeedRun = (runId: string, run: ActionRunMetadata): boolean =>
+    classifyE2eSeedRun(runId, run) === "initial";
 
   const isNonAttemptRun = (runId: string): boolean => {
     const run = actionRunMetadata(runId);
     const jobs = latestAttemptJobs(runId);
     if (!run || !jobs || jobs.size === 0) return false;
 
+    const successfulE2eSeedReuse = Boolean(
+      classifyE2eSeedRun(runId, run) === "reuse" &&
+        run.status === "COMPLETED" &&
+        run.conclusion === "SUCCESS" &&
+        [...jobs.values()].every(
+          (job) =>
+            job.status === "COMPLETED" &&
+            job.conclusion !== null &&
+            PASSING_ACTION_RUN_CONCLUSIONS.has(job.conclusion),
+        ),
+    );
+    if (successfulE2eSeedReuse) return true;
+
     const allSkippedTargetRun = Boolean(
       (runIdentityEvidence(runId, true) === "current" ||
         e2eControllerHeadBinding(run) === "current") &&
@@ -1083,7 +1896,7 @@ function currentCheckRollup(
     const e2eHeadBinding = e2eControllerHeadBinding(metadata);
     if (e2eHeadBinding === "other") return "other";
     if (e2eHeadBinding === "current") {
-      return e2eCoordinationIsEnclosed(metadata) ? "current" : "unknown";
+      return isCurrentE2eSeedRun(runId, metadata) ? "current" : "unknown";
     }
     if (
       exactDiff.headRepository !== repo &&
@@ -1106,6 +1919,16 @@ function currentCheckRollup(
   const allActionRunIds = new Set(
     statusCheckRollup.map(actionRunId).filter((runId): runId is string => Boolean(runId)),
   );
+  const initialE2eSeedRunIds = new Set<string>();
+  for (const runId of allActionRunIds) {
+    const run = actionRunMetadata(runId);
+    if (run && classifyE2eSeedRun(runId, run) === "initial") {
+      initialE2eSeedRunIds.add(runId);
+    }
+  }
+  if (initialE2eSeedRunIds.size !== 1) {
+    incompleteAttemptEvidence.add("E2E / PR Gate");
+  }
   const hasMeaningfulAlternateRun = (runId: string): boolean => {
     const { event, path } = actionRunMetadata(runId) ?? {};
     return Boolean(
@@ -1300,22 +2123,78 @@ function currentCheckRollup(
   return { checks: current, incompleteAttemptEvidence: [...incompleteAttemptEvidence].sort() };
 }
 
-function checkCi(
-  statusCheckRollup: StatusCheck[] | null,
-  repo: string,
-  exactDiff: ExactDiffIdentity,
-): GateResult & {
+interface CiGateResult extends GateResult {
   failingChecks?: string[];
   pendingChecks?: string[];
   missingChecks?: string[];
   trustedCustomCheckId?: number;
-} {
+}
+
+interface RequiredCheckSnapshotRecord {
+  type: string | null;
+  name: string | null;
+  context: string | null;
+  workflowName: string | null;
+  startedAt: string | null;
+  completedAt: string | null;
+  detailsUrl: string | null;
+  status: string | null;
+  conclusion: string | null;
+  state: string | null;
+}
+
+interface CiEvaluation {
+  gate: CiGateResult;
+  e2eCoordinationEvidence: E2eCoordinationEvidence;
+  requiredCheckSnapshot: RequiredCheckSnapshotRecord[] | null;
+}
+
+function captureRequiredCheckSnapshot(
+  statusCheckRollup: StatusCheck[] | null,
+): RequiredCheckSnapshotRecord[] | null {
+  if (!statusCheckRollup) return null;
+  const snapshot = statusCheckRollup
+    .filter((check) => REQUIRED_CHECK_NAMES.includes(check.name ?? check.context ?? ""))
+    .map((check) => ({
+      type: check.__typename ?? null,
+      name: check.name ?? null,
+      context: check.context ?? null,
+      workflowName: check.workflowName ?? null,
+      startedAt: check.startedAt ?? null,
+      completedAt: check.completedAt ?? null,
+      detailsUrl: check.detailsUrl ?? null,
+      status: check.status ?? null,
+      conclusion: check.conclusion ?? null,
+      state: check.state ?? null,
+    }));
+  snapshot.sort((left, right) => {
+    const leftKey = JSON.stringify(left);
+    const rightKey = JSON.stringify(right);
+    return leftKey < rightKey ? -1 : leftKey > rightKey ? 1 : 0;
+  });
+  return snapshot;
+}
+
+function evaluateCiRollup(
+  statusCheckRollup: StatusCheck[] | null,
+  repo: string,
+  exactDiff: ExactDiffIdentity,
+  e2eCoordinationEvidence: E2eCoordinationEvidence,
+  actionEvidence = createCiActionEvidenceCache(),
+  allowActionEvidenceReads = true,
+): CiGateResult {
   if (!statusCheckRollup || statusCheckRollup.length === 0) {
     return { pass: false, details: "No status checks found" };
   }
 
-  const e2eCoordinationEvidence = fetchE2eCoordinationEvidence(repo, exactDiff);
-  const rollup = currentCheckRollup(statusCheckRollup, repo, exactDiff, e2eCoordinationEvidence);
+  const rollup = currentCheckRollup(
+    statusCheckRollup,
+    repo,
+    exactDiff,
+    e2eCoordinationEvidence,
+    actionEvidence,
+    allowActionEvidenceReads,
+  );
   const currentChecks = rollup.checks;
   const incompleteAttemptEvidence = new Set(rollup.incompleteAttemptEvidence);
   if (e2eCoordinationEvidence.valid !== true) {
@@ -1393,6 +2272,123 @@ function checkCi(
   };
 }
 
+function checkCi(
+  statusCheckRollup: StatusCheck[] | null,
+  repo: string,
+  exactDiff: ExactDiffIdentity,
+  trustedWorkflowSha: string | null,
+): CiEvaluation {
+  const e2eCoordinationEvidence =
+    statusCheckRollup && statusCheckRollup.length > 0
+      ? fetchE2eCoordinationEvidence(repo, exactDiff, trustedWorkflowSha)
+      : { valid: false };
+  return {
+    gate: evaluateCiRollup(statusCheckRollup, repo, exactDiff, e2eCoordinationEvidence),
+    e2eCoordinationEvidence,
+    requiredCheckSnapshot: captureRequiredCheckSnapshot(statusCheckRollup),
+  };
+}
+
+function checkFinalCi(
+  initial: CiEvaluation,
+  finalStatusCheckRollup: StatusCheck[] | null,
+  repo: string,
+  exactDiff: ExactDiffIdentity,
+  actionEvidence: CiActionEvidenceCache,
+): CiGateResult {
+  if (!initial.gate.pass) return initial.gate;
+  const finalGate = evaluateCiRollup(
+    finalStatusCheckRollup,
+    repo,
+    exactDiff,
+    initial.e2eCoordinationEvidence,
+    actionEvidence,
+  );
+  if (!finalGate.pass) return finalGate;
+  const finalRequiredCheckSnapshot = captureRequiredCheckSnapshot(finalStatusCheckRollup);
+  if (
+    !initial.requiredCheckSnapshot ||
+    !finalRequiredCheckSnapshot ||
+    !isDeepStrictEqual(finalRequiredCheckSnapshot, initial.requiredCheckSnapshot)
+  ) {
+    return {
+      pass: false,
+      details: "Required check rollup changed during gate evaluation",
+      failingChecks: ["Required check rollup changed during gate evaluation"],
+    };
+  }
+  return finalGate;
+}
+
+function checkFinalE2eEvidence(
+  ci: CiGateResult,
+  initial: CiEvaluation,
+  finalE2eEvidence: E2eCoordinationEvidence,
+  exactDiff: ExactDiffIdentity,
+): CiGateResult {
+  if (!ci.pass) return ci;
+  const initialE2eCheckSnapshot = initial.e2eCoordinationEvidence.checkSnapshot;
+  const initialCoordinatorSnapshot = initial.e2eCoordinationEvidence.coordinatorSnapshot;
+  const initialSelectedCheckId = initial.e2eCoordinationEvidence.selectedCheckId;
+  const finalE2eCheckSnapshot = finalE2eEvidence.checkSnapshot;
+  const finalSelectedCheck = finalE2eCheckSnapshot
+    ? selectE2eCoordinationCheck(finalE2eCheckSnapshot, exactDiff)
+    : undefined;
+  if (
+    !initialE2eCheckSnapshot ||
+    !initialCoordinatorSnapshot ||
+    initialSelectedCheckId === undefined ||
+    finalE2eEvidence.valid !== true ||
+    !finalE2eCheckSnapshot ||
+    !finalE2eEvidence.coordinatorSnapshot ||
+    !finalSelectedCheck ||
+    finalSelectedCheck.id !== initialSelectedCheckId ||
+    !isDeepStrictEqual(finalE2eCheckSnapshot, initialE2eCheckSnapshot) ||
+    !isDeepStrictEqual(finalE2eEvidence.coordinatorSnapshot, initialCoordinatorSnapshot)
+  ) {
+    return {
+      pass: false,
+      details: "E2E custom-check history changed during gate evaluation",
+      failingChecks: ["E2E / PR Gate: final evidence changed"],
+    };
+  }
+  return ci;
+}
+
+function checkLastCi(
+  ci: CiGateResult,
+  initial: CiEvaluation,
+  lastStatusCheckRollup: StatusCheck[] | null,
+  repo: string,
+  exactDiff: ExactDiffIdentity,
+  finalE2eEvidence: E2eCoordinationEvidence,
+  actionEvidence: CiActionEvidenceCache,
+): CiGateResult {
+  if (!ci.pass) return ci;
+  const lastGate = evaluateCiRollup(
+    lastStatusCheckRollup,
+    repo,
+    exactDiff,
+    finalE2eEvidence,
+    actionEvidence,
+    false,
+  );
+  if (!lastGate.pass) return lastGate;
+  const lastRequiredCheckSnapshot = captureRequiredCheckSnapshot(lastStatusCheckRollup);
+  if (
+    !initial.requiredCheckSnapshot ||
+    !lastRequiredCheckSnapshot ||
+    !isDeepStrictEqual(lastRequiredCheckSnapshot, initial.requiredCheckSnapshot)
+  ) {
+    return {
+      pass: false,
+      details: "Required check rollup changed during final gate evaluation",
+      failingChecks: ["Required check rollup changed during final gate evaluation"],
+    };
+  }
+  return lastGate;
+}
+
 // ---------------------------------------------------------------------------
 // Gate 2: No conflicts
 // ---------------------------------------------------------------------------
@@ -1415,7 +2411,7 @@ function checkConflicts(
   if (!currentBaseSha) {
     return {
       pass: false,
-      details: "Unable to verify the current base branch revision",
+      details: "The gate checker could not verify the base SHA",
       mergeable: conflictStatus,
       mergeStateStatus: status,
       baseSha,
@@ -1754,7 +2750,7 @@ function checkContributorCompliance(
 // Main
 // ---------------------------------------------------------------------------
 
-interface PrRevisionSnapshot {
+interface PrRevisionIdentity {
   title: string;
   body: string;
   state: string;
@@ -1768,6 +2764,10 @@ interface PrRevisionSnapshot {
   headRepository: string;
 }
 
+interface PrRevisionSnapshot extends PrRevisionIdentity {
+  statusCheckRollup: StatusCheck[];
+}
+
 function parseHeadRepository(headRepository: unknown, headRepositoryOwner: unknown): string | null {
   if (
     typeof headRepository !== "object" ||
@@ -1807,7 +2807,7 @@ function fetchPrRevisionSnapshot(repo: string, number: number): PrRevisionSnapsh
     "--repo",
     repo,
     "--json",
-    "title,body,state,isDraft,mergeable,mergeStateStatus,headRefOid,baseRefOid,headRefName,baseRefName,headRepository,headRepositoryOwner",
+    "title,body,state,isDraft,mergeable,mergeStateStatus,headRefOid,baseRefOid,headRefName,baseRefName,headRepository,headRepositoryOwner,statusCheckRollup",
   ]);
   if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
   const record = value as Record<string, unknown>;
@@ -1823,6 +2823,10 @@ function fetchPrRevisionSnapshot(repo: string, number: number): PrRevisionSnapsh
     typeof record.baseRefOid !== "string" ||
     typeof record.headRefName !== "string" ||
     typeof record.baseRefName !== "string" ||
+    !Array.isArray(record.statusCheckRollup) ||
+    record.statusCheckRollup.some(
+      (check) => typeof check !== "object" || check === null || Array.isArray(check),
+    ) ||
     !headRepository
   ) {
     return null;
@@ -1839,12 +2843,261 @@ function fetchPrRevisionSnapshot(repo: string, number: number): PrRevisionSnapsh
     headRefName: record.headRefName,
     baseRefName: record.baseRefName,
     headRepository,
+    statusCheckRollup: record.statusCheckRollup as StatusCheck[],
   };
 }
 
+function fetchFinalPrSnapshot(
+  repo: string,
+  number: number,
+): { revision: PrRevisionSnapshot; currentBaseSha: string } | null {
+  const [owner, name, extra] = repo.split("/");
+  if (!owner || !name || extra) return null;
+
+  const response = ghJson([
+    "api",
+    "graphql",
+    "-F",
+    `owner=${owner}`,
+    "-F",
+    `name=${name}`,
+    "-F",
+    `number=${number}`,
+    "-f",
+    `query=query FinalPrSnapshot($owner: String!, $name: String!, $number: Int!) {
+      repository(owner: $owner, name: $name) {
+        pullRequest(number: $number) {
+          title
+          body
+          state
+          isDraft
+          mergeable
+          mergeStateStatus
+          headRefOid
+          baseRefOid
+          headRefName
+          baseRefName
+          headRepository { name nameWithOwner }
+          headRepositoryOwner { login }
+          baseRef { target { oid } }
+          commits(last: 1) {
+            totalCount
+            nodes {
+              commit {
+                oid
+                statusCheckRollup {
+                  contexts(first: 100) {
+                    totalCount
+                    pageInfo { hasNextPage }
+                    nodes {
+                      __typename
+                      ... on CheckRun {
+                        name
+                        status
+                        conclusion
+                        startedAt
+                        completedAt
+                        detailsUrl
+                        checkSuite { workflowRun { workflow { name } } }
+                      }
+                      ... on StatusContext {
+                        context
+                        state
+                        startedAt: createdAt
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }`,
+  ]) as {
+    data?: { repository?: { pullRequest?: Record<string, unknown> } };
+  } | null;
+  const record = response?.data?.repository?.pullRequest;
+  if (!record) return null;
+
+  const headRepository = parseHeadRepository(record.headRepository, record.headRepositoryOwner);
+  const baseRef =
+    typeof record.baseRef === "object" && record.baseRef !== null && !Array.isArray(record.baseRef)
+      ? (record.baseRef as Record<string, unknown>)
+      : null;
+  const target =
+    typeof baseRef?.target === "object" && baseRef.target !== null && !Array.isArray(baseRef.target)
+      ? (baseRef.target as Record<string, unknown>)
+      : null;
+  const currentBaseSha = target?.oid;
+  if (
+    typeof record.title !== "string" ||
+    typeof record.body !== "string" ||
+    typeof record.state !== "string" ||
+    typeof record.isDraft !== "boolean" ||
+    typeof record.mergeable !== "string" ||
+    typeof record.mergeStateStatus !== "string" ||
+    typeof record.headRefOid !== "string" ||
+    !/^[0-9a-f]{40}$/iu.test(record.headRefOid) ||
+    typeof record.baseRefOid !== "string" ||
+    !/^[0-9a-f]{40}$/iu.test(record.baseRefOid) ||
+    typeof record.headRefName !== "string" ||
+    typeof record.baseRefName !== "string" ||
+    typeof currentBaseSha !== "string" ||
+    !/^[0-9a-f]{40}$/iu.test(currentBaseSha) ||
+    !headRepository
+  ) {
+    return null;
+  }
+  const statusCheckRollup = parseFinalStatusCheckRollup(record.commits, record.headRefOid);
+  if (!statusCheckRollup) return null;
+  return {
+    revision: {
+      title: record.title,
+      body: record.body,
+      state: record.state,
+      isDraft: record.isDraft,
+      mergeable: record.mergeable,
+      mergeStateStatus: record.mergeStateStatus,
+      headRefOid: record.headRefOid,
+      baseRefOid: record.baseRefOid,
+      headRefName: record.headRefName,
+      baseRefName: record.baseRefName,
+      headRepository,
+      statusCheckRollup,
+    },
+    currentBaseSha,
+  };
+}
+
+function parseFinalStatusCheckRollup(
+  commitsValue: unknown,
+  expectedHeadSha: string,
+): StatusCheck[] | null {
+  if (typeof commitsValue !== "object" || commitsValue === null || Array.isArray(commitsValue)) {
+    return null;
+  }
+  const commits = commitsValue as Record<string, unknown>;
+  if (
+    typeof commits.totalCount !== "number" ||
+    !Number.isInteger(commits.totalCount) ||
+    commits.totalCount < 1 ||
+    !Array.isArray(commits.nodes) ||
+    commits.nodes.length !== 1
+  ) {
+    return null;
+  }
+  const commitNode = commits.nodes[0];
+  if (typeof commitNode !== "object" || commitNode === null || Array.isArray(commitNode)) {
+    return null;
+  }
+  const commitValue = (commitNode as Record<string, unknown>).commit;
+  if (typeof commitValue !== "object" || commitValue === null || Array.isArray(commitValue)) {
+    return null;
+  }
+  const commit = commitValue as Record<string, unknown>;
+  if (commit.oid !== expectedHeadSha) return null;
+  const rollupValue = commit.statusCheckRollup;
+  if (typeof rollupValue !== "object" || rollupValue === null || Array.isArray(rollupValue)) {
+    return null;
+  }
+  const contextsValue = (rollupValue as Record<string, unknown>).contexts;
+  if (typeof contextsValue !== "object" || contextsValue === null || Array.isArray(contextsValue)) {
+    return null;
+  }
+  const contexts = contextsValue as Record<string, unknown>;
+  const pageInfo = contexts.pageInfo;
+  if (
+    typeof contexts.totalCount !== "number" ||
+    !Number.isInteger(contexts.totalCount) ||
+    contexts.totalCount < 0 ||
+    !Array.isArray(contexts.nodes) ||
+    contexts.nodes.length !== contexts.totalCount ||
+    typeof pageInfo !== "object" ||
+    pageInfo === null ||
+    Array.isArray(pageInfo) ||
+    (pageInfo as Record<string, unknown>).hasNextPage !== false
+  ) {
+    return null;
+  }
+
+  const statusCheckRollup: StatusCheck[] = [];
+  for (const nodeValue of contexts.nodes) {
+    if (typeof nodeValue !== "object" || nodeValue === null || Array.isArray(nodeValue)) {
+      return null;
+    }
+    const node = nodeValue as Record<string, unknown>;
+    if (node.__typename === "CheckRun") {
+      const checkSuite =
+        typeof node.checkSuite === "object" &&
+        node.checkSuite !== null &&
+        !Array.isArray(node.checkSuite)
+          ? (node.checkSuite as Record<string, unknown>)
+          : null;
+      const workflowRun =
+        typeof checkSuite?.workflowRun === "object" &&
+        checkSuite.workflowRun !== null &&
+        !Array.isArray(checkSuite.workflowRun)
+          ? (checkSuite.workflowRun as Record<string, unknown>)
+          : null;
+      const workflow =
+        typeof workflowRun?.workflow === "object" &&
+        workflowRun.workflow !== null &&
+        !Array.isArray(workflowRun.workflow)
+          ? (workflowRun.workflow as Record<string, unknown>)
+          : null;
+      const workflowName = workflow?.name;
+      const scalarFields = [
+        node.name,
+        node.status,
+        node.conclusion,
+        node.startedAt,
+        node.completedAt,
+        node.detailsUrl,
+        workflowName,
+      ];
+      if (
+        typeof node.name !== "string" ||
+        typeof node.status !== "string" ||
+        scalarFields.some(
+          (value) => value !== undefined && value !== null && typeof value !== "string",
+        )
+      ) {
+        return null;
+      }
+      statusCheckRollup.push({
+        __typename: "CheckRun",
+        name: node.name,
+        status: node.status,
+        ...(typeof node.conclusion === "string" ? { conclusion: node.conclusion } : {}),
+        ...(typeof node.startedAt === "string" ? { startedAt: node.startedAt } : {}),
+        ...(typeof node.completedAt === "string" ? { completedAt: node.completedAt } : {}),
+        ...(typeof node.detailsUrl === "string" ? { detailsUrl: node.detailsUrl } : {}),
+        ...(typeof workflowName === "string" ? { workflowName } : {}),
+      });
+      continue;
+    }
+    if (
+      node.__typename !== "StatusContext" ||
+      typeof node.context !== "string" ||
+      typeof node.state !== "string" ||
+      typeof node.startedAt !== "string"
+    ) {
+      return null;
+    }
+    statusCheckRollup.push({
+      __typename: "StatusContext",
+      context: node.context,
+      state: node.state,
+      startedAt: node.startedAt,
+    });
+  }
+  return statusCheckRollup;
+}
+
 function checkFinalRevision(
-  captured: PrRevisionSnapshot,
-  current: PrRevisionSnapshot | null,
+  captured: PrRevisionIdentity,
+  current: PrRevisionIdentity | null,
   currentBaseSha: string | null,
 ): ReturnType<typeof checkConflicts> {
   if (!current) {
@@ -1946,13 +3199,15 @@ function main(): void {
     process.exit(1);
   }
 
-  const ci = checkCi(prData.statusCheckRollup, repo, {
+  const exactDiff = {
     number: prNumber,
     headSha: prData.headRefOid,
     baseSha: prData.baseRefOid,
     headRefName: prData.headRefName,
     headRepository,
-  });
+  };
+  const currentBaseSha = fetchCurrentBaseSha(repo, prNumber);
+  const initialCi = checkCi(prData.statusCheckRollup, repo, exactDiff, currentBaseSha);
   const coderabbit = checkCodeRabbit(repo, prNumber);
   const riskyCodeTested = checkRiskyCodeTested(prData.files ?? []);
   const contributorCompliance = checkContributorCompliance(
@@ -1966,25 +3221,102 @@ function main(): void {
     prData,
     contributorApprovalHistory,
   );
-  const currentBaseSha = fetchCurrentBaseSha(repo, prNumber);
+  const capturedRevision: PrRevisionSnapshot = {
+    title: prData.title,
+    body: prData.body,
+    state: prData.state,
+    isDraft: prData.isDraft,
+    mergeable: prData.mergeable,
+    mergeStateStatus: prData.mergeStateStatus,
+    headRefOid: prData.headRefOid,
+    baseRefOid: prData.baseRefOid,
+    headRefName: prData.headRefName,
+    baseRefName: prData.baseRefName,
+    headRepository,
+    statusCheckRollup: prData.statusCheckRollup,
+  };
+  const revisionBeforeFinalCi = fetchPrRevisionSnapshot(repo, prNumber);
+  const finalCiActionEvidence = createCiActionEvidenceCache();
+  const evaluatedRollupCi = checkFinalCi(
+    initialCi,
+    revisionBeforeFinalCi?.statusCheckRollup ?? null,
+    repo,
+    exactDiff,
+    finalCiActionEvidence,
+  );
+  const finalE2eEvidence = evaluatedRollupCi.pass
+    ? fetchE2eCoordinationEvidence(repo, exactDiff, currentBaseSha)
+    : { valid: false };
+  const evaluatedCi = checkFinalE2eEvidence(
+    evaluatedRollupCi,
+    initialCi,
+    finalE2eEvidence,
+    exactDiff,
+  );
   const currentRevision = fetchPrRevisionSnapshot(repo, prNumber);
-  const conflicts = checkFinalRevision(
-    {
-      title: prData.title,
-      body: prData.body,
-      state: prData.state,
-      isDraft: prData.isDraft,
-      mergeable: prData.mergeable,
-      mergeStateStatus: prData.mergeStateStatus,
-      headRefOid: prData.headRefOid,
-      baseRefOid: prData.baseRefOid,
-      headRefName: prData.headRefName,
-      baseRefName: prData.baseRefName,
-      headRepository,
-    },
-    currentRevision,
-    currentBaseSha,
+  const ciBeforeFinalSnapshot = checkLastCi(
+    evaluatedCi,
+    initialCi,
+    currentRevision?.statusCheckRollup ?? null,
+    repo,
+    exactDiff,
+    finalE2eEvidence,
+    finalCiActionEvidence,
+  );
+  const finalSnapshot = fetchFinalPrSnapshot(repo, prNumber);
+  const finalRevision = finalSnapshot?.revision ?? null;
+  const finalCurrentBaseSha = finalSnapshot?.currentBaseSha ?? null;
+  const stableCurrentBaseSha =
+    currentBaseSha && finalCurrentBaseSha && currentBaseSha === finalCurrentBaseSha
+      ? finalCurrentBaseSha
+      : null;
+  const ci = !ciBeforeFinalSnapshot.pass
+    ? ciBeforeFinalSnapshot
+    : !finalRevision
+      ? { pass: false, details: "Unable to verify the final PR checks" }
+      : checkLastCi(
+          ciBeforeFinalSnapshot,
+          initialCi,
+          finalRevision.statusCheckRollup,
+          repo,
+          exactDiff,
+          finalE2eEvidence,
+          finalCiActionEvidence,
+        );
+  const baseRevisionGate: ReturnType<typeof checkConflicts> =
+    stableCurrentBaseSha !== null
+      ? {
+          pass: true,
+          details: "The base SHA did not change during gate evaluation",
+          mergeable: capturedRevision.mergeable,
+          mergeStateStatus: capturedRevision.mergeStateStatus,
+          baseSha: capturedRevision.baseRefOid,
+          currentBaseSha: stableCurrentBaseSha,
+        }
+      : {
+          pass: false,
+          details:
+            currentBaseSha && finalCurrentBaseSha
+              ? "The base SHA changed during gate evaluation. Rerun the gate checker."
+              : "The gate checker could not verify the base SHA",
+          mergeable: capturedRevision.mergeable,
+          mergeStateStatus: capturedRevision.mergeStateStatus,
+          baseSha: capturedRevision.baseRefOid,
+          ...(finalCurrentBaseSha ? { currentBaseSha: finalCurrentBaseSha } : {}),
+        };
+  const revisionBeforeFinalCiGate = checkFinalRevision(
+    capturedRevision,
+    revisionBeforeFinalCi,
+    stableCurrentBaseSha,
   );
+  const revisionAfterFinalEvidenceGate = revisionBeforeFinalCiGate.pass
+    ? checkFinalRevision(revisionBeforeFinalCi!, currentRevision, stableCurrentBaseSha)
+    : revisionBeforeFinalCiGate;
+  const conflicts = !baseRevisionGate.pass
+    ? baseRevisionGate
+    : revisionAfterFinalEvidenceGate.pass
+      ? checkFinalRevision(currentRevision!, finalRevision, stableCurrentBaseSha)
+      : revisionAfterFinalEvidenceGate;
 
   const output: GateOutput = {
     pr: prNumber,
diff --git a/.agents/skills/nemoclaw-maintainer-day/scripts/shared.ts b/.agents/skills/nemoclaw-maintainer-day/scripts/shared.ts
index 85e87942493..fa39cfb6769 100644
--- a/.agents/skills/nemoclaw-maintainer-day/scripts/shared.ts
+++ b/.agents/skills/nemoclaw-maintainer-day/scripts/shared.ts
@@ -24,6 +24,7 @@ export const RISKY_PATTERNS: RegExp[] = [
   /^nemoclaw\/src\/blueprint\//,
   /^nemoclaw-blueprint\//,
   /^\.github\/workflows\//,
+  /^\.agents\/skills\/nemoclaw-maintainer-day\/scripts\/check-gates\.ts$/,
   /\.prek\./,
   /policy/i,
   /ssrf/i,
diff --git a/test/skills/check-gates-compliance.test.ts b/test/skills/check-gates-compliance.test.ts
index e21378a1df2..3cba8957573 100644
--- a/test/skills/check-gates-compliance.test.ts
+++ b/test/skills/check-gates-compliance.test.ts
@@ -6,6 +6,32 @@ import { describe, expect, it } from "vitest";
 import { REQUIRED_CHECK_NAMES, runComparatorGate, runGate } from "./check-gates-test-fixtures.ts";
 
 describe("maintainer merge-gate contributor compliance", () => {
+  it("classifies the merge-gate checker as risky code with direct test coverage", () => {
+    const output = JSON.parse(
+      runGate({
+        body: "Signed-off-by: Example User <user@example.com>",
+        verified: true,
+        files: [
+          {
+            path: ".agents/skills/nemoclaw-maintainer-day/scripts/check-gates.ts",
+            status: "modified",
+          },
+          {
+            path: "test/skills/check-gates-compliance.test.ts",
+            status: "modified",
+          },
+        ],
+      }).stdout,
+    );
+
+    expect(output.gates.riskyCodeTested).toMatchObject({
+      pass: true,
+      details: "1 risky file(s) changed; test files present in PR",
+      riskyFiles: [".agents/skills/nemoclaw-maintainer-day/scripts/check-gates.ts"],
+      hasTests: true,
+    });
+  });
+
   it("passes when the PR body has DCO and every commit is GitHub Verified", () => {
     const result = runGate({
       body: "## Summary\n\nPolicy alignment.\n\nSigned-off-by: Example User <user@example.com>",
diff --git a/test/skills/check-gates-coordinator-evidence.test.ts b/test/skills/check-gates-coordinator-evidence.test.ts
new file mode 100644
index 00000000000..a9f423455bb
--- /dev/null
+++ b/test/skills/check-gates-coordinator-evidence.test.ts
@@ -0,0 +1,1500 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { describe, expect, it } from "vitest";
+import type {
+  ActionJobFixture,
+  ActionRunFixture,
+  ComplianceFixture,
+  CoordinatorRunPartitionFixture,
+} from "./check-gates-test-fixtures.ts";
+import {
+  BASE_SHA,
+  coordinationCheck,
+  e2eCoordinatorRun,
+  e2eManualCoordinatorRun,
+  exactDiffGateRun,
+  HEAD_SHA,
+  prWorkflowRun,
+  runGate,
+  successfulRequiredChecks,
+} from "./check-gates-test-fixtures.ts";
+
+function seedJobs(): ActionJobFixture[] {
+  return [
+    { id: 471, name: "cancel-superseded" },
+    { id: 472, name: "initialize" },
+    { id: 473, name: "coordinate", conclusion: "skipped" },
+  ].map((job) => ({
+    ...job,
+    startedAt: "2026-01-01T00:01:00Z",
+    completedAt: "2026-01-01T00:01:31Z",
+  }));
+}
+
+function laterSeedJobs(): ActionJobFixture[] {
+  return seedJobs().map((job) => ({
+    ...job,
+    id: job.id + 100,
+    startedAt: "2026-01-01T00:02:42Z",
+    completedAt: "2026-01-01T00:02:50Z",
+  }));
+}
+
+function coordinatorJobs(overrides: Partial<ActionJobFixture> = {}): ActionJobFixture[] {
+  return (e2eCoordinatorRun().jobs ?? []).map((job) =>
+    job.name === "coordinate" ? { ...job, ...overrides } : job,
+  );
+}
+
+function historicalCoordinatorRun(): ActionRunFixture {
+  return {
+    ...e2eCoordinatorRun(
+      "success",
+      coordinatorJobs({
+        conclusion: "success",
+        startedAt: "2026-01-01T00:00:20Z",
+        completedAt: "2026-01-01T00:00:59Z",
+      }),
+    ),
+    createdAt: "2026-01-01T00:00:10Z",
+    updatedAt: "2026-01-01T00:01:00Z",
+  };
+}
+
+function retryableFailure(id: number, startedAt: string, completedAt: string) {
+  return coordinationCheck({
+    id,
+    conclusion: "failure",
+    started_at: startedAt,
+    completed_at: completedAt,
+    output: {
+      title: "Retryable E2E failure",
+      summary: "Retryable failure.\n\n<!-- nemoclaw-pr-e2e-retry:v1:prerequisite-ci -->",
+    },
+  });
+}
+
+const DEFAULT_COORDINATOR_RANGES = [
+  "2025-12-31T00:00:00Z..2025-12-31T12:00:00Z",
+  "2025-12-31T12:00:00Z..2026-01-01T00:00:00Z",
+  "2026-01-01T00:00:00Z..2026-01-01T00:03:00Z",
+] as const;
+
+function paginatedRunIds(ids: number[]): number[][] {
+  return Array.from({ length: Math.ceil(ids.length / 100) }, (_value, index) =>
+    ids.slice(index * 100, (index + 1) * 100),
+  );
+}
+
+interface CoordinatorFixture {
+  additionalStatusChecks?: NonNullable<ComplianceFixture["statusChecks"]>;
+  coordinator?: Partial<ActionRunFixture>;
+  coordinatorList?: Partial<ActionRunFixture>;
+  coordinatorJobs?: ActionJobFixture[];
+  coordinatorRunPages?: number[][];
+  coordinatorRunPartitions?: CoordinatorRunPartitionFixture[];
+  coordinationCheckPages?: unknown[];
+  customCheck?: Record<string, unknown>;
+  extraRuns?: Record<string, ActionRunFixture>;
+  finalCheckOverrides?: Record<
+    string,
+    Partial<NonNullable<ComplianceFixture["statusChecks"]>[number]>
+  >;
+  finalCoordinationCheckPages?: unknown[];
+  finalFormerCoordinationCheckPages?: unknown[];
+  finalPrAfterCiEvidence?: Record<string, unknown>;
+  additionalChecksAfterE2eEvidence?: NonNullable<ComplianceFixture["statusChecks"]>;
+  headRepository?: string;
+  includeInitialSeedEvidence?: boolean;
+  observationTime?: string;
+  seedRun?: Partial<ActionRunFixture>;
+  currentBaseSha?: string | null;
+}
+
+const LIVE_FORK_COORDINATOR_RANGES = [
+  "2026-08-03T00:00:00Z..2026-08-03T12:00:00Z",
+  "2026-08-03T12:00:00Z..2026-08-04T00:00:00Z",
+  "2026-08-04T00:00:00Z..2026-08-04T12:00:00Z",
+  "2026-08-04T12:00:00Z..2026-08-04T14:58:00Z",
+] as const;
+
+function authorizedForkLifecycleFixture(
+  additionalAutomaticRuns: Record<string, ActionRunFixture> = {},
+): CoordinatorFixture {
+  const automaticCoordinator = {
+    ...e2eCoordinatorRun(),
+    createdAt: "2026-08-04T14:36:34Z",
+    updatedAt: "2026-08-04T14:37:04Z",
+    jobs: coordinatorJobs({
+      startedAt: "2026-08-04T14:36:35Z",
+      completedAt: "2026-08-04T14:37:03Z",
+    }),
+  };
+  const manualCoordinator = {
+    ...e2eManualCoordinatorRun(),
+    createdAt: "2026-08-04T14:38:13Z",
+    updatedAt: "2026-08-04T14:57:43Z",
+    jobs: coordinatorJobs({
+      startedAt: "2026-08-04T14:38:14Z",
+      completedAt: "2026-08-04T14:57:42Z",
+    }),
+  };
+  const automaticRunIds = [9501, ...Object.keys(additionalAutomaticRuns).map(Number)];
+  return {
+    headRepository: "example/fork",
+    observationTime: "2026-08-04T14:58:00Z",
+    customCheck: {
+      started_at: "2026-08-04T14:23:40Z",
+      completed_at: "2026-08-04T14:57:39Z",
+    },
+    coordinator: manualCoordinator,
+    seedRun: {
+      headRepository: "example/fork",
+      createdAt: "2026-08-04T14:21:55Z",
+      updatedAt: "2026-08-04T14:23:47Z",
+      jobs: seedJobs().map((job) => ({
+        ...job,
+        startedAt: "2026-08-04T14:23:15Z",
+        completedAt: "2026-08-04T14:23:42Z",
+      })),
+    },
+    coordinatorRunPartitions: [
+      ...LIVE_FORK_COORDINATOR_RANGES.map((createdRange, index) => ({
+        createdRange,
+        runPages: [index === LIVE_FORK_COORDINATOR_RANGES.length - 1 ? automaticRunIds : []],
+      })),
+      {
+        createdRange: LIVE_FORK_COORDINATOR_RANGES.at(-1)!,
+        event: "workflow_dispatch",
+        runPages: [[9500]],
+      },
+    ],
+    extraRuns: {
+      "90": {
+        ...prWorkflowRun(
+          "success",
+          [
+            { id: 1, name: "checks" },
+            { id: 2, name: "changes" },
+          ],
+          true,
+        ),
+        headRepository: "example/fork",
+        pullRequests: [],
+      },
+      "9501": automaticCoordinator,
+      ...additionalAutomaticRuns,
+    },
+  };
+}
+
+function delayedRetryFixture(): CoordinatorFixture {
+  return {
+    seedRun: {
+      createdAt: "2026-08-04T14:07:32Z",
+      updatedAt: "2026-08-04T14:08:01Z",
+      jobs: seedJobs().map((job) => ({
+        ...job,
+        startedAt: "2026-08-04T14:07:40Z",
+        completedAt: "2026-08-04T14:08:00Z",
+      })),
+    },
+    customCheck: {
+      started_at: "2026-08-04T14:28:06Z",
+      completed_at: "2026-08-04T14:38:01Z",
+    },
+    coordinator: {
+      createdAt: "2026-08-04T14:27:44Z",
+      updatedAt: "2026-08-04T14:38:06Z",
+    },
+    coordinatorJobs: coordinatorJobs({
+      startedAt: "2026-08-04T14:27:47Z",
+      completedAt: "2026-08-04T14:38:05Z",
+    }),
+    coordinatorRunPartitions: [
+      {
+        createdRange: "2026-08-03T00:00:00Z..2026-08-03T12:00:00Z",
+        runPages: [[]],
+      },
+      {
+        createdRange: "2026-08-03T12:00:00Z..2026-08-04T00:00:00Z",
+        runPages: [[]],
+      },
+      {
+        createdRange: "2026-08-04T00:00:00Z..2026-08-04T12:00:00Z",
+        runPages: [[]],
+      },
+      {
+        createdRange: "2026-08-04T12:00:00Z..2026-08-04T14:38:01Z",
+        runPages: [[9500]],
+      },
+    ],
+  };
+}
+
+function seedStatusChecks(
+  runId: number,
+  jobs: ActionJobFixture[],
+  fallbackStartedAt = "2026-01-01T00:01:00Z",
+) {
+  return jobs.map((job) => ({
+    __typename: "CheckRun",
+    name: job.name,
+    workflowName: "E2E / PR Gate Controller",
+    detailsUrl: `https://github.com/NVIDIA/NemoClaw/actions/runs/${runId}/job/${job.id}`,
+    startedAt: job.startedAt ?? fallbackStartedAt,
+    status: (job.status ?? "completed").toUpperCase(),
+    ...(job.conclusion === null ? {} : { conclusion: (job.conclusion ?? "success").toUpperCase() }),
+  }));
+}
+
+function manualOnlyCoordinatorPartitions(): CoordinatorRunPartitionFixture[] {
+  return DEFAULT_COORDINATOR_RANGES.map((createdRange, index) => ({
+    createdRange,
+    event: "workflow_dispatch",
+    runPages: [index === DEFAULT_COORDINATOR_RANGES.length - 1 ? [9500] : []],
+  }));
+}
+
+function runGateWithCoordinator({
+  additionalStatusChecks = [],
+  coordinator = {},
+  coordinatorList,
+  coordinatorJobs: configuredJobs,
+  coordinatorRunPages = [[9500]],
+  coordinatorRunPartitions,
+  coordinationCheckPages,
+  customCheck = {},
+  extraRuns = {},
+  finalCheckOverrides = {},
+  finalCoordinationCheckPages,
+  finalFormerCoordinationCheckPages,
+  finalPrAfterCiEvidence,
+  additionalChecksAfterE2eEvidence,
+  headRepository,
+  includeInitialSeedEvidence = true,
+  observationTime,
+  seedRun = {},
+  currentBaseSha,
+}: CoordinatorFixture = {}) {
+  const defaultCoordinator = e2eCoordinatorRun();
+  const jobs = seedRun.jobs ?? seedJobs();
+  const statusChecks = [
+    ...successfulRequiredChecks().filter((check) => check.name !== "initialize"),
+    ...(includeInitialSeedEvidence
+      ? seedStatusChecks(407, jobs, seedRun.createdAt ?? undefined)
+      : []),
+    ...additionalStatusChecks,
+  ];
+  const finalStatusChecks =
+    Object.keys(finalCheckOverrides).length > 0
+      ? statusChecks.map((check) => {
+          const overrides = check.name === undefined ? undefined : finalCheckOverrides[check.name];
+          return { ...check, ...overrides };
+        })
+      : undefined;
+  const coordinatorJobs = configuredJobs ?? coordinator.jobs ?? defaultCoordinator.jobs;
+  return runGate({
+    body: "Signed-off-by: Example User <user@example.com>",
+    verified: true,
+    headRepository,
+    observationTime,
+    currentBaseSha,
+    statusChecks,
+    coordinatorRunPages,
+    coordinatorRunPartitions,
+    coordinatorListAttempts: coordinatorList
+      ? {
+          "9500": {
+            ...defaultCoordinator,
+            ...coordinator,
+            ...coordinatorList,
+            jobs: coordinatorJobs,
+          },
+        }
+      : undefined,
+    coordinationCheckPages: coordinationCheckPages ?? [
+      {
+        total_count: 1,
+        check_runs: [coordinationCheck(customCheck)],
+      },
+    ],
+    finalCoordinationCheckPages,
+    finalFormerCoordinationCheckPages,
+    finalPr: finalStatusChecks ? { statusCheckRollup: finalStatusChecks } : undefined,
+    finalPrAfterCiEvidence: additionalChecksAfterE2eEvidence
+      ? {
+          ...finalPrAfterCiEvidence,
+          statusCheckRollup: [
+            ...(finalStatusChecks ?? statusChecks),
+            ...additionalChecksAfterE2eEvidence,
+          ],
+        }
+      : finalPrAfterCiEvidence,
+    actionRunAttempts: {
+      "9500": {
+        ...defaultCoordinator,
+        ...coordinator,
+        jobs: coordinatorJobs,
+      },
+      "407": {
+        ...exactDiffGateRun("success", jobs),
+        createdAt: "2026-01-01T00:01:00Z",
+        updatedAt: "2026-01-01T00:01:31Z",
+        pullRequests: [],
+        ...seedRun,
+        jobs,
+      },
+      ...extraRuns,
+    },
+  });
+}
+
+describe("maintainer merge-gate E2E coordinator evidence", () => {
+  it("accepts a custom check completed after its seed run when the repository coordinator encloses completion", () => {
+    const result = runGateWithCoordinator();
+
+    expect(JSON.parse(result.stdout)).toMatchObject({
+      allPass: true,
+      gates: { ci: { pass: true } },
+    });
+  });
+
+  it("authenticates coordinator runs against the captured workflow revision", () => {
+    const workflowSha = "d".repeat(40);
+    const result = runGateWithCoordinator({
+      coordinator: { headSha: workflowSha },
+      currentBaseSha: workflowSha,
+    });
+    const output = JSON.parse(result.stdout);
+
+    expect(output.gates.ci).toMatchObject({ pass: true });
+    expect(output.gates.conflicts).toMatchObject({
+      pass: false,
+      baseSha: BASE_SHA,
+      currentBaseSha: workflowSha,
+    });
+    expect(output.allPass).toBe(false);
+  });
+
+  it("rejects a manual coordinator for a fork with no automatic predecessor", () => {
+    const manualCoordinator = e2eManualCoordinatorRun();
+    const result = runGateWithCoordinator({
+      headRepository: "example/fork",
+      coordinator: manualCoordinator,
+      seedRun: { headRepository: "example/fork" },
+      coordinatorRunPartitions: manualOnlyCoordinatorPartitions(),
+      extraRuns: {
+        "90": {
+          ...prWorkflowRun(
+            "success",
+            [
+              { id: 1, name: "checks" },
+              { id: 2, name: "changes" },
+            ],
+            true,
+          ),
+          headRepository: "example/fork",
+          pullRequests: [],
+        },
+      },
+    });
+    const output = JSON.parse(result.stdout);
+
+    expect(output).toMatchObject({
+      allPass: false,
+      gates: { ci: { pass: false } },
+    });
+    expect(output.gates.ci.failingChecks).toContain(
+      "E2E / PR Gate: latest attempt evidence incomplete",
+    );
+  });
+
+  it("rejects a manual coordinator for a same-repository revision", () => {
+    const result = runGateWithCoordinator({
+      coordinator: e2eManualCoordinatorRun(),
+      coordinatorRunPartitions: manualOnlyCoordinatorPartitions(),
+    });
+    const output = JSON.parse(result.stdout);
+
+    expect(output).toMatchObject({
+      allPass: false,
+      gates: { ci: { pass: false } },
+    });
+    expect(output.gates.ci.failingChecks).toContain(
+      "E2E / PR Gate: latest attempt evidence incomplete",
+    );
+  });
+
+  it("accepts a fork check completed by manual authorization after automatic coordination", () => {
+    const result = runGateWithCoordinator(authorizedForkLifecycleFixture());
+
+    expect(JSON.parse(result.stdout)).toMatchObject({
+      allPass: true,
+      gates: { ci: { pass: true } },
+    });
+  });
+
+  it("rejects a successful custom check without initial E2E seed evidence in the status rollup", () => {
+    const result = runGateWithCoordinator({ includeInitialSeedEvidence: false });
+    const output = JSON.parse(result.stdout);
+
+    expect(output).toMatchObject({
+      allPass: false,
+      gates: { ci: { pass: false } },
+    });
+    expect(output.gates.ci.failingChecks).toContain(
+      "E2E / PR Gate: latest attempt evidence incomplete",
+    );
+  });
+
+  it("rejects two initial E2E seed runs in the status rollup", () => {
+    const duplicateSeedJobs = seedJobs().map((job) => ({ ...job, id: job.id + 100 }));
+    const result = runGateWithCoordinator({
+      additionalStatusChecks: seedStatusChecks(408, duplicateSeedJobs).filter(
+        (check) => check.name === "initialize",
+      ),
+      extraRuns: {
+        "408": {
+          ...exactDiffGateRun("success", duplicateSeedJobs),
+          createdAt: "2026-01-01T00:01:00Z",
+          updatedAt: "2026-01-01T00:01:31Z",
+          pullRequests: [],
+        },
+      },
+    });
+    const output = JSON.parse(result.stdout);
+
+    expect(output).toMatchObject({
+      allPass: false,
+      gates: { ci: { pass: false } },
+    });
+    expect(output.gates.ci.failingChecks).toContain(
+      "E2E / PR Gate: latest attempt evidence incomplete",
+    );
+  });
+
+  it("rejects two authenticated initial E2E seed runs with different creation times and overlapping initialize windows", () => {
+    const staggeredSeedJobs = seedJobs().map((job) => ({
+      ...job,
+      id: job.id + 200,
+      startedAt: "2026-01-01T00:01:01Z",
+      completedAt: "2026-01-01T00:01:31Z",
+    }));
+    const result = runGateWithCoordinator({
+      additionalStatusChecks: seedStatusChecks(409, staggeredSeedJobs).filter(
+        (check) => check.name === "initialize",
+      ),
+      extraRuns: {
+        "409": {
+          ...exactDiffGateRun("success", staggeredSeedJobs),
+          createdAt: "2026-01-01T00:01:01Z",
+          updatedAt: "2026-01-01T00:01:31Z",
+          pullRequests: [],
+        },
+      },
+    });
+    const output = JSON.parse(result.stdout);
+
+    expect(output).toMatchObject({
+      allPass: false,
+      gates: { ci: { pass: false } },
+    });
+    expect(output.gates.ci.failingChecks).toContain(
+      "E2E / PR Gate: latest attempt evidence incomplete",
+    );
+  });
+
+  it("rejects two automatic authorization predecessors for one manual coordinator", () => {
+    const result = runGateWithCoordinator(
+      authorizedForkLifecycleFixture({
+        "9502": {
+          ...e2eCoordinatorRun(),
+          createdAt: "2026-08-04T14:37:05Z",
+          updatedAt: "2026-08-04T14:37:34Z",
+          jobs: coordinatorJobs({
+            startedAt: "2026-08-04T14:37:06Z",
+            completedAt: "2026-08-04T14:37:33Z",
+          }),
+        },
+      }),
+    );
+    const output = JSON.parse(result.stdout);
+
+    expect(output).toMatchObject({
+      allPass: false,
+      gates: { ci: { pass: false } },
+    });
+    expect(output.gates.ci.failingChecks).toContain(
+      "E2E / PR Gate: latest attempt evidence incomplete",
+    );
+  });
+
+  it("accepts a matching coordinator from a later page of a complete workflow-run inventory", () => {
+    const unrelatedRun = {
+      ...e2eCoordinatorRun(),
+      displayTitle: "E2E Gate coordinate from unrelated CI",
+    };
+    const result = runGateWithCoordinator({
+      coordinatorRunPages: [[9501], [9500]],
+      extraRuns: { "9501": unrelatedRun },
+    });
+
+    expect(JSON.parse(result.stdout)).toMatchObject({
+      allPass: true,
+      gates: { ci: { pass: true } },
+    });
+  });
+
+  it("accepts one enclosing coordinator with older same-revision coordinator history", () => {
+    const result = runGateWithCoordinator({
+      coordinatorRunPages: [[9501, 9500]],
+      extraRuns: { "9501": historicalCoordinatorRun() },
+    });
+
+    expect(JSON.parse(result.stdout)).toMatchObject({
+      allPass: true,
+      gates: { ci: { pass: true } },
+    });
+  });
+
+  it("accepts a retry coordinator created before the current custom check", () => {
+    const result = runGateWithCoordinator({
+      coordinator: { createdAt: "2026-01-01T00:01:20Z" },
+      coordinatorJobs: coordinatorJobs({
+        startedAt: "2026-01-01T00:01:25Z",
+      }),
+    });
+
+    expect(JSON.parse(result.stdout)).toMatchObject({
+      allPass: true,
+      gates: { ci: { pass: true } },
+    });
+  });
+
+  it("accepts a retry check created after its authenticated seed run finishes", () => {
+    const fixture = delayedRetryFixture();
+    const result = runGateWithCoordinator({
+      ...fixture,
+      coordinationCheckPages: [
+        {
+          total_count: 2,
+          check_runs: [
+            retryableFailure(7999, "2026-08-04T14:07:50Z", "2026-08-04T14:08:00Z"),
+            coordinationCheck(fixture.customCheck),
+          ],
+        },
+      ],
+    });
+
+    expect(JSON.parse(result.stdout)).toMatchObject({
+      allPass: true,
+      gates: { ci: { pass: true } },
+    });
+  });
+
+  it("rejects a retry check that starts before the previous check completes", () => {
+    const fixture = delayedRetryFixture();
+    const result = runGateWithCoordinator({
+      ...fixture,
+      coordinationCheckPages: [
+        {
+          total_count: 2,
+          check_runs: [
+            retryableFailure(7999, "2026-08-04T14:07:50Z", "2026-08-04T14:28:07Z"),
+            coordinationCheck(fixture.customCheck),
+          ],
+        },
+      ],
+    });
+
+    expect(JSON.parse(result.stdout)).toMatchObject({
+      allPass: false,
+      gates: {
+        ci: {
+          pass: false,
+          failingChecks: [
+            "E2E / PR Gate: latest attempt evidence incomplete",
+            "cancel-superseded: latest attempt evidence incomplete",
+            "coordinate: latest attempt evidence incomplete",
+            "initialize: latest attempt evidence incomplete",
+          ],
+        },
+      },
+    });
+  });
+
+  it("rejects a stale seed with no predecessor for a newer coordination check", () => {
+    const result = runGateWithCoordinator(delayedRetryFixture());
+
+    const output = JSON.parse(result.stdout);
+
+    expect(output).toMatchObject({
+      allPass: false,
+      gates: { ci: { pass: false } },
+    });
+    expect(output.gates.ci.failingChecks).toContain(
+      "initialize: latest attempt evidence incomplete",
+    );
+  });
+
+  it("rejects a seed run without observable initialize timing", () => {
+    const result = runGateWithCoordinator({
+      seedRun: {
+        jobs: seedJobs().map((job) =>
+          job.name === "initialize" ? { ...job, omitStartedAt: true } : job,
+        ),
+      },
+    });
+    const output = JSON.parse(result.stdout);
+
+    expect(output).toMatchObject({ allPass: false, gates: { ci: { pass: false } } });
+    expect(output.gates.ci.failingChecks).toContain(
+      "initialize: latest attempt evidence incomplete",
+    );
+  });
+
+  it("rejects a seed run that encloses one check without an initialize job", () => {
+    const result = runGateWithCoordinator({
+      seedRun: {
+        updatedAt: "2026-01-01T00:02:31Z",
+        jobs: seedJobs().filter((job) => job.name !== "initialize"),
+      },
+    });
+    const output = JSON.parse(result.stdout);
+
+    expect(output).toMatchObject({ allPass: false, gates: { ci: { pass: false } } });
+    expect(output.gates.ci.failingChecks).toContain(
+      "cancel-superseded: latest attempt evidence incomplete",
+    );
+  });
+
+  it("ignores a later successful seed that reuses the authenticated check", () => {
+    const reuseJobs = laterSeedJobs();
+    const result = runGateWithCoordinator({
+      additionalStatusChecks: seedStatusChecks(408, reuseJobs),
+      extraRuns: {
+        "408": {
+          ...exactDiffGateRun("success", reuseJobs),
+          createdAt: "2026-01-01T00:02:40Z",
+          updatedAt: "2026-01-01T00:02:51Z",
+          pullRequests: [],
+        },
+      },
+    });
+
+    expect(JSON.parse(result.stdout)).toMatchObject({
+      allPass: true,
+      gates: { ci: { pass: true } },
+    });
+  });
+
+  it.each([
+    {
+      state: "failed",
+      run: { status: "completed", conclusion: "failure" },
+      updateJobs: (jobs: ActionJobFixture[]) =>
+        jobs.map((job) =>
+          job.name === "cancel-superseded" ? { ...job, conclusion: "failure" } : job,
+        ),
+    },
+    {
+      state: "pending",
+      run: { status: "in_progress", conclusion: null },
+      updateJobs: (jobs: ActionJobFixture[]) =>
+        jobs.map((job) =>
+          job.name === "cancel-superseded"
+            ? { ...job, status: "in_progress", conclusion: null, completedAt: null }
+            : job,
+        ),
+    },
+  ])("keeps a later $state seed reuse blocking", ({ run, updateJobs }) => {
+    const reuseJobs = updateJobs(laterSeedJobs());
+    const result = runGateWithCoordinator({
+      additionalStatusChecks: seedStatusChecks(408, reuseJobs),
+      extraRuns: {
+        "408": {
+          ...exactDiffGateRun(run.conclusion ?? "success", reuseJobs),
+          ...run,
+          createdAt: "2026-01-01T00:02:40Z",
+          updatedAt: "2026-01-01T00:02:51Z",
+          pullRequests: [],
+        },
+      },
+    });
+    const output = JSON.parse(result.stdout);
+
+    expect(output).toMatchObject({ allPass: false, gates: { ci: { pass: false } } });
+    expect(output.gates.ci.failingChecks).toContain(
+      "initialize: latest attempt evidence incomplete",
+    );
+  });
+
+  it("finds a coordinator created before midnight for a check completed after midnight", () => {
+    const result = runGateWithCoordinator({
+      customCheck: {
+        started_at: "2026-01-02T00:00:10Z",
+        completed_at: "2026-01-02T00:00:40Z",
+      },
+      coordinator: {
+        createdAt: "2026-01-01T23:59:50Z",
+        updatedAt: "2026-01-02T00:00:45Z",
+      },
+      coordinatorJobs: coordinatorJobs({
+        startedAt: "2026-01-01T23:59:55Z",
+        completedAt: "2026-01-02T00:00:44Z",
+      }),
+      seedRun: {
+        createdAt: "2026-01-01T23:59:59Z",
+        updatedAt: "2026-01-02T00:00:11Z",
+        jobs: seedJobs().map((job) => ({
+          ...job,
+          startedAt: "2026-01-02T00:00:00Z",
+          completedAt: "2026-01-02T00:00:11Z",
+        })),
+      },
+      coordinatorRunPartitions: [
+        {
+          createdRange: "2026-01-01T00:00:00Z..2026-01-01T12:00:00Z",
+          runPages: [[]],
+        },
+        {
+          createdRange: "2026-01-01T12:00:00Z..2026-01-02T00:00:00Z",
+          runPages: [[9500]],
+        },
+        {
+          createdRange: "2026-01-02T00:00:00Z..2026-01-02T00:00:40Z",
+          runPages: [[]],
+        },
+      ],
+    });
+
+    expect(JSON.parse(result.stdout)).toMatchObject({
+      allPass: true,
+      gates: { ci: { pass: true } },
+    });
+  });
+
+  it("accepts more than 1,000 workflow runs when each partition returns its reported total", () => {
+    const firstPartitionIds = Array.from({ length: 600 }, (_value, index) => 10_000 + index);
+    const secondPartitionIds = Array.from({ length: 600 }, (_value, index) => 20_000 + index);
+    const result = runGateWithCoordinator({
+      coordinatorRunPartitions: [
+        {
+          createdRange: DEFAULT_COORDINATOR_RANGES[0],
+          runPages: paginatedRunIds(firstPartitionIds),
+          fallbackCreatedAt: "2025-12-31T06:00:00Z",
+        },
+        {
+          createdRange: DEFAULT_COORDINATOR_RANGES[1],
+          runPages: paginatedRunIds(secondPartitionIds),
+          fallbackCreatedAt: "2025-12-31T18:00:00Z",
+        },
+        {
+          createdRange: DEFAULT_COORDINATOR_RANGES[2],
+          runPages: [[9500]],
+        },
+      ],
+    });
+
+    expect(JSON.parse(result.stdout)).toMatchObject({
+      allPass: true,
+      gates: { ci: { pass: true } },
+    });
+  });
+
+  it("deduplicates an identical coordinator returned at an inclusive partition boundary", () => {
+    const result = runGateWithCoordinator({
+      coordinator: { createdAt: "2026-01-01T00:00:00Z" },
+      coordinatorRunPartitions: [
+        {
+          createdRange: DEFAULT_COORDINATOR_RANGES[0],
+          runPages: [[]],
+        },
+        {
+          createdRange: DEFAULT_COORDINATOR_RANGES[1],
+          runPages: [[9500]],
+        },
+        {
+          createdRange: DEFAULT_COORDINATOR_RANGES[2],
+          runPages: [[9500]],
+        },
+      ],
+    });
+
+    expect(JSON.parse(result.stdout)).toMatchObject({
+      allPass: true,
+      gates: { ci: { pass: true } },
+    });
+  });
+
+  it("rejects a newer custom-check retry that appears during final observation", () => {
+    const result = runGateWithCoordinator({
+      finalCoordinationCheckPages: [
+        {
+          total_count: 2,
+          check_runs: [
+            coordinationCheck(),
+            coordinationCheck({
+              id: 8001,
+              status: "in_progress",
+              conclusion: null,
+              started_at: "2026-01-01T00:02:31Z",
+              completed_at: null,
+            }),
+          ],
+        },
+      ],
+    });
+    const output = JSON.parse(result.stdout);
+
+    expect(output).toMatchObject({
+      allPass: false,
+      gates: { ci: { pass: false } },
+    });
+    expect(output.gates.ci.failingChecks).toContain("E2E / PR Gate: final evidence changed");
+  });
+
+  it("rejects a newer queued coordinator before it creates a custom check", () => {
+    const result = runGateWithCoordinator({
+      coordinatorRunPartitions: [
+        {
+          createdRange: DEFAULT_COORDINATOR_RANGES[0],
+          runPages: [[]],
+        },
+        {
+          createdRange: DEFAULT_COORDINATOR_RANGES[1],
+          runPages: [[]],
+        },
+        {
+          createdRange: DEFAULT_COORDINATOR_RANGES[2],
+          runPages: [[9500]],
+          finalRunPages: [[9500, 9501]],
+        },
+      ],
+      extraRuns: {
+        "9501": {
+          ...e2eCoordinatorRun(),
+          createdAt: "2026-01-01T00:02:40Z",
+          updatedAt: "2026-01-01T00:02:40Z",
+          status: "queued",
+          conclusion: null,
+          jobs: [],
+        },
+      },
+    });
+    const output = JSON.parse(result.stdout);
+
+    expect(output).toMatchObject({
+      allPass: false,
+      gates: { ci: { pass: false } },
+    });
+    expect(output.gates.ci.failingChecks).toContain("E2E / PR Gate: final evidence changed");
+  });
+
+  it("rejects a PR revision that changes while final CI evidence is read", () => {
+    const result = runGateWithCoordinator({
+      finalPrAfterCiEvidence: {
+        body: "Signed-off-by: Example User <user@example.com>\n\nChanged during final CI.",
+      },
+    });
+    const output = JSON.parse(result.stdout);
+
+    expect(output).toMatchObject({
+      allPass: false,
+      gates: {
+        conflicts: {
+          pass: false,
+          details:
+            "PR revision or merge state changed during gate evaluation; rerun the gate checker",
+        },
+      },
+    });
+  });
+
+  it("rejects failed coordinator history from an earlier day for the same revision", () => {
+    const result = runGateWithCoordinator({
+      coordinationCheckPages: [
+        {
+          total_count: 2,
+          check_runs: [
+            retryableFailure(7999, "2025-12-29T00:01:00Z", "2025-12-29T00:03:00Z"),
+            coordinationCheck(),
+          ],
+        },
+      ],
+      coordinatorRunPartitions: [
+        {
+          createdRange: "2025-12-28T00:00:00Z..2025-12-28T12:00:00Z",
+          runPages: [[]],
+        },
+        {
+          createdRange: "2025-12-28T12:00:00Z..2025-12-29T00:00:00Z",
+          runPages: [[]],
+        },
+        {
+          createdRange: "2025-12-29T00:00:00Z..2025-12-29T12:00:00Z",
+          runPages: [[9501]],
+        },
+        {
+          createdRange: "2025-12-29T12:00:00Z..2025-12-30T00:00:00Z",
+          runPages: [[]],
+        },
+        {
+          createdRange: "2025-12-30T00:00:00Z..2025-12-30T12:00:00Z",
+          runPages: [[]],
+        },
+        {
+          createdRange: "2025-12-30T12:00:00Z..2025-12-31T00:00:00Z",
+          runPages: [[]],
+        },
+        {
+          createdRange: "2025-12-31T00:00:00Z..2025-12-31T12:00:00Z",
+          runPages: [[]],
+        },
+        {
+          createdRange: "2025-12-31T12:00:00Z..2026-01-01T00:00:00Z",
+          runPages: [[]],
+        },
+        {
+          createdRange: DEFAULT_COORDINATOR_RANGES[2],
+          runPages: [[9500]],
+        },
+      ],
+      extraRuns: {
+        "9501": {
+          ...e2eCoordinatorRun("failure"),
+          createdAt: "2025-12-29T00:02:00Z",
+          updatedAt: "2025-12-29T00:03:01Z",
+          jobs: coordinatorJobs({
+            startedAt: "2025-12-29T00:02:01Z",
+            completedAt: "2025-12-29T00:03:00Z",
+          }),
+        },
+      },
+    });
+    const output = JSON.parse(result.stdout);
+
+    expect(output).toMatchObject({
+      allPass: false,
+      gates: { ci: { pass: false } },
+    });
+    expect(output.gates.ci.failingChecks).toContain(
+      "E2E / PR Gate: latest attempt evidence incomplete",
+    );
+  });
+
+  it("rejects a custom-check timestamp span beyond the 14-day inventory limit", () => {
+    const result = runGateWithCoordinator({
+      customCheck: {
+        started_at: "2000-01-01T00:00:00Z",
+        completed_at: "2026-01-01T00:02:30Z",
+      },
+    });
+    const output = JSON.parse(result.stdout);
+
+    expect(output).toMatchObject({
+      allPass: false,
+      gates: { ci: { pass: false } },
+    });
+    expect(output.gates.ci.failingChecks).toContain(
+      "E2E / PR Gate: latest attempt evidence incomplete",
+    );
+  });
+
+  it.each([
+    {
+      field: "status",
+      overrides: { status: "in_progress", conclusion: null, completed_at: null },
+    },
+    { field: "conclusion", overrides: { conclusion: "neutral" } },
+    { field: "start time", overrides: { started_at: "2026-01-01T00:01:31Z" } },
+    { field: "completion time", overrides: { completed_at: "2026-01-01T00:02:31Z" } },
+    {
+      field: "details URL",
+      overrides: { details_url: "https://github.com/NVIDIA/NemoClaw/runs/8001" },
+    },
+  ])("rejects a changed selected custom-check $field during final observation", ({ overrides }) => {
+    const result = runGateWithCoordinator({
+      finalCoordinationCheckPages: [
+        {
+          total_count: 1,
+          check_runs: [coordinationCheck(overrides)],
+        },
+      ],
+    });
+    const output = JSON.parse(result.stdout);
+
+    expect(output).toMatchObject({
+      allPass: false,
+      gates: { ci: { pass: false } },
+    });
+    expect(output.gates.ci.failingChecks).toContain("E2E / PR Gate: final evidence changed");
+  });
+
+  it("rejects changed former custom-check history during final observation", () => {
+    const result = runGateWithCoordinator({
+      finalFormerCoordinationCheckPages: [
+        {
+          total_count: 1,
+          check_runs: [
+            coordinationCheck({
+              id: 7999,
+              name: "E2E / PR Gate Coordination",
+            }),
+          ],
+        },
+      ],
+    });
+    const output = JSON.parse(result.stdout);
+
+    expect(output).toMatchObject({
+      allPass: false,
+      gates: { ci: { pass: false } },
+    });
+    expect(output.gates.ci.failingChecks).toContain("E2E / PR Gate: final evidence changed");
+  });
+
+  it.each([
+    {
+      condition: "fails",
+      status: "COMPLETED",
+      conclusion: "FAILURE",
+      resultField: "failingChecks",
+      expected: "Repository policy: FAILURE",
+    },
+    {
+      condition: "remains pending",
+      status: "IN_PROGRESS",
+      conclusion: undefined,
+      resultField: "pendingChecks",
+      expected: "Repository policy",
+    },
+  ])("rejects a non-required repository check that $condition after final E2E evidence", ({
+    status,
+    conclusion,
+    resultField,
+    expected,
+  }) => {
+    const result = runGateWithCoordinator({
+      additionalChecksAfterE2eEvidence: [
+        {
+          __typename: "CheckRun",
+          name: "Repository policy",
+          detailsUrl: "https://github.com/NVIDIA/NemoClaw/runs/99001",
+          startedAt: "2026-01-01T00:02:40Z",
+          completedAt: status === "COMPLETED" ? "2026-01-01T00:02:50Z" : undefined,
+          status,
+          conclusion,
+        },
+      ],
+    });
+    const output = JSON.parse(result.stdout);
+
+    expect(output).toMatchObject({
+      allPass: false,
+      gates: { ci: { pass: false } },
+    });
+    expect(output.gates.ci[resultField]).toContain(expected);
+  });
+
+  it("rejects a changed passing required-check record during final observation", () => {
+    const result = runGateWithCoordinator({
+      finalCheckOverrides: {
+        checks: { startedAt: "2026-01-01T00:00:01Z" },
+      },
+    });
+    const output = JSON.parse(result.stdout);
+
+    expect(output).toMatchObject({
+      allPass: false,
+      gates: { ci: { pass: false } },
+    });
+    expect(output.gates.ci.failingChecks).toContain(
+      "Required check rollup changed during gate evaluation",
+    );
+  });
+
+  it("rejects a required check that fails during final observation", () => {
+    const result = runGateWithCoordinator({
+      finalCheckOverrides: {
+        checks: { conclusion: "FAILURE" },
+      },
+    });
+    const output = JSON.parse(result.stdout);
+
+    expect(output).toMatchObject({
+      allPass: false,
+      gates: { ci: { pass: false } },
+    });
+    expect(output.gates.ci.failingChecks).toContain("checks: FAILURE");
+  });
+
+  it("rejects a required check that becomes pending during final observation", () => {
+    const result = runGateWithCoordinator({
+      finalCheckOverrides: {
+        checks: { conclusion: undefined, status: "IN_PROGRESS" },
+      },
+    });
+    const output = JSON.parse(result.stdout);
+
+    expect(output).toMatchObject({
+      allPass: false,
+      gates: { ci: { pass: false } },
+    });
+    expect(output.gates.ci.pendingChecks).toContain("checks");
+  });
+
+  it("rejects a workflow-run inventory at the 1,000-result cap", () => {
+    const cappedIds = Array.from({ length: 1_000 }, (_value, index) => 30_000 + index);
+    const result = runGateWithCoordinator({
+      coordinatorRunPartitions: [
+        {
+          createdRange: DEFAULT_COORDINATOR_RANGES[0],
+          runPages: paginatedRunIds(cappedIds),
+          totalCount: 1_000,
+          fallbackCreatedAt: "2025-12-31T06:00:00Z",
+        },
+        {
+          createdRange: DEFAULT_COORDINATOR_RANGES[1],
+          runPages: [[]],
+        },
+        {
+          createdRange: DEFAULT_COORDINATOR_RANGES[2],
+          runPages: [[9500]],
+        },
+      ],
+    });
+    const output = JSON.parse(result.stdout);
+
+    expect(output).toMatchObject({
+      allPass: false,
+      gates: { ci: { pass: false } },
+    });
+    expect(output.gates.ci.failingChecks).toContain(
+      "E2E / PR Gate: latest attempt evidence incomplete",
+    );
+  });
+
+  const rejectedCoordinatorEvidence: Array<
+    CoordinatorFixture & {
+      condition: string;
+    }
+  > = [
+    {
+      condition: "an inclusive boundary repeats changed metadata for the same run",
+      coordinator: { createdAt: "2026-01-01T00:00:00Z" },
+      coordinatorRunPartitions: [
+        {
+          createdRange: DEFAULT_COORDINATOR_RANGES[0],
+          runPages: [[]],
+        },
+        {
+          createdRange: DEFAULT_COORDINATOR_RANGES[1],
+          runPages: [[9500]],
+        },
+        {
+          createdRange: DEFAULT_COORDINATOR_RANGES[2],
+          runPages: [[9500]],
+          runOverrides: {
+            "9500": { updatedAt: "2026-01-01T00:02:33Z" },
+          },
+        },
+      ],
+    },
+    {
+      condition: "the same run appears outside adjacent partition boundaries",
+      coordinatorRunPartitions: [
+        {
+          createdRange: DEFAULT_COORDINATOR_RANGES[0],
+          runPages: [[10000]],
+          fallbackCreatedAt: "2025-12-31T06:00:00Z",
+        },
+        {
+          createdRange: DEFAULT_COORDINATOR_RANGES[1],
+          runPages: [[]],
+        },
+        {
+          createdRange: DEFAULT_COORDINATOR_RANGES[2],
+          runPages: [[10000, 9500]],
+          fallbackCreatedAt: "2026-01-01T00:01:00Z",
+        },
+      ],
+    },
+    {
+      condition: "coordinator metadata changes between inventory and detail reads",
+      coordinatorList: { updatedAt: "2026-01-01T00:02:33Z" },
+    },
+    {
+      condition: "a partition reports inconsistent totals across pages",
+      coordinatorRunPartitions: [
+        {
+          createdRange: DEFAULT_COORDINATOR_RANGES[0],
+          runPages: [[]],
+        },
+        {
+          createdRange: DEFAULT_COORDINATOR_RANGES[1],
+          runPages: [[]],
+        },
+        {
+          createdRange: DEFAULT_COORDINATOR_RANGES[2],
+          runPages: [[9500], []],
+          pageTotalCounts: [1, 2],
+        },
+      ],
+    },
+    {
+      condition: "the custom check has no coordinator",
+      coordinatorRunPages: [[]],
+    },
+    {
+      condition: "two coordinator runs enclose the current custom check",
+      coordinatorRunPages: [[9500, 9501]],
+      extraRuns: { "9501": e2eCoordinatorRun() },
+    },
+    {
+      condition: "older same-revision coordinator metadata is malformed",
+      coordinatorRunPages: [[9501, 9500]],
+      extraRuns: {
+        "9501": {
+          ...historicalCoordinatorRun(),
+          repository: "example/NemoClaw",
+        },
+      },
+    },
+    {
+      condition: "an older same-revision coordinator run failed",
+      coordinatorRunPages: [[9501, 9500]],
+      extraRuns: {
+        "9501": {
+          ...historicalCoordinatorRun(),
+          conclusion: "failure",
+        },
+      },
+    },
+    {
+      condition: "an older same-revision coordinate job failed",
+      coordinatorRunPages: [[9501, 9500]],
+      extraRuns: {
+        "9501": {
+          ...historicalCoordinatorRun(),
+          jobs: coordinatorJobs({
+            conclusion: "failure",
+            startedAt: "2026-01-01T00:00:20Z",
+            completedAt: "2026-01-01T00:00:59Z",
+          }),
+        },
+      },
+    },
+    {
+      condition: "an older same-revision coordinate job completes after its run",
+      coordinatorRunPages: [[9501, 9500]],
+      extraRuns: {
+        "9501": {
+          ...historicalCoordinatorRun(),
+          jobs: coordinatorJobs({
+            startedAt: "2026-01-01T00:00:20Z",
+            completedAt: "2026-01-01T00:01:01Z",
+          }),
+        },
+      },
+    },
+    {
+      condition: "a failed same-revision coordinator overlaps the current custom check",
+      coordinatorRunPages: [[9501, 9500]],
+      extraRuns: {
+        "9501": e2eCoordinatorRun("failure", coordinatorJobs({ conclusion: "failure" })),
+      },
+    },
+    {
+      condition: "the coordinator title does not match",
+      coordinator: { displayTitle: "E2E Gate coordinate from another workflow" },
+    },
+    {
+      condition: "the coordinator title names another PR head",
+      coordinator: {
+        displayTitle:
+          "E2E Gate coordinate from CI PR #42 head " +
+          "c".repeat(40) +
+          " base " +
+          BASE_SHA +
+          " gate true",
+      },
+    },
+    {
+      condition: "the coordinator title names another PR base",
+      coordinator: {
+        displayTitle:
+          "E2E Gate coordinate from CI PR #42 head " +
+          HEAD_SHA +
+          " base " +
+          "c".repeat(40) +
+          " gate true",
+      },
+    },
+    {
+      condition: "the coordinator title sets gate false",
+      coordinator: {
+        displayTitle:
+          "E2E Gate coordinate from CI PR #42 head " +
+          HEAD_SHA +
+          " base " +
+          BASE_SHA +
+          " gate false",
+      },
+    },
+    {
+      condition: "the coordinator uses another event",
+      coordinator: { event: "pull_request_target" },
+    },
+    {
+      condition: "the coordinator uses another workflow path",
+      coordinator: { path: ".github/workflows/pr.yaml" },
+    },
+    {
+      condition: "the coordinator runs on another branch",
+      coordinator: { headBranch: "release" },
+    },
+    {
+      condition: "the coordinator head commit SHA is malformed",
+      coordinator: { headSha: "not-a-sha" },
+    },
+    {
+      condition: "the coordinator commit SHA does not match the captured base SHA",
+      coordinator: { headSha: "d".repeat(40) },
+    },
+    {
+      condition: "the coordinator belongs to another repository",
+      coordinator: { repository: "example/NemoClaw" },
+    },
+    {
+      condition: "the coordinator head belongs to another repository",
+      coordinator: { headRepository: "example/NemoClaw" },
+    },
+    {
+      condition: "the coordinator uses another attempt",
+      coordinator: { attempt: 2 },
+    },
+    {
+      condition: "the coordinator run is not completed",
+      coordinator: { status: "in_progress", conclusion: null },
+    },
+    {
+      condition: "the coordinator run has a non-success conclusion",
+      coordinator: { conclusion: "neutral" },
+    },
+    {
+      condition: "the coordinator run failed",
+      coordinator: { conclusion: "failure" },
+    },
+    {
+      condition: "the coordinator has no coordinate job",
+      coordinatorJobs: coordinatorJobs().filter((job) => job.name !== "coordinate"),
+    },
+    {
+      condition: "the coordinator has duplicate coordinate jobs",
+      coordinatorJobs: [
+        ...coordinatorJobs(),
+        {
+          ...coordinatorJobs().find((job) => job.name === "coordinate")!,
+          id: 954,
+        },
+      ],
+    },
+    {
+      condition: "the coordinator job has another name",
+      coordinatorJobs: coordinatorJobs({ name: "finish" }),
+    },
+    {
+      condition: "the coordinate job is not completed",
+      coordinatorJobs: coordinatorJobs({ status: "in_progress", conclusion: null }),
+    },
+    {
+      condition: "the coordinate job failed",
+      coordinatorJobs: coordinatorJobs({ conclusion: "failure" }),
+    },
+    {
+      condition: "the coordinate job has no started_at timestamp",
+      coordinatorJobs: coordinatorJobs({ omitStartedAt: true }),
+    },
+    {
+      condition: "the coordinate job has no completed_at timestamp",
+      coordinatorJobs: coordinatorJobs({ omitCompletedAt: true }),
+    },
+    {
+      condition: "the coordinate job started_at timestamp is null",
+      coordinatorJobs: coordinatorJobs({ startedAt: null }),
+    },
+    {
+      condition: "the coordinate job completed_at timestamp is null",
+      coordinatorJobs: coordinatorJobs({ completedAt: null }),
+    },
+    {
+      condition: "the coordinate job started_at timestamp is malformed",
+      coordinatorJobs: coordinatorJobs({ startedAt: "not-a-time" }),
+    },
+    {
+      condition: "the coordinate job completed_at timestamp is malformed",
+      coordinatorJobs: coordinatorJobs({ completedAt: "not-a-time" }),
+    },
+    {
+      condition: "the coordinate job starts after it completes",
+      coordinatorJobs: coordinatorJobs({
+        startedAt: "2026-01-01T00:02:32Z",
+        completedAt: "2026-01-01T00:02:31Z",
+      }),
+    },
+    {
+      condition: "the coordinate job completes before custom check completion",
+      coordinatorJobs: coordinatorJobs({
+        completedAt: "2026-01-01T00:02:29Z",
+      }),
+    },
+    {
+      condition: "the coordinate job starts after custom check completion",
+      coordinatorJobs: coordinatorJobs({
+        startedAt: "2026-01-01T00:02:31Z",
+      }),
+    },
+    {
+      condition: "the coordinator run has no created_at timestamp",
+      coordinator: { omitCreatedAt: true },
+    },
+    {
+      condition: "the coordinator run has no updated_at timestamp",
+      coordinator: { omitUpdatedAt: true },
+    },
+    {
+      condition: "the coordinator run created_at timestamp is malformed",
+      coordinator: { createdAt: "not-a-time" },
+    },
+    {
+      condition: "the coordinator run updated_at timestamp is malformed",
+      coordinator: { updatedAt: "not-a-time" },
+    },
+    {
+      condition: "the coordinator run is updated before it is created",
+      coordinator: {
+        createdAt: "2026-01-01T00:02:33Z",
+        updatedAt: "2026-01-01T00:02:32Z",
+      },
+    },
+  ];
+
+  it.each(rejectedCoordinatorEvidence)("rejects terminal custom check evidence when $condition", ({
+    condition: _condition,
+    ...fixture
+  }) => {
+    const result = runGateWithCoordinator(fixture);
+    const output = JSON.parse(result.stdout);
+
+    expect(output).toMatchObject({
+      allPass: false,
+      gates: { ci: { pass: false } },
+    });
+    expect(output.gates.ci.failingChecks).toContain(
+      "E2E / PR Gate: latest attempt evidence incomplete",
+    );
+  });
+});
diff --git a/test/skills/check-gates-evidence.test.ts b/test/skills/check-gates-evidence.test.ts
index 2e8e2d13f16..69ff9621812 100644
--- a/test/skills/check-gates-evidence.test.ts
+++ b/test/skills/check-gates-evidence.test.ts
@@ -80,6 +80,25 @@ describe("maintainer merge-gate contributor compliance", () => {
     expect(output.allPass).toBe(false);
   });
 
+  it("fails closed when the base branch changes during gate evaluation", () => {
+    const finalCurrentBaseSha = "c".repeat(40);
+    const output = JSON.parse(
+      runGate({
+        body: "Signed-off-by: Example User <user@example.com>",
+        verified: true,
+        finalCurrentBaseSha,
+      }).stdout,
+    );
+
+    expect(output.gates.conflicts).toMatchObject({
+      pass: false,
+      details: "The base SHA changed during gate evaluation. Rerun the gate checker.",
+      baseSha: BASE_SHA,
+      currentBaseSha: finalCurrentBaseSha,
+    });
+    expect(output.allPass).toBe(false);
+  });
+
   it("fails closed while GitHub has not determined mergeability", () => {
     const result = runGate({
       body: "Signed-off-by: Example User <user@example.com>",
@@ -139,12 +158,12 @@ describe("maintainer merge-gate contributor compliance", () => {
     expect(output.allPass).toBe(false);
   });
 
-  it("makes the PR revision snapshot the final remote read", () => {
+  it("performs no remote read after the final PR snapshot", () => {
     const output = JSON.parse(
       runGate({
         body: "Signed-off-by: Example User <user@example.com>",
         verified: true,
-        finalPrAfterCurrentBase: { headRefOid: "c".repeat(40) },
+        finalPrAfterFinalCi: { headRefOid: "c".repeat(40) },
       }).stdout,
     );
 
@@ -542,7 +561,10 @@ describe("maintainer merge-gate contributor compliance", () => {
 
     expect(output.gates.ci).toMatchObject({
       pass: false,
-      failingChecks: ["E2E / PR Gate: latest attempt evidence incomplete"],
+      failingChecks: [
+        "E2E / PR Gate: latest attempt evidence incomplete",
+        "initialize: latest attempt evidence incomplete",
+      ],
     });
   });
 
@@ -897,31 +919,41 @@ describe("maintainer merge-gate contributor compliance", () => {
     });
   });
   it("uses an envelope-bound E2E run when a later association-less label run is skipped", () => {
-    const result = runGate(
-      e2eRunFixture(
-        [
-          [400, 40, "SUCCESS"],
-          [401, 41, "SKIPPED"],
-        ],
-        {
-          "400": {
-            ...exactDiffGateRun("success", [{ id: 40, name: "E2E / PR Gate" }]),
-            pullRequests: [],
-            createdAt: "2026-01-01T00:01:00Z",
-            updatedAt: "2026-01-01T00:03:00Z",
-          },
-          "401": {
-            ...exactDiffGateRun("skipped", [
-              { id: 41, name: "E2E / PR Gate", conclusion: "skipped" },
-            ]),
-            pullRequests: [],
-            createdAt: "2026-01-01T00:04:00Z",
-            updatedAt: "2026-01-01T00:05:00Z",
-            displayTitle: `E2E Gate PR #42 head ${HEAD_SHA} base ${BASE_SHA} gate false`,
-          },
+    const fixture = e2eRunFixture(
+      [
+        [400, 40, "SUCCESS"],
+        [401, 41, "SKIPPED"],
+      ],
+      {
+        "400": {
+          ...exactDiffGateRun("success", [
+            { id: 40, name: "E2E / PR Gate" },
+            {
+              id: 42,
+              name: "initialize",
+              startedAt: "2026-01-01T00:01:00Z",
+              completedAt: "2026-01-01T00:03:00Z",
+            },
+          ]),
+          pullRequests: [],
+          createdAt: "2026-01-01T00:01:00Z",
+          updatedAt: "2026-01-01T00:03:00Z",
         },
-      ),
+        "401": {
+          ...exactDiffGateRun("skipped", [
+            { id: 41, name: "E2E / PR Gate", conclusion: "skipped" },
+          ]),
+          pullRequests: [],
+          createdAt: "2026-01-01T00:04:00Z",
+          updatedAt: "2026-01-01T00:05:00Z",
+          displayTitle: `E2E Gate PR #42 head ${HEAD_SHA} base ${BASE_SHA} gate false`,
+        },
+      },
     );
+    const result = runGate({
+      ...fixture,
+      statusChecks: fixture.statusChecks?.filter((check) => check.name !== "initialize"),
+    });
 
     expect(JSON.parse(result.stdout)).toMatchObject({
       allPass: true,
@@ -1024,7 +1056,7 @@ describe("maintainer merge-gate contributor compliance", () => {
       failingChecks: INCOMPLETE_E2E,
     });
   });
-  it("keeps substantive PR CI ahead of a later metadata-only edit run", () => {
+  it("retains failing CI from a code-changing PR run after a later metadata-only run is canceled", () => {
     const checkRun = (
       name: string,
       runId: number,
@@ -1061,7 +1093,7 @@ describe("maintainer merge-gate contributor compliance", () => {
           true,
         ),
         "801": prWorkflowRun(
-          "success",
+          "cancelled",
           prWorkflowJobs("skipped", {
             checks: { conclusion: "success" },
             changes: { conclusion: "skipped" },
diff --git a/test/skills/check-gates-final-snapshot.test.ts b/test/skills/check-gates-final-snapshot.test.ts
new file mode 100644
index 00000000000..fff04fd17b6
--- /dev/null
+++ b/test/skills/check-gates-final-snapshot.test.ts
@@ -0,0 +1,65 @@
+// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { describe, expect, it } from "vitest";
+import { runGate, successfulRequiredChecks } from "./check-gates-test-fixtures.ts";
+
+describe("maintainer merge-gate final PR snapshot", () => {
+  it("rejects a required check that becomes pending in the final PR observation", () => {
+    const output = JSON.parse(
+      runGate({
+        body: "Signed-off-by: Example User <user@example.com>",
+        verified: true,
+        finalPrAfterFinalCi: {
+          statusCheckRollup: successfulRequiredChecks().map((check) =>
+            check.name === "checks"
+              ? { ...check, status: "IN_PROGRESS", conclusion: undefined }
+              : check,
+          ),
+        },
+      }).stdout,
+    );
+
+    expect(output.gates.ci).toMatchObject({ pass: false });
+    expect(output.gates.ci.pendingChecks).toContain("checks");
+    expect(output.allPass).toBe(false);
+  });
+
+  it.each([
+    ["the status rollup is incomplete", { finalStatusCheckHasNextPage: true }],
+    ["the status rollup belongs to another commit", { finalStatusCheckCommitOid: "c".repeat(40) }],
+    [
+      "the status rollup count does not match its returned contexts",
+      { finalStatusContextTotalCount: successfulRequiredChecks().length + 1 },
+    ],
+  ])("fails closed when %s in the final PR observation", (_condition, finalStatusFixture) => {
+    const output = JSON.parse(
+      runGate({
+        body: "Signed-off-by: Example User <user@example.com>",
+        verified: true,
+        ...finalStatusFixture,
+      }).stdout,
+    );
+
+    expect(output.gates.ci).toMatchObject({
+      pass: false,
+      details: "Unable to verify the final PR checks",
+    });
+    expect(output.allPass).toBe(false);
+  });
+
+  it("accepts a multi-commit PR when the final snapshot returns the PR commit SHA", () => {
+    const output = JSON.parse(
+      runGate({
+        body: "Signed-off-by: Example User <user@example.com>",
+        verified: true,
+        finalCommitTotalCount: 2,
+      }).stdout,
+    );
+
+    expect(output).toMatchObject({
+      allPass: true,
+      gates: { ci: { pass: true } },
+    });
+  });
+});
diff --git a/test/skills/check-gates-fork-evidence.test.ts b/test/skills/check-gates-fork-evidence.test.ts
index 4c65a859aa7..38c38892054 100644
--- a/test/skills/check-gates-fork-evidence.test.ts
+++ b/test/skills/check-gates-fork-evidence.test.ts
@@ -196,7 +196,10 @@ describe("maintainer merge-gate fork evidence", () => {
 
     expect(output.gates.ci).toMatchObject({
       pass: false,
-      failingChecks: ["E2E / PR Gate: latest attempt evidence incomplete"],
+      failingChecks: [
+        "E2E / PR Gate: latest attempt evidence incomplete",
+        "initialize: latest attempt evidence incomplete",
+      ],
     });
   });
 });
diff --git a/test/skills/check-gates-retry-history.test.ts b/test/skills/check-gates-retry-history.test.ts
index 53ace525fd7..d873f8abaa1 100644
--- a/test/skills/check-gates-retry-history.test.ts
+++ b/test/skills/check-gates-retry-history.test.ts
@@ -22,7 +22,21 @@ function retryableFailure(id: number, reason: string, title = "Retryable E2E fai
 }
 
 function gateOutput(checkRuns: unknown[]) {
-  const currentCheckId = Math.max(...checkRuns.map((check) => (check as { id: number }).id));
+  const orderedCheckIds = checkRuns
+    .map((check) => (check as { id: number }).id)
+    .sort((left, right) => left - right);
+  const timingWindowStart = Date.parse("2026-01-01T00:01:31Z");
+  const slotDuration = 60_000 / orderedCheckIds.length;
+  const checkRunsWithTiming = checkRuns.map((check) => {
+    const record = check as Record<string, unknown> & { id: number };
+    const position = orderedCheckIds.indexOf(record.id);
+    return {
+      ...record,
+      started_at: new Date(timingWindowStart + position * slotDuration).toISOString(),
+      completed_at: new Date(timingWindowStart + (position + 1) * slotDuration).toISOString(),
+    };
+  });
+  const currentCheckId = orderedCheckIds.at(-1)!;
   return JSON.parse(
     runGate({
       body: SIGNED_BODY,
@@ -35,7 +49,9 @@ function gateOutput(checkRuns: unknown[]) {
             }
           : check,
       ),
-      coordinationCheckPages: [{ total_count: checkRuns.length, check_runs: checkRuns }],
+      coordinationCheckPages: [
+        { total_count: checkRunsWithTiming.length, check_runs: checkRunsWithTiming },
+      ],
     }).stdout,
   );
 }
@@ -43,7 +59,10 @@ function gateOutput(checkRuns: unknown[]) {
 function expectIncompleteEvidence(checkRuns: unknown[]) {
   expect(gateOutput(checkRuns).gates.ci).toMatchObject({
     pass: false,
-    failingChecks: ["E2E / PR Gate: latest attempt evidence incomplete"],
+    failingChecks: [
+      "E2E / PR Gate: latest attempt evidence incomplete",
+      "initialize: latest attempt evidence incomplete",
+    ],
   });
 }
 
@@ -58,6 +77,15 @@ describe("maintainer merge-gate E2E retry history", () => {
     expect(output).toMatchObject({ allPass: true, gates: { ci: { pass: true } } });
   });
 
+  it("accepts retry history with more than 60 completed checks", () => {
+    const retryHistory = Array.from({ length: 61 }, (_value, index) =>
+      retryableFailure(8001 + index, "prerequisite-ci"),
+    );
+    const output = gateOutput([coordinationCheck({ id: 8062 }), ...retryHistory]);
+
+    expect(output).toMatchObject({ allPass: true, gates: { ci: { pass: true } } });
+  });
+
   it.each([
     ["an older success", [coordinationCheck({ id: 8002 }), coordinationCheck({ id: 8001 })]],
     [
diff --git a/test/skills/check-gates-test-fixtures.ts b/test/skills/check-gates-test-fixtures.ts
index e7f9a3cc495..d2c0b113b87 100644
--- a/test/skills/check-gates-test-fixtures.ts
+++ b/test/skills/check-gates-test-fixtures.ts
@@ -50,6 +50,10 @@ interface ActionJobFixture {
   name: string;
   status?: string;
   conclusion?: string | null;
+  startedAt?: string | null;
+  completedAt?: string | null;
+  omitStartedAt?: boolean;
+  omitCompletedAt?: boolean;
 }
 
 interface ActionRunFixture {
@@ -62,11 +66,14 @@ interface ActionRunFixture {
   nextConclusion?: string | null;
   jobs?: ActionJobFixture[];
   jobPages?: ActionJobFixture[][];
-  createdAt?: string;
-  updatedAt?: string;
+  createdAt?: string | null;
+  updatedAt?: string | null;
+  omitCreatedAt?: boolean;
+  omitUpdatedAt?: boolean;
   headSha?: string;
   headBranch?: string;
   headRepository?: string;
+  repository?: string;
   pullRequestHeadSha?: string;
   pullRequests?: unknown[];
   baseSha?: string;
@@ -77,6 +84,20 @@ interface ActionRunFixture {
   conclusion?: string | null;
 }
 
+interface CoordinatorRunPartitionFixture {
+  createdRange: string;
+  runPages: number[][];
+  event?: "workflow_run" | "workflow_dispatch";
+  totalCount?: number;
+  pageTotalCounts?: number[];
+  fallbackCreatedAt?: string;
+  runOverrides?: Record<string, Partial<ActionRunFixture>>;
+  finalRunPages?: number[][];
+  finalTotalCount?: number;
+  finalPageTotalCounts?: number[];
+  finalRunOverrides?: Record<string, Partial<ActionRunFixture>>;
+}
+
 interface ComplianceFixture {
   body: string;
   checkConclusions?: Record<string, string>;
@@ -120,14 +141,28 @@ interface ComplianceFixture {
   mergeable?: string;
   mergeStateStatus?: string;
   currentBaseSha?: string | null;
+  finalCurrentBaseSha?: string | null;
+  files?: Array<{ path: string; status: string }>;
   verified: boolean;
   reason?: string;
   actionRunAttempts?: Record<string, ActionRunFixture>;
+  coordinatorListAttempts?: Record<string, ActionRunFixture>;
+  coordinatorRunPages?: number[][];
+  coordinatorRunPartitions?: CoordinatorRunPartitionFixture[];
   issueEventPages?: unknown[];
   coordinationCheckPages?: unknown[];
   formerCoordinationCheckPages?: unknown[];
+  finalCoordinationCheckPages?: unknown[];
+  finalFormerCoordinationCheckPages?: unknown[];
+  observationTime?: string;
   finalPr?: Record<string, unknown>;
   finalPrAfterCurrentBase?: Record<string, unknown>;
+  finalPrAfterCiEvidence?: Record<string, unknown>;
+  finalPrAfterFinalCi?: Record<string, unknown>;
+  finalCommitTotalCount?: number;
+  finalStatusContextTotalCount?: number;
+  finalStatusCheckCommitOid?: string;
+  finalStatusCheckHasNextPage?: boolean;
 }
 
 interface ComparatorFixture extends ComplianceFixture {
@@ -147,7 +182,7 @@ function successfulRequiredChecksWithoutE2e() {
 }
 
 function successfulRequiredChecks() {
-  return REQUIRED_CHECK_NAMES.map((name) => requiredCheck(name));
+  return [...REQUIRED_CHECK_NAMES.map((name) => requiredCheck(name)), initialE2eSeedCheck()];
 }
 
 function requiredCheck(name: string, conclusion = "SUCCESS") {
@@ -165,6 +200,30 @@ function requiredCheck(name: string, conclusion = "SUCCESS") {
   return e2eGateCheck([runId, jobId, conclusion, undefined, undefined, workflowName, name]);
 }
 
+function initialE2eSeedJobs(): ActionJobFixture[] {
+  return [
+    { id: 471, name: "cancel-superseded" },
+    { id: 472, name: "initialize" },
+    { id: 473, name: "coordinate", conclusion: "skipped" },
+  ].map((job) => ({
+    ...job,
+    startedAt: "2026-01-01T00:01:00Z",
+    completedAt: "2026-01-01T00:01:31Z",
+  }));
+}
+
+function initialE2eSeedCheck() {
+  return {
+    __typename: "CheckRun",
+    name: "initialize",
+    workflowName: "E2E / PR Gate Controller",
+    detailsUrl: "https://github.com/NVIDIA/NemoClaw/actions/runs/407/job/472",
+    startedAt: "2026-01-01T00:01:00Z",
+    status: "COMPLETED",
+    conclusion: "SUCCESS",
+  };
+}
+
 function e2eGateCheck(check: E2eCheckFixture, index = 0) {
   const [runId, jobId, conclusion, startedAt, detailsUrl, workflowName, name] = check;
   return {
@@ -201,6 +260,60 @@ function exactDiffGateRun(result: string, jobs: ActionJobFixture[], attempt = 1)
   };
 }
 
+function e2eCoordinatorRun(
+  result = "success",
+  jobs: ActionJobFixture[] = [
+    {
+      id: 951,
+      name: "coordinate",
+      startedAt: "2026-01-01T00:02:00Z",
+      completedAt: "2026-01-01T00:02:31Z",
+    },
+    {
+      id: 952,
+      name: "initialize",
+      conclusion: "skipped",
+      startedAt: "2026-01-01T00:02:00Z",
+      completedAt: "2026-01-01T00:02:00Z",
+    },
+    {
+      id: 953,
+      name: "cancel-superseded",
+      conclusion: "skipped",
+      startedAt: "2026-01-01T00:02:00Z",
+      completedAt: "2026-01-01T00:02:00Z",
+    },
+  ],
+): ActionRunFixture {
+  return {
+    attempt: 1,
+    createdAt: "2026-01-01T00:02:00Z",
+    updatedAt: "2026-01-01T00:02:32Z",
+    headSha: BASE_SHA,
+    headBranch: "main",
+    headRepository: "NVIDIA/NemoClaw",
+    repository: "NVIDIA/NemoClaw",
+    pullRequests: [],
+    displayTitle: `E2E Gate coordinate from CI PR #42 head ${HEAD_SHA} base ${BASE_SHA} gate true`,
+    event: "workflow_run",
+    path: ".github/workflows/pr-e2e-gate.yaml",
+    status: "completed",
+    conclusion: result,
+    jobs,
+  };
+}
+
+function e2eManualCoordinatorRun(
+  result = "success",
+  jobs: ActionJobFixture[] = e2eCoordinatorRun().jobs ?? [],
+): ActionRunFixture {
+  return {
+    ...e2eCoordinatorRun(result, jobs),
+    displayTitle: `E2E Gate approve PR #42 head ${HEAD_SHA} base ${BASE_SHA}`,
+    event: "workflow_dispatch",
+  };
+}
+
 function installerHashRun(
   result: string,
   jobs: ActionJobFixture[],
@@ -267,20 +380,29 @@ function runGate(fixture: ComplianceFixture) {
   const bin = path.join(tmp, "bin");
   fs.mkdirSync(bin);
   const ghPath = path.join(bin, "gh");
+  const clockPath = path.join(tmp, "clock.mjs");
+  const observationTime =
+    fixture.observationTime ??
+    fixture.coordinatorRunPartitions?.at(-1)?.createdRange.split("..")[1] ??
+    "2026-01-01T00:03:00Z";
+  fs.writeFileSync(clockPath, `Date.now = () => ${Date.parse(observationTime)};\n`);
 
   const headRepository = fixture.headRepository ?? "NVIDIA/NemoClaw";
   const [headRepositoryOwner, headRepositoryName] = headRepository.split("/");
+  const defaultStatusChecks: NonNullable<ComplianceFixture["statusChecks"]> =
+    fixture.checkNames === undefined
+      ? successfulRequiredChecks().map((check) => {
+          const conclusion = fixture.checkConclusions?.[check.name];
+          return conclusion === undefined ? check : { ...check, conclusion };
+        })
+      : fixture.checkNames.map((name) => requiredCheck(name, fixture.checkConclusions?.[name]));
   const pr = {
     number: 42,
     title: "fix(policy): align maintainer workflow",
     url: "https://github.com/NVIDIA/NemoClaw/pull/42",
     body: fixture.body,
-    files: [],
-    statusCheckRollup:
-      fixture.statusChecks ??
-      (fixture.checkNames ?? REQUIRED_CHECK_NAMES).map((name) =>
-        requiredCheck(name, fixture.checkConclusions?.[name]),
-      ),
+    files: fixture.files ?? [],
+    statusCheckRollup: fixture.statusChecks ?? defaultStatusChecks,
     mergeable: fixture.mergeable ?? "MERGEABLE",
     mergeStateStatus: fixture.mergeStateStatus ?? "CLEAN",
     state: "OPEN",
@@ -300,6 +422,14 @@ function runGate(fixture: ComplianceFixture) {
   };
   const finalPr = { ...pr, ...fixture.finalPr };
   const finalPrAfterCurrentBase = { ...finalPr, ...fixture.finalPrAfterCurrentBase };
+  const finalPrAfterCiEvidence = {
+    ...finalPrAfterCurrentBase,
+    ...fixture.finalPrAfterCiEvidence,
+  };
+  const finalPrAfterFinalCi = {
+    ...finalPrAfterCiEvidence,
+    ...fixture.finalPrAfterFinalCi,
+  };
   const contributorCommitPages = (
     fixture.contributorCommitPages ?? [
       [
@@ -359,6 +489,60 @@ function runGate(fixture: ComplianceFixture) {
       },
     },
   });
+  const finalCurrentBaseSha =
+    fixture.finalCurrentBaseSha === undefined
+      ? fixture.currentBaseSha
+      : fixture.finalCurrentBaseSha;
+  const finalStatusCheckNodes = finalPrAfterFinalCi.statusCheckRollup.map(
+    ({ workflowName, ...check }) => ({
+      ...check,
+      ...(workflowName
+        ? { checkSuite: { workflowRun: { workflow: { name: workflowName } } } }
+        : {}),
+    }),
+  );
+  const finalPrSnapshotOutput = JSON.stringify({
+    data: {
+      repository: {
+        pullRequest: {
+          title: finalPrAfterFinalCi.title,
+          body: finalPrAfterFinalCi.body,
+          state: finalPrAfterFinalCi.state,
+          isDraft: finalPrAfterFinalCi.isDraft,
+          mergeable: finalPrAfterFinalCi.mergeable,
+          mergeStateStatus: finalPrAfterFinalCi.mergeStateStatus,
+          headRefOid: finalPrAfterFinalCi.headRefOid,
+          baseRefOid: finalPrAfterFinalCi.baseRefOid,
+          headRefName: finalPrAfterFinalCi.headRefName,
+          baseRefName: finalPrAfterFinalCi.baseRefName,
+          headRepository: finalPrAfterFinalCi.headRepository,
+          headRepositoryOwner: finalPrAfterFinalCi.headRepositoryOwner,
+          baseRef:
+            finalCurrentBaseSha === null
+              ? null
+              : { target: { oid: finalCurrentBaseSha ?? BASE_SHA } },
+          commits: {
+            totalCount: fixture.finalCommitTotalCount ?? 1,
+            nodes: [
+              {
+                commit: {
+                  oid: fixture.finalStatusCheckCommitOid ?? finalPrAfterFinalCi.headRefOid,
+                  statusCheckRollup: {
+                    contexts: {
+                      totalCount:
+                        fixture.finalStatusContextTotalCount ?? finalStatusCheckNodes.length,
+                      pageInfo: { hasNextPage: fixture.finalStatusCheckHasNextPage ?? false },
+                      nodes: finalStatusCheckNodes,
+                    },
+                  },
+                },
+              },
+            ],
+          },
+        },
+      },
+    },
+  });
   const issueEventPages = fixture.issueEventPages ?? [[]];
   const coordinationCheckPages = fixture.coordinationCheckPages ?? [
     {
@@ -369,7 +553,10 @@ function runGate(fixture: ComplianceFixture) {
   const formerCoordinationCheckPages = fixture.formerCoordinationCheckPages ?? [
     { total_count: 0, check_runs: [] },
   ];
-  const actionRunCases = Object.entries({
+  const finalCoordinationCheckPages = fixture.finalCoordinationCheckPages ?? coordinationCheckPages;
+  const finalFormerCoordinationCheckPages =
+    fixture.finalFormerCoordinationCheckPages ?? formerCoordinationCheckPages;
+  const actionRunFixtures: Record<string, ActionRunFixture> = {
     "90": prWorkflowRun(
       "success",
       [
@@ -392,50 +579,78 @@ function runGate(fixture: ComplianceFixture) {
       path: ".github/workflows/dco-check.yaml",
     },
     "94": exactDiffGateRun("success", [{ id: 1, name: "E2E / PR Gate" }]),
+    "407": {
+      ...exactDiffGateRun("success", initialE2eSeedJobs()),
+      createdAt: "2026-01-01T00:01:00Z",
+      updatedAt: "2026-01-01T00:01:31Z",
+      headRepository,
+      pullRequests: [],
+    },
+    "9500": e2eCoordinatorRun(),
     ...fixture.actionRunAttempts,
-  })
+  };
+  const actionRunData = (runId: string, value: ActionRunFixture): Record<string, unknown> => ({
+    id: Number(runId),
+    run_attempt: value.attempt,
+    ...(value.omitCreatedAt
+      ? {}
+      : {
+          created_at: value.createdAt === undefined ? "2026-01-01T00:01:00Z" : value.createdAt,
+        }),
+    ...(value.omitUpdatedAt
+      ? {}
+      : {
+          updated_at: value.updatedAt === undefined ? "2026-01-01T00:03:00Z" : value.updatedAt,
+        }),
+    event: value.event,
+    path: value.path,
+    status: value.status,
+    conclusion: value.conclusion,
+    display_title: value.displayTitle,
+    repository: { full_name: value.repository ?? "NVIDIA/NemoClaw" },
+    ...(value.headSha ? { head_sha: value.headSha } : {}),
+    ...(value.headBranch ? { head_branch: value.headBranch } : {}),
+    ...(value.headRepository ? { head_repository: { full_name: value.headRepository } } : {}),
+    ...(value.pullRequests !== undefined
+      ? { pull_requests: value.pullRequests }
+      : value.headSha
+        ? {
+            pull_requests: value.baseSha
+              ? [
+                  {
+                    number: 42,
+                    head: { sha: value.pullRequestHeadSha ?? value.headSha },
+                    base: { sha: value.baseSha },
+                  },
+                ]
+              : [],
+          }
+        : {}),
+  });
+  const actionRunCases = Object.entries(actionRunFixtures)
     .flatMap(([runId, value]) => {
       const jobPages = (value.jobPages ?? [value.jobs ?? []]).map((page) =>
-        page.map((job) => ({
+        page.map(({ startedAt, completedAt, omitStartedAt, omitCompletedAt, ...job }) => ({
           ...job,
           status: job.status ?? "completed",
           conclusion: job.conclusion === undefined ? "success" : job.conclusion,
+          ...(omitStartedAt
+            ? {}
+            : { started_at: startedAt === undefined ? "2026-01-01T00:01:00Z" : startedAt }),
+          ...(omitCompletedAt
+            ? {}
+            : {
+                completed_at: completedAt === undefined ? "2026-01-01T00:03:00Z" : completedAt,
+              }),
         })),
       );
       const jobs = jobPages.flat();
-      const runData = {
-        run_attempt: value.attempt,
-        created_at: value.createdAt ?? "2026-01-01T00:01:00Z",
-        updated_at: value.updatedAt ?? "2026-01-01T00:03:00Z",
-        event: value.event,
-        path: value.path,
-        status: value.status,
-        conclusion: value.conclusion,
-        display_title: value.displayTitle,
-        ...(value.headSha ? { head_sha: value.headSha } : {}),
-        ...(value.headBranch ? { head_branch: value.headBranch } : {}),
-        ...(value.headRepository ? { head_repository: { full_name: value.headRepository } } : {}),
-        ...(value.pullRequests !== undefined
-          ? { pull_requests: value.pullRequests }
-          : value.headSha
-            ? {
-                pull_requests: value.baseSha
-                  ? [
-                      {
-                        number: 42,
-                        head: { sha: value.pullRequestHeadSha ?? value.headSha },
-                        base: { sha: value.baseSha },
-                      },
-                    ]
-                  : [],
-              }
-            : {}),
-      };
+      const runData = actionRunData(runId, value);
       const refreshedRunData = {
         ...runData,
         run_attempt: value.nextAttempt ?? value.attempt,
-        created_at: value.nextCreatedAt ?? runData.created_at,
-        updated_at: value.nextUpdatedAt ?? runData.updated_at,
+        ...(value.nextCreatedAt === undefined ? {} : { created_at: value.nextCreatedAt }),
+        ...(value.nextUpdatedAt === undefined ? {} : { updated_at: value.nextUpdatedAt }),
         display_title: value.nextDisplayTitle ?? runData.display_title,
         status: value.nextStatus ?? runData.status,
         conclusion: value.nextConclusion === undefined ? runData.conclusion : value.nextConclusion,
@@ -454,22 +669,125 @@ function runGate(fixture: ComplianceFixture) {
       ];
     })
     .join("\n");
+  const coordinatorRunPages = fixture.coordinatorRunPages ?? [[9500]];
+  const configuredCoordinatorRunPartitions = fixture.coordinatorRunPartitions ?? [
+    {
+      createdRange: "2025-12-31T00:00:00Z..2025-12-31T12:00:00Z",
+      runPages: [[]],
+    },
+    {
+      createdRange: "2025-12-31T12:00:00Z..2026-01-01T00:00:00Z",
+      runPages: [[]],
+    },
+    {
+      createdRange: "2026-01-01T00:00:00Z..2026-01-01T00:03:00Z",
+      runPages: coordinatorRunPages,
+    },
+  ];
+  const coordinatorRunPartitions = [...configuredCoordinatorRunPartitions];
+  const coordinatorCreatedRanges = [
+    ...new Set(configuredCoordinatorRunPartitions.map((partition) => partition.createdRange)),
+  ];
+  for (const event of ["workflow_run", "workflow_dispatch"] as const) {
+    for (const createdRange of coordinatorCreatedRanges) {
+      if (
+        !coordinatorRunPartitions.some(
+          (partition) =>
+            (partition.event ?? "workflow_run") === event &&
+            partition.createdRange === createdRange,
+        )
+      ) {
+        coordinatorRunPartitions.push({ createdRange, event, runPages: [[]] });
+      }
+    }
+  }
+  const coordinatorWorkflowRunCases = coordinatorRunPartitions
+    .map((partition, partitionIndex) => {
+      const fallbackCreatedAt =
+        partition.fallbackCreatedAt ?? partition.createdRange.split("..")[0];
+      const event = partition.event ?? "workflow_run";
+      const responsePages = (
+        runPages: number[][],
+        totalCount: number | undefined,
+        pageTotalCounts: number[] | undefined,
+        runOverrides: Record<string, Partial<ActionRunFixture>> | undefined,
+      ) => {
+        const partitionTotal = totalCount ?? runPages.flat().length;
+        return runPages.map((page, pageIndex) => ({
+          total_count: pageTotalCounts?.[pageIndex] ?? partitionTotal,
+          workflow_runs: page.map((runId) => {
+            const listedValue =
+              fixture.coordinatorListAttempts?.[String(runId)] ?? actionRunFixtures[String(runId)];
+            const value =
+              listedValue && runOverrides?.[String(runId)]
+                ? { ...listedValue, ...runOverrides[String(runId)] }
+                : listedValue;
+            return value
+              ? actionRunData(String(runId), value)
+              : {
+                  id: runId,
+                  created_at: fallbackCreatedAt,
+                  display_title: `unrelated workflow run ${runId}`,
+                  event,
+                };
+          }),
+        }));
+      };
+      const pages = responsePages(
+        partition.runPages,
+        partition.totalCount,
+        partition.pageTotalCounts,
+        partition.runOverrides,
+      );
+      const finalPages = responsePages(
+        partition.finalRunPages ?? partition.runPages,
+        partition.finalTotalCount ?? partition.totalCount,
+        partition.finalPageTotalCounts ?? partition.pageTotalCounts,
+        partition.finalRunOverrides ?? partition.runOverrides,
+      );
+      const projection =
+        "{total_count,workflow_runs:[.workflow_runs[]|{id,run_attempt,event,display_title,path," +
+        "head_branch,head_sha,status,conclusion,repository:{full_name:.repository.full_name}," +
+        "head_repository:{full_name:.head_repository.full_name},created_at,updated_at}]}";
+      const query =
+        "api --paginate --jq " +
+        projection +
+        " repos/NVIDIA/NemoClaw/actions/workflows/pr-e2e-gate.yaml/runs?event=" +
+        event +
+        "&created=" +
+        encodeURIComponent(partition.createdRange) +
+        "&per_page=100";
+      const marker = path.join(tmp, `coordinator-partition-${partitionIndex}-seen`);
+      const output = pages.map((page) => JSON.stringify(page)).join("\n");
+      const finalOutput = finalPages.map((page) => JSON.stringify(page)).join("\n");
+      return `  ${shellSingleQuote(query)}) if mkdir ${shellSingleQuote(marker)} 2>/dev/null; then printf '%s' ${shellSingleQuote(output)}; else printf '%s' ${shellSingleQuote(finalOutput)}; fi ;;`;
+    })
+    .join("\n");
+  const coordinationCheckMarker = path.join(tmp, "coordination-checks-seen");
+  const formerCoordinationCheckMarker = path.join(tmp, "former-coordination-checks-seen");
+  const finalPrReadMarker = path.join(tmp, "final-pr-read");
 
   fs.writeFileSync(
     ghPath,
     `#!/usr/bin/env bash
 set -euo pipefail
+if [ -d ${shellSingleQuote(finalPrReadMarker)} ]; then
+  echo "unexpected gh args after final PR read: $*" >&2
+  exit 9
+fi
 case "$*" in
-  "pr view"*) if mkdir ${shellSingleQuote(path.join(tmp, "pr-view-seen"))} 2>/dev/null; then printf '%s' ${shellSingleQuote(JSON.stringify(pr))}; elif [ -d ${shellSingleQuote(path.join(tmp, "current-base-seen"))} ]; then printf '%s' ${shellSingleQuote(JSON.stringify(finalPrAfterCurrentBase))}; else printf '%s' ${shellSingleQuote(JSON.stringify(finalPr))}; fi ;;
+  "pr view"*) if mkdir ${shellSingleQuote(path.join(tmp, "pr-view-seen"))} 2>/dev/null; then printf '%s' ${shellSingleQuote(JSON.stringify(pr))}; elif mkdir ${shellSingleQuote(path.join(tmp, "pr-before-final-ci-seen"))} 2>/dev/null; then printf '%s' ${shellSingleQuote(JSON.stringify(finalPrAfterCurrentBase))}; else printf '%s' ${shellSingleQuote(JSON.stringify(finalPrAfterCiEvidence))}; fi ;;
   *"ContributorCommits"*) printf '%s' ${shellSingleQuote(contributorCommitOutput)} ;;
   *"ContributorReviews"*) printf '%s' ${shellSingleQuote(contributorReviewOutput)} ;;
   *"CurrentBaseRef"*) mkdir -p ${shellSingleQuote(path.join(tmp, "current-base-seen"))}; printf '%s' ${shellSingleQuote(currentBaseOutput)} ;;
+  *"FinalPrSnapshot"*) mkdir -p ${shellSingleQuote(finalPrReadMarker)}; printf '%s' ${shellSingleQuote(finalPrSnapshotOutput)} ;;
   "api graphql"*) printf '%s' '{"data":{"repository":{"pullRequest":{"reviewThreads":{"nodes":[]}}}}}' ;;
   "api repos/NVIDIA/NemoClaw/issues/42/comments"*) printf '%s' '{"id":1,"body":"ordinary comment","user":{"login":"reviewer"},"updated_at":"2026-01-01T00:00:00Z"}' ;;
   "api repos/NVIDIA/NemoClaw/pulls/42/commits"*) printf '%s' ${shellSingleQuote(commitOutput)} ;;
   "api --paginate --slurp repos/NVIDIA/NemoClaw/issues/42/events?per_page=100") printf '%s' ${shellSingleQuote(JSON.stringify(issueEventPages))} ;;
-  "api --paginate --slurp repos/NVIDIA/NemoClaw/commits/${HEAD_SHA}/check-runs?check_name=E2E%20%2F%20PR%20Gate&filter=all&per_page=100") printf '%s' ${shellSingleQuote(JSON.stringify(coordinationCheckPages))} ;;
-  "api --paginate --slurp repos/NVIDIA/NemoClaw/commits/${HEAD_SHA}/check-runs?check_name=E2E%20%2F%20PR%20Gate%20Coordination&filter=all&per_page=100") printf '%s' ${shellSingleQuote(JSON.stringify(formerCoordinationCheckPages))} ;;
+  "api --paginate --slurp repos/NVIDIA/NemoClaw/commits/${HEAD_SHA}/check-runs?check_name=E2E%20%2F%20PR%20Gate&filter=all&per_page=100") if mkdir ${shellSingleQuote(coordinationCheckMarker)} 2>/dev/null; then printf '%s' ${shellSingleQuote(JSON.stringify(coordinationCheckPages))}; else printf '%s' ${shellSingleQuote(JSON.stringify(finalCoordinationCheckPages))}; fi ;;
+  "api --paginate --slurp repos/NVIDIA/NemoClaw/commits/${HEAD_SHA}/check-runs?check_name=E2E%20%2F%20PR%20Gate%20Coordination&filter=all&per_page=100") if mkdir ${shellSingleQuote(formerCoordinationCheckMarker)} 2>/dev/null; then printf '%s' ${shellSingleQuote(JSON.stringify(formerCoordinationCheckPages))}; else printf '%s' ${shellSingleQuote(JSON.stringify(finalFormerCoordinationCheckPages))}; fi ;;
+${coordinatorWorkflowRunCases}
 ${actionRunCases}
   *) echo "unexpected gh args: $*" >&2; exit 9 ;;
 esac
@@ -481,6 +799,8 @@ esac
     return spawnSync(
       process.execPath,
       [
+        "--import",
+        clockPath,
         "--experimental-strip-types",
         "--no-warnings",
         ".agents/skills/nemoclaw-maintainer-day/scripts/check-gates.ts",
@@ -563,6 +883,7 @@ export type {
   ActionRunFixture,
   ComparatorFixture,
   ComplianceFixture,
+  CoordinatorRunPartitionFixture,
   E2eCheckFixture,
 };
 export {
@@ -572,6 +893,8 @@ export {
   E2E_COORDINATION_EXTERNAL_ID,
   E2E_COORDINATION_NAME,
   e2eChecks,
+  e2eCoordinatorRun,
+  e2eManualCoordinatorRun,
   e2eGateCheck,
   e2eJobs,
   e2eRunFixture,