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 1/9] 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 2/9] 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 3/9] 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 4/9] 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 5/9] 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 6/9] 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 7/9] 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 8/9] 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 9/9] 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")
 	})