From 158635198e8fc8b158c61935ac3dd972d2f32272 Mon Sep 17 00:00:00 2001
From: easonLiangWorldedtech <eason.liang@worldedtech.com>
Date: Tue, 6 Oct 2026 00:50:32 +0800
Subject: [PATCH 01/23] feat(label): mark stacked pull requests so reviewers
 can filter them

A stacked unit's head commit has exactly one parent, and that parent is another open pull request's head. The reconcile workflow already reads PR metadata, so it can identify that relationship and apply a `stacked` label, which lets reviewers filter the PR list to standalone PRs.

The label is orthogonal to the review-state labels, so it is reconciled separately and never removed by reconcileLabels. A stale label is removed when the parent is no longer another open PR head. The open-PR map is read only when there is a PR to reconcile, so an unassociated workflow run still resolves to zero reads. A commit lookup failure is an advisory, not a failure.

This is the labelling half of #1923; the measurement half is #1924.
---
 .github/workflows/label-pr-review-state.yml   | 54 ++++++++++++++++
 .../pr-review-state-workflow.test.ts          | 64 +++++++++++++++++--
 2 files changed, 113 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/label-pr-review-state.yml b/.github/workflows/label-pr-review-state.yml
index 08ecf2e3fe..f9fb20c2fd 100644
--- a/.github/workflows/label-pr-review-state.yml
+++ b/.github/workflows/label-pr-review-state.yml
@@ -33,6 +33,8 @@ permissions:
   issues: write
   checks: read
   statuses: write
+  # Reading a commit's parents is metadata only; no PR code is checked out or executed.
+  contents: read
 
 concurrency:
   group: label-pr-review-state
@@ -86,6 +88,11 @@ jobs:
                 color: 'c2e0c6',
                 description: 'Fresh community approval on the current head; maintainer review still required',
               },
+              {
+                name: 'stacked',
+                color: 'c2c2c2',
+                description: 'Head commit sits on another open PR, so its diff is only this unit',
+              },
             ];
             const guideMarker = '<!-- zoo-code-pr-review-process -->';
             const codeRabbitLabelMarkerPrefix = '<!-- coderabbit-review-label:';
@@ -244,6 +251,48 @@ jobs:
               }
             }
 
+            // A stacked unit's head commit has exactly one parent, and that parent is another open
+            // PR's head. Reviewers filter on this label to tell a unit apart from a standalone PR.
+            // It is orthogonal to the review-state labels, so it is reconciled separately and never
+            // removed by reconcileLabels.
+            const stackedLabel = 'stacked';
+
+            async function buildOpenPrHeads() {
+              const candidates = await github.paginate(github.rest.pulls.list, {
+                owner, repo, state: 'open', per_page: 100,
+              });
+              const heads = new Map();
+              for (const candidate of candidates) {
+                if (candidate.head?.sha) heads.set(candidate.head.sha.toLowerCase(), candidate.number);
+              }
+              return heads;
+            }
+
+            async function reconcileStackedLabel(pr, openPrHeads) {
+              if (isReadOnlyRun && isForkPR(pr)) {
+                core.info(`PR #${pr.number}: fork PR on a read-only run — skipping the stacked label`);
+                return;
+              }
+              try {
+                const { data: commit } = await github.rest.git.getCommit({ owner, repo, commit_sha: pr.head.sha });
+                const parents = Array.isArray(commit.parents) ? commit.parents : [];
+                const parentPr = parents.length === 1
+                  ? openPrHeads.get(String(parents[0].sha).toLowerCase())
+                  : undefined;
+                const hasLabel = pr.labels.some(label => label.name === stackedLabel);
+                if (hasLabel && parentPr === undefined) {
+                  await github.rest.issues.removeLabel({ owner, repo, issue_number: pr.number, name: stackedLabel });
+                  pr.labels = pr.labels.filter(label => label.name !== stackedLabel);
+                } else if (parentPr && !hasLabel) {
+                  await github.rest.issues.addLabels({ owner, repo, issue_number: pr.number, labels: [stackedLabel] });
+                  pr.labels = pr.labels.concat([{ name: stackedLabel }]);
+                  core.info(`PR #${pr.number}: stacked on #${parentPr}`);
+                }
+              } catch (error) {
+                core.warning(`PR #${pr.number}: could not reconcile the stacked label: ${error.message}`);
+              }
+            }
+
             async function findReviewGuide(pr) {
               const comments = await github.paginate(github.rest.issues.listComments, {
                 owner, repo, issue_number: pr.number, per_page: 100,
@@ -534,8 +583,13 @@ jobs:
 
             const failures = [];
 
+            // Only read the open-PR map when there is a PR to reconcile, so an
+            // unassociated workflow run still resolves to zero API reads.
+            const openPrHeads = prs.length > 0 ? await buildOpenPrHeads() : new Map();
+
             for (const pr of prs) {
               let failurePhase = 'ci-pending';
+              await reconcileStackedLabel(pr, openPrHeads);
               try {
                 const selfReferentialRequirements = (requiredChecks ?? []).filter(check =>
                   check.context === reviewGateName || check.context === reconciliationCheckName
diff --git a/src/services/__tests__/pr-review-state-workflow.test.ts b/src/services/__tests__/pr-review-state-workflow.test.ts
index 486112adf0..40216ce838 100644
--- a/src/services/__tests__/pr-review-state-workflow.test.ts
+++ b/src/services/__tests__/pr-review-state-workflow.test.ts
@@ -68,6 +68,9 @@ interface HarnessOptions {
 	timelineErrorStatus?: number
 	permissions?: Record<string, string>
 	permissionErrors?: Record<string, number>
+	commitParents?: string[]
+	getCommitErrorStatus?: number
+	openPrHeads?: Array<{ number: number; sha: string }>
 	permissionErrorStatus?: number
 	requiredContexts?: string[]
 	requiredIntegrationId?: number | null
@@ -274,7 +277,13 @@ async function runWorkflow(options: HarnessOptions = {}) {
 				return [{ ...pr, base: { ...pr.base, repo: { full_name: "another/repository" } } }]
 			}
 		}
-		return [pr]
+		return [pr, ...(options.openPrHeads ?? []).map((entry) => ({ number: entry.number, head: { sha: entry.sha } }))]
+	})
+	const getCommit = vi.fn(async () => {
+		if (options.getCommitErrorStatus) {
+			throw Object.assign(new Error("Commit lookup failed"), { status: options.getCommitErrorStatus })
+		}
+		return { data: { parents: (options.commitParents ?? []).map((sha) => ({ sha })) } }
 	})
 	let pullRequestGetIndex = 0
 	const getPullRequest = vi.fn(async () => {
@@ -333,6 +342,9 @@ async function runWorkflow(options: HarnessOptions = {}) {
 				createComment,
 				updateComment,
 			},
+			git: {
+				getCommit,
+			},
 			checks: {
 				listForRef: vi.fn(async () => checkRuns),
 			},
@@ -436,6 +448,7 @@ async function runWorkflow(options: HarnessOptions = {}) {
 		warning: core.warning,
 		getPullRequest,
 		listPullRequests: github.rest.pulls.list,
+		getCommit,
 		listCommitStatusesForRef: github.rest.repos.listCommitStatusesForRef,
 		permissionFor,
 	}
@@ -467,6 +480,7 @@ describe("PR review-state workflow", () => {
 			issues: "write",
 			checks: "read",
 			statuses: "write",
+			contents: "read",
 		})
 		expect(JSON.stringify(workflow.jobs.reconcile.steps)).not.toMatch(/actions\/checkout|\bpnpm\b|\bnpm\b/)
 		expect(workflowScript).not.toContain("@coderabbitai")
@@ -501,6 +515,42 @@ describe("PR review-state workflow", () => {
 		expect(result.createCommitStatus).toHaveBeenCalled()
 	})
 
+	it("labels a stacked unit from its head commit's parent", async () => {
+		const result = await runWorkflow({
+			commitParents: [OLD_SHA],
+			openPrHeads: [{ number: 1436, sha: OLD_SHA }],
+		})
+		fs.writeFileSync("C:/work/Zoo-Code-fork/.dbg.txt", JSON.stringify({ getCommit: result.getCommit.mock.calls, list: result.listPullRequests.mock.calls.length, info: result.info.mock.calls.map(function (x) { return x[0] }), warn: result.warning.mock.calls.map(function (x) { return x[0] }) }, null, 1) + "\n")
+
+		expect(result.addLabels).toHaveBeenCalledWith(expect.objectContaining({ labels: ["stacked"] }))
+		console.log("GETCOMMIT", JSON.stringify(result.getCommit.mock.calls), "LIST", result.listPullRequests.mock.calls.length, "INFO", result.info.mock.calls.map(function (x) { return x[0] }).join(" | ").slice(0, 300))
+		expect(result.warning).not.toHaveBeenCalled()
+	})
+
+	it("removes a stale stacked label when the parent is not another open PR head", async () => {
+		const result = await runWorkflow({
+			labels: ["stacked"],
+			commitParents: [OLD_SHA],
+		})
+
+		expect(result.removeLabel).toHaveBeenCalledWith(expect.objectContaining({ name: "stacked" }))
+	})
+
+	it("keeps the stacked label read-only on fork review events", async () => {
+		const result = await runWorkflow({ eventName: "pull_request_review", fork: true, commitParents: [OLD_SHA] })
+
+		expect(result.addLabels).not.toHaveBeenCalled()
+		expect(result.removeLabel).not.toHaveBeenCalled()
+		expect(result.getCommit).not.toHaveBeenCalled()
+	})
+
+	it("advises instead of failing when the stacked parent cannot be read", async () => {
+		const result = await runWorkflow({ getCommitErrorStatus: 500 })
+
+		expect(result.warning).toHaveBeenCalledWith(expect.stringContaining("could not reconcile the stacked label"))
+		expect(result.setFailed).not.toHaveBeenCalled()
+	})
+
 	it("reconciles CodeRabbit status comments with the canonical bot identity", async () => {
 		expect(workflow.on.issue_comment.types).toEqual(["created", "edited"])
 		expect(workflow.jobs.reconcile.if).toContain("github.event.comment.user.login == 'coderabbitai[bot]'")
@@ -520,7 +570,9 @@ describe("PR review-state workflow", () => {
 		})
 
 		expect(result.getPullRequest).toHaveBeenCalledTimes(1)
-		expect(result.listPullRequests).not.toHaveBeenCalled()
+		// The open-PR map is read once to identify a stacked parent; reconciliation still targets only the comment's PR.
+		expect(result.listPullRequests).toHaveBeenCalledTimes(1)
+		expect(result.getCommit).toHaveBeenCalledTimes(1)
 		expect(result.removeLabel).toHaveBeenCalledWith(expect.objectContaining({ name: "awaiting-maintainer" }))
 		expect(result.removeLabel).toHaveBeenCalledWith(expect.objectContaining({ name: "coderabbit-review-active" }))
 		expect(result.addLabels).toHaveBeenCalledWith(expect.objectContaining({ labels: ["awaiting-author"] }))
@@ -554,7 +606,7 @@ describe("PR review-state workflow", () => {
 	it("creates missing workflow labels", async () => {
 		const result = await runWorkflow({ labelLookupStatus: 404 })
 
-		expect(result.createLabel).toHaveBeenCalledTimes(5)
+		expect(result.createLabel).toHaveBeenCalledTimes(6)
 		const communityApproved = result.createLabel.mock.calls
 			.map(([args]) => args as { name: string; description: string })
 			.find((label) => label.name === "community-approved")
@@ -1729,14 +1781,16 @@ describe("PR review-state workflow", () => {
 	it("reconciles only the requested PR during manual dispatch", async () => {
 		const result = await runWorkflow({ eventName: "workflow_dispatch", workflowDispatchPrNumber: 1437 })
 
-		expect(result.listPullRequests).not.toHaveBeenCalled()
+		// One read for the open-PR map; only the requested PR is reconciled.
+		expect(result.listPullRequests).toHaveBeenCalledTimes(1)
 		expect(result.addLabels).toHaveBeenCalledWith(expect.objectContaining({ labels: ["coderabbit-review-active"] }))
 	})
 
 	it("reconciles the PR associated with a workflow run", async () => {
 		const result = await runWorkflow({ eventName: "workflow_run" })
 
-		expect(result.listPullRequests).not.toHaveBeenCalled()
+		// One read for the open-PR map; only the requested PR is reconciled.
+		expect(result.listPullRequests).toHaveBeenCalledTimes(1)
 		expect(result.addLabels).toHaveBeenCalledWith(expect.objectContaining({ labels: ["coderabbit-review-active"] }))
 	})
 

From 7752417ee27da809b6e4b3267ee05afc3f89f3e9 Mon Sep 17 00:00:00 2001
From: easonLiangWorldedtech <eason.liang@worldedtech.com>
Date: Tue, 6 Oct 2026 01:36:57 +0800
Subject: [PATCH 02/23] test(label): drop the debug write left in the
 stacked-label test

The test wrote a scratch file to an absolute path, which fails on CI. Removed the debug write and the debug console.log; 171 tests pass and ESLint is clean with --max-warnings=0.
---
 src/services/__tests__/pr-review-state-workflow.test.ts | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/services/__tests__/pr-review-state-workflow.test.ts b/src/services/__tests__/pr-review-state-workflow.test.ts
index 40216ce838..c4501fb8e9 100644
--- a/src/services/__tests__/pr-review-state-workflow.test.ts
+++ b/src/services/__tests__/pr-review-state-workflow.test.ts
@@ -520,11 +520,9 @@ describe("PR review-state workflow", () => {
 			commitParents: [OLD_SHA],
 			openPrHeads: [{ number: 1436, sha: OLD_SHA }],
 		})
-		fs.writeFileSync("C:/work/Zoo-Code-fork/.dbg.txt", JSON.stringify({ getCommit: result.getCommit.mock.calls, list: result.listPullRequests.mock.calls.length, info: result.info.mock.calls.map(function (x) { return x[0] }), warn: result.warning.mock.calls.map(function (x) { return x[0] }) }, null, 1) + "\n")
-
+		
 		expect(result.addLabels).toHaveBeenCalledWith(expect.objectContaining({ labels: ["stacked"] }))
-		console.log("GETCOMMIT", JSON.stringify(result.getCommit.mock.calls), "LIST", result.listPullRequests.mock.calls.length, "INFO", result.info.mock.calls.map(function (x) { return x[0] }).join(" | ").slice(0, 300))
-		expect(result.warning).not.toHaveBeenCalled()
+				expect(result.warning).not.toHaveBeenCalled()
 	})
 
 	it("removes a stale stacked label when the parent is not another open PR head", async () => {

From b098aa65816d5f8bae37c8c84bc3de5889b88ccb Mon Sep 17 00:00:00 2001
From: easonLiangWorldedtech <eason.liang@worldedtech.com>
Date: Tue, 6 Oct 2026 16:51:33 +0800
Subject: [PATCH 03/23] fix(workflow): keep review-state reconciliation running
 when the open-PR map fails

Three findings from the review at head:

1. Stability & Availability (major). A failed open-PR list call rejected before any PR reached the
   existing error handler, so one API failure stopped review-state labels and gate updates even when
   the target PR was fetched. The lookup is now caught and warned, and the map is left unset so
   reconcileStackedLabel skips label mutation for that run - an empty map would look like "no open
   parents" and remove valid stacked labels.
2. Maintainability (major). Added the boundary case: a head with two parents where one parent is an open
   PR head must not be labelled stacked, because a unit is one commit on top of its parent.
3. Functional Correctness (minor). The comment now describes what the check actually detects - the head
   commit directly descends from another open PR head - rather than claiming the PR targets the branch
   below it.

Local run: 173 tests pass, eslint clean, no suppression count change.
---
 .github/workflows/label-pr-review-state.yml   | 27 +++++++++++++----
 .../pr-review-state-workflow.test.ts          | 30 +++++++++++++++++++
 2 files changed, 52 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/label-pr-review-state.yml b/.github/workflows/label-pr-review-state.yml
index f9fb20c2fd..e4f3931714 100644
--- a/.github/workflows/label-pr-review-state.yml
+++ b/.github/workflows/label-pr-review-state.yml
@@ -251,10 +251,12 @@ jobs:
               }
             }
 
-            // A stacked unit's head commit has exactly one parent, and that parent is another open
-            // PR's head. Reviewers filter on this label to tell a unit apart from a standalone PR.
-            // It is orthogonal to the review-state labels, so it is reconciled separately and never
-            // removed by reconcileLabels.
+            // A stacked unit is detected from the commit graph: its head commit has exactly one
+            // parent, and that parent is another open PR's head. The label describes that detected
+            // relationship only -- it does not claim the PR targets the branch below it, which is
+            // how GitHub describes a focused stacked diff. Reviewers filter on this label to tell a
+            // unit apart from a standalone PR. It is orthogonal to the review-state labels, so it is
+            // reconciled separately and never removed by reconcileLabels.
             const stackedLabel = 'stacked';
 
             async function buildOpenPrHeads() {
@@ -269,6 +271,11 @@ jobs:
             }
 
             async function reconcileStackedLabel(pr, openPrHeads) {
+              if (openPrHeads === null) {
+                // The map could not be read this run; leave the label as it is rather than
+                // deciding from an empty map.
+                return;
+              }
               if (isReadOnlyRun && isForkPR(pr)) {
                 core.info(`PR #${pr.number}: fork PR on a read-only run — skipping the stacked label`);
                 return;
@@ -585,7 +592,17 @@ jobs:
 
             // Only read the open-PR map when there is a PR to reconcile, so an
             // unassociated workflow run still resolves to zero API reads.
-            const openPrHeads = prs.length > 0 ? await buildOpenPrHeads() : new Map();
+            // A failed open-PR list call must not stop review-state reconciliation. The map is left
+            // unset so reconcileStackedLabel skips label mutation for this run: an empty map would
+            // look like "no open parents" and remove valid stacked labels.
+            let openPrHeads = null;
+            if (prs.length > 0) {
+              try {
+                openPrHeads = await buildOpenPrHeads();
+              } catch (error) {
+                core.warning(`Could not read the open pull request map: ${error.message}; skipping the stacked label for this run`);
+              }
+            }
 
             for (const pr of prs) {
               let failurePhase = 'ci-pending';
diff --git a/src/services/__tests__/pr-review-state-workflow.test.ts b/src/services/__tests__/pr-review-state-workflow.test.ts
index c4501fb8e9..73c7adbb7f 100644
--- a/src/services/__tests__/pr-review-state-workflow.test.ts
+++ b/src/services/__tests__/pr-review-state-workflow.test.ts
@@ -71,6 +71,7 @@ interface HarnessOptions {
 	commitParents?: string[]
 	getCommitErrorStatus?: number
 	openPrHeads?: Array<{ number: number; sha: string }>
+	openPrHeadsError?: boolean
 	permissionErrorStatus?: number
 	requiredContexts?: string[]
 	requiredIntegrationId?: number | null
@@ -267,6 +268,7 @@ async function runWorkflow(options: HarnessOptions = {}) {
 		return { data: { permission } }
 	})
 	const listPullRequests = vi.fn(async ({ state }: { state?: string }) => {
+		if (state === "open" && options.openPrHeadsError) throw Object.assign(new Error("Bad credentials"), { status: 401 })
 		if (state === "open" && options.prState === "closed") return []
 		if (eventName === "workflow_run" && options.workflowRunAssociated === false) {
 			if (options.workflowRunFallback === "none" || options.workflowRunFallback === undefined) return []
@@ -549,6 +551,34 @@ describe("PR review-state workflow", () => {
 		expect(result.setFailed).not.toHaveBeenCalled()
 	})
 
+
+	it("keeps reconciling review state when the open-PR map lookup fails", async () => {
+		const result = await runWorkflow({
+			openPrHeadsError: true,
+			labels: ["stacked", "awaiting-maintainer"],
+			reviewState: "APPROVED",
+		})
+
+		// The map is unavailable, so the stacked label is left untouched instead of being decided from
+		// an empty map; the rest of the run still reconciles.
+		expect(result.warning).toHaveBeenCalledWith(expect.stringContaining("Could not read the open pull request map"))
+		expect(result.removeLabel).not.toHaveBeenCalledWith(expect.objectContaining({ name: "stacked" }))
+		expect(result.addLabels).not.toHaveBeenCalledWith(expect.objectContaining({ labels: ["stacked"] }))
+		expect(result.setFailed).not.toHaveBeenCalled()
+		expect(result.listPullRequests).toHaveBeenCalled()
+	})
+	it("does not label a merge commit stacked when only one of its parents is an open PR head", async () => {
+		const result = await runWorkflow({
+			commitParents: [OLD_SHA, SHA],
+			openPrHeads: [{ number: 1436, sha: OLD_SHA }],
+		})
+
+		// A unit is one commit on top of its parent. A head with two parents is a merge on the branch
+		// itself, so the relationship is not a stacked unit even though one parent matches.
+		expect(result.addLabels).not.toHaveBeenCalledWith(expect.objectContaining({ labels: ["stacked"] }))
+		expect(result.removeLabel).not.toHaveBeenCalledWith(expect.objectContaining({ name: "stacked" }))
+	})
+
 	it("reconciles CodeRabbit status comments with the canonical bot identity", async () => {
 		expect(workflow.on.issue_comment.types).toEqual(["created", "edited"])
 		expect(workflow.jobs.reconcile.if).toContain("github.event.comment.user.login == 'coderabbitai[bot]'")

From 9e772e253f8e7cedafccd1d12707cdf54d2386b4 Mon Sep 17 00:00:00 2001
From: easonLiangWorldedtech <eason.liang@worldedtech.com>
Date: Tue, 6 Oct 2026 17:02:03 +0800
Subject: [PATCH 04/23] test(label): use the harness reviews option in the
 failed-lookup case

The new test passed reviewState, which is not a harness option, so check-types failed at the pushed head.
Replaced it with a maintainer approval through the harness reviews option and asserted that review-state
reconciliation still ran for the PR (the stale awaiting-maintainer label is still reconciled) while the
stacked label is left untouched.

Local run: 173 tests pass, eslint clean, no suppression count change.
---
 .../__tests__/pr-review-state-workflow.test.ts       | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/src/services/__tests__/pr-review-state-workflow.test.ts b/src/services/__tests__/pr-review-state-workflow.test.ts
index 73c7adbb7f..419f432d0e 100644
--- a/src/services/__tests__/pr-review-state-workflow.test.ts
+++ b/src/services/__tests__/pr-review-state-workflow.test.ts
@@ -556,12 +556,22 @@ describe("PR review-state workflow", () => {
 		const result = await runWorkflow({
 			openPrHeadsError: true,
 			labels: ["stacked", "awaiting-maintainer"],
-			reviewState: "APPROVED",
+			permissions: { maintainer: "write" },
+			reviews: [
+				{
+					login: "maintainer",
+					type: "User",
+					state: "APPROVED",
+					submittedAt: REVIEWED_AT,
+				},
+			],
 		})
 
 		// The map is unavailable, so the stacked label is left untouched instead of being decided from
 		// an empty map; the rest of the run still reconciles.
 		expect(result.warning).toHaveBeenCalledWith(expect.stringContaining("Could not read the open pull request map"))
+		// Review-state reconciliation still ran for this PR despite the failed lookup.
+		expect(result.removeLabel).toHaveBeenCalledWith(expect.objectContaining({ name: "awaiting-maintainer" }))
 		expect(result.removeLabel).not.toHaveBeenCalledWith(expect.objectContaining({ name: "stacked" }))
 		expect(result.addLabels).not.toHaveBeenCalledWith(expect.objectContaining({ labels: ["stacked"] }))
 		expect(result.setFailed).not.toHaveBeenCalled()

From 623f0f4abda1a39abb9671f64fadc39147a30c63 Mon Sep 17 00:00:00 2001
From: easonLiangWorldedtech <eason.liang@worldedtech.com>
Date: Tue, 6 Oct 2026 17:19:54 +0800
Subject: [PATCH 05/23] test(label): cover the stacked label add and removal
 failure paths

The stacked reconciliation catches failures from issues.addLabels and issues.removeLabel, but nothing
asserted what happens after them. Added two harness cases:

- a stacked add that fails once: the run warns, the label is not recorded as present, and the run is not
  failed (the failure is isolated to the stacked add so the review-state add still succeeds);
- a stale stacked removal that fails: the run warns, the label stays on the PR so the next run retries it,
  and the run is not failed.

Local run: 175 tests pass, eslint clean, no suppression count change.
---
 .../pr-review-state-workflow.test.ts          | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/src/services/__tests__/pr-review-state-workflow.test.ts b/src/services/__tests__/pr-review-state-workflow.test.ts
index 419f432d0e..132af960b1 100644
--- a/src/services/__tests__/pr-review-state-workflow.test.ts
+++ b/src/services/__tests__/pr-review-state-workflow.test.ts
@@ -577,6 +577,32 @@ describe("PR review-state workflow", () => {
 		expect(result.setFailed).not.toHaveBeenCalled()
 		expect(result.listPullRequests).toHaveBeenCalled()
 	})
+
+	it("warns and leaves the label state unchanged when a stacked add fails", async () => {
+		const result = await runWorkflow({
+			commitParents: [OLD_SHA],
+			openPrHeads: [{ number: 1436, sha: OLD_SHA }],
+			addLabelsFailOnceName: "stacked",
+		})
+
+		expect(result.warning).toHaveBeenCalledWith(expect.stringContaining("could not reconcile the stacked label"))
+		// The failed add must not be recorded as a label the PR actually has.
+		expect(((await result.getPullRequest()).data.labels || []).map((label: { name: string }) => label.name)).not.toContain("stacked")
+		expect(result.setFailed).not.toHaveBeenCalled()
+	})
+
+	it("warns and leaves the label state unchanged when a stale stacked removal fails", async () => {
+		const result = await runWorkflow({
+			labels: ["stacked"],
+			commitParents: [OLD_SHA],
+			removeLabelStatus: 500,
+		})
+
+		expect(result.warning).toHaveBeenCalledWith(expect.stringContaining("could not reconcile the stacked label"))
+		// A failed removal leaves the label on the PR; the next run retries it.
+		expect(((await result.getPullRequest()).data.labels || []).map((label: { name: string }) => label.name)).toContain("stacked")
+		expect(result.setFailed).not.toHaveBeenCalled()
+	})
 	it("does not label a merge commit stacked when only one of its parents is an open PR head", async () => {
 		const result = await runWorkflow({
 			commitParents: [OLD_SHA, SHA],

From 34d5f07148f34c280baf75a63f2564eb2703e69d Mon Sep 17 00:00:00 2001
From: easonLiangWorldedtech <eason.liang@worldedtech.com>
Date: Tue, 6 Oct 2026 17:51:25 +0800
Subject: [PATCH 06/23] test(label): assert the stacked label is created and
 removed on the boundary case

Two uncovered assertions from the review:

- the missing-label path must create `stacked` as a label definition, not just six labels;
- a head with two parents where one parent is an open PR head must have a stale `stacked` label
  removed, so the negative boundary case now asserts both directions (no add, remove).

Local run: 176 tests pass, eslint clean, no suppression count change.
---
 .../__tests__/pr-review-state-workflow.test.ts | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/src/services/__tests__/pr-review-state-workflow.test.ts b/src/services/__tests__/pr-review-state-workflow.test.ts
index 132af960b1..60693a59e4 100644
--- a/src/services/__tests__/pr-review-state-workflow.test.ts
+++ b/src/services/__tests__/pr-review-state-workflow.test.ts
@@ -614,6 +614,18 @@ describe("PR review-state workflow", () => {
 		expect(result.addLabels).not.toHaveBeenCalledWith(expect.objectContaining({ labels: ["stacked"] }))
 		expect(result.removeLabel).not.toHaveBeenCalledWith(expect.objectContaining({ name: "stacked" }))
 	})
+	it("removes a stale stacked label from a merge commit whose parent matches an open PR head", async () => {
+		const result = await runWorkflow({
+			labels: ["stacked"],
+			commitParents: [OLD_SHA, SHA],
+			openPrHeads: [{ number: 1436, sha: OLD_SHA }],
+		})
+
+		// Two parents means the head is a merge on the branch, not one commit on top of a unit parent,
+		// so the label that was added earlier is stale and must be removed.
+		expect(result.removeLabel).toHaveBeenCalledWith(expect.objectContaining({ name: "stacked" }))
+		expect(result.addLabels).not.toHaveBeenCalledWith(expect.objectContaining({ labels: ["stacked"] }))
+	})
 
 	it("reconciles CodeRabbit status comments with the canonical bot identity", async () => {
 		expect(workflow.on.issue_comment.types).toEqual(["created", "edited"])
@@ -633,6 +645,7 @@ describe("PR review-state workflow", () => {
 			],
 		})
 
+
 		expect(result.getPullRequest).toHaveBeenCalledTimes(1)
 		// The open-PR map is read once to identify a stacked parent; reconciliation still targets only the comment's PR.
 		expect(result.listPullRequests).toHaveBeenCalledTimes(1)
@@ -676,6 +689,11 @@ describe("PR review-state workflow", () => {
 			.find((label) => label.name === "community-approved")
 		expect(communityApproved).toBeDefined()
 		expect(communityApproved?.description.length).toBeLessThanOrEqual(100)
+		// stacked is a label definition too, so the missing-label path must create it.
+		const stacked = result.createLabel.mock.calls
+			.map(([args]) => args as { name: string })
+			.find((label) => label.name === "stacked")
+		expect(stacked).toBeDefined()
 	})
 
 	it("fails closed when a managed label cannot be created", async () => {

From 9698e5064a0dd2e45ddd59f90f7b1c5456ba3d85 Mon Sep 17 00:00:00 2001
From: easonLiangWorldedtech <eason.liang@worldedtech.com>
Date: Tue, 6 Oct 2026 18:03:12 +0800
Subject: [PATCH 07/23] test(label): prove a stacked label survives an
 unreadable parent commit

The commit-lookup failure is advisory, but the test did not show what happens to a label already on the
PR. It now starts with `stacked`, asserts no removal call, and asserts the label is still on the PR after
the run - an unreadable parent is not evidence that the relationship ended.

Local run: 176 tests pass, eslint clean, no suppression count change.
---
 src/services/__tests__/pr-review-state-workflow.test.ts | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/services/__tests__/pr-review-state-workflow.test.ts b/src/services/__tests__/pr-review-state-workflow.test.ts
index 60693a59e4..fc06532dd9 100644
--- a/src/services/__tests__/pr-review-state-workflow.test.ts
+++ b/src/services/__tests__/pr-review-state-workflow.test.ts
@@ -545,10 +545,14 @@ describe("PR review-state workflow", () => {
 	})
 
 	it("advises instead of failing when the stacked parent cannot be read", async () => {
-		const result = await runWorkflow({ getCommitErrorStatus: 500 })
+		const result = await runWorkflow({ labels: ["stacked"], getCommitErrorStatus: 500 })
 
 		expect(result.warning).toHaveBeenCalledWith(expect.stringContaining("could not reconcile the stacked label"))
 		expect(result.setFailed).not.toHaveBeenCalled()
+		// A lookup failure is advisory: the label already on the PR must not be decided from
+		// an unreadable parent, so it stays as it is.
+		expect(result.removeLabel).not.toHaveBeenCalledWith(expect.objectContaining({ name: "stacked" }))
+		expect(((await result.getPullRequest()).data.labels || []).map((label: { name: string }) => label.name)).toContain("stacked")
 	})
 
 

From b3d4cba47c71d11b33ef8a321f4e46e21f66fe4c Mon Sep 17 00:00:00 2001
From: easonLiangWorldedtech <eason.liang@worldedtech.com>
Date: Tue, 6 Oct 2026 18:15:01 +0800
Subject: [PATCH 08/23] test(label): assert the definition, the recorded label
 state, and the commit looked up

Three weak assertions from the review:

- the stale-removal case now also asserts the label recorded for the PR is cleared, not only that the
  removal call happened;
- the missing-label case asserts the full definition (name, colour, description) rather than that some
  call mentioned the name;
- the stacked test asserts the lookup targets the PR head SHA, so a regression that reads the wrong
  commit no longer passes.

Local run: 176 tests pass, eslint clean, no suppression count change.
---
 .../__tests__/pr-review-state-workflow.test.ts  | 17 ++++++++++++++---
 1 file changed, 14 insertions(+), 3 deletions(-)

diff --git a/src/services/__tests__/pr-review-state-workflow.test.ts b/src/services/__tests__/pr-review-state-workflow.test.ts
index fc06532dd9..ebe3103391 100644
--- a/src/services/__tests__/pr-review-state-workflow.test.ts
+++ b/src/services/__tests__/pr-review-state-workflow.test.ts
@@ -524,6 +524,8 @@ describe("PR review-state workflow", () => {
 		})
 		
 		expect(result.addLabels).toHaveBeenCalledWith(expect.objectContaining({ labels: ["stacked"] }))
+		// The relationship is read from the PR head commit, so the lookup must target it.
+		expect(result.getCommit).toHaveBeenCalledWith(expect.objectContaining({ commit_sha: SHA }))
 				expect(result.warning).not.toHaveBeenCalled()
 	})
 
@@ -629,6 +631,8 @@ describe("PR review-state workflow", () => {
 		// so the label that was added earlier is stale and must be removed.
 		expect(result.removeLabel).toHaveBeenCalledWith(expect.objectContaining({ name: "stacked" }))
 		expect(result.addLabels).not.toHaveBeenCalledWith(expect.objectContaining({ labels: ["stacked"] }))
+		// The removal must also clear the label recorded for this PR, not just the remote state.
+		expect(((await result.getPullRequest()).data.labels || []).map((label: { name: string }) => label.name)).not.toContain("stacked")
 	})
 
 	it("reconciles CodeRabbit status comments with the canonical bot identity", async () => {
@@ -693,11 +697,18 @@ describe("PR review-state workflow", () => {
 			.find((label) => label.name === "community-approved")
 		expect(communityApproved).toBeDefined()
 		expect(communityApproved?.description.length).toBeLessThanOrEqual(100)
-		// stacked is a label definition too, so the missing-label path must create it.
+		// stacked is a label definition too, so the missing-label path must create it with the
+		// configured definition, not just a name.
 		const stacked = result.createLabel.mock.calls
-			.map(([args]) => args as { name: string })
+			.map(([args]) => args as { name: string; color: string; description: string })
 			.find((label) => label.name === "stacked")
-		expect(stacked).toBeDefined()
+		expect(stacked).toEqual(
+			expect.objectContaining({
+				name: "stacked",
+				color: "c2c2c2",
+				description: "Head commit sits on another open PR, so its diff is only this unit",
+			}),
+		)
 	})
 
 	it("fails closed when a managed label cannot be created", async () => {

From 092b03d7206c27878271eec868bc134c9794e1e4 Mon Sep 17 00:00:00 2001
From: easonLiangWorldedtech <eason.liang@worldedtech.com>
Date: Tue, 6 Oct 2026 18:56:27 +0800
Subject: [PATCH 09/23] fix(workflow): a failed stacked label creation must not
 block reconciliation

The 404 from getLabel is handled, but if createLabel then rejects the error escapes the provisioning
loop before any PR is reconciled, so adding stacked added a new failure point for the whole run.

Creation failures for stacked are now caught, warned, and skipped - the label is only a reviewer
filter. Every other managed label still fails closed, because reconciliation cannot work without it.

Added a harness case that rejects creation of stacked and asserts reconciliation continues (the stale
awaiting-maintainer label is still reconciled and the run is not failed).

Local run: 177 tests pass, eslint clean, no suppression count change.
---
 .github/workflows/label-pr-review-state.yml   | 13 +++++++-
 .../pr-review-state-workflow.test.ts          | 31 ++++++++++++++++++-
 2 files changed, 42 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/label-pr-review-state.yml b/.github/workflows/label-pr-review-state.yml
index e4f3931714..9c2392083c 100644
--- a/.github/workflows/label-pr-review-state.yml
+++ b/.github/workflows/label-pr-review-state.yml
@@ -177,12 +177,24 @@ jobs:
               return pr.head?.repo?.full_name && pr.head.repo.full_name !== pr.base?.repo?.full_name;
             }
 
+            const stackedLabel = 'stacked';
             if (!isReadOnlyRun) {
               for (const label of labelDefinitions) {
                 try {
                   await github.rest.issues.getLabel({ owner, repo, name: label.name });
                 } catch (error) {
                   if (error.status !== 404) throw error;
+                  if (label.name === stackedLabel) {
+                    // stacked is only a reviewer filter, so a failed provisioning must not stop
+                    // reconciliation for every PR. Every other managed label still fails closed,
+                    // because reconciliation cannot work without it.
+                    try {
+                      await github.rest.issues.createLabel({ owner, repo, ...label });
+                    } catch (createError) {
+                      core.warning(`Could not create the ${stackedLabel} label: ${createError.message}; continuing without it`);
+                    }
+                    continue;
+                  }
                   await github.rest.issues.createLabel({ owner, repo, ...label });
                 }
               }
@@ -257,7 +269,6 @@ jobs:
             // how GitHub describes a focused stacked diff. Reviewers filter on this label to tell a
             // unit apart from a standalone PR. It is orthogonal to the review-state labels, so it is
             // reconciled separately and never removed by reconcileLabels.
-            const stackedLabel = 'stacked';
 
             async function buildOpenPrHeads() {
               const candidates = await github.paginate(github.rest.pulls.list, {
diff --git a/src/services/__tests__/pr-review-state-workflow.test.ts b/src/services/__tests__/pr-review-state-workflow.test.ts
index ebe3103391..502b4fa93c 100644
--- a/src/services/__tests__/pr-review-state-workflow.test.ts
+++ b/src/services/__tests__/pr-review-state-workflow.test.ts
@@ -44,6 +44,7 @@ interface HarnessOptions {
 	addLabelsFailOnceName?: string
 	labelLookupStatus?: number
 	createLabelStatus?: number
+	createLabelFailOnceName?: string
 	listCommentsErrorStatus?: number
 	createCommentErrorStatus?: number
 	updateCommentErrorStatus?: number
@@ -249,7 +250,12 @@ async function runWorkflow(options: HarnessOptions = {}) {
 			return { data: args }
 		},
 	)
-	const createLabel = vi.fn(async (_args: unknown) => {
+	let createdOnce = false
+	const createLabel = vi.fn(async (args: unknown) => {
+		if (options.createLabelFailOnceName && (args as { name: string }).name === options.createLabelFailOnceName && !createdOnce) {
+			createdOnce = true
+			throw Object.assign(new Error("Create label failed once"), { status: 500 })
+		}
 		if (options.createLabelStatus) {
 			throw Object.assign(new Error("Create label failed"), { status: options.createLabelStatus })
 		}
@@ -717,6 +723,29 @@ describe("PR review-state workflow", () => {
 		)
 	})
 
+	it("keeps reconciling when only the stacked label cannot be created", async () => {
+		const result = await runWorkflow({
+			labelLookupStatus: 404,
+			createLabelFailOnceName: "stacked",
+			labels: ["awaiting-maintainer"],
+			permissions: { maintainer: "write" },
+			reviews: [
+				{
+					login: "maintainer",
+					type: "User",
+					state: "APPROVED",
+					submittedAt: REVIEWED_AT,
+				},
+			],
+		})
+
+		// stacked is only a reviewer filter, so its provisioning failure is advisory while every other
+		// managed label still fails closed.
+		expect(result.warning).toHaveBeenCalledWith(expect.stringContaining("Could not create the stacked label"))
+		expect(result.setFailed).not.toHaveBeenCalled()
+		expect(result.removeLabel).toHaveBeenCalledWith(expect.objectContaining({ name: "awaiting-maintainer" }))
+	})
+
 	it("propagates non-404 label lookup failures", async () => {
 		await expect(runWorkflow({ labelLookupStatus: 500 })).rejects.toThrow("Label lookup failed")
 	})

From 16ac4c49448ff268c12826da119a0a8a607f4187 Mon Sep 17 00:00:00 2001
From: Eason Liang <easonliang28@gmail.com>
Date: Mon, 12 Oct 2026 22:58:10 +0800
Subject: [PATCH 10/23] style: satisfy the compile job format:check gate on
 this PR's test file

Prettier-only rewrap of a long condition in the createLabelFailOnceName guard (the new format:check step in the compile job flags it). No semantic change; 177/177 tests pass, eslint clean.
---
 .../pr-review-state-workflow.test.ts          | 31 +++++++++++++------
 1 file changed, 21 insertions(+), 10 deletions(-)

diff --git a/src/services/__tests__/pr-review-state-workflow.test.ts b/src/services/__tests__/pr-review-state-workflow.test.ts
index 502b4fa93c..f888806026 100644
--- a/src/services/__tests__/pr-review-state-workflow.test.ts
+++ b/src/services/__tests__/pr-review-state-workflow.test.ts
@@ -252,7 +252,11 @@ async function runWorkflow(options: HarnessOptions = {}) {
 	)
 	let createdOnce = false
 	const createLabel = vi.fn(async (args: unknown) => {
-		if (options.createLabelFailOnceName && (args as { name: string }).name === options.createLabelFailOnceName && !createdOnce) {
+		if (
+			options.createLabelFailOnceName &&
+			(args as { name: string }).name === options.createLabelFailOnceName &&
+			!createdOnce
+		) {
 			createdOnce = true
 			throw Object.assign(new Error("Create label failed once"), { status: 500 })
 		}
@@ -274,7 +278,8 @@ async function runWorkflow(options: HarnessOptions = {}) {
 		return { data: { permission } }
 	})
 	const listPullRequests = vi.fn(async ({ state }: { state?: string }) => {
-		if (state === "open" && options.openPrHeadsError) throw Object.assign(new Error("Bad credentials"), { status: 401 })
+		if (state === "open" && options.openPrHeadsError)
+			throw Object.assign(new Error("Bad credentials"), { status: 401 })
 		if (state === "open" && options.prState === "closed") return []
 		if (eventName === "workflow_run" && options.workflowRunAssociated === false) {
 			if (options.workflowRunFallback === "none" || options.workflowRunFallback === undefined) return []
@@ -528,11 +533,11 @@ describe("PR review-state workflow", () => {
 			commitParents: [OLD_SHA],
 			openPrHeads: [{ number: 1436, sha: OLD_SHA }],
 		})
-		
+
 		expect(result.addLabels).toHaveBeenCalledWith(expect.objectContaining({ labels: ["stacked"] }))
 		// The relationship is read from the PR head commit, so the lookup must target it.
 		expect(result.getCommit).toHaveBeenCalledWith(expect.objectContaining({ commit_sha: SHA }))
-				expect(result.warning).not.toHaveBeenCalled()
+		expect(result.warning).not.toHaveBeenCalled()
 	})
 
 	it("removes a stale stacked label when the parent is not another open PR head", async () => {
@@ -560,10 +565,11 @@ describe("PR review-state workflow", () => {
 		// A lookup failure is advisory: the label already on the PR must not be decided from
 		// an unreadable parent, so it stays as it is.
 		expect(result.removeLabel).not.toHaveBeenCalledWith(expect.objectContaining({ name: "stacked" }))
-		expect(((await result.getPullRequest()).data.labels || []).map((label: { name: string }) => label.name)).toContain("stacked")
+		expect(
+			((await result.getPullRequest()).data.labels || []).map((label: { name: string }) => label.name),
+		).toContain("stacked")
 	})
 
-
 	it("keeps reconciling review state when the open-PR map lookup fails", async () => {
 		const result = await runWorkflow({
 			openPrHeadsError: true,
@@ -599,7 +605,9 @@ describe("PR review-state workflow", () => {
 
 		expect(result.warning).toHaveBeenCalledWith(expect.stringContaining("could not reconcile the stacked label"))
 		// The failed add must not be recorded as a label the PR actually has.
-		expect(((await result.getPullRequest()).data.labels || []).map((label: { name: string }) => label.name)).not.toContain("stacked")
+		expect(
+			((await result.getPullRequest()).data.labels || []).map((label: { name: string }) => label.name),
+		).not.toContain("stacked")
 		expect(result.setFailed).not.toHaveBeenCalled()
 	})
 
@@ -612,7 +620,9 @@ describe("PR review-state workflow", () => {
 
 		expect(result.warning).toHaveBeenCalledWith(expect.stringContaining("could not reconcile the stacked label"))
 		// A failed removal leaves the label on the PR; the next run retries it.
-		expect(((await result.getPullRequest()).data.labels || []).map((label: { name: string }) => label.name)).toContain("stacked")
+		expect(
+			((await result.getPullRequest()).data.labels || []).map((label: { name: string }) => label.name),
+		).toContain("stacked")
 		expect(result.setFailed).not.toHaveBeenCalled()
 	})
 	it("does not label a merge commit stacked when only one of its parents is an open PR head", async () => {
@@ -638,7 +648,9 @@ describe("PR review-state workflow", () => {
 		expect(result.removeLabel).toHaveBeenCalledWith(expect.objectContaining({ name: "stacked" }))
 		expect(result.addLabels).not.toHaveBeenCalledWith(expect.objectContaining({ labels: ["stacked"] }))
 		// The removal must also clear the label recorded for this PR, not just the remote state.
-		expect(((await result.getPullRequest()).data.labels || []).map((label: { name: string }) => label.name)).not.toContain("stacked")
+		expect(
+			((await result.getPullRequest()).data.labels || []).map((label: { name: string }) => label.name),
+		).not.toContain("stacked")
 	})
 
 	it("reconciles CodeRabbit status comments with the canonical bot identity", async () => {
@@ -659,7 +671,6 @@ describe("PR review-state workflow", () => {
 			],
 		})
 
-
 		expect(result.getPullRequest).toHaveBeenCalledTimes(1)
 		// The open-PR map is read once to identify a stacked parent; reconciliation still targets only the comment's PR.
 		expect(result.listPullRequests).toHaveBeenCalledTimes(1)

From bb7295f41278fede95d672e4097f3744cf72d895 Mon Sep 17 00:00:00 2001
From: Eason Liang <easonliang28@gmail.com>
Date: Tue, 13 Oct 2026 00:05:25 +0800
Subject: [PATCH 11/23] Move the open-PR head map into the resolve job

CR review at 4f41973: with main's sharding, every reconcile shard built the
open-PR head map itself, multiplying the paginated pulls.list read by the shard
count against the Actions token budget (a 201-300 open-PR sweep adds ~600 calls).

- resolve builds the map once and exports it as the open_pr_heads output; the
  sweep branch reuses the open list it already paged, so sweeps pay zero extra
  reads and direct events pay exactly one.
- shards parse the map from the OPEN_PR_HEADS env. An empty or unparseable value
  keeps the existing fail-soft: reconcileStackedLabel skips label mutation
  rather than deciding from an empty map.
- buildOpenPrHeads is gone from the reconcile script.

Tests: harness passes the map through the env like the matrix wiring does; new
resolve-level tests cover the sweep reuse and the fail-soft output; shard tests
assert zero pull-request reads. 207/207 pass; eslint 0; prettier clean.
---
 .github/workflows/label-pr-review-state.yml   | 63 +++++++++++-------
 .../pr-review-state-workflow.test.ts          | 66 +++++++++++++++----
 2 files changed, 95 insertions(+), 34 deletions(-)

diff --git a/.github/workflows/label-pr-review-state.yml b/.github/workflows/label-pr-review-state.yml
index e50fafc39b..cd9f61299e 100644
--- a/.github/workflows/label-pr-review-state.yml
+++ b/.github/workflows/label-pr-review-state.yml
@@ -93,6 +93,7 @@ jobs:
         runs-on: ubuntu-latest
         outputs:
             pr_numbers: ${{ steps.resolve.outputs.pr_numbers }}
+            open_pr_heads: ${{ steps.resolve.outputs.open_pr_heads }}
         env:
             # Mirrors the workflow-level concurrency group so the run's queueing
             # identity is visible in the logs (kept in sync by the workflow tests).
@@ -133,6 +134,7 @@ jobs:
                       // associated PRs, with a fork-safe backfill by exact head owner,
                       // branch, and SHA when GitHub left pull_requests empty.
                       let prNumbers = [];
+                      let openPrsCache = null;
                       if (context.payload.pull_request?.number) {
                         prNumbers = [context.payload.pull_request.number];
                       } else if (context.eventName === 'issue_comment') {
@@ -165,14 +167,14 @@ jobs:
                           );
                         }
                       } else {
-                        const openPrs = await github.paginate(github.rest.pulls.list, {
+                        openPrsCache = await github.paginate(github.rest.pulls.list, {
                           owner, repo, state: 'open', per_page: 100,
                         });
                         // GitHub rejects matrices over 256 jobs, so the sweep pages the
                         // sorted open-PR list: consecutive runs rotate through
                         // fixed-size windows by run number, covering every open PR on a
                         // bounded cadence without ever exceeding the limit.
-                        const allNumbers = openPrs.map(pr => pr.number).sort((a, b) => a - b);
+                        const allNumbers = openPrsCache.map(pr => pr.number).sort((a, b) => a - b);
                         const sweepPageSize = 200;
                         const pageCount = Math.max(1, Math.ceil(allNumbers.length / sweepPageSize));
                         const page = context.runNumber % pageCount;
@@ -191,6 +193,29 @@ jobs:
                       );
                       core.setOutput('pr_numbers', JSON.stringify(prNumbers));
 
+                      // Build the open-PR head map once here for every shard: a sweep would otherwise
+                      // multiply the paginated open-PR read by every shard against the Actions token
+                      // budget. Sweep triggers already hold the full open list, so the map costs them
+                      // no extra read. An empty output means the map was unavailable (or nothing was
+                      // resolved); shards then skip the stacked label rather than deciding from an
+                      // empty map.
+                      let openPrHeadsOutput = '';
+                      if (prNumbers.length > 0) {
+                        try {
+                          const openPrsForMap = openPrsCache ?? (await github.paginate(github.rest.pulls.list, {
+                            owner, repo, state: 'open', per_page: 100,
+                          }));
+                          const heads = {};
+                          for (const candidate of openPrsForMap) {
+                            if (candidate.head?.sha) heads[candidate.head.sha.toLowerCase()] = candidate.number;
+                          }
+                          openPrHeadsOutput = JSON.stringify(heads);
+                        } catch (error) {
+                          core.warning(`Could not read the open pull request map: ${error.message}; shards will skip the stacked label this run`);
+                        }
+                      }
+                      core.setOutput('open_pr_heads', openPrHeadsOutput);
+
     reconcile:
         name: Zoo Code / reconcile PR review state
         needs: resolve
@@ -232,6 +257,7 @@ jobs:
         runs-on: ubuntu-latest
         env:
             PR_NUMBER: ${{ matrix.pr_number }}
+            OPEN_PR_HEADS: ${{ needs.resolve.outputs.open_pr_heads }}
             # Mirrors this job's concurrency group so a superseded shard's queueing
             # identity is visible in the logs (kept in sync by the workflow tests).
             CONCURRENCY_GROUP: >-
@@ -440,17 +466,6 @@ jobs:
                       // unit apart from a standalone PR. It is orthogonal to the review-state labels, so it is
                       // reconciled separately and never removed by reconcileLabels.
 
-                      async function buildOpenPrHeads() {
-                        const candidates = await github.paginate(github.rest.pulls.list, {
-                          owner, repo, state: 'open', per_page: 100,
-                        });
-                        const heads = new Map();
-                        for (const candidate of candidates) {
-                          if (candidate.head?.sha) heads.set(candidate.head.sha.toLowerCase(), candidate.number);
-                        }
-                        return heads;
-                      }
-
                       async function reconcileStackedLabel(pr, openPrHeads) {
                         if (openPrHeads === null) {
                           // The map could not be read this run; leave the label as it is rather than
@@ -771,17 +786,21 @@ jobs:
 
                       const failures = [];
 
-                      // Only read the open-PR map when there is a PR to reconcile, so an
-                      // unassociated workflow run still resolves to zero API reads.
-                      // A failed open-PR list call must not stop review-state reconciliation. The map is left
-                      // unset so reconcileStackedLabel skips label mutation for this run: an empty map would
-                      // look like "no open parents" and remove valid stacked labels.
+                      // The open-PR head map is built once in the resolve job and passed through the
+                      // job env, so a sweep pays one paginated read instead of one per shard. An empty
+                      // value means the map was unavailable this run: leave existing stacked labels as
+                      // they are rather than deciding from an empty map, which would look like
+                      // "no open parents" and remove valid labels.
                       let openPrHeads = null;
                       if (prs.length > 0) {
-                        try {
-                          openPrHeads = await buildOpenPrHeads();
-                        } catch (error) {
-                          core.warning(`Could not read the open pull request map: ${error.message}; skipping the stacked label for this run`);
+                        if (process.env.OPEN_PR_HEADS) {
+                          try {
+                            openPrHeads = new Map(Object.entries(JSON.parse(process.env.OPEN_PR_HEADS)));
+                          } catch (error) {
+                            core.warning(`Could not read the open pull request map: ${error.message}; skipping the stacked label for this run`);
+                          }
+                        } else {
+                          core.warning('Could not read the open pull request map: the resolve job provided none; skipping the stacked label for this run');
                         }
                       }
 
diff --git a/src/services/__tests__/pr-review-state-workflow.test.ts b/src/services/__tests__/pr-review-state-workflow.test.ts
index 2c66e480ac..662ca2c245 100644
--- a/src/services/__tests__/pr-review-state-workflow.test.ts
+++ b/src/services/__tests__/pr-review-state-workflow.test.ts
@@ -513,15 +513,26 @@ async function runWorkflow(options: HarnessOptions = {}) {
 	// The reconcile job runs one matrix shard per PR and receives the target
 	// through the job's PR_NUMBER env mapping, plus the job's concurrency group
 	// through CONCURRENCY_GROUP.
-	const previousEnv = { prNumber: process.env.PR_NUMBER, group: process.env.CONCURRENCY_GROUP }
+	const previousEnv = {
+		prNumber: process.env.PR_NUMBER,
+		group: process.env.CONCURRENCY_GROUP,
+		openPrHeads: process.env.OPEN_PR_HEADS,
+	}
 	process.env.PR_NUMBER = String(pr.number)
 	process.env.CONCURRENCY_GROUP = `label-pr-review-state-reconcile-${pr.number}`
+	// The resolve job builds the open-PR head map once and passes it to shards through
+	// the job env; the harness mirrors that contract. openPrHeadsError simulates a
+	// resolve-side lookup failure, which reaches shards as an empty value.
+	const headMap: Record<string, number> = { [SHA.toLowerCase()]: pr.number }
+	for (const entry of options.openPrHeads ?? []) headMap[entry.sha.toLowerCase()] = entry.number
+	process.env.OPEN_PR_HEADS = options.openPrHeadsError ? "" : JSON.stringify(headMap)
 	try {
 		await new AsyncFunction("github", "context", "core", workflowScript)(github, context, core)
 	} finally {
 		for (const [key, value] of [
 			["PR_NUMBER", previousEnv.prNumber],
 			["CONCURRENCY_GROUP", previousEnv.group],
+			["OPEN_PR_HEADS", previousEnv.openPrHeads],
 		] as const) {
 			if (value === undefined) {
 				delete process.env[key]
@@ -600,12 +611,15 @@ async function runResolve(options: HarnessOptions = {}) {
 	}
 
 	const prNumbersOutput = setOutput.mock.calls.find(([name]) => name === "pr_numbers")?.[1] as string | undefined
+	const openPrHeadsOutput = setOutput.mock.calls.find(([name]) => name === "open_pr_heads")?.[1] as string | undefined
 	return {
 		setOutput,
 		listPullRequests,
 		getPullRequest,
 		info: core.info,
+		warning: core.warning,
 		prNumbers: () => (prNumbersOutput !== undefined ? (JSON.parse(prNumbersOutput) as number[]) : undefined),
+		openPrHeads: () => (openPrHeadsOutput ? (JSON.parse(openPrHeadsOutput) as Record<string, number>) : null),
 	}
 }
 
@@ -727,15 +741,16 @@ describe("PR review-state workflow", () => {
 			],
 		})
 
-		// The map is unavailable, so the stacked label is left untouched instead of being decided from
-		// an empty map; the rest of the run still reconciles.
+		// The map is unavailable (resolve failed to read it), so the stacked label is left
+		// untouched instead of being decided from an empty map; the rest still reconciles.
 		expect(result.warning).toHaveBeenCalledWith(expect.stringContaining("Could not read the open pull request map"))
 		// Review-state reconciliation still ran for this PR despite the failed lookup.
 		expect(result.removeLabel).toHaveBeenCalledWith(expect.objectContaining({ name: "awaiting-maintainer" }))
 		expect(result.removeLabel).not.toHaveBeenCalledWith(expect.objectContaining({ name: "stacked" }))
 		expect(result.addLabels).not.toHaveBeenCalledWith(expect.objectContaining({ labels: ["stacked"] }))
 		expect(result.setFailed).not.toHaveBeenCalled()
-		expect(result.listPullRequests).toHaveBeenCalled()
+		// The map arrives through the env, so the shard itself never lists pull requests.
+		expect(result.listPullRequests).not.toHaveBeenCalled()
 	})
 
 	it("warns and leaves the label state unchanged when a stacked add fails", async () => {
@@ -814,8 +829,9 @@ describe("PR review-state workflow", () => {
 		})
 
 		expect(result.getPullRequest).toHaveBeenCalledTimes(1)
-		// The open-PR map is read once to identify a stacked parent; reconciliation still targets only the comment's PR.
-		expect(result.listPullRequests).toHaveBeenCalledTimes(1)
+		// The open-PR head map arrives from the resolve job's env, so the shard reads no
+		// pull-request list; reconciliation still targets only the comment's PR.
+		expect(result.listPullRequests).not.toHaveBeenCalled()
 		expect(result.getCommit).toHaveBeenCalledTimes(1)
 		expect(result.removeLabel).toHaveBeenCalledWith(expect.objectContaining({ name: "awaiting-maintainer" }))
 		expect(result.removeLabel).toHaveBeenCalledWith(expect.objectContaining({ name: "coderabbit-review-active" }))
@@ -2112,16 +2128,41 @@ describe("PR review-state workflow", () => {
 	it("reconciles only the requested PR during manual dispatch", async () => {
 		const resolution = await runResolve({ eventName: "workflow_dispatch", workflowDispatchPrNumber: 1437 })
 
-		expect(resolution.listPullRequests).not.toHaveBeenCalled()
+		// One paginated read builds the open-PR head map once for the whole fan-out.
+		expect(resolution.listPullRequests).toHaveBeenCalledTimes(1)
 		expect(resolution.prNumbers()).toEqual([1437])
 
 		const result = await runWorkflow({ eventName: "workflow_dispatch", workflowDispatchPrNumber: 1437 })
 
-		// One read for the open-PR map; only the requested PR is reconciled.
-		expect(result.listPullRequests).toHaveBeenCalledTimes(1)
+		// The shard receives the map through the env; only the requested PR is reconciled.
+		expect(result.listPullRequests).not.toHaveBeenCalled()
 		expect(result.addLabels).toHaveBeenCalledWith(expect.objectContaining({ labels: ["coderabbit-review-active"] }))
 	})
 
+	it("reuses the sweep's open list for the head map without an extra read", async () => {
+		const resolution = await runResolve({ eventName: "schedule" })
+
+		// The sweep already paged the open list to pick its window, so the map is free.
+		expect(resolution.listPullRequests).toHaveBeenCalledTimes(1)
+		expect(resolution.openPrHeads()).toEqual({ [SHA.toLowerCase()]: 1437 })
+	})
+
+	it("passes an empty head map to shards when the open list cannot be read", async () => {
+		const resolution = await runResolve({
+			eventName: "workflow_dispatch",
+			workflowDispatchPrNumber: 1437,
+			openPrHeadsError: true,
+		})
+
+		// Fail-soft: review-state resolution survives, and shards skip the stacked label
+		// rather than deciding from an empty map.
+		expect(resolution.warning).toHaveBeenCalledWith(
+			expect.stringContaining("Could not read the open pull request map"),
+		)
+		expect(resolution.openPrHeads()).toBeNull()
+		expect(resolution.prNumbers()).toEqual([1437])
+	})
+
 	it("chains the resolve output through the matrix wiring into shard runs", async () => {
 		// End to end: the resolve output name/shape feeds the matrix expression,
 		// which feeds the shard's PR_NUMBER env. A wiring rename or shape change
@@ -2149,13 +2190,14 @@ describe("PR review-state workflow", () => {
 	it("reconciles the PR associated with a workflow run", async () => {
 		const resolution = await runResolve({ eventName: "workflow_run" })
 
-		expect(resolution.listPullRequests).not.toHaveBeenCalled()
+		// Associated runs need no lookup, but the head map is still built once here.
+		expect(resolution.listPullRequests).toHaveBeenCalledTimes(1)
 		expect(resolution.prNumbers()).toEqual([1437])
 
 		const result = await runWorkflow({ eventName: "workflow_run" })
 
-		// One read for the open-PR map; only the requested PR is reconciled.
-		expect(result.listPullRequests).toHaveBeenCalledTimes(1)
+		// The shard receives the map through the env; only the requested PR is reconciled.
+		expect(result.listPullRequests).not.toHaveBeenCalled()
 		expect(result.addLabels).toHaveBeenCalledWith(expect.objectContaining({ labels: ["coderabbit-review-active"] }))
 	})
 

From 50734f7f64e8363a8ce7ceed3ca0724278fa83d2 Mon Sep 17 00:00:00 2001
From: Eason Liang <easonliang28@gmail.com>
Date: Tue, 13 Oct 2026 00:23:58 +0800
Subject: [PATCH 12/23] Treat an empty open-PR list as an unavailable head map

CR review at bb7295f, thread 1: a pulls.list that returns zero entries would
serialize as {} - a non-null empty map the shard could decide from, removing a
valid stacked label with no known parent relationship. Since the reconciliation
target itself is open, a zero-entry list is anomalous: resolve now emits an empty
output in that case and shards keep the fail-soft (label unchanged).

Thread 2: added the resolver-to-shard contract test - the shard consumes the
actual open_pr_heads output through the declared OPEN_PR_HEADS env wiring, which
the test asserts by name.

209/207 tests pass (two new); eslint 0; prettier clean.
---
 .github/workflows/label-pr-review-state.yml   |  5 ++-
 .../pr-review-state-workflow.test.ts          | 39 ++++++++++++++++++-
 2 files changed, 42 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/label-pr-review-state.yml b/.github/workflows/label-pr-review-state.yml
index cd9f61299e..7d9baca0a6 100644
--- a/.github/workflows/label-pr-review-state.yml
+++ b/.github/workflows/label-pr-review-state.yml
@@ -209,7 +209,10 @@ jobs:
                           for (const candidate of openPrsForMap) {
                             if (candidate.head?.sha) heads[candidate.head.sha.toLowerCase()] = candidate.number;
                           }
-                          openPrHeadsOutput = JSON.stringify(heads);
+                          // An open-PR list with no entries is anomalous (the reconciliation
+                          // target itself is open), so treat it like an unavailable map:
+                          // shards must not decide from a map that looks empty.
+                          if (Object.keys(heads).length > 0) openPrHeadsOutput = JSON.stringify(heads);
                         } catch (error) {
                           core.warning(`Could not read the open pull request map: ${error.message}; shards will skip the stacked label this run`);
                         }
diff --git a/src/services/__tests__/pr-review-state-workflow.test.ts b/src/services/__tests__/pr-review-state-workflow.test.ts
index 662ca2c245..805b7433c8 100644
--- a/src/services/__tests__/pr-review-state-workflow.test.ts
+++ b/src/services/__tests__/pr-review-state-workflow.test.ts
@@ -81,6 +81,7 @@ interface HarnessOptions {
 	getCommitErrorStatus?: number
 	openPrHeads?: Array<{ number: number; sha: string }>
 	openPrHeadsError?: boolean
+	openPrHeadsEnv?: string
 	permissionErrorStatus?: number
 	requiredContexts?: string[]
 	requiredIntegrationId?: number | null
@@ -525,7 +526,7 @@ async function runWorkflow(options: HarnessOptions = {}) {
 	// resolve-side lookup failure, which reaches shards as an empty value.
 	const headMap: Record<string, number> = { [SHA.toLowerCase()]: pr.number }
 	for (const entry of options.openPrHeads ?? []) headMap[entry.sha.toLowerCase()] = entry.number
-	process.env.OPEN_PR_HEADS = options.openPrHeadsError ? "" : JSON.stringify(headMap)
+	process.env.OPEN_PR_HEADS = options.openPrHeadsError ? "" : (options.openPrHeadsEnv ?? JSON.stringify(headMap))
 	try {
 		await new AsyncFunction("github", "context", "core", workflowScript)(github, context, core)
 	} finally {
@@ -2163,6 +2164,42 @@ describe("PR review-state workflow", () => {
 		expect(resolution.prNumbers()).toEqual([1437])
 	})
 
+	it("treats an empty open-PR list as an unavailable head map", async () => {
+		const resolution = await runResolve({
+			eventName: "workflow_dispatch",
+			workflowDispatchPrNumber: 1437,
+			prState: "closed",
+		})
+
+		// The reconciliation target itself is open, so a zero-entry list is anomalous;
+		// emitting it as an empty map would let shards remove valid stacked labels.
+		expect(resolution.openPrHeads()).toBeNull()
+		expect(resolution.prNumbers()).toEqual([1437])
+	})
+
+	it("hands the resolver's head map to shards through the declared env wiring", async () => {
+		// Contract: the shard consumes exactly what resolve emits, through the job env
+		// expression under test - not a map the harness rebuilt independently.
+		expect(String(workflow.jobs.reconcile.env.OPEN_PR_HEADS)).toContain("needs.resolve.outputs.open_pr_heads")
+
+		const resolution = await runResolve({
+			eventName: "workflow_dispatch",
+			workflowDispatchPrNumber: 1437,
+			openPrHeads: [{ number: 1436, sha: OLD_SHA }],
+		})
+		const emitted = resolution.setOutput.mock.calls.find(([name]) => name === "open_pr_heads")?.[1] as string
+
+		const result = await runWorkflow({
+			eventName: "workflow_dispatch",
+			workflowDispatchPrNumber: 1437,
+			openPrHeadsEnv: emitted,
+			commitParents: [OLD_SHA],
+		})
+
+		expect(result.addLabels).toHaveBeenCalledWith(expect.objectContaining({ labels: ["stacked"] }))
+		expect(result.warning).not.toHaveBeenCalled()
+	})
+
 	it("chains the resolve output through the matrix wiring into shard runs", async () => {
 		// End to end: the resolve output name/shape feeds the matrix expression,
 		// which feeds the shard's PR_NUMBER env. A wiring rename or shape change

From 2ce4e3691039c163effcdaa9b608e699b2ea184c Mon Sep 17 00:00:00 2001
From: Eason Liang <easonliang28@gmail.com>
Date: Tue, 13 Oct 2026 01:28:52 +0800
Subject: [PATCH 13/23] Cover the anomalous empty-list case with the target
 open CR nitpick at 50734f7: the empty-map test drove prState closed,
 conflating the anomalous case (open target, zero-entry open list). New
 emptyOpenList harness option covers exactly that: resolve emits the
 unavailable-map output, and the shard - consuming the emitted value - leaves
 the existing stacked label untouched while review-state reconciliation still
 runs.

209/209 tests; eslint 0; prettier clean.
---
 .../pr-review-state-workflow.test.ts          | 31 +++++++++++++++++--
 1 file changed, 28 insertions(+), 3 deletions(-)

diff --git a/src/services/__tests__/pr-review-state-workflow.test.ts b/src/services/__tests__/pr-review-state-workflow.test.ts
index 805b7433c8..260520fc75 100644
--- a/src/services/__tests__/pr-review-state-workflow.test.ts
+++ b/src/services/__tests__/pr-review-state-workflow.test.ts
@@ -82,6 +82,7 @@ interface HarnessOptions {
 	openPrHeads?: Array<{ number: number; sha: string }>
 	openPrHeadsError?: boolean
 	openPrHeadsEnv?: string
+	emptyOpenList?: boolean
 	permissionErrorStatus?: number
 	requiredContexts?: string[]
 	requiredIntegrationId?: number | null
@@ -144,6 +145,7 @@ function createListPullRequests(options: HarnessOptions, eventName: string, pr:
 	return vi.fn(async ({ state }: { state?: string }) => {
 		if (state === "open" && options.openPrHeadsError)
 			throw Object.assign(new Error("Bad credentials"), { status: 401 })
+		if (state === "open" && options.emptyOpenList) return []
 		if (state === "open" && options.prState === "closed") return []
 		if (eventName === "workflow_run" && options.workflowRunAssociated === false) {
 			if (options.workflowRunFallback === "none" || options.workflowRunFallback === undefined) return []
@@ -2168,13 +2170,36 @@ describe("PR review-state workflow", () => {
 		const resolution = await runResolve({
 			eventName: "workflow_dispatch",
 			workflowDispatchPrNumber: 1437,
-			prState: "closed",
+			emptyOpenList: true,
 		})
 
-		// The reconciliation target itself is open, so a zero-entry list is anomalous;
-		// emitting it as an empty map would let shards remove valid stacked labels.
+		// The target itself is open, so a zero-entry open list is anomalous; emitting it
+		// as an empty map would let shards remove valid stacked labels.
 		expect(resolution.openPrHeads()).toBeNull()
 		expect(resolution.prNumbers()).toEqual([1437])
+
+		// The shard consumes the emitted (empty) output: the stacked label stays as it
+		// is while review-state reconciliation still runs.
+		const emitted = resolution.setOutput.mock.calls.find(([name]) => name === "open_pr_heads")?.[1] as string
+		const result = await runWorkflow({
+			eventName: "workflow_dispatch",
+			workflowDispatchPrNumber: 1437,
+			openPrHeadsEnv: emitted,
+			labels: ["stacked", "awaiting-maintainer"],
+			permissions: { maintainer: "write" },
+			reviews: [
+				{
+					login: "maintainer",
+					type: "User",
+					state: "APPROVED",
+					submittedAt: REVIEWED_AT,
+				},
+			],
+		})
+
+		expect(result.removeLabel).not.toHaveBeenCalledWith(expect.objectContaining({ name: "stacked" }))
+		expect(result.removeLabel).toHaveBeenCalledWith(expect.objectContaining({ name: "awaiting-maintainer" }))
+		expect(result.setFailed).not.toHaveBeenCalled()
 	})
 
 	it("hands the resolver's head map to shards through the declared env wiring", async () => {

From e689ebda0e135aa655604480178e8cc5eccb5d5c Mon Sep 17 00:00:00 2001
From: easonLiangWorldedtech
 <136036952+easonLiangWorldedtech@users.noreply.github.com>
Date: Fri, 23 Oct 2026 01:40:32 +0800
Subject: [PATCH 14/23] chore: retrigger CI (compile check stayed in progress
 after the merge run completed)


From 25894543078a306a6fbab6ce28e5f298d7758050 Mon Sep 17 00:00:00 2001
From: easonLiangWorldedtech
 <136036952+easonLiangWorldedtech@users.noreply.github.com>
Date: Fri, 23 Oct 2026 01:59:47 +0800
Subject: [PATCH 15/23] fix(workflow): do not label a PR stacked on its own
 previous head

The open-PR head map can predate a push to the PR being reconciled, so a parent sha can resolve to the PR itself. A self-match is not a parent PR: the label is left untouched instead of marking the PR stacked on its own old head. Adds the regression test the review suggested.
---
 .github/workflows/label-pr-review-state.yml           |  5 ++++-
 .../__tests__/pr-review-state-workflow.test.ts        | 11 +++++++++++
 2 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/label-pr-review-state.yml b/.github/workflows/label-pr-review-state.yml
index 8c3fc67e9f..a0249a19da 100644
--- a/.github/workflows/label-pr-review-state.yml
+++ b/.github/workflows/label-pr-review-state.yml
@@ -495,9 +495,12 @@ jobs:
                         try {
                           const { data: commit } = await github.rest.git.getCommit({ owner, repo, commit_sha: pr.head.sha });
                           const parents = Array.isArray(commit.parents) ? commit.parents : [];
-                          const parentPr = parents.length === 1
+                          const matchedPr = parents.length === 1
                             ? openPrHeads.get(String(parents[0].sha).toLowerCase())
                             : undefined;
+                          // The open-PR map can predate a push to this PR: its own previous (or now
+                          // base) head is not a parent PR, so a self-match must not label it stacked.
+                          const parentPr = matchedPr === pr.number ? undefined : matchedPr;
                           const hasLabel = pr.labels.some(label => label.name === stackedLabel);
                           if (hasLabel && parentPr === undefined) {
                             await github.rest.issues.removeLabel({ owner, repo, issue_number: pr.number, name: stackedLabel });
diff --git a/src/services/__tests__/pr-review-state-workflow.test.ts b/src/services/__tests__/pr-review-state-workflow.test.ts
index cee3a682dd..f7ce803dc4 100644
--- a/src/services/__tests__/pr-review-state-workflow.test.ts
+++ b/src/services/__tests__/pr-review-state-workflow.test.ts
@@ -739,6 +739,17 @@ describe("PR review-state workflow", () => {
 		expect(result.warning).not.toHaveBeenCalled()
 	})
 
+	it("does not label a PR stacked when the matched open head is its own", async () => {
+		const result = await runWorkflow({
+			commitParents: [OLD_SHA],
+			// The open-PR map predates this PR's latest push: its own previous head is listed.
+			openPrHeads: [{ number: 1437, sha: OLD_SHA }],
+		})
+
+		expect(result.addLabels).not.toHaveBeenCalledWith(expect.objectContaining({ labels: ["stacked"] }))
+		expect(result.removeLabel).not.toHaveBeenCalledWith(expect.objectContaining({ name: "stacked" }))
+	})
+
 	it("removes a stale stacked label when the parent is not another open PR head", async () => {
 		const result = await runWorkflow({
 			labels: ["stacked"],

From bb4ef327e3f1b1b3f36a1f568cc157b2ed728ae4 Mon Sep 17 00:00:00 2001
From: easonLiangWorldedtech
 <136036952+easonLiangWorldedtech@users.noreply.github.com>
Date: Fri, 23 Oct 2026 02:14:00 +0800
Subject: [PATCH 16/23] fix(workflow): skip every stacked-label mutation on a
 self-match

A self-match means the open-PR map still lists this PR own previous head, which is not evidence that a current stacked relationship is stale. Returning before any mutation keeps an existing label untouched instead of letting the removal branch delete it. Tests: an existing stacked label survives a self-match run, and a valid stacked label survives review-state reconciliation. Workflow suite 236 passed.
---
 .github/workflows/label-pr-review-state.yml   |  7 +++-
 .../pr-review-state-workflow.test.ts          | 38 +++++++++++++++++++
 2 files changed, 43 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/label-pr-review-state.yml b/.github/workflows/label-pr-review-state.yml
index a0249a19da..9314bf0ea9 100644
--- a/.github/workflows/label-pr-review-state.yml
+++ b/.github/workflows/label-pr-review-state.yml
@@ -499,8 +499,11 @@ jobs:
                             ? openPrHeads.get(String(parents[0].sha).toLowerCase())
                             : undefined;
                           // The open-PR map can predate a push to this PR: its own previous (or now
-                          // base) head is not a parent PR, so a self-match must not label it stacked.
-                          const parentPr = matchedPr === pr.number ? undefined : matchedPr;
+                          // base) head resolves back to this PR. That is not a parent PR, and it is
+                          // also not evidence that an existing stacked label is stale - leave every
+                          // stacked-label mutation untouched for this ambiguous self-match.
+                          if (matchedPr === pr.number) return;
+                          const parentPr = matchedPr;
                           const hasLabel = pr.labels.some(label => label.name === stackedLabel);
                           if (hasLabel && parentPr === undefined) {
                             await github.rest.issues.removeLabel({ owner, repo, issue_number: pr.number, name: stackedLabel });
diff --git a/src/services/__tests__/pr-review-state-workflow.test.ts b/src/services/__tests__/pr-review-state-workflow.test.ts
index f7ce803dc4..a9be6f9e31 100644
--- a/src/services/__tests__/pr-review-state-workflow.test.ts
+++ b/src/services/__tests__/pr-review-state-workflow.test.ts
@@ -750,6 +750,44 @@ describe("PR review-state workflow", () => {
 		expect(result.removeLabel).not.toHaveBeenCalledWith(expect.objectContaining({ name: "stacked" }))
 	})
 
+	it("leaves an existing stacked label untouched on a self-match", async () => {
+		// A valid label must survive a run whose open-PR map still contains this PR's own
+		// previous head: a self-match is not evidence that the relationship is stale.
+		const result = await runWorkflow({
+			labels: ["stacked"],
+			commitParents: [OLD_SHA],
+			openPrHeads: [{ number: 1437, sha: OLD_SHA }],
+		})
+
+		expect(result.removeLabel).not.toHaveBeenCalledWith(expect.objectContaining({ name: "stacked" }))
+		expect(result.addLabels).not.toHaveBeenCalledWith(expect.objectContaining({ labels: ["stacked"] }))
+		const labels = ((await result.getPullRequest()).data.labels || []).map((label: { name: string }) => label.name)
+		expect(labels).toContain("stacked")
+	})
+
+	it("keeps a valid stacked label through review-state reconciliation", async () => {
+		const result = await runWorkflow({
+			labels: ["stacked", "awaiting-maintainer"],
+			commitParents: [OLD_SHA],
+			openPrHeads: [{ number: 1436, sha: OLD_SHA }],
+			permissions: { maintainer: "write" },
+			reviews: [
+				{
+					login: "maintainer",
+					type: "User",
+					state: "APPROVED",
+					submittedAt: REVIEWED_AT,
+				},
+			],
+		})
+
+		// The reconcileLabels turn may replace review-state labels; the orthogonal stacked
+		// label must be neither removed nor re-added.
+		expect(result.removeLabel).not.toHaveBeenCalledWith(expect.objectContaining({ name: "stacked" }))
+		const labels = ((await result.getPullRequest()).data.labels || []).map((label: { name: string }) => label.name)
+		expect(labels).toContain("stacked")
+	})
+
 	it("removes a stale stacked label when the parent is not another open PR head", async () => {
 		const result = await runWorkflow({
 			labels: ["stacked"],

From eca78435f1ab33161bcb9fb39e7e8c2cef5aab8a Mon Sep 17 00:00:00 2001
From: easonLiangWorldedtech
 <136036952+easonLiangWorldedtech@users.noreply.github.com>
Date: Fri, 23 Oct 2026 04:42:09 +0800
Subject: [PATCH 17/23] test(workflow): assert review-state reconciliation in
 the stacked-label tests

Self-match case now starts with stacked + awaiting-maintainer and a maintainer approval, and asserts awaiting-maintainer is removed while stacked remains; the valid-parent reconciliation test gains the same removal assertion. Workflow suite 236 passed.
---
 .../pr-review-state-workflow.test.ts          | 22 +++++++++++++++----
 1 file changed, 18 insertions(+), 4 deletions(-)

diff --git a/src/services/__tests__/pr-review-state-workflow.test.ts b/src/services/__tests__/pr-review-state-workflow.test.ts
index a9be6f9e31..2b2507dcdc 100644
--- a/src/services/__tests__/pr-review-state-workflow.test.ts
+++ b/src/services/__tests__/pr-review-state-workflow.test.ts
@@ -750,19 +750,32 @@ describe("PR review-state workflow", () => {
 		expect(result.removeLabel).not.toHaveBeenCalledWith(expect.objectContaining({ name: "stacked" }))
 	})
 
-	it("leaves an existing stacked label untouched on a self-match", async () => {
+	it("leaves an existing stacked label untouched on a self-match while review state reconciles", async () => {
 		// A valid label must survive a run whose open-PR map still contains this PR's own
-		// previous head: a self-match is not evidence that the relationship is stale.
+		// previous head: a self-match is not evidence that the relationship is stale. The
+		// review-state turn still runs and must move awaiting-maintainer independently.
 		const result = await runWorkflow({
-			labels: ["stacked"],
+			labels: ["stacked", "awaiting-maintainer"],
 			commitParents: [OLD_SHA],
 			openPrHeads: [{ number: 1437, sha: OLD_SHA }],
+			permissions: { maintainer: "write" },
+			reviews: [
+				{
+					login: "maintainer",
+					type: "User",
+					state: "APPROVED",
+					submittedAt: REVIEWED_AT,
+				},
+			],
 		})
 
 		expect(result.removeLabel).not.toHaveBeenCalledWith(expect.objectContaining({ name: "stacked" }))
 		expect(result.addLabels).not.toHaveBeenCalledWith(expect.objectContaining({ labels: ["stacked"] }))
+		// The review-state reconciliation still removes the review-state label on its own.
+		expect(result.removeLabel).toHaveBeenCalledWith(expect.objectContaining({ name: "awaiting-maintainer" }))
 		const labels = ((await result.getPullRequest()).data.labels || []).map((label: { name: string }) => label.name)
 		expect(labels).toContain("stacked")
+		expect(labels).not.toContain("awaiting-maintainer")
 	})
 
 	it("keeps a valid stacked label through review-state reconciliation", async () => {
@@ -782,7 +795,8 @@ describe("PR review-state workflow", () => {
 		})
 
 		// The reconcileLabels turn may replace review-state labels; the orthogonal stacked
-		// label must be neither removed nor re-added.
+		// label must be neither removed nor re-added, while the review-state label is removed.
+		expect(result.removeLabel).toHaveBeenCalledWith(expect.objectContaining({ name: "awaiting-maintainer" }))
 		expect(result.removeLabel).not.toHaveBeenCalledWith(expect.objectContaining({ name: "stacked" }))
 		const labels = ((await result.getPullRequest()).data.labels || []).map((label: { name: string }) => label.name)
 		expect(labels).toContain("stacked")

From 25104607243098be356545a559a07ebd5541b79f Mon Sep 17 00:00:00 2001
From: Eason Liang <easonliang28@gmail.com>
Date: Wed, 28 Oct 2026 23:26:35 +0800
Subject: [PATCH 18/23] fix(workflow): read the stacked head map only when an
 event can change a stack

Outside the sweep path every direct event paged the full open-PR list to build the stacked head map, including reviews, CodeRabbit status comments, workflow_run completions, and manual dispatch - none of which can publish a head commit, so none of them can change a stacked relationship. The resolve job now builds the map only on sweeps (which already hold the open list) and on opened/reopened/synchronize, and emits a 'not-evaluated' sentinel otherwise; shards treat that sentinel as 'label not evaluated' (info, no warning) while an empty value still means the read failed.

Also corrects the permissions header comment, which still claimed every unspecified permission including contents is none, while contents: read is granted for the commit-parent lookup.

Tests: opened/reopened/synchronize read the map once and emit it; dispatch and workflow_run emit the sentinel with no list read; the shard logs the sentinel at info level and leaves the label alone; a non-JSON OPEN_PR_HEADS value reaches the shard's JSON.parse catch and is advisory. The accept side of the read-only guard is now covered: a same-repository review run and a fork PR on a writable pull_request_target run both still add the stacked label. Negative controls: always reading the map turns the dispatch/workflow_run tests red; dropping the sentinel branch turns the sentinel and dispatch tests red.
---
 .github/workflows/label-pr-review-state.yml   |  50 +++++--
 .../pr-review-state-workflow.test.ts          | 122 ++++++++++++++++--
 2 files changed, 146 insertions(+), 26 deletions(-)

diff --git a/.github/workflows/label-pr-review-state.yml b/.github/workflows/label-pr-review-state.yml
index 9314bf0ea9..15733aba58 100644
--- a/.github/workflows/label-pr-review-state.yml
+++ b/.github/workflows/label-pr-review-state.yml
@@ -47,8 +47,9 @@ on:
 
 permissions:
     # This privileged workflow only reads PR/check metadata and writes issue labels,
-    # comments, and commit statuses. All unspecified permissions, including contents,
-    # are none; no fork code or configuration is checked out or executed.
+    # comments, and commit statuses. All unspecified permissions are none; contents is
+    # read-only and used only for the commit-parent lookup below. No fork code or
+    # configuration is checked out or executed.
     pull-requests: write
     issues: write
     checks: read
@@ -211,11 +212,22 @@ jobs:
                       // Build the open-PR head map once here for every shard: a sweep would otherwise
                       // multiply the paginated open-PR read by every shard against the Actions token
                       // budget. Sweep triggers already hold the full open list, so the map costs them
-                      // no extra read. An empty output means the map was unavailable (or nothing was
-                      // resolved); shards then skip the stacked label rather than deciding from an
-                      // empty map.
+                      // no extra read.
+                      //
+                      // The map only describes which commits are open pull request heads, so it can
+                      // only change when a pull request's head is (re)published: opened, reopened, or
+                      // synchronize. Reviews, comments, workflow_run completions, and manual dispatch
+                      // cannot change it, so they skip the paginated read entirely and pass a sentinel
+                      // that tells shards the label was not evaluated. Reading it on every direct event
+                      // would add one full open-PR listing to each review and status-comment run.
+                      //
+                      // An empty output means the map was unavailable this run; shards then skip the
+                      // stacked label rather than deciding from an empty map.
+                      const stackMayHaveChanged =
+                        context.eventName === 'pull_request_target' &&
+                        ['opened', 'reopened', 'synchronize'].includes(context.payload.action);
                       let openPrHeadsOutput = '';
-                      if (prNumbers.length > 0) {
+                      if (prNumbers.length > 0 && (openPrsCache || stackMayHaveChanged)) {
                         try {
                           const openPrsForMap = openPrsCache ?? (await github.paginate(github.rest.pulls.list, {
                             owner, repo, state: 'open', per_page: 100,
@@ -231,6 +243,13 @@ jobs:
                         } catch (error) {
                           core.warning(`Could not read the open pull request map: ${error.message}; shards will skip the stacked label this run`);
                         }
+                      } else if (prNumbers.length > 0) {
+                        // Sentinel: this event cannot change a stacked relationship, so the label was
+                        // not evaluated rather than found unavailable. Shards skip it silently.
+                        openPrHeadsOutput = 'not-evaluated';
+                        core.info(
+                          `Open-PR head map not read: ${context.eventName} cannot change a stacked unit; shards skip the stacked label.`
+                        );
                       }
                       core.setOutput('open_pr_heads', openPrHeadsOutput);
 
@@ -853,15 +872,22 @@ jobs:
                       const failures = [];
 
                       // The open-PR head map is built once in the resolve job and passed through the
-                      // job env, so a sweep pays one paginated read instead of one per shard. An empty
-                      // value means the map was unavailable this run: leave existing stacked labels as
-                      // they are rather than deciding from an empty map, which would look like
-                      // "no open parents" and remove valid labels.
+                      // job env, so a sweep pays one paginated read instead of one per shard. The resolve
+                      // job passes NOT_EVALUATED_MAP when the event could not change a stacked
+                      // relationship, and an empty value when it tried to read the map and failed.
+                      // Either way existing stacked labels are left as they are: a map that is absent,
+                      // empty, or not read must never look like "no open parents" and remove them.
+                      const NOT_EVALUATED_MAP = 'not-evaluated';
                       let openPrHeads = null;
                       if (prs.length > 0) {
-                        if (process.env.OPEN_PR_HEADS) {
+                        const emittedMap = process.env.OPEN_PR_HEADS;
+                        if (emittedMap === NOT_EVALUATED_MAP) {
+                          core.info(
+                            `PR #${prs[0].number}: this event cannot change a stacked unit; skipping the stacked label`
+                          );
+                        } else if (emittedMap) {
                           try {
-                            openPrHeads = new Map(Object.entries(JSON.parse(process.env.OPEN_PR_HEADS)));
+                            openPrHeads = new Map(Object.entries(JSON.parse(emittedMap)));
                           } catch (error) {
                             core.warning(`Could not read the open pull request map: ${error.message}; skipping the stacked label for this run`);
                           }
diff --git a/src/services/__tests__/pr-review-state-workflow.test.ts b/src/services/__tests__/pr-review-state-workflow.test.ts
index 2b2507dcdc..3dfb4840c3 100644
--- a/src/services/__tests__/pr-review-state-workflow.test.ts
+++ b/src/services/__tests__/pr-review-state-workflow.test.ts
@@ -36,6 +36,9 @@ interface HarnessOptions {
 	headShaSequence?: string[]
 	fork?: boolean
 	eventName?: string
+	// pull_request_target activity type; it decides whether the resolve job reads the open-PR
+	// head map (only opened/reopened/synchronize can change a stacked relationship).
+	action?: string
 	issueCommentActor?: string
 	workflowRunAssociated?: boolean
 	workflowRunFallback?: "match" | "sha-mismatch" | "base-mismatch" | "none"
@@ -210,7 +213,7 @@ function buildEventPayload(eventName: string, options: HarnessOptions) {
 							},
 						}
 					: {
-							action: "ready_for_review",
+							action: options.action ?? "ready_for_review",
 							pull_request: pullRequestPayload,
 						}
 }
@@ -662,6 +665,8 @@ async function runResolve(options: HarnessOptions = {}) {
 		info: core.info,
 		warning: core.warning,
 		prNumbers: () => (prNumbersOutput !== undefined ? (JSON.parse(prNumbersOutput) as number[]) : undefined),
+		// The sentinel is deliberately not JSON: pin the exact emitted value instead of guessing.
+		openPrHeadsRaw: () => openPrHeadsOutput,
 		openPrHeads: () => (openPrHeadsOutput ? (JSON.parse(openPrHeadsOutput) as Record<string, number>) : null),
 	}
 }
@@ -819,6 +824,75 @@ describe("PR review-state workflow", () => {
 		expect(result.getCommit).not.toHaveBeenCalled()
 	})
 
+	// The pair of the read-only test above: the guard skips a fork PR only when the RUN is
+	// read-only too. These two pin the accept side, so dropping either half of
+	// `isReadOnlyRun && isForkPR(pr)` cannot pass silently.
+	it("adds the stacked label on a same-repository review event", async () => {
+		const result = await runWorkflow({
+			eventName: "pull_request_review",
+			fork: false,
+			commitParents: [OLD_SHA],
+			openPrHeads: [{ number: 1436, sha: OLD_SHA }],
+		})
+
+		// A review of a base-repository PR runs with a writable token, so the label still mutates.
+		expect(result.addLabels).toHaveBeenCalledWith(expect.objectContaining({ labels: ["stacked"] }))
+	})
+
+	it("adds the stacked label to a fork PR on a writable run", async () => {
+		const result = await runWorkflow({
+			eventName: "pull_request_target",
+			action: "synchronize",
+			fork: true,
+			commitParents: [OLD_SHA],
+			openPrHeads: [{ number: 1436, sha: OLD_SHA }],
+		})
+
+		// pull_request_target runs in the base repository with a writable token, so a fork PR is
+		// reconciled normally; only the fork pull_request_review run is read-only.
+		expect(result.addLabels).toHaveBeenCalledWith(expect.objectContaining({ labels: ["stacked"] }))
+	})
+	it("skips the stacked label silently when the event could not evaluate the head map", async () => {
+		const result = await runWorkflow({
+			eventName: "workflow_dispatch",
+			openPrHeadsEnv: "not-evaluated",
+			labels: ["stacked", "awaiting-maintainer"],
+			permissions: { maintainer: "write" },
+			reviews: [
+				{
+					login: "maintainer",
+					type: "User",
+					state: "APPROVED",
+					submittedAt: REVIEWED_AT,
+				},
+			],
+		})
+
+		// Not evaluated is not the same as unavailable: the label is left alone without a warning,
+		// because the resolve job deliberately skipped the read for a non-head-publishing event.
+		expect(result.info).toHaveBeenCalledWith(expect.stringContaining("cannot change a stacked unit"))
+		expect(result.warning).not.toHaveBeenCalledWith(expect.stringContaining("open pull request map"))
+		expect(result.removeLabel).not.toHaveBeenCalledWith(expect.objectContaining({ name: "stacked" }))
+		// Review-state reconciliation still runs for the PR.
+		expect(result.removeLabel).toHaveBeenCalledWith(expect.objectContaining({ name: "awaiting-maintainer" }))
+		expect(result.setFailed).not.toHaveBeenCalled()
+	})
+
+	it("warns and leaves the stacked label alone when the head map is not JSON", async () => {
+		const result = await runWorkflow({
+			openPrHeadsEnv: "{not-json",
+			labels: ["stacked"],
+		})
+
+		// A malformed map reaches the shard's JSON.parse catch: warn and leave the label as it is
+		// rather than deciding from a map that could not be read.
+		expect(result.warning).toHaveBeenCalledWith(
+			expect.stringContaining("Could not read the open pull request map"),
+		)
+		expect(result.removeLabel).not.toHaveBeenCalledWith(expect.objectContaining({ name: "stacked" }))
+		expect(result.setFailed).not.toHaveBeenCalled()
+	})
+
 	it("advises instead of failing when the stacked parent cannot be read", async () => {
 		const result = await runWorkflow({ labels: ["stacked"], getCommitErrorStatus: 500 })
 
@@ -2590,20 +2664,38 @@ describe("PR review-state workflow", () => {
 		expect(pages[0].info).toHaveBeenCalledWith(expect.stringContaining("450"))
 	})
 
-	it("reconciles only the requested PR during manual dispatch", async () => {
+	it("reconciles only the requested PR during manual dispatch and does not read the head map", async () => {
 		const resolution = await runResolve({ eventName: "workflow_dispatch", workflowDispatchPrNumber: 1437 })
 
-		// One paginated read builds the open-PR head map once for the whole fan-out.
-		expect(resolution.listPullRequests).toHaveBeenCalledTimes(1)
+		// A manual dispatch cannot publish a head commit, so it cannot change a stacked relationship:
+		// the paginated open-PR read is skipped and shards are told the label was not evaluated.
+		expect(resolution.listPullRequests).not.toHaveBeenCalled()
 		expect(resolution.prNumbers()).toEqual([1437])
+		expect(resolution.openPrHeadsRaw()).toBe("not-evaluated")
+		expect(resolution.info).toHaveBeenCalledWith(expect.stringContaining("cannot change a stacked unit"))
 
-		const result = await runWorkflow({ eventName: "workflow_dispatch", workflowDispatchPrNumber: 1437 })
+		const result = await runWorkflow({
+			eventName: "workflow_dispatch",
+			workflowDispatchPrNumber: 1437,
+			openPrHeadsEnv: "not-evaluated",
+		})
 
-		// The shard receives the map through the env; only the requested PR is reconciled.
+		// The shard receives the sentinel through the env; only the requested PR is reconciled.
 		expect(result.listPullRequests).not.toHaveBeenCalled()
+		expect(result.warning).not.toHaveBeenCalledWith(expect.stringContaining("open pull request map"))
 		expect(result.addLabels).toHaveBeenCalledWith(expect.objectContaining({ labels: ["coderabbit-review-active"] }))
 	})
 
+	it.each(["opened", "reopened", "synchronize"])(
+		"reads the head map on a %s event, which can publish a head commit",
+		async (action) => {
+			const resolution = await runResolve({ eventName: "pull_request_target", action })
+
+			expect(resolution.listPullRequests).toHaveBeenCalledTimes(1)
+			expect(resolution.openPrHeads()).toEqual({ [SHA.toLowerCase()]: 1437 })
+		},
+	)
+
 	it("reuses the sweep's open list for the head map without an extra read", async () => {
 		const resolution = await runResolve({ eventName: "schedule" })
 
@@ -2614,8 +2706,8 @@ describe("PR review-state workflow", () => {
 
 	it("passes an empty head map to shards when the open list cannot be read", async () => {
 		const resolution = await runResolve({
-			eventName: "workflow_dispatch",
-			workflowDispatchPrNumber: 1437,
+			eventName: "pull_request_target",
+			action: "synchronize",
 			openPrHeadsError: true,
 		})
 
@@ -2630,8 +2722,8 @@ describe("PR review-state workflow", () => {
 
 	it("treats an empty open-PR list as an unavailable head map", async () => {
 		const resolution = await runResolve({
-			eventName: "workflow_dispatch",
-			workflowDispatchPrNumber: 1437,
+			eventName: "pull_request_target",
+			action: "synchronize",
 			emptyOpenList: true,
 		})
 
@@ -2670,8 +2762,8 @@ describe("PR review-state workflow", () => {
 		expect(String(workflow.jobs.reconcile.env.OPEN_PR_HEADS)).toContain("needs.resolve.outputs.open_pr_heads")
 
 		const resolution = await runResolve({
-			eventName: "workflow_dispatch",
-			workflowDispatchPrNumber: 1437,
+			eventName: "pull_request_target",
+			action: "synchronize",
 			openPrHeads: [{ number: 1436, sha: OLD_SHA }],
 		})
 		const emitted = resolution.setOutput.mock.calls.find(([name]) => name === "open_pr_heads")?.[1] as string
@@ -2714,8 +2806,10 @@ describe("PR review-state workflow", () => {
 	it("reconciles the PR associated with a workflow run", async () => {
 		const resolution = await runResolve({ eventName: "workflow_run" })
 
-		// Associated runs need no lookup, but the head map is still built once here.
-		expect(resolution.listPullRequests).toHaveBeenCalledTimes(1)
+		// Associated runs need no lookup, and a workflow_run cannot publish a head commit, so the
+		// head map is not read here either.
+		expect(resolution.listPullRequests).not.toHaveBeenCalled()
+		expect(resolution.openPrHeadsRaw()).toBe("not-evaluated")
 		expect(resolution.prNumbers()).toEqual([1437])
 
 		const result = await runWorkflow({ eventName: "workflow_run" })

From 67a97fcf34afd50836f82e9313d80cbcc137f5bb Mon Sep 17 00:00:00 2001
From: Eason Liang <easonliang28@gmail.com>
Date: Wed, 28 Oct 2026 23:42:55 +0800
Subject: [PATCH 19/23] style: format the workflow spec for the compile job's
 format check

main added a repo-wide prettier check to the compile job after this branch's base; the touched spec is now prettier-clean with no behavior change (243 tests still pass).
---
 src/services/__tests__/pr-review-state-workflow.test.ts | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/services/__tests__/pr-review-state-workflow.test.ts b/src/services/__tests__/pr-review-state-workflow.test.ts
index 3dfb4840c3..3b8204476d 100644
--- a/src/services/__tests__/pr-review-state-workflow.test.ts
+++ b/src/services/__tests__/pr-review-state-workflow.test.ts
@@ -886,9 +886,7 @@ describe("PR review-state workflow", () => {
 
 		// A malformed map reaches the shard's JSON.parse catch: warn and leave the label as it is
 		// rather than deciding from a map that could not be read.
-		expect(result.warning).toHaveBeenCalledWith(
-			expect.stringContaining("Could not read the open pull request map"),
-		)
+		expect(result.warning).toHaveBeenCalledWith(expect.stringContaining("Could not read the open pull request map"))
 		expect(result.removeLabel).not.toHaveBeenCalledWith(expect.objectContaining({ name: "stacked" }))
 		expect(result.setFailed).not.toHaveBeenCalled()
 	})

From eb14b6bd2eb3f29ae44c5b28ec7f5df86727a235 Mon Sep 17 00:00:00 2001
From: Eason Liang <136036952+easonLiangWorldedtech@users.noreply.github.com>
Date: Wed, 4 Nov 2026 04:12:18 +0800
Subject: [PATCH 20/23] fix(label): keep the stacked label on the run that
 replaces a pending synchronize

A labeled/unlabeled run shares the PR's concurrency group, so it can replace a
pending synchronize run for the same PR. The replacement emitted the
not-evaluated sentinel and skipped the stacked label for the new head, leaving it
stale until the hourly sweep. Those actions now read the open-PR head map too.

The stacked label description no longer claims "its diff is only this unit": the
label comes from commit-graph detection alone (reconcileStackedLabel never reads
the base branch), so a child PR targeting main while sitting on another open
head keeps the label and its diff still contains the parent's commits.
---
 .github/workflows/label-pr-review-state.yml   | 19 +++++++++++--------
 .../pr-review-state-workflow.test.ts          |  9 ++++++---
 2 files changed, 17 insertions(+), 11 deletions(-)

diff --git a/.github/workflows/label-pr-review-state.yml b/.github/workflows/label-pr-review-state.yml
index 4d2a5d1532..8a6a45b86c 100644
--- a/.github/workflows/label-pr-review-state.yml
+++ b/.github/workflows/label-pr-review-state.yml
@@ -214,18 +214,21 @@ jobs:
                       // budget. Sweep triggers already hold the full open list, so the map costs them
                       // no extra read.
                       //
-                      // The map only describes which commits are open pull request heads, so it can
-                      // only change when a pull request's head is (re)published: opened, reopened, or
-                      // synchronize. Reviews, comments, workflow_run completions, and manual dispatch
-                      // cannot change it, so they skip the paginated read entirely and pass a sentinel
-                      // that tells shards the label was not evaluated. Reading it on every direct event
-                      // would add one full open-PR listing to each review and status-comment run.
+                      // The map describes which commits are open pull request heads. It can change when a
+                      // head is (re)published (opened, reopened, synchronize), and a labeled/unlabeled
+                      // run is included for a different reason: it shares this PR's concurrency group,
+                      // so it can replace a pending synchronize run for the same PR. A replacement run
+                      // that skipped the map would skip the stacked label for the new head and leave it
+                      // stale until the hourly sweep. Reviews, comments, workflow_run completions, and
+                      // manual dispatch cannot change it (and cannot displace a synchronize run in a way
+                      // that leaves the label stale), so they skip the paginated read entirely and pass
+                      // a sentinel that tells shards the label was not evaluated.
                       //
                       // An empty output means the map was unavailable this run; shards then skip the
                       // stacked label rather than deciding from an empty map.
                       const stackMayHaveChanged =
                         context.eventName === 'pull_request_target' &&
-                        ['opened', 'reopened', 'synchronize'].includes(context.payload.action);
+                        ['opened', 'reopened', 'synchronize', 'labeled', 'unlabeled'].includes(context.payload.action);
                       let openPrHeadsOutput = '';
                       if (prNumbers.length > 0 && (openPrsCache || stackMayHaveChanged)) {
                         try {
@@ -360,7 +363,7 @@ jobs:
                         {
                           name: 'stacked',
                           color: 'c2c2c2',
-                          description: 'Head commit sits on another open PR, so its diff is only this unit',
+                          description: 'Head commit also sits on another open PR (detected from the commit graph)',
                         },
                       ];
                       const guideMarker = '<!-- zoo-code-pr-review-process -->';
diff --git a/src/services/__tests__/pr-review-state-workflow.test.ts b/src/services/__tests__/pr-review-state-workflow.test.ts
index cdf4e07e61..4b888efaf5 100644
--- a/src/services/__tests__/pr-review-state-workflow.test.ts
+++ b/src/services/__tests__/pr-review-state-workflow.test.ts
@@ -1082,7 +1082,7 @@ describe("PR review-state workflow", () => {
 			expect.objectContaining({
 				name: "stacked",
 				color: "c2c2c2",
-				description: "Head commit sits on another open PR, so its diff is only this unit",
+				description: "Head commit also sits on another open PR (detected from the commit graph)",
 			}),
 		)
 	})
@@ -2713,8 +2713,11 @@ describe("PR review-state workflow", () => {
 		expect(result.addLabels).toHaveBeenCalledWith(expect.objectContaining({ labels: ["coderabbit-review-active"] }))
 	})
 
-	it.each(["opened", "reopened", "synchronize"])(
-		"reads the head map on a %s event, which can publish a head commit",
+	// labeled/unlabeled are here because such a run shares the PR's concurrency group: it can
+	// replace a pending synchronize run for the same PR, and a replacement that skipped the map
+	// would leave the stacked label stale until the hourly sweep.
+	it.each(["opened", "reopened", "synchronize", "labeled", "unlabeled"])(
+		"reads the head map on a %s event, which can publish a head commit or replace the run that would",
 		async (action) => {
 			const resolution = await runResolve({ eventName: "pull_request_target", action })
 

From 97cbeb76f2b2a39df8e64127080df64e702361fc Mon Sep 17 00:00:00 2001
From: Eason Liang <136036952+easonLiangWorldedtech@users.noreply.github.com>
Date: Wed, 4 Nov 2026 05:03:21 +0800
Subject: [PATCH 21/23] fix(ci): describe the stacked label by the parent
 relationship it detects

The stacked label description said the head commit "also sits on another open PR", but the
detection rule checks that the head commit's sole parent is another open PR's head - the head
commit itself is not on that PR. The description now names the parent relationship, and the
workflow test that pins the exact text is updated with it.

pr-review-state-workflow.test.ts passes. Documented in the review thread that the detection rule
is unchanged; only the reviewer-facing text moves.
---
 .github/workflows/label-pr-review-state.yml             | 2 +-
 src/services/__tests__/pr-review-state-workflow.test.ts | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/label-pr-review-state.yml b/.github/workflows/label-pr-review-state.yml
index 8a6a45b86c..af645926b3 100644
--- a/.github/workflows/label-pr-review-state.yml
+++ b/.github/workflows/label-pr-review-state.yml
@@ -363,7 +363,7 @@ jobs:
                         {
                           name: 'stacked',
                           color: 'c2c2c2',
-                          description: 'Head commit also sits on another open PR (detected from the commit graph)',
+                          description: 'Head commit sits directly on another open PR head (detected from the commit graph)',
                         },
                       ];
                       const guideMarker = '<!-- zoo-code-pr-review-process -->';
diff --git a/src/services/__tests__/pr-review-state-workflow.test.ts b/src/services/__tests__/pr-review-state-workflow.test.ts
index 4b888efaf5..65982a5947 100644
--- a/src/services/__tests__/pr-review-state-workflow.test.ts
+++ b/src/services/__tests__/pr-review-state-workflow.test.ts
@@ -1082,7 +1082,7 @@ describe("PR review-state workflow", () => {
 			expect.objectContaining({
 				name: "stacked",
 				color: "c2c2c2",
-				description: "Head commit also sits on another open PR (detected from the commit graph)",
+				description: "Head commit sits directly on another open PR head (detected from the commit graph)",
 			}),
 		)
 	})

From 3535359cb614245436605f3551a01845b6c35dd2 Mon Sep 17 00:00:00 2001
From: Eason Liang <136036952+easonLiangWorldedtech@users.noreply.github.com>
Date: Wed, 4 Nov 2026 05:05:03 +0800
Subject: [PATCH 22/23] fix(ci): read the open-PR head map for every run that
 targets a PR

Reviews, bot comments, manual dispatches and workflow_run completions share the PR's concurrency
group with synchronize runs, so a displaced synchronize used to leave its stacked label stale
until the hourly sweep: those runs passed a not-evaluated sentinel instead of reading the map.
The gate is gone, every targeted run reads the map (the sweep still reuses openPrsCache and pays
nothing extra), and the sentinel is removed with it.

Two tests pinned the old contract and now assert the read:
'reconciles only the requested PR during manual dispatch and still reads the head map' and
'reconciles the PR associated with a workflow run and reads the head map'.
Control: restoring a gate that skips the read makes them fail again; pr-review-state-workflow.test.ts
246 passed with the change.
---
 .github/workflows/label-pr-review-state.yml   | 17 +++++-------
 .../pr-review-state-workflow.test.ts          | 27 ++++++++++---------
 2 files changed, 20 insertions(+), 24 deletions(-)

diff --git a/.github/workflows/label-pr-review-state.yml b/.github/workflows/label-pr-review-state.yml
index af645926b3..302c8b1a1c 100644
--- a/.github/workflows/label-pr-review-state.yml
+++ b/.github/workflows/label-pr-review-state.yml
@@ -226,11 +226,13 @@ jobs:
                       //
                       // An empty output means the map was unavailable this run; shards then skip the
                       // stacked label rather than deciding from an empty map.
-                      const stackMayHaveChanged =
-                        context.eventName === 'pull_request_target' &&
-                        ['opened', 'reopened', 'synchronize', 'labeled', 'unlabeled'].includes(context.payload.action);
+                      // Every execution that targets a PR reads the map: reviews, comments, manual
+                      // dispatches and workflow_run completions share this PR's concurrency group with
+                      // synchronize runs, so a displaced synchronize leaves its stacked label stale unless
+                      // the replacement run evaluates it too. The sweep already holds the list in
+                      // `openPrsCache`, so its cost is unchanged.
                       let openPrHeadsOutput = '';
-                      if (prNumbers.length > 0 && (openPrsCache || stackMayHaveChanged)) {
+                      if (prNumbers.length > 0) {
                         try {
                           const openPrsForMap = openPrsCache ?? (await github.paginate(github.rest.pulls.list, {
                             owner, repo, state: 'open', per_page: 100,
@@ -246,13 +248,6 @@ jobs:
                         } catch (error) {
                           core.warning(`Could not read the open pull request map: ${error.message}; shards will skip the stacked label this run`);
                         }
-                      } else if (prNumbers.length > 0) {
-                        // Sentinel: this event cannot change a stacked relationship, so the label was
-                        // not evaluated rather than found unavailable. Shards skip it silently.
-                        openPrHeadsOutput = 'not-evaluated';
-                        core.info(
-                          `Open-PR head map not read: ${context.eventName} cannot change a stacked unit; shards skip the stacked label.`
-                        );
                       }
                       core.setOutput('open_pr_heads', openPrHeadsOutput);
 
diff --git a/src/services/__tests__/pr-review-state-workflow.test.ts b/src/services/__tests__/pr-review-state-workflow.test.ts
index 65982a5947..4529215688 100644
--- a/src/services/__tests__/pr-review-state-workflow.test.ts
+++ b/src/services/__tests__/pr-review-state-workflow.test.ts
@@ -2691,20 +2691,19 @@ describe("PR review-state workflow", () => {
 		expect(pages[0].info).toHaveBeenCalledWith(expect.stringContaining("450"))
 	})
 
-	it("reconciles only the requested PR during manual dispatch and does not read the head map", async () => {
+	it("reconciles only the requested PR during manual dispatch and still reads the head map", async () => {
 		const resolution = await runResolve({ eventName: "workflow_dispatch", workflowDispatchPrNumber: 1437 })
 
-		// A manual dispatch cannot publish a head commit, so it cannot change a stacked relationship:
-		// the paginated open-PR read is skipped and shards are told the label was not evaluated.
-		expect(resolution.listPullRequests).not.toHaveBeenCalled()
+		// A manual dispatch shares the PR's concurrency group with synchronize runs, so it can replace
+		// a pending run: it reads the map instead of passing a not-evaluated sentinel.
+		expect(resolution.listPullRequests).toHaveBeenCalledTimes(1)
 		expect(resolution.prNumbers()).toEqual([1437])
-		expect(resolution.openPrHeadsRaw()).toBe("not-evaluated")
-		expect(resolution.info).toHaveBeenCalledWith(expect.stringContaining("cannot change a stacked unit"))
+		expect(resolution.openPrHeads()).toEqual({ [SHA.toLowerCase()]: 1437 })
 
 		const result = await runWorkflow({
 			eventName: "workflow_dispatch",
 			workflowDispatchPrNumber: 1437,
-			openPrHeadsEnv: "not-evaluated",
+			openPrHeadsEnv: JSON.stringify({ [SHA.toLowerCase()]: 1437 }),
 		})
 
 		// The shard receives the sentinel through the env; only the requested PR is reconciled.
@@ -2833,16 +2832,18 @@ describe("PR review-state workflow", () => {
 		}
 	})
 
-	it("reconciles the PR associated with a workflow run", async () => {
+	it("reconciles the PR associated with a workflow run and reads the head map", async () => {
 		const resolution = await runResolve({ eventName: "workflow_run" })
 
-		// Associated runs need no lookup, and a workflow_run cannot publish a head commit, so the
-		// head map is not read here either.
-		expect(resolution.listPullRequests).not.toHaveBeenCalled()
-		expect(resolution.openPrHeadsRaw()).toBe("not-evaluated")
+		// A run completion shares the PR's concurrency group, so it evaluates the map too.
+		expect(resolution.listPullRequests).toHaveBeenCalledTimes(1)
+		expect(resolution.openPrHeads()).toEqual({ [SHA.toLowerCase()]: 1437 })
 		expect(resolution.prNumbers()).toEqual([1437])
 
-		const result = await runWorkflow({ eventName: "workflow_run" })
+		const result = await runWorkflow({
+			eventName: "workflow_run",
+			openPrHeadsEnv: JSON.stringify({ [SHA.toLowerCase()]: 1437 }),
+		})
 
 		// The shard receives the map through the env; only the requested PR is reconciled.
 		expect(result.listPullRequests).not.toHaveBeenCalled()

From 4d2365d52fb8e75f347074231015f329915c0fc6 Mon Sep 17 00:00:00 2001
From: Eason Liang <easonliang28@gmail.com>
Date: Thu, 5 Nov 2026 03:15:36 +0800
Subject: [PATCH 23/23] test(checkpoints): stop the checkpoint suite from
 outrunning its hook budget on Windows

platform-unit-test (windows-latest) failed test:services with 5 failures in
ShadowCheckpointService.spec.ts, every one of them a hook timeout in the shared beforeEach.
One setup there spawns about 14 git subprocesses (workspace repo init plus shadow repo init),
and the ~40 tests that share those hooks never released the repositories they created, so the
shared temp dir carried one git repository pair per test until the afterAll. vitest.config.ts
gives this lane two workers only on Windows CI, and every repository that is still on disk is
extra cost on every spawn, which is what pushed the hook past the 20s hookTimeout there and
nowhere else.

Release each test's pair in the afterEach, the way the standalone tests in this file already
release their own scratch repos, and give the setup and cleanup hooks the same 60s allowance
the afterAll cleanup already carries. Nothing was skipped and no suppression was added.

Two tests pin the release: a marker written into the repository the hooks created has to be
gone before the next test runs. With the two rmScratch calls commented out the suite reports
1 failed | 43 passed (44) and the failure reads
"AssertionError: expected true to be false // Object.is equality.
With them restored the suite reports 44 passed.
---
 .../__tests__/ShadowCheckpointService.spec.ts | 45 +++++++++++++++++--
 1 file changed, 41 insertions(+), 4 deletions(-)

diff --git a/src/services/checkpoints/__tests__/ShadowCheckpointService.spec.ts b/src/services/checkpoints/__tests__/ShadowCheckpointService.spec.ts
index 1da478900c..e2486edc0b 100644
--- a/src/services/checkpoints/__tests__/ShadowCheckpointService.spec.ts
+++ b/src/services/checkpoints/__tests__/ShadowCheckpointService.spec.ts
@@ -41,6 +41,15 @@ afterAll(() => {
 	}
 })
 
+// Each test gets its own shadow + workspace repo, so the shared temp dir would otherwise
+// hold one git repository pair per test until the afterAll. Removing them as soon as the test
+// ends is what keeps the git-heavy setup below inside its hook budget on Windows CI workers,
+// where the retry absorbs the window in which git's own handles and antivirus scans still
+// hold the just-used repository.
+const rmScratch = async (dir: string) => {
+	await fs.rm(dir, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 })
+}
+
 const initWorkspaceRepo = async ({
 	workspaceDir,
 	userName = "Roo Code",
@@ -83,10 +92,16 @@ describe.each([[RepoPerTaskCheckpointService, "RepoPerTaskCheckpointService"]])(
 		let workspaceGit: SimpleGit
 		let testFile: string
 		let service: RepoPerTaskCheckpointService
+		let shadowDir: string
+		let workspaceDir: string
 
+		// One test setup spawns about 14 git subprocesses: workspace repo init plus shadow repo
+		// init. On a Windows CI worker, where vitest.config.ts gives this lane two workers and
+		// every spawn is scanned, that can outrun the 20s hook budget from vitest.config.ts, so
+		// setup and cleanup get the same 60s allowance the afterAll cleanup already carries.
 		beforeEach(async () => {
-			const shadowDir = path.join(tmpDir, `${prefix}-${Date.now()}`)
-			const workspaceDir = path.join(tmpDir, `workspace-${Date.now()}`)
+			shadowDir = path.join(tmpDir, `${prefix}-${Date.now()}`)
+			workspaceDir = path.join(tmpDir, `workspace-${Date.now()}`)
 			const repo = await initWorkspaceRepo({ workspaceDir })
 
 			workspaceGit = repo.git
@@ -94,11 +109,17 @@ describe.each([[RepoPerTaskCheckpointService, "RepoPerTaskCheckpointService"]])(
 
 			service = await klass.create({ taskId, shadowDir, workspaceDir, log: () => {} })
 			await service.initShadowGit()
-		})
+		}, 60_000)
 
 		afterEach(async () => {
 			vitest.restoreAllMocks()
-		})
+
+			// The standalone tests below already delete the scratch repos they create; this hook
+			// does the same for the pair created above, so the temp dir never accumulates one
+			// repository pair per test for the ~40 tests that share these hooks.
+			await rmScratch(shadowDir)
+			await rmScratch(workspaceDir)
+		}, 60_000)
 
 		afterAll(async () => {
 			await fs.rm(tmpDir, { recursive: true, force: true })
@@ -1166,6 +1187,22 @@ describe.each([[RepoPerTaskCheckpointService, "RepoPerTaskCheckpointService"]])(
 				}
 			})
 		})
+
+		describe(`${klass.name}#scratchCleanup`, () => {
+			let markedFile: string
+
+			it("writes a marker into the repository its hooks created", async () => {
+				markedFile = path.join(workspaceDir, "scratch-marker.txt")
+
+				await fs.writeFile(markedFile, "written by the marker test")
+
+				expect(await fileExistsAtPath(markedFile)).toBe(true)
+			})
+
+			it("removes the marker with the repository before the next test runs", async () => {
+				expect(await fileExistsAtPath(markedFile)).toBe(false)
+			})
+		})
 	},
 )