diff --git a/.github/scripts/handle-merge-queue-dequeue.mjs b/.github/scripts/handle-merge-queue-dequeue.mjs
index 1ff578ce3..b1498e601 100644
--- a/.github/scripts/handle-merge-queue-dequeue.mjs
+++ b/.github/scripts/handle-merge-queue-dequeue.mjs
@@ -13,6 +13,13 @@
 // 판정 순서는 «실패 job 이 있는가» 가 먼저다. payload 의 reason 문자열은 GitHub 이 열거값을 문서화하지
 // 않아 정본으로 삼지 않는다 — 실패 job 은 데이터로 확인하고, reason 은 «사람이 뺐다·이미 머지됐다» 를
 // 거르는 데만 쓴다. 그 밖의 reason 은 전부 조용한 방출로 본다.
+//
+// 재투입 수단은 PR 이 GitHub 네이티브 스택의 일원인지로 갈린다(#2177). 스택 PR 은 GraphQL enqueuePullRequest 가
+// UNPROCESSABLE("part of a stack and must be enqueued using the asynchronous merge REST API")로 거부되므로
+// (0919 #2053, 0926 #2123 실측) REST merge-async 에 merge_action=merge_queue 로 넣는다. 판정표는 같다.
+// merge-async 는 202 pending 으로 받으므로 결과(enqueued·merged·failed)를 폴링해 확인하고, failed·미확정은 job 을
+// red 로 남긴다. 스택 위쪽 PR 은 자동 재투입하지 않는다 — merge-async 가 downstack 의 열린 PR 까지 함께 넣어
+// 아래 PR 의 판정(실패 job 이면 재투입 안 함)을 덮기 때문이다. 위쪽 PR 에는 마커 없는 안내 코멘트만 남긴다.
 
 import { readFile } from "node:fs/promises";
 import path from "node:path";
@@ -24,6 +31,7 @@ export const REQUEUE_MARKER_PREFIX = "<!-- merge-queue-dequeue:requeued head=";
 export const NO_ACTION_REASONS = new Set(["MANUAL", "ALREADY_MERGED", "MERGE", "MERGED"]);
 const FAILED_JOB_CONCLUSIONS = new Set(["failure", "timed_out"]);
 const QUEUE_RUNS_TO_INSPECT = 10;
+const defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
 export function queueBranchPrefix(baseRef, number) {
     return `gh-readonly-queue/${baseRef}/pr-${number}-`;
@@ -81,7 +89,15 @@ export function decide({ reason, failedJobs, requeueCount }) {
 
 const shortSha = (sha) => sha.slice(0, 7);
 
-export function renderFailureComment({ reason, headSha, failedJobs, repository, number }) {
+/**
+ * 스택 PR 은 gh pr merge 가 "Auto-merge is not supported for stacked pull requests" 로 거부하므로 gh stack merge 를 안내한다.
+ * gh stack 은 --repo 플래그가 없어(gh 2.85 실측) 저장소 체크아웃 안에서 번호로 부른다.
+ */
+export function manualEnqueueCommand({ repository, number, stack = false }) {
+    return stack ? `gh stack merge ${number} --yes` : `gh pr merge ${number} --repo ${repository}`;
+}
+
+export function renderFailureComment({ reason, headSha, failedJobs, repository, number, stack = false }) {
     const lines = failedJobs.map((job) => `- [${job.runName} / ${job.jobName}](${job.jobUrl}) — ${job.conclusion}`);
     return [
         "### merge queue 방출 — merge group CI 실패",
@@ -91,7 +107,7 @@ export function renderFailureComment({ reason, headSha, failedJobs, repository,
         "실패한 job:",
         ...lines,
         "",
-        `고친 뒤 \`gh pr merge ${number} --repo ${repository}\` 로 다시 투입한다.`,
+        `고친 뒤 \`${manualEnqueueCommand({ repository, number, stack })}\` 로 다시 투입한다.`,
     ].join("\n");
 }
 
@@ -105,12 +121,23 @@ export function renderRequeueComment({ reason, headSha }) {
     ].join("\n");
 }
 
-export function renderGiveUpComment({ reason, headSha }) {
+export function renderGiveUpComment({ reason, headSha, repository, number, stack = false }) {
     return [
         "### merge queue 방출 — 같은 head 두 번째, 재투입하지 않는다",
         "",
         `사유 \`${reason}\` · head \`${shortSha(headSha)}\`. 실패 job 은 없다.`,
         "`gh run list --event merge_group` 으로 merge group run 을 확인하고 수동으로 투입한다.",
+        `확인한 뒤 \`${manualEnqueueCommand({ repository, number, stack })}\` 로 다시 투입한다.`,
+    ].join("\n");
+}
+
+export function renderStackUpperComment({ reason, headSha, repository, number }) {
+    return [
+        "### merge queue 방출: 스택 위쪽 PR",
+        "",
+        `사유 \`${reason}\` · head \`${shortSha(headSha)}\`. 스택 위쪽 PR 이라 자동 재투입하지 않았다.`,
+        "이 PR 을 재투입하면 아래의 열린 PR 까지 큐에 다시 넣어 아래 PR 의 판정을 덮는다.",
+        `스택 밑단부터 확인한 뒤 \`${manualEnqueueCommand({ repository, number, stack: true })}\` 로 다시 투입한다.`,
     ].join("\n");
 }
 
@@ -160,6 +187,7 @@ export async function fetchLivePullRequest(api, repository, number) {
                     headRefOid
                     baseRefName
                     mergeQueueEntry { state position }
+                    stack { number baseRefName }
                     timelineItems(last: 5, itemTypes: [ADDED_TO_MERGE_QUEUE_EVENT]) {
                         nodes { ... on AddedToMergeQueueEvent { createdAt } }
                     }
@@ -171,6 +199,16 @@ export async function fetchLivePullRequest(api, repository, number) {
     return data.repository.pullRequest;
 }
 
+/** GitHub 네이티브 스택의 일원인가. 비스택 PR 은 stack 이 null 로 온다(0926 #2176, #2171 실측). */
+export function isStackMember(pullRequest) {
+    return pullRequest?.stack != null;
+}
+
+/** 스택의 기준 브랜치를 base 로 삼는 PR 만 밑단이다(2026-09-27 #2177). */
+export function isStackBottom(pullRequest) {
+    return isStackMember(pullRequest) && pullRequest.baseRefName === pullRequest.stack.baseRefName;
+}
+
 /** 마지막으로 큐에 들어간 시각 — 그 뒤의 merge_group run 만 이번 방출의 근거다. */
 export function lastEnqueuedAt(pullRequest) {
     const stamps = (pullRequest.timelineItems?.nodes ?? []).map((node) => node?.createdAt).filter(Boolean);
@@ -219,39 +257,96 @@ export async function enqueue(api, pullRequestId) {
     return data.enqueuePullRequest.mergeQueueEntry;
 }
 
-export async function handleDequeue({ api, repository, number, reason, dryRun = false, logger = console }) {
+/**
+ * 스택 PR 의 큐 투입. GraphQL enqueuePullRequest 는 스택 PR 을 거부하므로 REST 비동기 머지에
+ * merge_action=merge_queue 를 준다. 요청한 PR 과 downstack 의 열린 PR 을 모두 함께 넣는다(2026-09-27 #2177).
+ * 새 요청은 202 pending 으로 받아 details.uuid 를 GET 폴링해 enqueued·merged·failed 를 확인한다.
+ * 이미 큐에 있거나 머지됐으면 200 enqueued·merged, 같은 PR 의 다른 비동기 요청이 pending 이면 409 다.
+ * sha 는 판정한 head 로 고정한다. head 가 어긋나면 요청이 거부되거나 배경에서 취소돼 failed 로 끝난다.
+ * failed 는 예외로 올리고, uuid 가 없거나 폴링 상한까지 미확정이면 live 큐 상태를 다시 확인하게 한다.
+ */
+export async function enqueueStacked(api, repository, number, headSha, { sleep = defaultSleep, pollIntervalMs = 5000, maxPolls = 24 } = {}) {
+    const apiPath = `/repos/${repository}/pulls/${number}/merge-async`;
+    let result = await api(apiPath, {
+        method: "PUT",
+        body: { merge_action: "merge_queue", sha: headSha },
+    });
+    const uuid = result?.details?.uuid;
+    for (let polls = 0; ; polls += 1) {
+        if (result?.status === "enqueued" || result?.status === "merged") return result;
+        if (result?.status === "failed") {
+            throw new Error(`merge-async 실패: ${JSON.stringify(result)}`);
+        }
+        if (result?.status !== "pending" || !uuid || polls >= maxPolls) {
+            return { ...result, unresolved: true };
+        }
+        await sleep(pollIntervalMs);
+        result = await api(`${apiPath}/${uuid}`);
+    }
+}
+
+export async function handleDequeue({
+    api,
+    repository,
+    number,
+    reason,
+    dryRun = false,
+    logger = console,
+    sleep = defaultSleep,
+}) {
     const live = await fetchLivePullRequest(api, repository, number);
     if (!live) throw new Error(`#${number} 를 찾을 수 없습니다`);
     if (live.state !== "OPEN") {
         logger.log(`#${number} 는 ${live.state} — 아무것도 하지 않는다`);
-        return { action: "none", why: live.state };
+        return { action: "none", why: live.state, stack: live.stack?.number ?? null };
     }
     if (live.mergeQueueEntry) {
         logger.log(`#${number} 는 이미 큐에 있다(${live.mergeQueueEntry.state}) — 아무것도 하지 않는다`);
-        return { action: "none", why: "already-queued" };
+        return { action: "none", why: "already-queued", stack: live.stack?.number ?? null };
     }
 
     const headSha = live.headRefOid;
+    const stack = isStackMember(live);
     const since = lastEnqueuedAt(live);
     const failedJobs = await fetchQueueFailedJobs(api, repository, { baseRef: live.baseRefName, number, since });
     const comments = await fetchComments(api, repository, number);
     const requeueCount = countRequeuesForHead(comments, headSha);
-    const action = decide({ reason, failedJobs, requeueCount });
-    logger.log(`#${number} reason=${reason} head=${shortSha(headSha)} 마지막투입=${since ?? "?"} 실패job=${failedJobs.length} 재투입횟수=${requeueCount} → ${action}`);
+    let action = decide({ reason, failedJobs, requeueCount });
+    // 위쪽 PR 의 재투입이 아래 PR 의 실패 판정을 덮지 않게 밑단에서만 자동 재투입한다(2026-09-27 #2177).
+    if (action === "requeue" && stack && !isStackBottom(live)) action = "comment-stack-upper";
+    logger.log(`#${number} reason=${reason} head=${shortSha(headSha)} 스택=${stack ? live.stack?.number ?? "?" : "없음"} 마지막투입=${since ?? "?"} 실패job=${failedJobs.length} 재투입횟수=${requeueCount} → ${action}`);
 
-    if (dryRun) return { action, dryRun: true, failedJobs, requeueCount };
+    const result = { action, failedJobs, requeueCount, stack: live.stack?.number ?? null };
+    if (dryRun) return { ...result, dryRun: true };
 
     if (action === "comment-failure") {
-        await postComment(api, repository, number, renderFailureComment({ reason, headSha, failedJobs, repository, number }));
+        await postComment(api, repository, number, renderFailureComment({ reason, headSha, failedJobs, repository, number, stack }));
     } else if (action === "comment-give-up") {
-        await postComment(api, repository, number, renderGiveUpComment({ reason, headSha }));
+        await postComment(api, repository, number, renderGiveUpComment({ reason, headSha, repository, number, stack }));
+    } else if (action === "comment-stack-upper") {
+        await postComment(api, repository, number, renderStackUpperComment({ reason, headSha, repository, number }));
     } else if (action === "requeue") {
         // 마커를 먼저 남긴다 — 재투입 뒤 코멘트가 실패하면 다음 방출에서 두 번째 재투입이 나간다.
         await postComment(api, repository, number, renderRequeueComment({ reason, headSha }));
-        const entry = await enqueue(api, live.id);
-        logger.log(`#${number} 재투입 → ${entry?.state ?? "?"} position=${entry?.position ?? "?"}`);
+        if (stack) {
+            const enqueueResult = await enqueueStacked(api, repository, number, headSha, { sleep });
+            if (enqueueResult.unresolved) {
+                const refreshed = await fetchLivePullRequest(api, repository, number);
+                if (!refreshed?.mergeQueueEntry) {
+                    throw new Error(`merge-async 결과 미확정: ${JSON.stringify(enqueueResult)} 큐에도 없다`);
+                }
+                logger.log(`#${number} 스택 ${live.stack?.number ?? "?"} 재투입(merge-async) → live 재조회로 큐 진입 확인(${refreshed.mergeQueueEntry.state})`);
+            } else {
+                logger.log(`#${number} 스택 ${live.stack?.number ?? "?"} 재투입(merge-async) → ${enqueueResult?.status ?? "?"} ${enqueueResult?.details?.message ?? ""}`.trimEnd());
+            }
+            result.enqueueMethod = "merge-async";
+        } else {
+            const entry = await enqueue(api, live.id);
+            logger.log(`#${number} 재투입 → ${entry?.state ?? "?"} position=${entry?.position ?? "?"}`);
+            result.enqueueMethod = "graphql";
+        }
     }
-    return { action, failedJobs, requeueCount };
+    return result;
 }
 
 async function main() {
@@ -274,7 +369,7 @@ async function main() {
 
     const api = createApi(token);
     const result = await handleDequeue({ api, repository, number, reason, dryRun: process.env.DRY_RUN === "true" });
-    const summary = `merge-queue-dequeue: #${number} reason=${reason} → ${result.action}${result.dryRun ? " (dry-run)" : ""}`;
+    const summary = `merge-queue-dequeue: #${number} reason=${reason} → ${result.action}${result.dryRun ? " (dry-run)" : ""}${result.stack !== null ? ` (스택 ${result.stack}, ${result.enqueueMethod ?? "판정만"})` : ""}`;
     console.log(summary);
     if (process.env.GITHUB_STEP_SUMMARY) {
         const { appendFile } = await import("node:fs/promises");
diff --git a/.github/scripts/handle-merge-queue-dequeue.test.mjs b/.github/scripts/handle-merge-queue-dequeue.test.mjs
index f09f58d9a..d498d0bac 100644
--- a/.github/scripts/handle-merge-queue-dequeue.test.mjs
+++ b/.github/scripts/handle-merge-queue-dequeue.test.mjs
@@ -7,10 +7,15 @@ import {
     collectFailedJobs,
     countRequeuesForHead,
     decide,
+    enqueueStacked,
     handleDequeue,
+    isStackBottom,
+    isStackMember,
     lastEnqueuedAt,
+    manualEnqueueCommand,
     queueBranchPrefix,
     renderFailureComment,
+    renderGiveUpComment,
     renderRequeueComment,
     requeueMarker,
 } from "./handle-merge-queue-dequeue.mjs";
@@ -18,6 +23,7 @@ import {
 const REPO = "Afternote/Afternote-FE";
 const HEAD = "0123456789abcdef0123456789abcdef01234567";
 const silent = { log() {} };
+const immediateSleep = async () => {};
 
 // ---- 판정표 (#1892) ----
 
@@ -109,10 +115,76 @@ test("실패 코멘트는 job 링크와 재투입 명령을 담고, 재투입했
     assert.ok(!body.includes(requeueMarker(HEAD)));
 });
 
+test("스택 PR 의 실패 코멘트는 gh pr merge 가 아니라 gh stack merge 를 안내한다 — gh pr merge 는 스택 PR 을 거부한다", () => {
+    assert.equal(manualEnqueueCommand({ repository: REPO, number: 2123 }), "gh pr merge 2123 --repo Afternote/Afternote-FE");
+    assert.equal(manualEnqueueCommand({ repository: REPO, number: 2123, stack: true }), "gh stack merge 2123 --yes", "gh stack 에는 --repo 가 없다");
+    const body = renderFailureComment({
+        reason: "CI_FAILURE",
+        headSha: HEAD,
+        repository: REPO,
+        number: 2123,
+        stack: true,
+        failedJobs: [{ runName: "Unit Test", jobName: "Run Unit Tests", jobUrl: "https://x/jobs/11", conclusion: "failure" }],
+    });
+    assert.match(body, /gh stack merge 2123 --yes/);
+    assert.ok(!body.includes("gh pr merge"));
+});
+
+test("재투입 중단 코멘트는 스택 여부에 맞는 수동 명령을 덧붙인다 — 기존 확인 안내를 보존한다", () => {
+    for (const [stack, number, command] of [
+        [true, 2123, "gh stack merge 2123 --yes"],
+        [false, 1509, "gh pr merge 1509 --repo Afternote/Afternote-FE"],
+    ]) {
+        const body = renderGiveUpComment({ reason: "MERGE_CONFLICT", headSha: HEAD, repository: REPO, number, stack });
+        assert.match(body, /같은 head 두 번째, 재투입하지 않는다/);
+        assert.ok(body.includes("`gh run list --event merge_group` 으로 merge group run 을 확인하고 수동으로 투입한다."));
+        assert.ok(body.split("\n").at(-1).includes(command));
+        assert.ok(!body.includes(requeueMarker(HEAD)));
+    }
+});
+
+// ---- 스택 판정 (2026-09-27 #2177) ----
+
+test("stack 이 null·없음이면 비스택, 객체면 스택이다", () => {
+    assert.equal(isStackMember({ stack: null }), false);
+    assert.equal(isStackMember({}), false);
+    assert.equal(isStackMember({ stack: { number: 2125 } }), true);
+});
+
+test("스택 기준 브랜치와 PR base 가 같을 때만 밑단이다 — 위쪽 PR 은 아래 PR 의 판정을 덮을 수 있다", () => {
+    assert.equal(isStackBottom({ stack: null, baseRefName: "develop" }), false);
+    assert.equal(isStackBottom({}), false);
+    assert.equal(isStackBottom({ baseRefName: "develop", stack: { number: 2125, baseRefName: "develop" } }), true);
+    assert.equal(isStackBottom({ baseRefName: "refactor/1429-setting-repositories", stack: { number: 2125, baseRefName: "develop" } }), false);
+});
+
 // ---- handleDequeue 흐름: live 상태가 정본, 쓰기 순서 ----
 
-function fakeApi({ live, runs = [], jobs = {}, comments = [] }) {
+function fakeApi({
+    live,
+    liveAfter = live,
+    runs = [],
+    jobs = {},
+    comments = [],
+    mergeAsync = {
+        status: "pending",
+        details: {
+            message: "Merge request enqueued.",
+            uuid: "u-1",
+            merge_method: "default",
+            merge_action: "merge_queue",
+            expected_head_sha: HEAD,
+        },
+    },
+    mergeAsyncPolls = [{ status: "enqueued", details: { message: "Pull request added to merge queue." } }],
+}) {
     const calls = [];
+    let liveReads = 0;
+    let pollReads = 0;
+    const respond = (response) => {
+        if (response instanceof Error) throw response;
+        return response;
+    };
     const api = async (apiPath, options = {}) => {
         calls.push({ apiPath, method: options.method ?? "GET", body: options.body });
         if (apiPath === "/graphql") {
@@ -120,7 +192,11 @@ function fakeApi({ live, runs = [], jobs = {}, comments = [] }) {
             if (query.includes("enqueuePullRequest")) {
                 return { data: { enqueuePullRequest: { mergeQueueEntry: { state: "QUEUED", position: 1 } } } };
             }
-            return { data: { repository: { pullRequest: live } } };
+            return { data: { repository: { pullRequest: respond(liveReads++ === 0 ? live : liveAfter) } } };
+        }
+        if (/\/pulls\/\d+\/merge-async$/.test(apiPath) && options.method === "PUT") return respond(mergeAsync);
+        if (/\/pulls\/\d+\/merge-async\/u-1$/.test(apiPath) && (options.method ?? "GET") === "GET") {
+            return respond(mergeAsyncPolls[Math.min(pollReads++, mergeAsyncPolls.length - 1)]);
         }
         if (apiPath.startsWith(`/repos/${REPO}/actions/runs?`)) return { workflow_runs: runs };
         const jobsMatch = /\/actions\/runs\/(\d+)\/jobs/.exec(apiPath);
@@ -133,25 +209,44 @@ function fakeApi({ live, runs = [], jobs = {}, comments = [] }) {
     return api;
 }
 
+const enqueueMutations = (api) => api.calls.filter((call) => call.body?.query?.includes("enqueuePullRequest"));
+const mergeAsyncCalls = (api) => api.calls.filter((call) => call.apiPath.endsWith("/merge-async"));
+const mergeAsyncGets = (api) => api.calls.filter((call) => call.method === "GET" && call.apiPath.endsWith("/merge-async/u-1"));
+const liveQueries = (api) => api.calls.filter((call) => call.apiPath === "/graphql" && !call.body.query.includes("enqueuePullRequest"));
+const commentPosts = (api) => api.calls.filter((call) => call.method === "POST" && call.apiPath.endsWith("/comments"));
+
 const openLive = {
     id: "PR_1",
     state: "OPEN",
     headRefOid: HEAD,
     baseRefName: "develop",
     mergeQueueEntry: null,
+    stack: null,
     timelineItems: { nodes: [{ createdAt: "2026-09-04T08:00:00Z" }] },
 };
 
+// 0926 #2123: base 는 develop 이지만 위에 #2124 가 얹혀 스택 2125 의 밑단이다.
+const stackedLive = { ...openLive, stack: { number: 2125, baseRefName: "develop" } };
+const stackUpperLive = { ...stackedLive, baseRefName: "refactor/1429-setting-repositories" };
+
 test("MERGED·CLOSED 거나 이미 큐에 있으면 payload 와 무관하게 아무것도 쓰지 않는다", async () => {
     for (const live of [
         { ...openLive, state: "MERGED" },
         { ...openLive, state: "CLOSED" },
         { ...openLive, mergeQueueEntry: { state: "QUEUED", position: 2 } },
+        { ...stackedLive, state: "MERGED" },
+        { ...stackedLive, state: "CLOSED" },
+        { ...stackedLive, mergeQueueEntry: { state: "QUEUED", position: 2 } },
+        { ...stackUpperLive, state: "MERGED" },
+        { ...stackUpperLive, state: "CLOSED" },
+        { ...stackUpperLive, mergeQueueEntry: { state: "QUEUED", position: 2 } },
     ]) {
         const api = fakeApi({ live });
         const result = await handleDequeue({ api, repository: REPO, number: 1509, reason: "UNKNOWN_REMOVAL_REASON", logger: silent });
         assert.equal(result.action, "none");
-        assert.equal(api.calls.filter((call) => call.method === "POST" && call.apiPath !== "/graphql").length, 0);
+        assert.equal(result.stack, live.stack?.number ?? null);
+        assert.ok(!("enqueueMethod" in result));
+        assert.equal(api.calls.filter((call) => call.method !== "GET" && call.apiPath !== "/graphql").length, 0);
         assert.ok(!api.calls.some((call) => call.body?.query?.includes("enqueuePullRequest")));
     }
 });
@@ -160,11 +255,253 @@ test("조용한 방출: 마커 코멘트를 먼저 남기고 그 다음 enqueueP
     const api = fakeApi({ live: openLive });
     const result = await handleDequeue({ api, repository: REPO, number: 1509, reason: "UNKNOWN_REMOVAL_REASON", logger: silent });
     assert.equal(result.action, "requeue");
-    const writes = api.calls.filter((call) => call.method === "POST" && (call.apiPath !== "/graphql" || call.body.query.includes("enqueuePullRequest")));
+    assert.equal(result.stack, null);
+    assert.equal(result.enqueueMethod, "graphql");
+    const writes = api.calls.filter((call) => call.method !== "GET" && (call.apiPath !== "/graphql" || call.body.query.includes("enqueuePullRequest")));
     assert.equal(writes.length, 2);
     assert.match(writes[0].apiPath, /\/issues\/1509\/comments$/);
     assert.ok(writes[0].body.body.startsWith(requeueMarker(HEAD)));
     assert.equal(writes[1].apiPath, "/graphql");
+    assert.equal(mergeAsyncCalls(api).length, 0, "비스택 PR 은 종전대로 GraphQL 로만 넣는다");
+});
+
+// ---- 스택 PR 의 재투입은 REST merge-async (2026-09-27 #2177) ----
+
+test("live 조회는 stack 필드를 함께 읽는다 — 재투입 수단을 고르는 근거다", async () => {
+    const api = fakeApi({ live: openLive });
+    await handleDequeue({ api, repository: REPO, number: 1509, reason: "UNKNOWN_REMOVAL_REASON", dryRun: true, logger: silent });
+    const liveQuery = api.calls.find((call) => call.apiPath === "/graphql").body.query;
+    assert.match(liveQuery, /stack\s*\{\s*number\s+baseRefName\s*\}/);
+});
+
+test("스택 밑단은 마커 뒤 merge-async 로 넣고 GET enqueued 를 확인한다 — enqueuePullRequest 는 스택 PR 을 거부한다", async () => {
+    const api = fakeApi({ live: stackedLive });
+    const result = await handleDequeue({ api, repository: REPO, number: 2123, reason: "MERGE_CONFLICT", logger: silent, sleep: immediateSleep });
+    assert.equal(result.action, "requeue");
+    assert.equal(result.stack, 2125);
+    assert.equal(result.enqueueMethod, "merge-async");
+    assert.equal(enqueueMutations(api).length, 0, "GraphQL enqueuePullRequest 는 스택 PR 을 UNPROCESSABLE 로 거부한다");
+    const writes = api.calls.filter((call) => call.method !== "GET" && call.apiPath !== "/graphql");
+    assert.equal(writes.length, 2);
+    assert.match(writes[0].apiPath, /\/issues\/2123\/comments$/);
+    assert.ok(writes[0].body.body.startsWith(requeueMarker(HEAD)), "마커가 먼저다 — 재투입 뒤 코멘트가 실패하면 두 번째 재투입이 나간다");
+    assert.deepEqual(
+        { apiPath: writes[1].apiPath, method: writes[1].method, body: writes[1].body },
+        { apiPath: `/repos/${REPO}/pulls/2123/merge-async`, method: "PUT", body: { merge_action: "merge_queue", sha: HEAD } },
+    );
+    assert.equal(mergeAsyncGets(api).length, 1);
+    assert.equal(mergeAsyncGets(api)[0].apiPath, `/repos/${REPO}/pulls/2123/merge-async/u-1`);
+    assert.ok(api.calls.indexOf(writes[1]) < api.calls.indexOf(mergeAsyncGets(api)[0]));
+    assert.equal(liveQueries(api).length, 1, "최종 결과가 확인되면 live 재조회는 필요 없다");
+});
+
+test("스택 위쪽은 마커 없는 안내만 남긴다 — 아래 PR 의 실패 판정을 우회하는 자동 재투입을 막는다", async () => {
+    const api = fakeApi({ live: stackUpperLive });
+    const result = await handleDequeue({ api, repository: REPO, number: 2124, reason: "MERGE_CONFLICT", logger: silent, sleep: immediateSleep });
+    assert.equal(result.action, "comment-stack-upper");
+    assert.equal(result.stack, 2125);
+    assert.ok(!("enqueueMethod" in result));
+    assert.equal(mergeAsyncCalls(api).length, 0);
+    assert.equal(mergeAsyncGets(api).length, 0);
+    assert.equal(enqueueMutations(api).length, 0);
+    assert.equal(commentPosts(api).length, 1);
+    const body = commentPosts(api)[0].body.body;
+    assert.ok(!body.includes("<!-- merge-queue-dequeue:requeued"));
+    assert.match(body, /스택 위쪽 PR 이라 자동 재투입하지 않았다/);
+    assert.match(body, /아래의 열린 PR 까지 큐에 다시 넣어 아래 PR 의 판정을 덮는다/);
+    assert.match(body, /밑단부터 확인한 뒤 `gh stack merge 2124 --yes`/);
+});
+
+test("스택 여부는 판정표를 바꾸지 않는다 — 실패 job 이면 comment-failure, 같은 head 두 번째면 comment-give-up, 어느 쪽도 재투입 없음", async () => {
+    for (const live of [stackedLive, stackUpperLive]) {
+        const runs = [{ id: 7, name: "Unit Test", html_url: "https://x/runs/7", head_branch: queueBranchPrefix(live.baseRefName, 2123) + "abc", created_at: "2026-09-04T08:05:00Z" }];
+        const jobs = { 7: [{ name: "Run Unit Tests", conclusion: "failure", html_url: "https://x/jobs/71" }] };
+        const failed = fakeApi({ live, runs, jobs });
+        assert.equal((await handleDequeue({ api: failed, repository: REPO, number: 2123, reason: "CI_FAILURE", logger: silent })).action, "comment-failure");
+        assert.match(commentPosts(failed)[0].body.body, /gh stack merge 2123 --yes/);
+
+        const second = fakeApi({ live, comments: [{ body: renderRequeueComment({ reason: "MERGE_CONFLICT", headSha: HEAD }) }] });
+        assert.equal((await handleDequeue({ api: second, repository: REPO, number: 2123, reason: "MERGE_CONFLICT", logger: silent })).action, "comment-give-up");
+        assert.match(commentPosts(second)[0].body.body, /gh stack merge 2123 --yes/);
+
+        const manual = fakeApi({ live });
+        assert.equal((await handleDequeue({ api: manual, repository: REPO, number: 2123, reason: "MANUAL", logger: silent })).action, "none");
+
+        for (const api of [failed, second, manual]) {
+            assert.equal(mergeAsyncCalls(api).length, 0);
+            assert.equal(enqueueMutations(api).length, 0);
+        }
+        assert.equal(commentPosts(failed).length, 1);
+        assert.equal(commentPosts(second).length, 1);
+        assert.equal(commentPosts(manual).length, 0);
+    }
+});
+
+test("merge-async GET 결과가 failed 면 마커 한 건을 남긴 채 예외로 올린다 — 배경 실패도 job 이 red 로 남는다", async () => {
+    const failed = { status: "failed", details: { message: "Merge conflict: the pull request could not be merged." } };
+    const api = fakeApi({ live: stackedLive, mergeAsyncPolls: [failed] });
+    await assert.rejects(
+        handleDequeue({ api, repository: REPO, number: 2123, reason: "MERGE_CONFLICT", logger: silent, sleep: immediateSleep }),
+        { message: `merge-async 실패: ${JSON.stringify(failed)}` },
+    );
+    assert.equal(mergeAsyncCalls(api).length, 1);
+    assert.equal(mergeAsyncGets(api).length, 1);
+    assert.equal(commentPosts(api).length, 1);
+    assert.ok(commentPosts(api)[0].body.body.startsWith(requeueMarker(HEAD)));
+    assert.ok(api.calls.indexOf(commentPosts(api)[0]) < api.calls.indexOf(mergeAsyncCalls(api)[0]));
+    assert.equal(liveQueries(api).length, 1, "확정된 실패를 live 조회로 성공 처리하지 않는다");
+    await assert.rejects(enqueueStacked(api, REPO, 2123, HEAD, { sleep: immediateSleep }), /merge-async 실패/);
+    assert.equal(mergeAsyncCalls(api).length, 2);
+    assert.equal(mergeAsyncGets(api).length, 2);
+    assert.equal(commentPosts(api).length, 1);
+});
+
+test("GET pending 두 번 뒤 enqueued 면 성공한다 — 매 조회 전에 주입한 sleep 으로 5초 간격을 지킨다", async () => {
+    const api = fakeApi({
+        live: stackedLive,
+        mergeAsyncPolls: [{ status: "pending" }, { status: "pending" }, { status: "enqueued" }],
+    });
+    const sleeps = [];
+    const result = await handleDequeue({
+        api, repository: REPO, number: 2123, reason: "MERGE_CONFLICT", logger: silent,
+        sleep: async (ms) => {
+            sleeps.push(ms);
+            assert.equal(mergeAsyncGets(api).length, sleeps.length - 1);
+        },
+    });
+    assert.equal(result.action, "requeue");
+    assert.equal(result.enqueueMethod, "merge-async");
+    assert.deepEqual(sleeps, [5000, 5000, 5000]);
+    assert.equal(mergeAsyncGets(api).length, 3);
+    assert.equal(mergeAsyncCalls(api).length, 1);
+    assert.equal(commentPosts(api).length, 1);
+    assert.equal(liveQueries(api).length, 1);
+});
+
+test("PUT 200 enqueued·merged 는 즉시 반환한다 — 이미 끝난 요청은 GET 과 sleep 이 필요 없다", async () => {
+    for (const status of ["enqueued", "merged"]) {
+        const response = { status, details: { message: "Pull request is already in the merge queue." } };
+        const api = fakeApi({ live: stackedLive, mergeAsync: response });
+        const result = await enqueueStacked(api, REPO, 2123, HEAD, {
+            sleep: async () => assert.fail("완료 응답은 기다리지 않는다"),
+        });
+        assert.deepEqual(result, response);
+        assert.equal(mergeAsyncCalls(api).length, 1);
+        assert.equal(mergeAsyncGets(api).length, 0);
+    }
+});
+
+test("마지막 허용 GET 이 merged 면 성공으로 반환한다 — 폴링 상한에서 받은 완료도 확정 결과다", async () => {
+    const response = { status: "merged", details: { message: "Pull request merged." } };
+    const api = fakeApi({ live: stackedLive, mergeAsyncPolls: [{ status: "pending" }, response] });
+    const sleeps = [];
+    assert.deepEqual(await enqueueStacked(api, REPO, 2123, HEAD, {
+        sleep: async (ms) => sleeps.push(ms), pollIntervalMs: 7, maxPolls: 2,
+    }), response);
+    assert.deepEqual(sleeps, [7, 7]);
+    assert.equal(mergeAsyncGets(api).length, 2);
+});
+
+test("폴링 상한까지 pending 이면 마지막 응답에 unresolved 를 붙인다 — PUT 응답으로 되돌리지 않는다", async () => {
+    const pending = { status: "pending", details: { message: "Still pending." } };
+    const api = fakeApi({ live: stackedLive, mergeAsyncPolls: [pending] });
+    const sleeps = [];
+    assert.deepEqual(await enqueueStacked(api, REPO, 2123, HEAD, {
+        sleep: async (ms) => sleeps.push(ms), pollIntervalMs: 7, maxPolls: 2,
+    }), { ...pending, unresolved: true });
+    assert.deepEqual(sleeps, [7, 7]);
+    assert.equal(mergeAsyncGets(api).length, 2);
+});
+
+test("24회 pending 이어도 live 재조회에 큐 항목이 있으면 성공한다 — 비동기 결과의 미확정을 큐 상태로 보완한다", async () => {
+    const api = fakeApi({
+        live: stackedLive,
+        liveAfter: { ...stackedLive, mergeQueueEntry: { state: "QUEUED", position: 1 } },
+        mergeAsyncPolls: [{ status: "pending" }],
+    });
+    const sleeps = [];
+    const logs = [];
+    const result = await handleDequeue({
+        api, repository: REPO, number: 2123, reason: "MERGE_CONFLICT",
+        logger: { log: (line) => logs.push(line) }, sleep: async (ms) => sleeps.push(ms),
+    });
+    assert.equal(result.action, "requeue");
+    assert.equal(result.stack, 2125);
+    assert.equal(result.enqueueMethod, "merge-async");
+    assert.equal(mergeAsyncGets(api).length, 24);
+    assert.deepEqual(sleeps, Array(24).fill(5000));
+    assert.equal(liveQueries(api).length, 2);
+    assert.equal(commentPosts(api).length, 1);
+    assert.equal(mergeAsyncCalls(api).length, 1);
+    assert.ok(logs.some((line) => line.includes("스택 2125") && line.includes("큐 진입 확인")));
+});
+
+test("24회 pending 이고 live 재조회에도 큐 항목이 없으면 실패한다 — 미확정을 재투입 성공으로 보고하지 않는다", async () => {
+    const api = fakeApi({ live: stackedLive, mergeAsyncPolls: [{ status: "pending" }] });
+    const sleeps = [];
+    await assert.rejects(handleDequeue({
+        api, repository: REPO, number: 2123, reason: "MERGE_CONFLICT", logger: silent,
+        sleep: async (ms) => sleeps.push(ms),
+    }), /merge-async 결과 미확정: .*pending.* 큐에도 없다/);
+    assert.equal(mergeAsyncGets(api).length, 24);
+    assert.deepEqual(sleeps, Array(24).fill(5000));
+    assert.equal(liveQueries(api).length, 2);
+    assert.equal(commentPosts(api).length, 1);
+    assert.ok(commentPosts(api)[0].body.body.startsWith(requeueMarker(HEAD)));
+    assert.equal(mergeAsyncCalls(api).length, 1);
+});
+
+test("pending 에 uuid 가 없으면 live 큐 상태로 판정한다 — 조회할 비동기 요청을 추측하지 않는다", async () => {
+    for (const mergeQueueEntry of [null, { state: "QUEUED", position: 1 }]) {
+        const api = fakeApi({
+            live: stackedLive, liveAfter: { ...stackedLive, mergeQueueEntry },
+            mergeAsync: { status: "pending", details: { message: "Merge request enqueued." } },
+        });
+        const result = handleDequeue({
+            api, repository: REPO, number: 2123, reason: "MERGE_CONFLICT", logger: silent,
+            sleep: async () => assert.fail("uuid 가 없으면 기다리지 않는다"),
+        });
+        if (mergeQueueEntry) {
+            assert.equal((await result).enqueueMethod, "merge-async");
+        } else {
+            await assert.rejects(result, /merge-async 결과 미확정: .* 큐에도 없다/);
+        }
+        assert.equal(mergeAsyncGets(api).length, 0);
+        assert.equal(liveQueries(api).length, 2);
+        assert.equal(commentPosts(api).length, 1);
+        assert.equal(mergeAsyncCalls(api).length, 1);
+    }
+});
+
+test("PUT HTTP 오류는 마커 한 건을 남긴 채 그대로 올라온다 — 400·409·422 를 성공으로 삼지 않는다", async () => {
+    for (const status of [400, 409, 422]) {
+        const error = new Error(`GitHub API PUT merge-async 실패: ${status}`);
+        const api = fakeApi({ live: stackedLive, mergeAsync: error });
+        await assert.rejects(
+            handleDequeue({ api, repository: REPO, number: 2123, reason: "MERGE_CONFLICT", logger: silent, sleep: immediateSleep }),
+            (caught) => caught === error,
+        );
+        assert.equal(commentPosts(api).length, 1);
+        assert.ok(commentPosts(api)[0].body.body.startsWith(requeueMarker(HEAD)));
+        assert.ok(api.calls.indexOf(commentPosts(api)[0]) < api.calls.indexOf(mergeAsyncCalls(api)[0]));
+        assert.equal(mergeAsyncCalls(api).length, 1);
+        assert.equal(mergeAsyncGets(api).length, 0);
+        assert.equal(liveQueries(api).length, 1);
+        assert.equal(enqueueMutations(api).length, 0);
+    }
+});
+
+test("GET HTTP 오류도 그대로 올라온다 — 폴링 실패를 미확정 성공으로 삼지 않는다", async () => {
+    const error = new Error("GitHub API GET merge-async/u-1 실패: 500");
+    const api = fakeApi({ live: stackedLive, mergeAsyncPolls: [error] });
+    await assert.rejects(
+        handleDequeue({ api, repository: REPO, number: 2123, reason: "MERGE_CONFLICT", logger: silent, sleep: immediateSleep }),
+        (caught) => caught === error,
+    );
+    assert.equal(commentPosts(api).length, 1);
+    assert.ok(commentPosts(api)[0].body.body.startsWith(requeueMarker(HEAD)));
+    assert.equal(mergeAsyncGets(api).length, 1);
+    assert.equal(liveQueries(api).length, 1);
 });
 
 test("같은 head 의 두 번째 방출은 코멘트만 남기고 enqueuePullRequest 를 쏘지 않는다", async () => {
@@ -173,6 +510,7 @@ test("같은 head 의 두 번째 방출은 코멘트만 남기고 enqueuePullReq
     assert.equal(result.action, "comment-give-up");
     assert.ok(!api.calls.some((call) => call.body?.query?.includes("enqueuePullRequest")));
     assert.equal(api.calls.filter((call) => call.method === "POST" && call.apiPath.endsWith("/comments")).length, 1);
+    assert.match(commentPosts(api)[0].body.body, /gh pr merge 1509 --repo Afternote\/Afternote-FE/);
 });
 
 test("CI 실패: 실패 job 링크 코멘트만, 재투입 없음", async () => {
@@ -186,12 +524,19 @@ test("CI 실패: 실패 job 링크 코멘트만, 재투입 없음", async () =>
     assert.ok(!api.calls.some((call) => call.body?.query?.includes("enqueuePullRequest")));
 });
 
-test("dry-run 은 판정만 하고 아무것도 쓰지 않는다", async () => {
-    const api = fakeApi({ live: openLive });
-    const result = await handleDequeue({ api, repository: REPO, number: 1509, reason: "ROLL_BACK", dryRun: true, logger: silent });
-    assert.equal(result.action, "requeue");
-    assert.equal(api.calls.filter((call) => call.method === "POST" && call.apiPath !== "/graphql").length, 0);
-    assert.ok(!api.calls.some((call) => call.body?.query?.includes("enqueuePullRequest")));
+test("dry-run 은 판정만 하고 아무것도 쓰지 않는다 — 스택 PR 도 같다", async () => {
+    for (const live of [openLive, stackedLive, stackUpperLive]) {
+        const api = fakeApi({ live });
+        const result = await handleDequeue({ api, repository: REPO, number: 1509, reason: "ROLL_BACK", dryRun: true, logger: silent });
+        assert.equal(result.action, live === stackUpperLive ? "comment-stack-upper" : "requeue");
+        assert.equal(result.dryRun, true);
+        assert.equal(result.stack, live.stack?.number ?? null);
+        assert.ok(!("enqueueMethod" in result));
+        assert.equal(api.calls.filter((call) => call.method !== "GET" && call.apiPath !== "/graphql").length, 0);
+        assert.equal(enqueueMutations(api).length, 0);
+        assert.equal(mergeAsyncCalls(api).length, 0);
+        assert.equal(mergeAsyncGets(api).length, 0);
+    }
 });
 
 // ---- 워크플로 정책 ----