diff --git a/.github/workflows/label-pr-review-state.yml b/.github/workflows/label-pr-review-state.yml
index 1bffbd3e02..7d9baca0a6 100644
--- a/.github/workflows/label-pr-review-state.yml
+++ b/.github/workflows/label-pr-review-state.yml
@@ -44,6 +44,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 is keyed at two levels (issue #1707):
 #
@@ -91,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).
@@ -131,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') {
@@ -163,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;
@@ -189,6 +193,32 @@ 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;
+                          }
+                          // 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`);
+                        }
+                      }
+                      core.setOutput('open_pr_heads', openPrHeadsOutput);
+
     reconcile:
         name: Zoo Code / reconcile PR review state
         needs: resolve
@@ -230,6 +260,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: >-
@@ -286,6 +317,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:';
@@ -329,6 +365,7 @@ jobs:
                         return pr.head?.repo?.full_name && pr.head.repo.full_name !== pr.base?.repo?.full_name;
                       }
 
+                      const stackedLabel = 'stacked';
                       if (!isReadOnlyRun) {
                         // One paginated list keeps the per-shard API budget flat no matter
                         // how many labels are managed; per-label getLabel calls would
@@ -342,6 +379,14 @@ jobs:
                           try {
                             await github.rest.issues.createLabel({ owner, repo, ...label });
                           } catch (createError) {
+                            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. A concurrent shard winning
+                              // the creation race lands the label anyway; the next sweep reconciles it.
+                              core.warning(`Could not create the ${stackedLabel} label: ${createError.message}; continuing without it`);
+                              continue;
+                            }
                             // Concurrent shards for other PRs can win the creation race.
                             // Tolerate only the duplicate-label payload; any other 422
                             // must fail the shard.
@@ -417,6 +462,43 @@ jobs:
                         }
                       }
 
+                      // 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.
+
+                      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;
+                        }
+                        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,
@@ -707,8 +789,27 @@ 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.
+                      let openPrHeads = null;
+                      if (prs.length > 0) {
+                        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');
+                        }
+                      }
+
                       for (const pr of prs) {
                         let failurePhase = 'ci-pending';
+                        await reconcileStackedLabel(pr, openPrHeads);
                         try {
                           // The matrix job reports one check per shard named
                           // "<reconciliationCheckName> (<pr_number>)", so catch both the
diff --git a/src/services/__tests__/pr-review-state-workflow.test.ts b/src/services/__tests__/pr-review-state-workflow.test.ts
index 852fca2643..260520fc75 100644
--- a/src/services/__tests__/pr-review-state-workflow.test.ts
+++ b/src/services/__tests__/pr-review-state-workflow.test.ts
@@ -50,6 +50,7 @@ interface HarnessOptions {
 	addLabelsFailOnceName?: string
 	labelLookupStatus?: number
 	createLabelStatus?: number
+	createLabelFailOnceName?: string
 	createLabelErrors?: Array<{ code: string; field: string }>
 	existingRepoLabels?: string[]
 	listCommentsErrorStatus?: number
@@ -76,6 +77,12 @@ interface HarnessOptions {
 	timelineErrorStatus?: number
 	permissions?: Record<string, string>
 	permissionErrors?: Record<string, number>
+	commitParents?: string[]
+	getCommitErrorStatus?: number
+	openPrHeads?: Array<{ number: number; sha: string }>
+	openPrHeadsError?: boolean
+	openPrHeadsEnv?: string
+	emptyOpenList?: boolean
 	permissionErrorStatus?: number
 	requiredContexts?: string[]
 	requiredIntegrationId?: number | null
@@ -136,6 +143,9 @@ type HarnessPr = ReturnType<typeof buildHarnessPr>
 
 function createListPullRequests(options: HarnessOptions, eventName: string, pr: HarnessPr) {
 	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 []
@@ -149,7 +159,7 @@ function createListPullRequests(options: HarnessOptions, eventName: string, pr:
 		if (options.openPrNumbers) {
 			return options.openPrNumbers.map((number) => ({ ...pr, number }))
 		}
-		return [pr]
+		return [pr, ...(options.openPrHeads ?? []).map((entry) => ({ number: entry.number, head: { sha: entry.sha } }))]
 	})
 }
 
@@ -348,7 +358,16 @@ 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,
@@ -370,6 +389,12 @@ async function runWorkflow(options: HarnessOptions = {}) {
 		return { data: { permission } }
 	})
 	const listPullRequests = createListPullRequests(options, eventName, pr)
+	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 () => {
 		const index = pullRequestGetIndex++
@@ -434,6 +459,9 @@ async function runWorkflow(options: HarnessOptions = {}) {
 				createComment,
 				updateComment,
 			},
+			git: {
+				getCommit,
+			},
 			checks: {
 				listForRef: vi.fn(async () => checkRuns),
 			},
@@ -488,15 +516,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 ? "" : (options.openPrHeadsEnv ?? 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]
@@ -521,6 +560,7 @@ async function runWorkflow(options: HarnessOptions = {}) {
 		warning: core.warning,
 		getPullRequest,
 		listPullRequests: github.rest.pulls.list,
+		getCommit,
 		listCommitStatusesForRef: github.rest.repos.listCommitStatusesForRef,
 		permissionFor,
 	}
@@ -574,12 +614,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),
 	}
 }
 
@@ -609,6 +652,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")
@@ -643,6 +687,132 @@ 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 }],
+		})
+
+		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()
+	})
+
+	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({ 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")
+	})
+
+	it("keeps reconciling review state when the open-PR map lookup fails", async () => {
+		const result = await runWorkflow({
+			openPrHeadsError: true,
+			labels: ["stacked", "awaiting-maintainer"],
+			permissions: { maintainer: "write" },
+			reviews: [
+				{
+					login: "maintainer",
+					type: "User",
+					state: "APPROVED",
+					submittedAt: REVIEWED_AT,
+				},
+			],
+		})
+
+		// 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()
+		// 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 () => {
+		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],
+			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("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"] }))
+		// 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 () => {
 		expect(workflow.on.issue_comment.types).toEqual(["created", "edited"])
 		expect(workflow.jobs.reconcile.if).toContain("github.event.comment.user.login == 'coderabbitai[bot]'")
@@ -662,7 +832,10 @@ describe("PR review-state workflow", () => {
 		})
 
 		expect(result.getPullRequest).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" }))
 		expect(result.addLabels).toHaveBeenCalledWith(expect.objectContaining({ labels: ["awaiting-author"] }))
@@ -697,12 +870,24 @@ describe("PR review-state workflow", () => {
 		const result = await runWorkflow({ existingRepoLabels: [] })
 
 		expect(result.listLabelsForRepo).toHaveBeenCalledTimes(1)
-		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")
 		expect(communityApproved).toBeDefined()
 		expect(communityApproved?.description.length).toBeLessThanOrEqual(100)
+		// 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; color: string; description: string })
+			.find((label) => label.name === "stacked")
+		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 () => {
@@ -711,6 +896,29 @@ describe("PR review-state workflow", () => {
 		)
 	})
 
+	it("keeps reconciling when only the stacked label cannot be created", async () => {
+		const result = await runWorkflow({
+			existingRepoLabels: [],
+			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 label listing failures", async () => {
 		await expect(runWorkflow({ labelLookupStatus: 500 })).rejects.toThrow("List labels failed")
 	})
@@ -1923,14 +2131,100 @@ 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 })
 
+		// 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("treats an empty open-PR list as an unavailable head map", async () => {
+		const resolution = await runResolve({
+			eventName: "workflow_dispatch",
+			workflowDispatchPrNumber: 1437,
+			emptyOpenList: true,
+		})
+
+		// 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 () => {
+		// 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
@@ -1958,11 +2252,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" })
 
+		// 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"] }))
 	})
 
@@ -3656,8 +3953,9 @@ describe("PR review-state workflow concurrency groups (#1707)", () => {
 		})
 
 		expect(result.listLabelsForRepo).toHaveBeenCalledTimes(1)
-		// All five definitions race; every duplicate payload is tolerated.
-		expect(result.createLabel).toHaveBeenCalledTimes(5)
+		// All six definitions race: the stacked one is tolerated by its advisory path, the
+		// other five by the duplicate-payload race tolerance.
+		expect(result.createLabel).toHaveBeenCalledTimes(6)
 		expect(result.addLabels).toHaveBeenCalledWith(expect.objectContaining({ labels: ["coderabbit-review-active"] }))
 		expect(result.setFailed).not.toHaveBeenCalled()
 	})