Sync upstream rust-v0.140.0

.codex/skills/babysit-pr/SKILL.md

@@ -28,7 +28,7 @@ Accept any of the following:
 3. Inspect the `actions` list in the JSON response.
 4. If `diagnose_ci_failure` is present, inspect failed run logs and classify the failure.
 5. If the failure is likely caused by the current branch, patch code locally, commit, and push. Do not patch random flaky tests, CI infrastructure, dependency outages, runner issues, or other failures that are unrelated to the branch.
-6. If `process_review_comment` is present, inspect surfaced review items and decide whether to address them.
+6. If `process_review_comment` is present, inspect surfaced published review items and decide whether to address them.
 7. If a review item is actionable and correct, patch code locally, commit, push, and then resolve the associated review thread only when allowed by the GitHub state mutation policy below.
 8. Do not post replies to human-authored review comments/threads unless the user explicitly confirms the exact response. If a human review item is non-actionable, already addressed, or not valid, surface the item and recommended response to the user instead of replying on GitHub.
 9. If the failure is likely flaky/unrelated and `retry_failed_checks` is present, rerun failed jobs with `--retry-failed-now`.
@@ -92,9 +92,13 @@ The watcher surfaces review items from:
 - Inline review comments
 - Review submissions (COMMENT / APPROVED / CHANGES_REQUESTED)
 
+Only act on published feedback. Ignore review submissions in GitHub's `PENDING` state and inline
+comments attached to those pending reviews. Do not mark pending review feedback as seen; it should
+be eligible to surface after the reviewer submits the review.
+
 It intentionally surfaces Codex reviewer bot feedback (for example comments/reviews from `chatgpt-codex-connector[bot]`) in addition to human reviewer feedback. Most unrelated bot noise should still be ignored.
 For safety, the watcher only auto-surfaces trusted human review authors (for example repo OWNER/MEMBER/COLLABORATOR, plus the authenticated operator) and approved review bots such as Codex.
-On a fresh watcher state file, existing pending review feedback may be surfaced immediately (not only comments that arrive after monitoring starts). This is intentional so already-open review comments are not missed.
+On a fresh watcher state file, existing unaddressed published review feedback may be surfaced immediately (not only comments that arrive after monitoring starts). This is intentional so already-open review comments are not missed.
 
 When you agree with a comment and it is actionable:
 

.codex/skills/babysit-pr/agents/openai.yaml

@@ -1,4 +1,4 @@
 interface:
   display_name: "PR Babysitter"
   short_description: "Watch PR review comments, CI, and merge conflicts"
-  default_prompt: "Babysit the current PR: monitor reviewer comments, CI, and merge-conflict status (prefer the watcher’s --watch mode for live monitoring); surface new review feedback before acting on CI or mergeability work, fix valid issues, push updates, and rerun flaky failures up to 3 times. Do not post replies to human-authored review comments unless the user explicitly confirms the exact response. Do not patch unrelated flaky tests, CI infrastructure, dependency outages, runner issues, or other failures that are not caused by the branch. Keep exactly one watcher session active for the PR (do not leave duplicate --watch terminals running). If you pause monitoring to patch review/CI feedback, restart --watch yourself immediately after the push in the same turn. If a watcher is still running and no strict stop condition has been reached, the task is still in progress: keep consuming watcher output and sending progress updates instead of ending the turn. Do not treat a green + mergeable PR as a terminal stop while it is still open; continue polling autonomously after any push/rerun so newly posted review comments are surfaced until a strict terminal stop condition is reached or the user interrupts."
+  default_prompt: "Babysit the current PR: monitor published reviewer comments, CI, and merge-conflict status (prefer the watcher’s --watch mode for live monitoring); ignore unpublished comments in pending GitHub reviews; surface new published review feedback before acting on CI or mergeability work, fix valid issues, push updates, and rerun flaky failures up to 3 times. Do not post replies to human-authored review comments unless the user explicitly confirms the exact response. Do not patch unrelated flaky tests, CI infrastructure, dependency outages, runner issues, or other failures that are not caused by the branch. Keep exactly one watcher session active for the PR (do not leave duplicate --watch terminals running). If you pause monitoring to patch review/CI feedback, restart --watch yourself immediately after the push in the same turn. If a watcher is still running and no strict stop condition has been reached, the task is still in progress: keep consuming watcher output and sending progress updates instead of ending the turn. Do not treat a green + mergeable PR as a terminal stop while it is still open; continue polling autonomously after any push/rerun so newly posted review comments are surfaced until a strict terminal stop condition is reached or the user interrupts."

.codex/skills/babysit-pr/references/github-api-notes.md

@@ -44,6 +44,9 @@ Reruns only failed jobs (and dependencies) for a workflow run.
 - Review submissions:
   - `gh api repos/{owner}/{repo}/pulls/<pr_number>/reviews?per_page=100`
 
+Use each inline comment's `pull_request_review_id` to find its parent review. Ignore parent reviews
+whose `state` is `PENDING`, along with their inline comments, until the review is submitted.
+
 ## JSON fields consumed by the watcher
 
 ### `gh pr view`

.codex/skills/babysit-pr/scripts/gh_pr_watch.py

@@ -452,11 +452,14 @@ def normalize_issue_comments(items):
     return out
 
 
-def normalize_review_comments(items):
+def normalize_review_comments(items, review_states):
     out = []
     for item in items:
         if not isinstance(item, dict):
             continue
+        review_id = str(item.get("pull_request_review_id") or "")
+        if review_states.get(review_id) == "PENDING":
+            continue
         line = item.get("line")
         if line is None:
             line = item.get("original_line")
@@ -481,6 +484,8 @@ def normalize_reviews(items):
     for item in items:
         if not isinstance(item, dict):
             continue
+        if str(item.get("state") or "").upper() == "PENDING":
+            continue
         out.append(
             {
                 "kind": "review",
@@ -534,16 +539,33 @@ def fetch_new_review_items(pr, state, fresh_state, authenticated_login=None):
     review_payload = gh_api_list_paginated(endpoints["review"], repo=repo)
 
     issue_items = normalize_issue_comments(issue_payload)
-    review_comment_items = normalize_review_comments(review_comment_payload)
+    review_states = {
+        str(item.get("id")): str(item.get("state") or "").upper()
+        for item in review_payload
+        if isinstance(item, dict) and item.get("id") not in (None, "")
+    }
+    pending_review_ids = {
+        review_id for review_id, review_state in review_states.items() if review_state == "PENDING"
+    }
+    pending_review_comment_ids = {
+        str(item.get("id"))
+        for item in review_comment_payload
+        if isinstance(item, dict)
+        and item.get("id") not in (None, "")
+        and str(item.get("pull_request_review_id") or "") in pending_review_ids
+    }
+    review_comment_items = normalize_review_comments(review_comment_payload, review_states)
     review_items = normalize_reviews(review_payload)
     all_items = issue_items + review_comment_items + review_items
 
     seen_issue = {str(x) for x in state.get("seen_issue_comment_ids") or []}
     seen_review_comment = {str(x) for x in state.get("seen_review_comment_ids") or []}
     seen_review = {str(x) for x in state.get("seen_review_ids") or []}
+    seen_review_comment.difference_update(pending_review_comment_ids)
+    seen_review.difference_update(pending_review_ids)
 
     # On a brand-new state file, surface existing review activity instead of
-    # silently treating it as seen. This avoids missing already-pending review
+    # silently treating it as seen. This avoids missing already-published review
     # feedback when monitoring starts after comments were posted.
 
     new_items = []

.codex/skills/babysit-pr/scripts/test_gh_pr_watch.py

@@ -118,6 +118,74 @@ def test_recommend_actions_prioritizes_review_comments():
     ]
 
 
+def test_pending_review_feedback_surfaces_only_after_publication(monkeypatch):
+    state = {
+        "seen_review_comment_ids": ["20"],
+        "seen_review_ids": ["10"],
+    }
+    review = {
+        "id": 10,
+        "user": {"login": "octocat"},
+        "author_association": "MEMBER",
+        "state": "PENDING",
+        "body": "Please rename this.",
+        "created_at": "2026-06-08T10:00:00Z",
+        "submitted_at": None,
+        "html_url": "https://github.com/openai/codex/pull/123#pullrequestreview-10",
+    }
+    review_comment = {
+        "id": 20,
+        "pull_request_review_id": 10,
+        "user": {"login": "octocat"},
+        "author_association": "MEMBER",
+        "body": "Please rename this.",
+        "created_at": "2026-06-08T10:00:00Z",
+        "path": "src/example.rs",
+        "line": 7,
+        "html_url": "https://github.com/openai/codex/pull/123#discussion_r20",
+    }
+
+    def fake_list(endpoint, **kwargs):
+        if endpoint.endswith("/issues/123/comments"):
+            return []
+        if endpoint.endswith("/pulls/123/comments"):
+            return [review_comment]
+        if endpoint.endswith("/pulls/123/reviews"):
+            return [review]
+        raise AssertionError(f"unexpected endpoint: {endpoint}")
+
+    monkeypatch.setattr(gh_pr_watch, "gh_api_list_paginated", fake_list)
+
+    assert (
+        gh_pr_watch.fetch_new_review_items(
+            sample_pr(),
+            state,
+            fresh_state=True,
+            authenticated_login="octocat",
+        )
+        == []
+    )
+    assert state["seen_review_comment_ids"] == []
+    assert state["seen_review_ids"] == []
+
+    review["state"] = "COMMENTED"
+    review["submitted_at"] = "2026-06-08T10:05:00Z"
+
+    published_items = gh_pr_watch.fetch_new_review_items(
+        sample_pr(),
+        state,
+        fresh_state=False,
+        authenticated_login="octocat",
+    )
+
+    assert {(item["kind"], item["id"]) for item in published_items} == {
+        ("review", "10"),
+        ("review_comment", "20"),
+    }
+    assert state["seen_review_comment_ids"] == ["20"]
+    assert state["seen_review_ids"] == ["10"]
+
+
 def test_run_watch_keeps_polling_open_ready_to_merge_pr(monkeypatch):
     sleeps = []
     events = []

.github/scripts/test_v8_canary_changes.py

@@ -0,0 +1,98 @@
+import subprocess
+import tempfile
+import unittest
+from pathlib import Path
+
+from v8_canary_changes import changed_files
+from v8_canary_changes import merge_base
+from v8_canary_changes import resolved_v8_version
+from v8_canary_changes import windows_source_required
+
+
+class V8CanaryChangesTest(unittest.TestCase):
+    def test_resolved_v8_version(self) -> None:
+        cargo_lock = b"""\
+[[package]]
+name = "other"
+version = "1.0.0"
+
+[[package]]
+name = "v8"
+version = "149.2.0"
+"""
+
+        self.assertEqual(resolved_v8_version(cargo_lock), "149.2.0")
+
+    def test_unrelated_cargo_manifest_change_does_not_require_source_build(
+        self,
+    ) -> None:
+        self.assertFalse(
+            windows_source_required(
+                {"codex-rs/Cargo.toml"},
+                "149.2.0",
+                "149.2.0",
+            )
+        )
+
+    def test_v8_version_change_requires_source_build(self) -> None:
+        self.assertTrue(windows_source_required(set(), "149.2.0", "150.0.0"))
+
+    def test_module_helper_change_requires_source_build(self) -> None:
+        self.assertTrue(
+            windows_source_required(
+                {".github/scripts/rusty_v8_module_bazel.py"},
+                "149.2.0",
+                "149.2.0",
+            )
+        )
+
+    def test_manual_dispatch_requires_source_build(self) -> None:
+        self.assertTrue(
+            windows_source_required(
+                set(),
+                "149.2.0",
+                "149.2.0",
+                force=True,
+            )
+        )
+
+    def test_changed_files_excludes_changes_made_only_on_base_branch(self) -> None:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            root = Path(temp_dir)
+            self.run_git(root, "init", "--initial-branch=main")
+            self.run_git(root, "config", "user.name", "Test User")
+            self.run_git(root, "config", "user.email", "test@example.com")
+
+            self.write_and_commit(root, "initial", "initial.txt")
+            common = self.run_git(root, "rev-parse", "HEAD")
+            self.run_git(root, "switch", "-c", "feature")
+            self.run_git(root, "switch", "main")
+            self.write_and_commit(root, "base-only", "base-only.txt")
+            base = self.run_git(root, "rev-parse", "HEAD")
+
+            self.run_git(root, "switch", "feature")
+            self.write_and_commit(root, "feature-only", "feature-only.txt")
+            head = self.run_git(root, "rev-parse", "HEAD")
+
+            self.assertEqual(
+                changed_files(base, head, root=root),
+                {"feature-only.txt"},
+            )
+            self.assertEqual(merge_base(base, head, root=root), common)
+
+    def write_and_commit(self, root: Path, contents: str, path: str) -> None:
+        (root / path).write_text(contents)
+        self.run_git(root, "add", path)
+        self.run_git(root, "commit", "-m", contents)
+
+    def run_git(self, root: Path, *args: str) -> str:
+        return subprocess.check_output(
+            ["git", *args],
+            cwd=root,
+            stderr=subprocess.PIPE,
+            text=True,
+        ).strip()
+
+
+if __name__ == "__main__":
+    unittest.main()

.github/scripts/v8_canary_changes.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+
+import argparse
+import subprocess
+import tomllib
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[2]
+WINDOWS_SOURCE_BUILD_PATHS = {
+    ".github/scripts/rusty_v8_bazel.py",
+    ".github/scripts/rusty_v8_module_bazel.py",
+    ".github/scripts/v8_canary_changes.py",
+    ".github/workflows/rusty-v8-release.yml",
+    ".github/workflows/v8-canary.yml",
+}
+
+
+def resolved_v8_version(cargo_lock: bytes) -> str:
+    versions = sorted(
+        {
+            package["version"]
+            for package in tomllib.loads(cargo_lock.decode())["package"]
+            if package["name"] == "v8"
+        }
+    )
+    if len(versions) != 1:
+        raise ValueError(f"expected exactly one resolved v8 version, found: {versions}")
+    return versions[0]
+
+
+def windows_source_required(
+    changed_files: set[str],
+    base_v8_version: str,
+    head_v8_version: str,
+    *,
+    force: bool = False,
+) -> bool:
+    return (
+        force
+        or base_v8_version != head_v8_version
+        or not changed_files.isdisjoint(WINDOWS_SOURCE_BUILD_PATHS)
+    )
+
+
+def git_output(*args: str, root: Path = ROOT) -> bytes:
+    return subprocess.check_output(["git", *args], cwd=root)
+
+
+def v8_version_at_revision(revision: str, *, root: Path = ROOT) -> str:
+    return resolved_v8_version(
+        git_output("show", f"{revision}:codex-rs/Cargo.lock", root=root)
+    )
+
+
+def merge_base(base: str, head: str, *, root: Path = ROOT) -> str:
+    return git_output("merge-base", base, head, root=root).decode().strip()
+
+
+def changed_files(base: str, head: str, *, root: Path = ROOT) -> set[str]:
+    output = git_output(
+        "diff",
+        "--name-only",
+        "--no-renames",
+        f"{base}...{head}",
+        root=root,
+    )
+    return set(output.decode().splitlines())
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--base")
+    parser.add_argument("--head")
+    parser.add_argument("--force", action="store_true")
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    if args.force:
+        required = True
+        reason = "manual workflow dispatch"
+    elif not args.base or not args.head:
+        raise SystemExit("--base and --head are required unless --force is set")
+    else:
+        files = changed_files(args.base, args.head)
+        base_version = v8_version_at_revision(merge_base(args.base, args.head))
+        head_version = v8_version_at_revision(args.head)
+        required = windows_source_required(files, base_version, head_version)
+        if base_version != head_version:
+            reason = f"v8 version changed from {base_version} to {head_version}"
+        else:
+            matched_paths = sorted(files & WINDOWS_SOURCE_BUILD_PATHS)
+            reason = (
+                ", ".join(matched_paths) if matched_paths else "no relevant changes"
+            )
+
+    print(f"windows_source_required={str(required).lower()}")
+    print(f"windows_source_reason={reason}")
+
+
+if __name__ == "__main__":
+    main()

.github/workflows/ci.yml

@@ -29,10 +29,15 @@ jobs:
       - name: Verify feature specs
         env:
           PR_BASE_REF: ${{ github.event.pull_request.base.ref }}
+          PR_HEAD_REF: ${{ github.event.pull_request.head.ref }}
         shell: bash
         run: |
           set -euo pipefail
           if [ "${GITHUB_EVENT_NAME}" = "pull_request" ]; then
+            if [[ "${PR_HEAD_REF}" == sync/upstream-* ]]; then
+              echo "Skipping feature spec verification for upstream sync branch ${PR_HEAD_REF}."
+              exit 0
+            fi
             git fetch --no-tags --depth=1 origin "+refs/heads/${PR_BASE_REF}:refs/remotes/origin/${PR_BASE_REF}"
             python3 .github/scripts/verify_feature_specs.py --base "origin/${PR_BASE_REF}" --head HEAD
           else